From 026ea1d96d6c37886bda13b53b69b7f3bc92087f Mon Sep 17 00:00:00 2001
From: Chris Adams <chris@productscience.co.uk>
Date: Fri, 15 Nov 2024 18:17:13 +0100
Subject: [PATCH 1/3] Remove unused user update form

---
 apps/accounts/urls.py                        |  2 --
 apps/accounts/views.py                       | 14 ---------
 apps/theme/templates/accounts/user_form.html | 30 --------------------
 3 files changed, 46 deletions(-)
 delete mode 100644 apps/theme/templates/accounts/user_form.html

diff --git a/apps/accounts/urls.py b/apps/accounts/urls.py
index 44df56e3..c5389f4b 100644
--- a/apps/accounts/urls.py
+++ b/apps/accounts/urls.py
@@ -9,7 +9,6 @@
     UserActivationView,
     UserRegistrationView,
     DashboardView,
-    UserUpdateView,
     ProviderPortalHomeView,
     ProviderRequestDetailView,
     ProviderRequestWizardView,
@@ -104,7 +103,6 @@
     # include admin URLs
     path("admin/", admin.urls),
     # custom views
-    path("user/<pk>/", UserUpdateView.as_view(), name="user_edit"),
     path(
         "provider-portal/",
         ProviderPortalHomeView.as_view(),
diff --git a/apps/accounts/views.py b/apps/accounts/views.py
index 481d3351..7c705c92 100644
--- a/apps/accounts/views.py
+++ b/apps/accounts/views.py
@@ -163,20 +163,6 @@ def get(self, *args, **kwargs):
         return HttpResponseRedirect(force_str(self.get_success_url()))
 
 
-class UserUpdateView(UpdateView):
-    """
-    A view for allowing users to edit basic details, and control
-    notification settings
-    """
-
-    model = User
-    form_class = UserUpdateForm
-
-    def get(self, request, *args, **kwargs):
-        """Handle GET requests: instantiate a blank version of the form."""
-        return super().get(request, args, kwargs)
-
-
 class ProviderPortalHomeView(LoginRequiredMixin, ListView):
     """
     Home page of the Provider Portal:
diff --git a/apps/theme/templates/accounts/user_form.html b/apps/theme/templates/accounts/user_form.html
deleted file mode 100644
index 63b86073..00000000
--- a/apps/theme/templates/accounts/user_form.html
+++ /dev/null
@@ -1,30 +0,0 @@
-{% extends "base.html" %}
-
-{% load widget_tweaks %}
-{% load tailwind_filters %}
-{% block content %}
-
-<div class="container mx-auto">
-  <section class="mx-auto max-w-lg bg-white border-2 border-dark-gray rounded-md  h-100-l mt-8 p-8">
-
-  <h2 class="text-xl text-gray-500">Update your profile, <span class="text-gray-900">{{ user.username }}<span></h2>
-
-    <form class="mt-4"
-      action="{% url 'user_edit' user.id %}"
-      method="post">
-      {% csrf_token %}
-      {{ form|crispy }}
-      <button
-        class="bg-green-500 p-4 mt-4 rounded"
-        type="submit">
-        Save changes.
-      </button>
-    </form>
-
-  </section>
-</div>
-
-
-{% endblock %}
-
-

From cbf9d199b8eec9156fc50981ffa43e31afbce751 Mon Sep 17 00:00:00 2001
From: Chris Adams <chris@productscience.co.uk>
Date: Fri, 15 Nov 2024 19:54:23 +0100
Subject: [PATCH 2/3] Remove unused daily stats code

---
 .tool-versions                                |   1 -
 apps/accounts/views.py                        |   3 +-
 apps/greencheck/factories.py                  |   5 -
 .../management/commands/backfill_stats.py     | 103 ---
 apps/greencheck/models/__init__.py            |   1 -
 apps/greencheck/models/stats.py               | 450 -------------
 .../tests/dummy_greencheck_stat_data.py       |  32 -
 .../tests/management/test_backfill_stats.py   | 107 ----
 .../tests/models/test_greencheck_stats.py     | 590 ------------------
 .../greencheck/tests/views/test_stats_view.py | 231 -------
 apps/greencheck/url2green.py                  |  50 --
 apps/greencheck/urls.py                       |   8 +-
 apps/greencheck/views.py                      | 171 +----
 apps/theme/static_src/src/stats-charts.js     |  45 --
 .../templates/greencheck/stats_index.html     | 152 -----
 conftest.py                                   |   1 -
 16 files changed, 3 insertions(+), 1947 deletions(-)
 delete mode 100644 .tool-versions
 delete mode 100644 apps/greencheck/management/commands/backfill_stats.py
 delete mode 100644 apps/greencheck/models/stats.py
 delete mode 100644 apps/greencheck/tests/dummy_greencheck_stat_data.py
 delete mode 100644 apps/greencheck/tests/management/test_backfill_stats.py
 delete mode 100644 apps/greencheck/tests/models/test_greencheck_stats.py
 delete mode 100644 apps/greencheck/tests/views/test_stats_view.py
 delete mode 100644 apps/greencheck/url2green.py
 delete mode 100644 apps/theme/static_src/src/stats-charts.js
 delete mode 100644 apps/theme/templates/greencheck/stats_index.html

diff --git a/.tool-versions b/.tool-versions
deleted file mode 100644
index 8aa451a5..00000000
--- a/.tool-versions
+++ /dev/null
@@ -1 +0,0 @@
-python 3.11.9
diff --git a/apps/accounts/views.py b/apps/accounts/views.py
index 7c705c92..8552f5fd 100644
--- a/apps/accounts/views.py
+++ b/apps/accounts/views.py
@@ -17,7 +17,7 @@
 from django.urls import reverse
 from django.utils.encoding import force_str
 from django.utils.safestring import mark_safe
-from django.views.generic import DetailView, ListView, UpdateView
+from django.views.generic import DetailView, ListView
 from django.views.generic.base import TemplateView
 from django_registration import signals, validators
 from django_registration.backends.activation.views import (
@@ -39,7 +39,6 @@
     OrgDetailsForm,
     PreviewForm,
     ServicesForm,
-    UserUpdateForm,
 )
 from .models import (
     Hostingprovider,
diff --git a/apps/greencheck/factories.py b/apps/greencheck/factories.py
index 63fa8d87..9bace7e7 100644
--- a/apps/greencheck/factories.py
+++ b/apps/greencheck/factories.py
@@ -192,8 +192,3 @@ def _adjust_kwargs(cls, **kwargs):
     class Meta:
         model = GreenDomain
         django_get_or_create = ("url",)
-
-
-class DailyStatFactory(dj_factory.DjangoModelFactory):
-    class Meta:
-        model = gc_models.DailyStat
diff --git a/apps/greencheck/management/commands/backfill_stats.py b/apps/greencheck/management/commands/backfill_stats.py
deleted file mode 100644
index 429f5c79..00000000
--- a/apps/greencheck/management/commands/backfill_stats.py
+++ /dev/null
@@ -1,103 +0,0 @@
-import logging
-
-from dateutil import parser, rrule
-from django.conf import settings
-from django.core.management.base import BaseCommand
-
-from ... import models as gc_models
-
-logger = logging.getLogger(__name__)
-# console = logging.StreamHandler()
-# logger.addHandler(console)
-# logger.setLevel(logging.DEBUG)
-
-
-class StatGenerator:
-    """
-    A wrapper class for generating a range of jobs
-    """
-
-    def _generate_inclusive_date_list(
-        self, start_date: str = None, end_date: str = None
-    ):
-        """
-        Generate a list of dates from two given date strings, inclusive of the
-        dates provided
-        """
-        parsed_start_date = parser.parse(start_date)
-        parsed_end_date = parser.parse(end_date)
-
-        days_between_dates = rrule.rrule(
-            freq=rrule.DAILY, dtstart=parsed_start_date, until=parsed_end_date
-        )
-        return [date for date in days_between_dates]
-
-    def generate_query_jobs_for_date_range(
-        self,
-        start_date_string: str = None,
-        end_date_string: str = None,
-        query_name: str = None,
-    ):
-        """
-        Accept the start date_string, end date_string, and the corresponding query
-        method name on DailyStat to generate the requested stats.
-        """
-
-        inclusive_day_list = self._generate_inclusive_date_list(
-            start_date_string, end_date_string
-        )
-
-        gc_models.DailyStat.clear_counts_for_date_range(
-            inclusive_day_list, query_name=query_name
-        )
-
-        jobs = gc_models.DailyStat.create_jobs_for_date_range_async(
-            inclusive_day_list, query_name=query_name
-        )
-
-        return jobs
-
-
-class Command(BaseCommand):
-
-    sg = StatGenerator()
-
-    help = (
-        "Generate a set of daily stats for the provided date range. "
-        "Accepts an optional query_name"
-    )
-
-    def add_arguments(self, parser):
-        parser.add_argument(
-            "start_date", type=str, help="The inclusive start date for generating stats"
-        )
-        parser.add_argument(
-            "end_date", type=str, help="The inclusive end date for generating stats"
-        )
-        parser.add_argument(
-            "-q",
-            "--query",
-            type=str,
-            help="the chosen query to run against each date in the date range. Defaults to a daily total count of greenchecks",
-        )
-
-    def handle(self, *args, **options):
-        """
-        """
-
-        start_date = options["start_date"]
-        end_date = options["end_date"]
-
-        query_name = options.get("query")
-        if query_name is None:
-            query_name = "total_count"
-
-        self.sg.generate_query_jobs_for_date_range(
-            start_date_string=start_date,
-            end_date_string=end_date,
-            query_name=query_name,
-        )
-
-        self.stdout.write(
-            f"OK. Queued up daily '{query_name}' queries from {start_date} to {end_date}"
-        )
diff --git a/apps/greencheck/models/__init__.py b/apps/greencheck/models/__init__.py
index 1b64a062..8d42ab21 100644
--- a/apps/greencheck/models/__init__.py
+++ b/apps/greencheck/models/__init__.py
@@ -1,2 +1 @@
 from .checks import *  #  noqa
-from .stats import *  #  noqa
diff --git a/apps/greencheck/models/stats.py b/apps/greencheck/models/stats.py
deleted file mode 100644
index e0c682ba..00000000
--- a/apps/greencheck/models/stats.py
+++ /dev/null
@@ -1,450 +0,0 @@
-import datetime
-import logging
-from typing import List
-
-from dateutil import parser as date_parser
-from dateutil.relativedelta import relativedelta
-from django.conf import settings
-from django.db import connection, models
-from django.utils import timezone
-from django.utils.translation import gettext as _
-from django_mysql.models import EnumField
-from model_utils.models import TimeStampedModel
-
-from .. import choices as gc_choices
-from .. import tasks
-from . import checks
-
-logger = logging.getLogger(__name__)
-
-def yesterday():
-    """Return the the day before today.
-    Used as default value for date fields.
-    """
-    now = timezone.now()
-    return now - relativedelta(days=1)
-
-
-class Stats(models.Model):
-    checked_through = EnumField(choices=gc_choices.CheckedOptions.choices)
-    count = models.IntegerField()
-    ips = models.IntegerField()
-
-    class Meta:
-        abstract = True
-
-
-class DailyStatQuerySet(models.QuerySet):
-    """
-    Table level queries for DailyStats
-    """
-
-    def daily_stats(self):
-        return self.filter(stat_key=gc_choices.DailyStatChoices.DAILY_TOTAL)
-
-    def daily_stats_for_provider(self, provider_id: int = None):
-        """
-        Return all the daily counts for a given provider
-        """
-        daily_total = gc_choices.DailyStatChoices.DAILY_TOTAL
-
-        # exit early if no provider
-        if not provider_id:
-            domain_key = f"{daily_total}:provider"
-            return self.filter(stat_key__icontains=domain_key)
-
-        # otherwise be more
-        provider_key = f"{daily_total}:provider:{provider_id}"
-        return self.filter(stat_key=provider_key)
-
-    def daily_stats_for_domain(self, domain: str = None):
-        """
-        Return all the daily counts for a given domain
-        """
-
-        # validate domain
-
-        daily_total = gc_choices.DailyStatChoices.DAILY_TOTAL
-
-        # return early if we're not filtering to specific domain
-        if not domain:
-            domain_key = f"{daily_total}:domain"
-            return self.filter(stat_key__icontains=domain_key)
-
-        # otherwise use the domain too
-        domain_key = f"{daily_total}:domain:{domain}"
-        return self.filter(stat_key=domain_key)
-
-
-class DailyStat(TimeStampedModel):
-    """
-    Represents the counts of checks for each day
-    """
-
-    objects = DailyStatQuerySet.as_manager()
-
-    stat_date = models.DateField(
-        _("Date for stats"), auto_now=False, auto_now_add=False, default=yesterday
-    )
-    # we add this key
-    stat_key = models.CharField(_(""), max_length=256)
-    count = models.IntegerField()
-    green = EnumField(choices=gc_choices.GreenStatChoice.choices, blank=True, null=True)
-
-    @classmethod
-    def create_counts_for_date_range(cls, date_range, query):
-        """
-        Accept an iterable of dates, and generate a daily stat
-        for every date in the iterable, by running through them one
-        at a time in a loop, using the provided query.
-        """
-        stats = []
-
-        for date in date_range:
-            stat_generation_function = getattr(cls, query)
-            stat = stat_generation_function(date)
-            stats.append(stat)
-
-        return stats
-
-    @classmethod
-    def create_jobs_for_date_range_async(
-        cls, date_range: List[datetime.datetime], query_name=None
-    ):
-        """
-        Accept an iterable of dates, and add a job for a worker to pick up
-        to create daily stat for every date in the iterable, running the
-        named query.
-        """
-
-        deferred_stats = []
-
-        for stat_datetime in date_range:
-
-            # We default to running these on a separate queue, but
-            # if we use the "default" queue, they'll be picked up by
-            # regular workers too
-            res = tasks.create_stat_async.send_with_options(
-                queue=settings.DRAMATIQ_EXTRA_QUEUES.get("stats", "stats"),
-                kwargs={
-                    "date_string": str(stat_datetime.date()),
-                    "query_name": query_name,
-                },
-            )
-            deferred_stats.append(res)
-
-        logger.debug(deferred_stats)
-        return deferred_stats
-
-    # Factories
-    @classmethod
-    def total_count(cls, date_to_check: datetime.datetime = None):
-        """
-        Create a total count for the given day
-        """
-
-        logger.info(f"Generating stats for {date_to_check.date()}, with 'total_count'")
-
-        one_day_ahead = date_to_check + relativedelta(days=1)
-
-        # return all the checks for the day
-        qs = checks.Greencheck.objects.filter(
-            date__gt=date_to_check.date(), date__lt=one_day_ahead.date()
-        )
-        # return just the green ones
-        green_qs = checks.Greencheck.objects.filter(
-            date__gt=date_to_check.date(),
-            date__lt=one_day_ahead.date(),
-            green=gc_choices.BoolChoice.YES,
-        )
-        # return just the grey ones
-        grey_qs = checks.Greencheck.objects.filter(
-            date__gt=date_to_check.date(),
-            date__lt=one_day_ahead.date(),
-            green=gc_choices.BoolChoice.NO,
-        )
-
-        logger.debug(f"date to check: {date_to_check}, qs count: {qs.count()}")
-        logger.debug(str(qs.query))
-
-        logger.debug(
-            f"date to check: {date_to_check}, green qs count: {grey_qs.count()}"
-        )
-        logger.debug(str(grey_qs.query))
-        logger.debug(
-            f"date to check: {date_to_check}, grey qs count: {green_qs.count()}"
-        )
-        logger.debug(str(green_qs.query))
-
-        # clear out older examples
-        cls.objects.filter(
-            stat_key=gc_choices.DailyStatChoices.DAILY_TOTAL,
-            stat_date=date_to_check.date(),
-        ).delete()
-
-        # persist new versions to db
-        mixed_stat = cls.objects.create(
-            count=qs.count(),
-            stat_date=date_to_check.date(),
-            stat_key=gc_choices.DailyStatChoices.DAILY_TOTAL,
-        )
-        green_stat = cls.objects.create(
-            count=green_qs.count(),
-            stat_date=date_to_check.date(),
-            stat_key=gc_choices.DailyStatChoices.DAILY_TOTAL,
-            green=gc_choices.BoolChoice.YES,
-        )
-        grey_stat = cls.objects.create(
-            count=grey_qs.count(),
-            stat_date=date_to_check.date(),
-            stat_key=gc_choices.DailyStatChoices.DAILY_TOTAL,
-            green=gc_choices.BoolChoice.NO,
-        )
-
-        logger.info(f"Saved stats: {mixed_stat}, {green_stat}, {grey_stat}")
-
-        return [mixed_stat, green_stat, grey_stat]
-
-    @classmethod
-    def total_count_for_provider(
-        cls, date_to_check: datetime.datetime = None, provider_id: int = None
-    ):
-        """
-        Create a total count for given day for the provider.
-        """
-        one_day_ahead = date_to_check + relativedelta(days=1)
-
-        qs = checks.Greencheck.objects.filter(
-            date__gt=date_to_check.date(),
-            date__lt=one_day_ahead.date(),
-            hostingprovider=provider_id,
-        )
-
-        green_qs = checks.Greencheck.objects.filter(
-            date__gt=date_to_check.date(),
-            date__lt=one_day_ahead.date(),
-            hostingprovider=provider_id,
-            green=gc_choices.BoolChoice.YES,
-        )
-        grey_qs = checks.Greencheck.objects.filter(
-            date__gt=date_to_check.date(),
-            date__lt=one_day_ahead.date(),
-            hostingprovider=provider_id,
-            green=gc_choices.BoolChoice.NO,
-        )
-
-        # clear out any earlier duplicate results
-        cls.objects.filter(
-            stat_date=date_to_check.date(),
-            stat_key=f"{gc_choices.DailyStatChoices.DAILY_TOTAL}:provider:{provider_id}",
-        ).delete()
-
-        # persist to db
-        stat = cls.objects.create(
-            count=qs.count(),
-            stat_date=date_to_check.date(),
-            stat_key=f"{gc_choices.DailyStatChoices.DAILY_TOTAL}:provider:{provider_id}",
-        )
-
-        green_stat = cls.objects.create(
-            count=green_qs.count(),
-            stat_date=date_to_check.date(),
-            green=gc_choices.BoolChoice.YES,
-            stat_key=f"{gc_choices.DailyStatChoices.DAILY_TOTAL}:provider:{provider_id}",
-        )
-        grey_stat = cls.objects.create(
-            count=grey_qs.count(),
-            stat_date=date_to_check.date(),
-            stat_key=f"{gc_choices.DailyStatChoices.DAILY_TOTAL}:provider:{provider_id}",
-            green=gc_choices.BoolChoice.NO,
-        )
-
-        return [stat, green_stat, grey_stat]
-
-    @classmethod
-    def top_domains_for_day(
-        cls,
-        date_to_check: datetime.datetime = None,
-        green: str = gc_choices.GreenStatChoice.YES,
-    ):
-        """
-        Create a top N listing of domains grouped by count, and ordered
-        by number of checks, for the dates given.
-        We drop down to raw SQL to generate this, because the greencheck
-        table is some integrity issues that prevent us from using
-        foreign keys.
-        """
-        from .checks import Greencheck
-
-        greencheck_table = Greencheck._meta.db_table
-
-        chosen_date = date_to_check.date()
-
-        logger.info(f"provided chosen date: {chosen_date}")
-
-        date_start, date_end = cls._single_day_date_range(chosen_date=str(chosen_date))
-
-        logger.info(f"sending these dates: {date_start}, {date_end}")
-
-        results = []
-        with connection.cursor() as cursor:
-            # passing in greencheck table to execute below, escapes the
-            # table name, making mysql crash, so we need to add it like so.
-            # it isn't user input anyway, so it should be safe to do so.
-            raw_query = (
-                "SELECT url , count(id) AS popularity "
-                f"FROM {greencheck_table} "
-                "WHERE datum BETWEEN %s AND %s "
-                "AND green = %s "
-                "GROUP BY url "
-                "ORDER BY popularity DESC "
-                "LIMIT 20"
-            )
-            logger.info(raw_query)
-            cursor.execute(raw_query, [date_start, date_end, green])
-
-            results = cursor.fetchall()
-        logger.info("results: {results}")
-
-        for res in results:
-            domain, count = res
-            daily_total = gc_choices.DailyStatChoices.DAILY_TOTAL
-            domain_key = f"{daily_total}:domain:{domain}"
-
-            # if we have any matching results, we want to delete them
-            cls.objects.filter(
-                green=green, stat_key=domain_key, stat_date=str(chosen_date),
-            ).delete()
-
-            # save our results as DailyStats
-            cls.objects.create(
-                count=count,
-                green=green,
-                stat_key=domain_key,
-                stat_date=str(chosen_date),
-            )
-
-        return results
-
-    @classmethod
-    def top_hosting_providers_for_day(
-        cls,
-        date_to_check: datetime.datetime = None,
-        green: str = gc_choices.GreenStatChoice.YES,
-    ):
-        """
-        Create a top N listing of hosting providers grouped by count, and ordered
-        by number of checks, for the dates given.
-        We drop down to raw SQL to generate this, because the greencheck
-        table has some integrity issues that prevent us from using
-        foreign keys.
-        """
-        from .checks import Greencheck
-
-        greencheck_table = Greencheck._meta.db_table
-
-        chosen_date = date_to_check.date()
-        logger.info(f"provided chosen date: {chosen_date}")
-
-        date_start, date_end = cls._single_day_date_range(chosen_date=str(chosen_date))
-
-        logger.info(f"sending these dates: {date_start}, {date_end}")
-
-        results = []
-        with connection.cursor() as cursor:
-            # passing in greencheck table to execute below, escapes the
-            # table name, making mysql crash, so we need to add it like so
-            raw_query = (
-                "SELECT id_hp , count(id) AS popularity "
-                f"FROM {greencheck_table} "
-                "WHERE datum BETWEEN %s AND %s "
-                "AND green = %s "
-                "GROUP BY id_hp "
-                "ORDER BY popularity DESC "
-                "LIMIT 20 "
-            )
-            cursor.execute(raw_query, [date_start, date_end, green])
-            results = cursor.fetchall()
-
-        for res in results:
-            hosting_provider_id, count = res
-            daily_total = gc_choices.DailyStatChoices.DAILY_TOTAL
-            provider_key = f"{daily_total}:provider:{hosting_provider_id}"
-
-            # if we have any matching results, we want to delete any dupes
-            DailyStat.objects.filter(
-                green=green, stat_key=provider_key, stat_date=str(chosen_date),
-            ).delete()
-
-            # save our results as DailyStats
-            DailyStat.objects.create(
-                count=count,
-                green=green,
-                stat_key=provider_key,
-                stat_date=str(chosen_date),
-            )
-        return results
-
-    @classmethod
-    def _single_day_date_range(cls, chosen_date: str = None):
-        """
-        Accept a datestring, and return start and end datestrings
-        suitable for using in day calculations
-        """
-        logger.info(f"chosen date: {chosen_date}")
-        if chosen_date is None:
-            chosen_date = str(timezone.now().date())
-
-        following_day = date_parser.parse(chosen_date) + relativedelta(days=1)
-
-        return [chosen_date, str(following_day.date())]
-
-    # Mutators
-    @classmethod
-    def clear_counts_for_date_range(
-        cls, date_range: List[datetime.datetime] = None, query_name: str = None
-    ):
-        """
-        Accept an iterable of dates, and query_name, then delete all the Daily stats
-        matching this combination of dates and query.
-
-        Used to clear out duplicates, before generating new stats.
-        """
-
-        date_strings = [str(stat_datetime.date()) for stat_datetime in date_range]
-        cls.objects.filter(stat_key=query_name, stat_date__in=date_strings).delete()
-
-    # Queries
-    @classmethod
-    def stats_by_day_since(cls, start_date=None):
-        """
-        """
-        return (
-            cls.objects.daily_stats()
-            .filter(stat_date__gte=start_date, green__in=["yes", "no"])
-            .order_by("-stat_date")
-        )
-
-    @classmethod
-    def stats_by_day_(cls, start_date=None):
-        return (
-            cls.objects.daily_stats()
-            .filter(stat_date__gte=start_date, green__in=["yes", "no"])
-            .order_by("-stat_date")
-        )
-
-    # Properties
-
-    def __str__(self):
-        title = f"{self.stat_key}-{self.stat_date}"
-
-        if self.green == gc_choices.BoolChoice.YES:
-            return f"{title}-green"
-        elif self.green == gc_choices.BoolChoice.NO:
-            return f"{title}-grey"
-        return title
-
-    class Meta:
-        indexes = [
-            models.Index(fields=["stat_date", "stat_key"]),
-        ]
diff --git a/apps/greencheck/tests/dummy_greencheck_stat_data.py b/apps/greencheck/tests/dummy_greencheck_stat_data.py
deleted file mode 100644
index 218e0cfb..00000000
--- a/apps/greencheck/tests/dummy_greencheck_stat_data.py
+++ /dev/null
@@ -1,32 +0,0 @@
-# select id_hp, checks from greencheck_2021 WHERE datum > "2021-05-01" AND green = 'yes' GROUP BY id_hp ORDER BY 2 DESC LIMIT 10;
-# +-------+-----------+
-# | id_hp | checks |
-# +-------+-----------+
-# | 595   | 5343854   |
-# | 779   | 1511123   |
-# | 793   | 827239    |
-# | 475   | 658133    |
-# | 698   | 341040    |
-# | 131   | 183759    |
-# | 697   | 158123    |
-# | 696   | 68853     |
-# | 564   | 55754     |
-# | 821   | 33126     |
-# +-------+-----------+
-
-
-# select url , count(id) as popularity from greencheck_2021 WHERE datum > "2021-05-01" AND green = 'yes' GROUP BY url ORDER BY popularity DESC LIMIT 10;
-# +-------------------+------------+
-# | url               | popularity |
-# +-------------------+------------+
-# | www.youtube.com   | 1062410    |
-# | www.google.com    | 622153     |
-# | i.ytimg.com       | 224544     |
-# | play.google.com   | 202459     |
-# | www.facebook.com  | 202263     |
-# | www.google.fr     | 186672     |
-# | www.gstatic.com   | 167688     |
-# | docs.google.com   | 137244     |
-# | ssl.gstatic.com   | 133650     |
-# | fonts.gstatic.com | 122881     |
-# +-------------------+------------+
diff --git a/apps/greencheck/tests/management/test_backfill_stats.py b/apps/greencheck/tests/management/test_backfill_stats.py
deleted file mode 100644
index 51a3c31e..00000000
--- a/apps/greencheck/tests/management/test_backfill_stats.py
+++ /dev/null
@@ -1,107 +0,0 @@
-import logging
-import pytest
-import io
-from django.core import management
-
-from ... import models as gc_models
-from ... import choices as gc_choices
-from ... import factories as gc_factories
-from ... import tasks as gc_tasks
-from ...management.commands import backfill_stats
-
-
-logger = logging.getLogger(__name__)
-console = logging.StreamHandler()
-# logger.setLevel(logging.DEBUG)
-# logger.addHandler(console)
-
-FIRST_OF_JAN = "2020-01-01"
-END_OF_JAN = "2020-01-31"
-
-
-class TestStatManagement:
-    @pytest.mark.parametrize(
-        "start_date, end_date, no_of_days",
-        [(FIRST_OF_JAN, END_OF_JAN, 31), (FIRST_OF_JAN, FIRST_OF_JAN, 1)],
-    )
-    def test_backfill_generate_dates(self, start_date, end_date, no_of_days):
-        """
-        Check that we can backfill our stats from our management commands.
-        """
-
-        sg = backfill_stats.StatGenerator()
-
-        dates = sg._generate_inclusive_date_list(start_date, end_date)
-
-        assert len(dates) == no_of_days
-
-    def test_backfill_generate_jobs(self, db):
-        """
-        Check that we generate the expected jobs to be
-        finished by a worker
-        """
-
-        sg = backfill_stats.StatGenerator()
-
-        jobs = sg.generate_query_jobs_for_date_range(
-            start_date_string=FIRST_OF_JAN,
-            end_date_string=END_OF_JAN,
-            query_name="daily_total",
-        )
-
-        assert len(jobs) == 31
-
-    def test_backfill_top_domains(self, db):
-        """
-        Test that we can generate the jobs to be picked up
-        by workers.
-        """
-
-        sg = backfill_stats.StatGenerator()
-
-        jobs = sg.generate_query_jobs_for_date_range(
-            start_date_string=FIRST_OF_JAN,
-            end_date_string=FIRST_OF_JAN,
-            query_name="total_count_for_domains",
-        )
-
-        assert len(jobs) == 1
-
-    def test_calling_command(self, db):
-        out = io.StringIO()
-        management.call_command(
-            "backfill_stats", FIRST_OF_JAN, FIRST_OF_JAN, stdout=out
-        )
-
-        assert (
-            f"Queued up daily 'total_count' queries from {FIRST_OF_JAN} to {FIRST_OF_JAN}"
-            in out.getvalue()
-        )
-
-    def test_calling_command_for_providers(self, db):
-        out = io.StringIO()
-        management.call_command(
-            "backfill_stats",
-            FIRST_OF_JAN,
-            FIRST_OF_JAN,
-            "--query",
-            "total_count_for_providers",
-            stdout=out,
-        )
-
-        assert "OK" in out.getvalue()
-
-    def test_calling_command_for_domains(self, db):
-        """
-        Test that we can generate the rankings for top doamains for the given days
-        """
-        out = io.StringIO()
-        management.call_command(
-            "backfill_stats",
-            FIRST_OF_JAN,
-            FIRST_OF_JAN,
-            "--query",
-            "total_count_for_domains",
-            stdout=out,
-        )
-
diff --git a/apps/greencheck/tests/models/test_greencheck_stats.py b/apps/greencheck/tests/models/test_greencheck_stats.py
deleted file mode 100644
index 5b8a7504..00000000
--- a/apps/greencheck/tests/models/test_greencheck_stats.py
+++ /dev/null
@@ -1,590 +0,0 @@
-import datetime
-import io
-import logging
-from typing import List
-from unittest import mock
-
-import dramatiq
-import faker
-import pytest
-from dateutil import rrule
-from dateutil.relativedelta import relativedelta
-from django import urls
-from django.core import management
-from django.utils import timezone
-from dramatiq.brokers import stub
-
-from ....accounts import models as ac_models
-from ... import choices as gc_choices
-from ... import factories as gc_factories
-from ... import models as gc_models
-from ... import tasks as gc_tasks
-from ...management.commands import backfill_stats
-
-logger = logging.getLogger(__name__)
-console = logging.StreamHandler()
-# logger.setLevel(logging.DEBUG)
-# logger.addHandler(console)
-
-fake = faker.Faker()
-
-
-class TestGreencheckStatsDaily:
-    @pytest.mark.skip(reason="Not in use - will be refactored")
-    @pytest.mark.parametrize(
-        "date_to_check, expected_count",
-        [
-            (timezone.now() - relativedelta(days=1), 1),
-            (timezone.now() - relativedelta(days=2), 0),
-            (timezone.now() - relativedelta(days=0), 0),
-        ],
-    )
-    def test_count_daily_checks(
-        self,
-        db,
-        hosting_provider_with_sample_user: ac_models.Hostingprovider,
-        green_ip: gc_models.GreencheckIp,
-        client,
-        date_to_check,
-        expected_count,
-    ):
-        """
-        Do we run a count of all the checks for the last day?
-        """
-        two_am_yesterday = timezone.now() + relativedelta(hours=2, days=-1)
-
-        gc = gc_factories.GreencheckFactory.create(date=two_am_yesterday)
-        logger.info(f"logger date: {gc.date}")
-
-        stat, green_stat, grey_stat = gc_models.DailyStat.total_count(
-            date_to_check=date_to_check
-        )
-
-        assert stat.count == expected_count
-
-    @pytest.mark.skip(reason="Not in use - will be refactored")
-    @pytest.mark.parametrize(
-        "date_to_check, expected_count",
-        [
-            (timezone.now() - relativedelta(days=1), 1),
-            (timezone.now() - relativedelta(days=2), 0),
-            (timezone.now() - relativedelta(days=0), 0),
-        ],
-    )
-    def test_count_daily_checks_is_idempotent(
-        self,
-        db,
-        hosting_provider_with_sample_user: ac_models.Hostingprovider,
-        green_ip: gc_models.GreencheckIp,
-        client,
-        date_to_check,
-        expected_count,
-    ):
-        """
-        Do we run a count of all the checks for the last day?
-        """
-        two_am_yesterday = timezone.now() + relativedelta(hours=2, days=-1)
-
-        gc = gc_factories.GreencheckFactory.create(date=two_am_yesterday)
-        logger.info(f"logger date: {gc.date}")
-
-        stat, green_stat, grey_stat = gc_models.DailyStat.total_count(
-            date_to_check=date_to_check
-        )
-        stat, green_stat, grey_stat = gc_models.DailyStat.total_count(
-            date_to_check=date_to_check
-        )
-
-        assert stat.count == expected_count
-
-    @pytest.mark.skip(reason="Not in use - will be refactored")
-    @pytest.mark.parametrize(
-        "date_to_check, expected_count",
-        [
-            (timezone.now() - relativedelta(days=1), 1),
-            (timezone.now() - relativedelta(days=2), 0),
-            (timezone.now() - relativedelta(days=0), 0),
-        ],
-    )
-    def test_count_daily_by_provider(
-        self,
-        db,
-        hosting_provider_with_sample_user: ac_models.Hostingprovider,
-        green_ip: gc_models.GreencheckIp,
-        client,
-        date_to_check,
-        expected_count,
-    ):
-        """
-        Do we run a count of all the checks for the last day?
-        """
-        two_am_yesterday = timezone.now() + relativedelta(hours=2, days=-1)
-
-        gc = gc_factories.GreencheckFactory.create(
-            date=two_am_yesterday, hostingprovider=hosting_provider_with_sample_user.id
-        )
-
-        logger.info(f"logger date: {gc.date}")
-
-        stat, green_stat, grey_stat = gc_models.DailyStat.total_count_for_provider(
-            date_to_check=date_to_check,
-            provider_id=hosting_provider_with_sample_user.id,
-        )
-        assert stat.count == expected_count
-        assert grey_stat.count == expected_count
-        assert green_stat.count == 0
-
-    @pytest.mark.skip(reason="Not in use - will be refactored")
-    @pytest.mark.parametrize(
-        "date_to_check, expected_count",
-        [
-            (timezone.now() - relativedelta(days=1), 1),
-            (timezone.now() - relativedelta(days=2), 0),
-            (timezone.now() - relativedelta(days=0), 0),
-        ],
-    )
-    def test_count_daily_by_provider_is_idempotent(
-        self,
-        db,
-        hosting_provider_with_sample_user: ac_models.Hostingprovider,
-        green_ip: gc_models.GreencheckIp,
-        client,
-        date_to_check,
-        expected_count,
-    ):
-        """
-        Do we run a count of all the checks for the last day?
-        """
-        two_am_yesterday = timezone.now() + relativedelta(hours=2, days=-1)
-
-        gc = gc_factories.GreencheckFactory.create(
-            date=two_am_yesterday, hostingprovider=hosting_provider_with_sample_user.id
-        )
-
-        logger.info(f"logger date: {gc.date}")
-
-        gc_models.DailyStat.total_count_for_provider(
-            date_to_check=date_to_check,
-            provider_id=hosting_provider_with_sample_user.id,
-        )
-        stat, green_stat, grey_stat = gc_models.DailyStat.total_count_for_provider(
-            date_to_check=date_to_check,
-            provider_id=hosting_provider_with_sample_user.id,
-        )
-        assert stat.count == expected_count
-        assert grey_stat.count == expected_count
-        assert green_stat.count == 0
-
-    @pytest.mark.skip(reason="Not in use - will be refactored")
-    def test_count_daily_by_provider_green(
-        self,
-        db,
-        hosting_provider_with_sample_user: ac_models.Hostingprovider,
-        green_ip: gc_models.GreencheckIp,
-    ):
-        """
-        We should see greem checks
-        """
-        two_am_yesterday = timezone.now() + relativedelta(hours=2, days=-1)
-        date_to_check = timezone.now() - relativedelta(days=1)
-
-        green_gc = gc_factories.GreencheckFactory.create(
-            date=two_am_yesterday,
-            hostingprovider=hosting_provider_with_sample_user.id,
-            greencheck_ip=green_ip.id,
-            ip=green_ip.ip_end,
-            green=gc_choices.BoolChoice.YES,
-        )
-        stat, green_stat, grey_stat = gc_models.DailyStat.total_count_for_provider(
-            date_to_check=date_to_check,
-            provider_id=hosting_provider_with_sample_user.id,
-        )
-
-        assert stat.count == 1
-        assert green_stat.count == 1
-        assert grey_stat.count == 0
-
-    # this test flickers, most likely because of our use of
-    # fake and factories. See this issue here for discussion
-    # and fixes
-    # https://github.com/thegreenwebfoundation/admin-portal/issues/163
-    @pytest.mark.flaky
-    @pytest.mark.skip(reason="Not in use - will be refactored")
-    @pytest.mark.skip(reason="an intermittent flaky test")
-    def test_create_top_domains_by_date(
-        self,
-        db,
-        hosting_provider_with_sample_user: ac_models.Hostingprovider,
-        green_ip: gc_models.GreencheckIp,
-    ):
-        """
-        Check that we can create the rankings of domains we want, from a
-        set of greenchecks on a given day
-        """
-        two_am_yesterday = timezone.now() + relativedelta(hours=2, days=-1)
-        date_to_check = timezone.now() - relativedelta(days=1)
-        domains_to_check = []
-
-        for x in range(10):
-            fake_domain = fake.domain_name()
-            domains_to_check.append(fake_domain)
-            no_of_checks = int(fake.numerify())
-
-            for y in range(no_of_checks):
-                gc_factories.GreencheckFactory.create(
-                    url=fake_domain,
-                    date=two_am_yesterday,
-                    hostingprovider=hosting_provider_with_sample_user.id,
-                    greencheck_ip=green_ip.id,
-                    ip=green_ip.ip_end,
-                    green=gc_choices.BoolChoice.YES,
-                )
-
-        res = gc_models.DailyStat.top_domains_for_day(date_to_check=date_to_check)
-
-        assert len(res) == 10
-
-        assert gc_models.DailyStat.objects.count() == 10
-        stat_keys = [
-            stat.stat_key.replace("total_daily_checks:domain:", "")
-            for stat in gc_models.DailyStat.objects.all()
-        ]
-
-        for dom in domains_to_check:
-            assert dom in stat_keys
-
-    @pytest.mark.skip(reason="Not in use - will be refactored")
-    def test_create_top_domains_by_date_is_idempotent(
-        self,
-        db,
-        hosting_provider_with_sample_user: ac_models.Hostingprovider,
-        green_ip: gc_models.GreencheckIp,
-    ):
-        """
-        Check running our generation commands is idempotent, and that we don't make duplicate stats for a given day.
-        """
-        two_am_yesterday = timezone.now() + relativedelta(hours=2, days=-1)
-        date_to_check = timezone.now() - relativedelta(days=1)
-        domains_to_check = []
-
-        for x in range(10):
-            fake_domain = fake.domain_name()
-            domains_to_check.append(fake_domain)
-            no_of_checks = int(fake.numerify())
-
-            for y in range(no_of_checks):
-                gc_factories.GreencheckFactory.create(
-                    url=fake_domain,
-                    date=two_am_yesterday,
-                    hostingprovider=hosting_provider_with_sample_user.id,
-                    greencheck_ip=green_ip.id,
-                    ip=green_ip.ip_end,
-                    green=gc_choices.BoolChoice.YES,
-                )
-
-        res = gc_models.DailyStat.top_domains_for_day(date_to_check=date_to_check)
-        res = gc_models.DailyStat.top_domains_for_day(date_to_check=date_to_check)
-
-        assert len(res) == 10
-
-        assert gc_models.DailyStat.objects.count() == 10
-        stat_keys = [
-            stat.stat_key.replace("total_daily_checks:domain:", "")
-            for stat in gc_models.DailyStat.objects.all()
-        ]
-
-        for dom in domains_to_check:
-            assert dom in stat_keys
-
-    @pytest.mark.skip(reason="Flaky test")
-    def test_create_top_providers_by_date(
-        self,
-        db,
-    ):
-        """
-        Check that we can create the rankings of providers we want, from a
-        set of greenchecks on a given day
-        """
-
-        two_am_yesterday = timezone.now() + relativedelta(hours=2, days=-1)
-        date_to_check = timezone.now() - relativedelta(days=1)
-        providers = []
-
-        # we need a factory for creating a hosting provider, and then a factory
-        # for the corresponding user
-
-        for x in range(10):
-            provider = gc_factories.HostingProviderFactory()
-            green_ip = gc_factories.GreenIpFactory(hostingprovider=provider)
-
-            fake_domain = fake.domain_name()
-            providers.append(provider)
-            no_of_checks = int(fake.numerify())
-
-            for y in range(no_of_checks):
-                gc_factories.GreencheckFactory.create(
-                    url=fake_domain,
-                    date=two_am_yesterday,
-                    hostingprovider=provider.id,
-                    greencheck_ip=green_ip.id,
-                    ip=green_ip.ip_end,
-                    green=gc_choices.BoolChoice.YES,
-                )
-
-        res = gc_models.DailyStat.top_hosting_providers_for_day(
-            date_to_check=date_to_check
-        )
-
-        assert len(res) == 10
-
-        assert gc_models.DailyStat.objects.count() == 10
-        stat_keys = [
-            stat.stat_key.replace("total_daily_checks:provider:", "")
-            for stat in gc_models.DailyStat.objects.all()
-        ]
-
-        for provider_id in [provider.id for provider in providers]:
-            # we need to coerce so we are checking strings against strings,
-            # not 1234 against '1234'
-            assert str(provider_id) in stat_keys
-
-    @pytest.mark.skip(reason="Not in use - will be refactored")
-    def test_create_top_providers_by_date_is_idempotent(
-        self,
-        db,
-    ):
-        """
-        Check that we can create the rankings of providers we want, from a
-        set of greenchecks on a given day
-        """
-
-        two_am_yesterday = timezone.now() + relativedelta(hours=2, days=-1)
-        date_to_check = timezone.now() - relativedelta(days=1)
-        providers = []
-
-        # we need a factory for creating a hosting provider, and then a factory
-        # for the corresponding user
-
-        for x in range(10):
-            provider = gc_factories.HostingProviderFactory()
-            green_ip = gc_factories.GreenIpFactory(hostingprovider=provider)
-
-            fake_domain = fake.domain_name()
-            providers.append(provider)
-            no_of_checks = int(fake.numerify())
-
-            for y in range(no_of_checks):
-                gc_factories.GreencheckFactory.create(
-                    url=fake_domain,
-                    date=two_am_yesterday,
-                    hostingprovider=provider.id,
-                    greencheck_ip=green_ip.id,
-                    ip=green_ip.ip_end,
-                    green=gc_choices.BoolChoice.YES,
-                )
-
-        gc_models.DailyStat.top_hosting_providers_for_day(date_to_check=date_to_check)
-
-        res = gc_models.DailyStat.top_hosting_providers_for_day(
-            date_to_check=date_to_check
-        )
-
-        assert len(res) == 10
-
-        assert gc_models.DailyStat.objects.count() == 10
-        stat_keys = [
-            stat.stat_key.replace("total_daily_checks:provider:", "")
-            for stat in gc_models.DailyStat.objects.all()
-        ]
-
-        for provider_id in [provider.id for provider in providers]:
-            # we need to coerce so we are checking strings against strings,
-            # not 1234 against '1234'
-            assert str(provider_id) in stat_keys
-
-
-class TestDailyStatQuerySet:
-    """
-    Tests that the queries we run
-    """
-
-
-class TestGreencheckStatsGeneration:
-    def _set_up_dates_for_last_week(self):
-
-        # set up our date range
-        seven_days_ago = timezone.now() - relativedelta(days=7)
-        yesterday = timezone.now() - relativedelta(days=1)
-
-        last_seven_days = rrule.rrule(
-            freq=rrule.DAILY, dtstart=seven_days_ago.date(), until=yesterday.date()
-        )
-        return [date for date in last_seven_days]
-
-    def test_create_range_for_stats(
-        self,
-        db,
-        hosting_provider_with_sample_user: ac_models.Hostingprovider,
-        green_ip: gc_models.GreencheckIp,
-        client,
-    ):
-        """
-        Create a collection of daily stats, for a range of dates provided
-        """
-
-        generated_dates = self._set_up_dates_for_last_week()
-        generated_stats = gc_models.DailyStat.create_counts_for_date_range(
-            generated_dates, "total_count"
-        )
-        assert len(generated_stats) == len(generated_dates)
-
-    def test_clear_range_for_stats(
-        self,
-        db,
-        hosting_provider_with_sample_user: ac_models.Hostingprovider,
-        green_ip: gc_models.GreencheckIp,
-        client,
-    ):
-        """
-        Create a collection of daily stats, for a range of dates provided
-        """
-
-        generated_dates = self._set_up_dates_for_last_week()
-        generated_stats = gc_models.DailyStat.create_counts_for_date_range(
-            generated_dates, "total_count"
-        )
-
-        # do we have the stats generated?
-        assert len(generated_stats) == len(generated_dates)
-
-        # flatten our nested list of stats
-        import functools
-
-        daily_stats = functools.reduce(lambda x, y: x + y, generated_stats, [])
-        daily_stats_query = [stat for stat in gc_models.DailyStat.objects.all()]
-
-        assert daily_stats == daily_stats_query
-
-        gc_models.DailyStat.clear_counts_for_date_range(
-            generated_dates, query_name="total_daily_checks"
-        )
-
-        assert gc_models.DailyStat.objects.all().count() == 0
-
-    @pytest.mark.flaky
-    def test_create_range_for_stats_async(
-        self,
-        transactional_db,
-        broker: stub.StubBroker,
-        worker: dramatiq.Worker,
-        hosting_provider_with_sample_user: ac_models.Hostingprovider,
-        green_ip: gc_models.GreencheckIp,
-        client,
-    ):
-        """
-        Create a collection of daily stats, for a range of dates provided.
-
-        """
-        broker.declare_queue("default")
-        generated_dates = self._set_up_dates_for_last_week()
-
-        for date in generated_dates:
-            gc = gc_factories.GreencheckFactory.create(
-                date=date + relativedelta(hours=2)
-            )
-            # logger.info(f"gc {date}: {gc.__dict__}")
-
-        logger.info(f"just this date: { generated_dates[0] }")
-
-        gc_models.DailyStat.create_jobs_for_date_range_async(
-            generated_dates, "total_count"
-        )
-
-        # Wait for all the tasks to be processed
-        broker.join("default")
-        worker.join()
-
-        green_stats = gc_models.DailyStat.objects.filter(
-            green=gc_choices.BoolChoice.YES
-        )
-        grey_stats = gc_models.DailyStat.objects.filter(green=gc_choices.BoolChoice.NO)
-        mixed_stats = gc_models.DailyStat.objects.exclude(
-            green__in=[gc_choices.BoolChoice.YES, gc_choices.BoolChoice.NO]
-        )
-
-        # have we generated the expected stats per day?
-        assert green_stats.count() == 7
-        assert grey_stats.count() == 7
-        assert mixed_stats.count() == 7
-
-        # we should one count showing zero green checks for each day
-        assert [stat.count for stat in green_stats] == [0, 0, 0, 0, 0, 0, 0]
-
-        # mixed and grey should be the same
-        assert [stat.count for stat in grey_stats] == [1, 1, 1, 1, 1, 1, 1]
-        assert [stat.count for stat in grey_stats] == [1, 1, 1, 1, 1, 1, 1]
-
-    @pytest.mark.flaky
-    def test_create_stat_async(
-        self,
-        transactional_db,
-        broker: stub.StubBroker,
-        worker: dramatiq.Worker,
-        hosting_provider_with_sample_user: ac_models.Hostingprovider,
-        green_ip: gc_models.GreencheckIp,
-        client,
-    ):
-        """
-        Create a collection of daily stats, for a range of dates provided,
-        but have a worker create the stats asynchronously.
-        """
-
-        # make sure we have our queues set up
-        broker.declare_queue("default")
-        broker.declare_queue("stats")
-
-        assert gc_models.DailyStat.objects.count() == 0
-
-        # set up our date range
-        generated_dates = self._set_up_dates_for_last_week()
-
-        # create our greenchecks to build an aggregate view of
-        for date in generated_dates:
-            gc_factories.GreencheckFactory.create(date=date + relativedelta(hours=2))
-
-        chosen_date = str(generated_dates[0].date())
-
-        # we use the 'send' with the 'transactional_db' fixture here instead of db
-        # because if we use the regular db fixture, the workers can not see what is
-        # happening 'inside' this test,
-
-        gc_tasks.create_stat_async.send(
-            date_string=chosen_date, query_name="total_count"
-        )
-
-        # Wait for all the tasks to be processed
-
-        broker.join(gc_tasks.create_stat_async.queue_name)
-        worker.join()
-
-        # have we generated the daily stats?
-        assert gc_models.DailyStat.objects.count() == 3
-
-        # do that they have the right date?
-        for stat in gc_models.DailyStat.objects.all():
-            assert str(stat.stat_date) == chosen_date
-
-        # do the stats count up to what we expect?
-        green_daily_stat = gc_models.DailyStat.objects.filter(
-            green=gc_choices.BoolChoice.YES
-        ).first()
-        grey_daily_stat = gc_models.DailyStat.objects.filter(
-            green=gc_choices.BoolChoice.NO
-        ).first()
-        mixed_daily_stat = gc_models.DailyStat.objects.exclude(
-            green__in=[gc_choices.BoolChoice.YES, gc_choices.BoolChoice.NO]
-        ).first()
-
-        assert green_daily_stat.count == 0
-        assert grey_daily_stat.count == 1
-        assert mixed_daily_stat.count == 1
diff --git a/apps/greencheck/tests/views/test_stats_view.py b/apps/greencheck/tests/views/test_stats_view.py
deleted file mode 100644
index e3f2375b..00000000
--- a/apps/greencheck/tests/views/test_stats_view.py
+++ /dev/null
@@ -1,231 +0,0 @@
-import functools
-import logging
-
-import faker
-import pytest
-from dateutil.relativedelta import relativedelta
-from django import urls
-from django.utils import timezone
-from waffle.testutils import override_flag
-
-from ....accounts import models as ac_models
-from ... import choices as gc_choices
-from ... import factories as gc_factories
-from ... import models as gc_models
-from .. import range_of_dates, view_in_browser
-
-logger = logging.getLogger(__name__)
-console = logging.StreamHandler()
-# logger.setLevel(logging.DEBUG)
-# logger.addHandler(console)
-fake = faker.Faker()
-
-
-class TestDailyStatsView:
-    """
-    Check that we render the right templates
-    """
-
-    def _setup_top_green_domains(self):
-        """
-        Set up a set of daily stats listing the top domains
-        for a given date
-        """
-
-        yesterday = timezone.now() - relativedelta(days=1)
-        thirty_days_back = timezone.now() - relativedelta(days=30)
-        last_30_days = range_of_dates(thirty_days_back, yesterday)
-
-        for x in range(10):
-            realist_random_no = int(fake.numerify()) * int(fake.numerify())
-            domain = fake.domain_name()
-
-            for given_datetime in last_30_days:
-
-                daily_total = gc_choices.DailyStatChoices.DAILY_TOTAL
-                domain_key = f"{daily_total}:domain:{domain}"
-
-                # set up domain to check against, with
-                # corresponding hosting provider
-
-                gc_factories.GreenDomainFactory(url=domain)
-
-                gc_models.DailyStat.objects.create(
-                    stat_key=domain_key,
-                    count=realist_random_no,
-                    green=gc_choices.GreenStatChoice.YES,
-                    stat_date=given_datetime.date(),
-                )
-
-    def _get_top_green_hosters(self):
-        """
-        Set up a set of stats for the top providers for a
-        given date
-        """
-
-        yesterday = timezone.now() - relativedelta(days=1)
-        thirty_days_back = timezone.now() - relativedelta(days=30)
-        last_30_days = range_of_dates(thirty_days_back, yesterday)
-
-        for x in range(10):
-            realist_random_no = int(fake.numerify()) * int(fake.numerify())
-            provider_name = fake.company()
-
-            for given_datetime in last_30_days:
-                daily_total = gc_choices.DailyStatChoices.DAILY_TOTAL
-                provider = gc_factories.HostingProviderFactory(name=provider_name)
-
-                domain_key = f"{daily_total}:provider:{provider.id}"
-
-                gc_models.DailyStat.objects.create(
-                    stat_key=domain_key,
-                    count=realist_random_no,
-                    green=gc_choices.GreenStatChoice.YES,
-                    stat_date=given_datetime.date(),
-                )
-
-    def _setup_30_days_of_stats_for_chart(
-        self, hosting_provider_with_sample_user, green_ip
-    ):
-        # for each date, add one green and two grey checks for every day
-        now = timezone.now()
-        thirty_days_back = now - relativedelta(days=30)
-        yesterday = now - relativedelta(days=1)
-        last_30_days = range_of_dates(thirty_days_back, yesterday)
-
-        for given_datetime in last_30_days:
-            gc_factories.GreencheckFactory.create(
-                date=given_datetime + relativedelta(hours=2),
-                hostingprovider=hosting_provider_with_sample_user.id,
-                greencheck_ip=green_ip.id,
-                ip=green_ip.ip_end,
-                green=gc_choices.BoolChoice.YES,
-            )
-
-            gc_factories.GreencheckFactory.create_batch(
-                size=2,
-                date=given_datetime + relativedelta(hours=2),
-            )
-
-        gc_models.DailyStat.create_counts_for_date_range(last_30_days, "total_count")
-
-    @override_flag("greencheck-stats", active=True)
-    def test_stat_view_templates(self, db, client):
-        """
-        Test that we render successfully and the write template
-        """
-
-        stat_path = urls.reverse("greencheck-stats-index")
-        res = client.get(stat_path)
-
-        assert res.status_code == 200
-        assert "greencheck/stats_index.html" in [tmpl.name for tmpl in res.templates]
-
-    @override_flag("greencheck-stats", active=True)
-    def test_stat_view_headlines(
-        self,
-        db,
-        client,
-        hosting_provider_with_sample_user: ac_models.Hostingprovider,
-        green_ip: gc_models.GreencheckIp,
-    ):
-        """
-        Check that we have the aggregated headline figures available to us
-        """
-
-        self._setup_30_days_of_stats_for_chart(
-            hosting_provider_with_sample_user, green_ip
-        )
-
-        stat_path = urls.reverse("greencheck-stats-index")
-        res = client.get(stat_path)
-
-        assert res.status_code == 200
-
-        # do we have plausible numbers now?
-        headlines = res.context_data["stats"]["headlines"]
-
-        stats = [
-            stat.count
-            for stat in gc_models.DailyStat.objects.filter(
-                stat_key="total_daily_checks", green="yes"
-            )
-        ]
-
-        total_green = functools.reduce(lambda x, y: x + y, stats)
-
-        assert headlines["green"] == total_green
-
-    @override_flag("greencheck-stats", active=True)
-    def test_stat_view_chart(
-        self,
-        db,
-        hosting_provider_with_sample_user: ac_models.Hostingprovider,
-        green_ip: gc_models.GreencheckIp,
-        client,
-    ):
-        """
-        Test that we fetch the last 30 days of stats, and make it avaiable for graphing
-        """
-        self._setup_30_days_of_stats_for_chart(
-            hosting_provider_with_sample_user, green_ip
-        )
-
-        stat_path = urls.reverse("greencheck-stats-index")
-        res = client.get(stat_path)
-
-        assert res.status_code == 200
-
-        stats = res.context_data["stats"]
-
-        assert "headlines" in stats.keys()
-        assert "chart_data" in stats.keys()
-
-        chart_data = stats["chart_data"]
-
-        # we want to see the green, grey, for our charts
-        assert len(chart_data["green"]) == 30
-        assert len(chart_data["grey"]) == 30
-
-    @pytest.mark.flaky
-    @override_flag("greencheck-stats", active=True)
-    def test_stat_view_top_domains(
-        self,
-        db,
-        client,
-    ):
-        """
-        Test that we have can display a list of the top domains
-        """
-
-        self._setup_top_green_domains()
-
-        stat_path = urls.reverse("greencheck-stats-index")
-        res = client.get(stat_path)
-
-        stats = res.context_data["stats"]
-
-        assert "top_green_domains" in stats.keys()
-        top_green_domains = stats["top_green_domains"]
-
-        assert len(top_green_domains) == 10
-
-    @pytest.mark.flaky
-    @override_flag("greencheck-stats", active=True)
-    def test_stat_view_top_providers(self, db, client):
-        """
-        Test that we can display a list of the top domains
-        """
-
-        self._get_top_green_hosters()
-
-        stat_path = urls.reverse("greencheck-stats-index")
-
-        res = client.get(stat_path)
-
-        stats = res.context_data["stats"]
-
-        assert "top_green_hosters" in stats.keys()
-        top_green_hosters = stats["top_green_hosters"]
-
-        assert len(top_green_hosters) == 10
diff --git a/apps/greencheck/url2green.py b/apps/greencheck/url2green.py
deleted file mode 100644
index 0ce8a899..00000000
--- a/apps/greencheck/url2green.py
+++ /dev/null
@@ -1,50 +0,0 @@
-import re
-
-# this module exists for working with some files are very large.
-# To clean the data instead, it we needed to read from one file,
-# and only write the lines that counted as real hostnames, so we had a white
-# list of valid urls
-
-
-def lazy_messy_url_list(path_to_infile):
-    """
-    Accept a text file at `path`, with one url per line,
-    and return an generator to iterate through each line
-    """
-    with open(path_to_infile, "r") as messy_list_of_urls:
-        for line in messy_list_of_urls.readlines():
-            yield line
-
-
-def write_clean_urls(lazy_url_list, path_to_outfile):
-    """
-    Accept `lazy_url_list`, a iterable list of urls and
-    write the valid urls to the file `path_to_outfile`
-    """
-    with open(path_to_outfile, "w") as clean_url_list:
-        for url in lazy_url_list:
-            if is_valid_hostname(url):
-                clean_url_list.write(url)
-
-
-def is_valid_hostname(hostname):
-    """
-    Check that hostname passed in is valid.
-    Pretty much a copy paste of this
-    https://stackoverflow.com/questions/2532053/validate-a-hostname-string
-    """
-    if len(hostname) > 255:
-        return False
-    if hostname[-1] == ".":
-        hostname = hostname[:-1]  # strip exactly one dot from the right, if present
-    allowed = re.compile("(?!-)[A-Z0-9-]{1,63}(?<!-)$", re.IGNORECASE)
-    return all(allowed.match(x) for x in hostname.split("."))
-
-
-def create_clean_url_list(path_to_infile, path_to_outfile):
-    """
-    Accepts an path to an CSV file to read, and path to an outfile
-    to write to, then writes the cleaned urls to the file.
-    """
-    urls = lazy_messy_url_list("path/to/file")
-    write_clean_urls(urls, path_to_outfile)
diff --git a/apps/greencheck/urls.py b/apps/greencheck/urls.py
index 6c8c04f1..637600f5 100644
--- a/apps/greencheck/urls.py
+++ b/apps/greencheck/urls.py
@@ -1,7 +1 @@
-from django.urls import path
-
-from .views import GreencheckStatsView
-
-urlpatterns = [
-    path("", GreencheckStatsView.as_view(), name="greencheck-stats-index"),
-]
+urlpatterns = []
diff --git a/apps/greencheck/views.py b/apps/greencheck/views.py
index 42f0a816..e95b4fec 100644
--- a/apps/greencheck/views.py
+++ b/apps/greencheck/views.py
@@ -1,30 +1,12 @@
-import collections
-import typing
 from datetime import date, timedelta
 
-from dateutil.relativedelta import relativedelta
-from django.db.models import Sum
-from django.http import HttpResponseRedirect
-from django.urls import reverse
-from django.utils import timezone
-from django.utils.safestring import mark_safe
-from django.utils.decorators import method_decorator
-from django.views.decorators.cache import cache_page
-from django.views.generic.base import TemplateView
-
 import django_filters
-
-from waffle.mixins import WaffleFlagMixin
+from django.views.generic.base import TemplateView
 
 from apps.accounts.models.hosting import Hostingprovider
-from apps.greencheck.models.checks import GreenDomain
-from apps.greencheck.models.stats import DailyStat
 
 from ..accounts import models as ac_models
-from . import choices as gc_choices
-from . import models as gc_models
 from . import object_storage
-from .tests import dummy_greencheck_stat_data as dummy_data
 
 bucket = object_storage.green_domains_bucket()
 
@@ -61,157 +43,6 @@ def get_context_data(self, **kwargs):
         return context
 
 
-class GreencheckStatsView(WaffleFlagMixin, TemplateView):
-    template_name = "greencheck/stats_index.html"
-    waffle_flag = "greencheck-stats"
-
-    def _get_headline_counts(self, daily_stat_queryset=None):
-        """
-        Accept a DailyStat queryset and return a dict of the aggregated counts
-        from queryset
-        """
-
-        green_count = daily_stat_queryset.filter(green="yes").aggregate(
-            total=Sum("count")
-        )["total"]
-
-        grey_count = daily_stat_queryset.filter(green="no").aggregate(
-            total=Sum("count")
-        )["total"]
-
-        if not green_count:
-            green_count = 0
-        if not grey_count:
-            grey_count = 0
-
-        total_count = grey_count + green_count
-
-        if total_count == 0:
-            percentage_green = f"{0:.{1}%}"
-        else:
-            percentage_green = f"{green_count /  (grey_count + green_count):.{1}%}"
-
-        return {
-            "green_count": green_count,
-            "grey_count": green_count,
-            "percentage_green": percentage_green,
-        }
-
-    def _get_top_green_hosters(self, begin_at, end_at) -> typing.List[typing.Dict]:
-        """
-        Return a list of hosts, with a count of checks in this time period
-        defined by the start and end dates
-        """
-
-        hosters = (
-            gc_models.DailyStat.objects.daily_stats_for_provider()
-            .filter(stat_date__gte=begin_at.date(), stat_date__lte=end_at.date())
-            .order_by("-count")
-        )
-
-        enriched_hosters = []
-        counter = collections.Counter()
-
-        # aggregated_hoster_counts = (
-        #     hosters.values("stat_key").annotate(total=Sum("count")).order_by("-count")
-        # )[:10]
-
-        for host in hosters:
-            counter[host.stat_key] = host.count
-
-        for hoster_stat in counter.most_common(10):
-            stat_key, total = hoster_stat
-            hoster_id = stat_key.replace("total_daily_checks:provider:", "")
-            if hoster_id != "None":
-                provider = Hostingprovider.objects.get(pk=hoster_id)
-            else:
-                provider = None
-            enriched_hosters.append({"provider": provider, "count": total})
-
-        return enriched_hosters
-
-    def _get_top_green_domains(self, begin_at, end_at) -> typing.List[DailyStat]:
-        """
-        Return a list of domains, with the count of checks in this time period.
-        """
-        domains = gc_models.DailyStat.objects.daily_stats_for_domain().filter(
-            stat_date__gte=begin_at.date(), stat_date__lte=end_at.date()
-        )
-
-        enriched_domains = []
-        domain_counter = collections.Counter()
-
-        # we use a counter instead of aggregating in the database query, because
-        # django's annotation framework was adding a second group by clause, so we
-        # didn't get grouping by domains
-        for dom in domains:
-            domain_counter[dom.stat_key] += dom.count
-
-        for dom_count in domain_counter.most_common(10):
-            stat_key, total = dom_count
-            domain_name = stat_key.replace("total_daily_checks:domain:", "")
-
-            # go from the domain to the provider
-            green_domain = gc_models.GreenDomain.objects.get(url=domain_name)
-            provider = green_domain.hosting_provider
-
-            enriched_domains.append(
-                {"domain": domain_name, "hosted_by": provider, "count": total}
-            )
-
-        return enriched_domains
-
-    def get_context_data(self, **kwargs):
-        """
-        Fetch the context for making our charts, and dashboards
-        """
-        context = super().get_context_data(**kwargs)
-
-        query_name = self.request.GET.get("query_name")
-
-        if query_name is None:
-            query_name = gc_choices.DailyStatChoices.DAILY_TOTAL
-
-        now = timezone.now()
-        thirty_days_ago = now - relativedelta(days=30)
-
-        last_thirty_days_of_stats = (
-            gc_models.DailyStat.objects.daily_stats()
-            .filter(stat_date__gte=thirty_days_ago.date(), stat_date__lte=now)
-            .order_by("-stat_date")
-        )
-
-        headline_counts = self._get_headline_counts(last_thirty_days_of_stats)
-
-        chart_data = {
-            "green": [
-                {"x": str(datum.stat_date), "y": datum.count}
-                for datum in last_thirty_days_of_stats
-                if datum.green == "yes"
-            ],
-            "grey": [
-                {"x": str(datum.stat_date), "y": datum.count}
-                for datum in last_thirty_days_of_stats
-                if datum.green == "no"
-            ],
-        }
-
-        res = {
-            "headlines": {
-                "percentage_green": headline_counts["percentage_green"],
-                "green": headline_counts["green_count"],
-                "grey": headline_counts["grey_count"],
-            },
-            "chart_data": chart_data,
-            "top_green_hosters": self._get_top_green_hosters(thirty_days_ago, now),
-            "top_green_domains": self._get_top_green_domains(thirty_days_ago, now),
-        }
-
-        context["stats"] = res
-
-        return context
-
-
 class ProviderFilter(django_filters.FilterSet):
     """
     A filter set class to support filtering by
diff --git a/apps/theme/static_src/src/stats-charts.js b/apps/theme/static_src/src/stats-charts.js
deleted file mode 100644
index fd467e86..00000000
--- a/apps/theme/static_src/src/stats-charts.js
+++ /dev/null
@@ -1,45 +0,0 @@
-import Chart from 'chart.js/auto';
-
-
-const statsCharts = {
-  render(domId, data) {
-
-    const ctx = domId;
-
-    console.log({ data })
-
-    const myChart = new Chart(ctx, {
-      type: 'bar',
-      labels: data.green.map(function (elem) { return elem.y }),
-      data: {
-        labels: data.green.map(function (elem) { return elem.x }),
-        datasets: [{
-          label: "Green",
-          data: data.green.map(function (elem) { return elem.y }),
-          // backgroundColor: "#1E320C"
-          backgroundColor: "#8AC850"
-        }, {
-          label: "Grey",
-          data: data.grey.map(function (elem) { return elem.y }),
-          backgroundColor: "#777"
-        }],
-      },
-
-      options: {
-        scales: {
-          y: {
-            beginAtZero: true,
-            stacked: true
-          },
-          x: {
-            stacked: true
-          }
-        }
-      }
-    })
-  }
-}
-
-
-export default statsCharts
-
diff --git a/apps/theme/templates/greencheck/stats_index.html b/apps/theme/templates/greencheck/stats_index.html
deleted file mode 100644
index 6830bbcb..00000000
--- a/apps/theme/templates/greencheck/stats_index.html
+++ /dev/null
@@ -1,152 +0,0 @@
-{% extends 'base.html' %}
-{% load humanize %}
-{% load static %}
-{% load widget_tweaks %}
-{% load tailwind_filters %}
-{% block content %}
-
-
-<div class="container mx-auto">
-  <section class="mx-auto max-w-6xl bg-white border-2 border-dark-gray rounded-md  h-100-l mt-8 py-8">
-
-  {% block stats %}
-    <section class="main-content">
-
-      <section class="description m-3 px-8">
-        <h2 class="text-2xl">
-          Currently showing results for the
-          <em>last 24hrs</em>,
-          and
-          <strong>🌍  the entire world</strong>
-          <span class="text-sm text-red-500 underline hover:no-underline">
-            <a href="">
-              (change)
-            </a>
-          </span
-        </h2>
-      </section>
-
-      <section
-        class="headline-stats mx-auto bg-tgwf-green-900 h-100-l mt-8 p-8 flex px-8"
-      >
-      <div class="hero-stat flex-1">
-          <div class="h-32">
-            <h3 class="text-8xl">
-              {{ stats.headlines.percentage_green }}
-            </h3>
-          </div>
-
-          <p>
-            {{ stats.headlines.percentage_green }} of our checks show websites running on servers powered by green energy. 
-          </p>
-      </div>
-      <div class="green-results flex-1">
-          <div class="h-32">
-            <h3 class="text-4xl mb-8">
-              {{ stats.headlines.green | intcomma }}
-            </h3>
-          </div>
-          <p class="max-w-xs">
-          {{ stats.headlines.green | intcomma }} checks where we could find evidence of servers running on green energy.
-          </p>
-      </div>
-      <div class="grey-results flex-1">
-          <div class="h-32">
-            <h3 class="text-4xl mb-8">
-            {{ stats.headlines.grey | intcomma }}
-            </h3>
-          </div>
-
-          <p class="max-w-xs">
-              {{ stats.headlines.grey | intcomma }} checks where we couldn't find evidence of running on green energy.
-          </p>
-      
-      </div>
-      </section>
-
-      <section class="last-30-days m-3 px-8 mt-6">
-      
-        <script>
-          window.chartData = {{ stats.chart_data|safe }}
-        </script>
-
-
-        <h3 class="text-xl my-4">Green check summary of the last 30 days</h3>
-
-        <p>
-          The chart below shows the daily summaries of checks for 'green' domains, showing as uring infrastructure powered by green energy, versus grey domains - infrastructure running on conventional, often fossil energy.
-        </p>
-
-        <div class="mx-auto w-full h-96 mt-4">
-          <canvas id="chart-last-30-days" width="1200" height="400">
-            
-          
-          </canvas>
-        </div>
-
-        <h3 class="text-xl my-4">Most popular green domains globally </h3>
-
-        <p>
-          The table below shows the most commonly checked domains, along with the organsations running their infrastructure, based on usage data from 1) our  green web foundation browser extension, 2) our green check service, and 3) third party users of our API services,
-        </p>
-
-        <table class="table-auto my-8 mx-auto w-full">
-          <thead>
-            <tr class="border-b border-b-gray-900">
-              <th class="p-2 text-left">Domain</th>
-              <th class="p-2 text-left">Hosted By</th>
-              <th class="p-2 text-right">No. of checks</th>
-
-            </tr>
-          </thead>
-          <tbody>
-            {% for line in stats.top_green_domains %}
-            <tr class="border-b">
-              <td class="text-sm p-2 text-left">{{ line.domain }}</td>
-              <td class="text-sm p-2 text-left"><a href="{{ line.hosted_by }}">{{ line.hosted_by }}</a>  </td>
-              <td class="text-sm p-2 text-right">{{ line.count|intcomma }}</td>
-
-            </tr>
-            {% endfor %}
-          </tbody>
-        </table>
-
-
-        <h3 class="text-xl my-4">Most popular green hosting providers globally</h3>
-
-        <p>
-          Below are top ten green hosting providers, again from the same aggregated sourrces - again based on usage data from 1) our green web foundation browser extension, 2) our green check service, and 3) third party users of our API services.
-        </p>
-      2
-         <table class="table-auto mt-8 mx-auto w-full">
-          <thead>
-            <tr class="border-b">
-              <th class="p-2 text-left">Provider</th>
-              <th class="p-2 text-left">Link</th>
-              <th class="p-2 text-right">Count</th>
-            </tr>
-          </thead>
-          <tbody>
-            {% for line in stats.top_green_hosters %}
-            <tr class="border-b">
-              <td class="text-sm p-2 text-left">{{ line.provider.name }}</td>
-              <td class="text-sm p-2 text-left">{{ line.provider.website }}</td>
-              <td class="text-sm p-2 text-right">{{ line.count|intcomma }}</td>
-            </tr>
-            {% endfor %}
-          </tbody>
-        </table>
-      </section>
-    </section>
-
-  {% endblock %}
-  </section>
-</div>
-
-
-{% endblock %}
-
-{% block extra_js %}
-  <script src="{% static 'js/dist/app.bundle.js' %}"> </script>
-  
-{% endblock %}
diff --git a/conftest.py b/conftest.py
index 9bec848a..422fabfc 100644
--- a/conftest.py
+++ b/conftest.py
@@ -27,7 +27,6 @@
 register(gc_factories.GreenIpFactory)
 register(gc_factories.GreenASNFactory)
 register(gc_factories.GreenDomainFactory)
-register(gc_factories.DailyStatFactory)
 register(gc_factories.SiteCheckFactory)
 register(ac_factories.SupportingEvidenceFactory)
 register(ac_factories.ProviderRequestFactory)

From 89b6ccac7f1a1ab565b88eadfa7a65ded6c988f5 Mon Sep 17 00:00:00 2001
From: Chris Adams <chris@productscience.co.uk>
Date: Fri, 15 Nov 2024 20:04:27 +0100
Subject: [PATCH 3/3] Remove last unused stats code

---
 apps/greencheck/tasks.py |  51 --------------
 one_day_to_parquet.py    | 139 ---------------------------------------
 2 files changed, 190 deletions(-)
 delete mode 100644 one_day_to_parquet.py

diff --git a/apps/greencheck/tasks.py b/apps/greencheck/tasks.py
index 2c784ebb..b4c3833c 100644
--- a/apps/greencheck/tasks.py
+++ b/apps/greencheck/tasks.py
@@ -5,8 +5,6 @@
 import dramatiq
 import MySQLdb
 
-from one_day_to_parquet import backup_day_to_parquet
-
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
 # console = logging.StreamHandler()
@@ -35,52 +33,3 @@ def process_log(domain):
         except Exception as err:
             logger.exception(err)
             return False
-
-
-@dramatiq.actor(queue_name="stats")
-def create_stat_async(date_string: str = None, query_name: str = "total_count", *args):
-    """
-    Accept a date_string, and a query name then execute the query. Used to carry out
-    expensive aggregation queries outside the request cycle.
-    """
-
-    from .models.stats import DailyStat
-
-    allowed_queries = [
-        "total_count",
-        "total_count_for_providers",
-        "top_domains_for_day",
-        "top_hosting_providers_for_day",
-    ]
-
-    if query_name not in allowed_queries:
-        raise Exception("Unsupported query. Ignoring")
-
-    parsed_date = date_parser.parse(date_string)
-
-    query_function = getattr(DailyStat, query_name)
-    query_function(date_to_check=parsed_date)
-
-
-@dramatiq.actor(queue_name="stats")
-def backup_day_to_parquet_queue_actor(date_string: str):
-    """
-    Intended for use dramatiq:
-    Accept a isoformat date string, convert it to a date
-    and call back the day of checks to object storage as a parquert
-    file.
-
-    date_string (str): the isoformat YYYY-MM-DD string for the chosen date
-    """
-
-    try:
-        target_date = datetime.date.fromisoformat(date_string)
-        backup_day_to_parquet(target_date)
-    except ValueError as e:
-        logger.warning(
-            (
-                f"Could not parse a date out of the given string {date_string}. "
-                "Please check that the format is YYYY-MM-DD"
-            )
-        )
-        logger.warning(e)
diff --git a/one_day_to_parquet.py b/one_day_to_parquet.py
deleted file mode 100644
index 074dcd7e..00000000
--- a/one_day_to_parquet.py
+++ /dev/null
@@ -1,139 +0,0 @@
-import csv
-import datetime
-import logging
-import tempfile
-
-import duckdb
-from dateutils import timedelta
-
-
-from django.utils import timezone  # noqa
-
-from apps.greencheck.models import checks  # noqa
-from apps.greencheck.object_storage import object_storage_bucket  # noqa
-
-logger = logging.getLogger(__name__)
-infra_bucket = object_storage_bucket("internal-infra")
-
-
-def csv_of_checks_for_day(day: datetime.date, csv_path: str) -> bool:
-    """
-    Run a query extracting the checks for the given day, and write the results
-    date stamped csv file .
-    If a directory is given, output the file into the given directory.
-    """
-
-    logger.info(f"Starting export for {day}")
-    start_time = timezone.now()
-
-    one_day_forward = timedelta(days=1)
-    one_day_back = timedelta(days=-1)
-
-    res = (
-        checks.Greencheck.objects.filter(
-            date__gt=day + one_day_back, date__lt=day + one_day_forward
-        )
-        .values_list()
-        .iterator()
-    )
-
-    # return early if we have no results from our greencheck query.
-    if not res:
-        return False
-
-    logger.info(f"Writing query results to {csv_path}")
-
-    with open(csv_path, "w") as f:
-        list_writer = csv.writer(f)
-        for check in res:
-            list_writer.writerow(check)
-
-    logger.info(f"Finished export for {day}")
-
-    end_time = timezone.now()
-    logger.info(end_time)
-
-    time_span = end_time - start_time
-    logger.info(f"Took {time_span.seconds} seconds")
-
-    return True
-
-
-def convert_csv_to_parquet(csv_path: str, parquet_path: str) -> bool:
-    """
-    Load a CSV file at the path of `prefix/YYYY_MM_DD.csv`, and
-    create a compressed parquet file at the path
-    `prefix/YYYY_MM_DD.zstd.parquet`.
-    If a directory is given, look inside it for the csv, and output
-    the parquet file into it.
-    """
-
-    start_time = timezone.now()
-    logger.info(f"Starting conversion to parquet for {csv_path}")
-    logger.info(start_time)
-
-    # set up our in-memory database with duckdb
-    con = duckdb.connect(database=":memory:")
-
-    # run our query to convert the day of checks to a compressed parquet file
-    con.execute(
-        (
-            f"COPY (SELECT * from '{csv_path}') "
-            f"TO '{parquet_path}' (FORMAT 'PARQUET', CODEC 'ZSTD')"
-        )
-    )
-    logger.info(f"Finished conversion to parquet for {csv_path}")
-    end_time = timezone.now()
-    logger.info(end_time)
-
-    time_span = end_time - start_time
-    logger.info(f"Took {time_span.seconds} seconds")
-
-    return True
-
-
-def upload_to_object_storage(parquet_path: str, upload_path: str) -> bool:
-    """
-    Upload parquet file at `"prefix/YYYY_MM_DD.zstd.parquet" to object storage
-    with the the key /parquet/days/TABLENAME_YYYY_MM_DD.zstd.parquet
-
-    If a directory is provided, look in the directory for the parquet file.
-    """
-    start_time = timezone.now()
-    logger.info(f"Start uploading at {start_time}")
-
-    infra_bucket.upload_file(parquet_path, upload_path)
-
-    end_time = timezone.now()
-    time_span = end_time - start_time
-
-    logger.info(f"Finished uploading at {end_time}")
-    logger.info(f"Took {time_span.seconds} seconds")
-
-
-def backup_day_to_parquet(target_date: datetime.date):
-    """
-    Accept a target date to back up, and then extract all
-    the greenchecks for tha given day, and back up to object
-    storage as a compressed parquet file.
-    """
-
-    # use a temporary directory, to clean up after ourselves
-    # and avoid clashes
-    with tempfile.TemporaryDirectory() as tmpdir:
-        date_string = target_date.strftime("%Y-%m-%d")
-        greencheck_table = "greencheck"
-
-        csv_path = f"{tmpdir}/{date_string}.local_file.csv"
-        parquet_path = f"{tmpdir}/{date_string}.zstd.parquet"
-        upload_path = f"parquet/days/{date_string}.{greencheck_table}.zstd.parquet"
-
-        csv_generated, parquet_created = None, None
-
-        # only proceed with following steps we get a truthy result from earlier steps
-        csv_generated = csv_of_checks_for_day(target_date, csv_path)
-
-        if csv_generated:
-            parquet_created = convert_csv_to_parquet(csv_path, parquet_path)
-        if parquet_created:
-            upload_to_object_storage(parquet_path, upload_path)