fix: Counter.edit_groups

club/migrations/0012_club_board_group_club_members_group.py

@@ -34,12 +34,10 @@ def migrate_meta_groups(apps: StateApps, schema_editor):
     clubs = list(Club.objects.all())
     for club in clubs:
         club.board_group = meta_groups.get_or_create(
-            name=club.unix_name + settings.SITH_BOARD_SUFFIX,
+            name=f"{club.unix_name}-bureau", defaults={"is_meta": True}
-            defaults={"is_meta": True},
         )[0]
         club.members_group = meta_groups.get_or_create(
-            name=club.unix_name + settings.SITH_MEMBER_SUFFIX,
+            name=f"{club.unix_name}-membres", defaults={"is_meta": True}
-            defaults={"is_meta": True},
         )[0]
         club.save()
         club.refresh_from_db()

counter/models.py

@@ -535,13 +535,6 @@ class Counter(models.Model):
     def __str__(self):
         return self.name
 
-    def __getattribute__(self, name: str):
-        if name == "edit_groups":
-            return Group.objects.filter(
-                name=self.club.unix_name + settings.SITH_BOARD_SUFFIX
-            ).all()
-        return object.__getattribute__(self, name)
-
     def get_absolute_url(self) -> str:
         if self.type == "EBOUTIC":
             return reverse("eboutic:main")

galaxy/management/commands/rule_galaxy.py

@@ -45,9 +45,8 @@ class Command(BaseCommand):
                 "verbosity level should be between 0 and 2 included", stacklevel=2
             )
 
-        if options["verbosity"] >= 2:
+        if options["verbosity"] == 2:
             logger.setLevel(logging.DEBUG)
-            logging.getLogger("django.db.backends").setLevel(logging.DEBUG)
         elif options["verbosity"] == 1:
             logger.setLevel(logging.INFO)
         else:
@@ -60,3 +59,6 @@ class Command(BaseCommand):
         Galaxy.objects.filter(state__isnull=True).delete()
 
         logger.info("Ruled the galaxy in {} queries.".format(len(connection.queries)))
+        if options["verbosity"] > 2:
+            for q in connection.queries:
+                logger.debug(q)

galaxy/models.py

@@ -31,14 +31,13 @@ from collections import defaultdict
 from typing import NamedTuple, TypedDict
 
 from django.db import models
-from django.db.models import Count, Exists, F, OuterRef, Q, QuerySet
+from django.db.models import Count, F, Q, QuerySet
-from django.utils.timezone import localdate, now
+from django.utils.timezone import localdate
 from django.utils.translation import gettext_lazy as _
 
 from club.models import Membership
 from core.models import User
 from sas.models import PeoplePictureRelation, Picture
-from subscription.models import Subscription
 
 
 class GalaxyStar(models.Model):
@@ -199,16 +198,8 @@ class Galaxy(models.Model):
         cls, picture_count_threshold: int = DEFAULT_PICTURE_COUNT_THRESHOLD
     ) -> QuerySet[User]:
         return (
-            User.objects.filter(is_subscriber_viewable=True)
+            User.objects.exclude(subscriptions=None)
-            .exclude(subscriptions=None)
+            .annotate(pictures_count=Count("pictures"))
-            .annotate(
-                pictures_count=Count("pictures"),
-                is_active_in_galaxy=Exists(
-                    Subscription.objects.filter(
-                        member=OuterRef("id"), subscription_end__gt=now()
-                    )
-                ),
-            )
             .filter(pictures_count__gt=picture_count_threshold)
             .distinct()
         )
@@ -299,9 +290,9 @@ class Galaxy(models.Model):
         31/12/2022 (also two years, but with an offset of one year), then their
         club score is 365.
         """
-        memberships = user.memberships.values("start_date", "end_date", "club_id")
+        memberships = user.memberships.only("start_date", "end_date", "club_id")
         result = defaultdict(int)
-        today = localdate()
+        now = localdate()
         for membership in memberships:
             # This is a N+1 query, but 92% of galaxy users have less than 10 memberships.
             # Only 5 users have more than 30 memberships.
@@ -309,23 +300,23 @@ class Galaxy(models.Model):
                 Membership.objects.exclude(user=user)
                 .filter(
                     Q(  # start2 <= start1 <= end2
-                        start_date__lte=membership["start_date"],
+                        start_date__lte=membership.start_date,
-                        end_date__gte=membership["start_date"],
+                        end_date__gte=membership.start_date,
                     )
-                    | Q(  # start2 <= start1 <= today
+                    | Q(  # start2 <= start1 <= now
-                        start_date__lte=membership["start_date"], end_date=None
+                        start_date__lte=membership.start_date, end_date=None
                     )
                     | Q(  # start1 <= start2 <= end2
-                        start_date__gte=membership["start_date"],
+                        start_date__gte=membership.start_date,
-                        start_date__lte=membership["end_date"] or today,
+                        start_date__lte=membership.end_date or now,
                     ),
-                    club_id=membership["club_id"],
+                    club_id=membership.club_id,
                 )
                 .only("start_date", "end_date", "user_id")
             )
             for other in common_memberships:
-                start = max(membership["start_date"], other.start_date)
+                start = max(membership.start_date, other.start_date)
-                end = min(membership["end_date"] or today, other.end_date or today)
+                end = min(membership.end_date or now, other.end_date or now)
                 result[other.user_id] += (end - start).days * cls.CLUBS_POINTS
         return result
 
@@ -391,22 +382,18 @@ class Galaxy(models.Model):
         # this is memory expensive but prevents a lot of db hits, therefore
         # is far more time efficient
 
-        rulable_users_qs = self.get_rulable_users(picture_count_threshold)
+        rulable_users = list(self.get_rulable_users(picture_count_threshold))
-        active_users_count = rulable_users_qs.filter(is_active_in_galaxy=True).count()
+        rulable_users_count = len(rulable_users)
-        rulable_users = list(rulable_users_qs)
         user1_count = 0
         self.logger.info(
-            f" {len(rulable_users)} citizens (with {active_users_count} active ones) "
+            f"{rulable_users_count} citizen have been listed. Starting to rule."
-            f"have been listed. Starting to rule."
         )
 
         self.logger.info("Creating stars for all citizen")
         individual_scores = self.compute_individual_scores()
         GalaxyStar.objects.bulk_create(
             [
-                GalaxyStar(
+                GalaxyStar(owner=user, galaxy=self, mass=individual_scores[user.id])
-                    owner_id=user.id, galaxy=self, mass=individual_scores[user.id]
-                )
                 for user in rulable_users
             ]
         )
@@ -418,9 +405,9 @@ class Galaxy(models.Model):
         t_global_start = time.time()
         while len(rulable_users) > 0:
             user1 = rulable_users.pop()
-            if not user1.is_active_in_galaxy:
-                continue
             user1_count += 1
+            rulable_users_count2 = len(rulable_users)
+
             star1 = stars[user1.id]
 
             lanes = []
@@ -461,20 +448,17 @@ class Galaxy(models.Model):
                 self.logger.info("")
                 self.logger.info(f" Ruling of {self} ".center(60, "#"))
                 self.logger.info(
-                    f"Progression: {user1_count}/{active_users_count} "
+                    f"Progression: {user1_count}/{rulable_users_count} "
-                    f"citizen -- {active_users_count - user1_count} remaining"
+                    f"citizen -- {rulable_users_count - user1_count} remaining"
                 )
                 self.logger.info(f"Speed: {global_avg_speed:.2f} citizen per second")
-                eta = len(rulable_users) // global_avg_speed
+                eta = rulable_users_count2 // global_avg_speed
                 self.logger.info(
                     f"ETA: {int(eta // 60 % 60)} minutes {int(eta % 60)} seconds"
                 )
                 self.logger.info("#" * 60)
             t_global_start = time.time()
 
-        count, _ = self.stars.filter(Q(lanes1=None) & Q(lanes2=None)).delete()
-        self.logger.info(f"{count} orphan stars have been trimmed.")
-
         # Here, we get the IDs of the old galaxies that we'll need to delete. In normal operation, only one galaxy
         # should be returned, and we can't delete it yet, as it's the one still displayed by the Sith.
         old_galaxies_pks = list(

galaxy/tests.py

@@ -122,7 +122,7 @@ class TestGalaxyModel(TestCase):
             self.com,
         ]
 
-        with self.assertNumQueries(38):
+        with self.assertNumQueries(44):
             while len(users) > 0:
                 user1 = users.pop(0)
                 family_scores = Galaxy.compute_user_family_score(user1)
@@ -150,7 +150,7 @@ class TestGalaxyModel(TestCase):
         that the number of queries to rule the galaxy is stable.
         """
         galaxy = Galaxy.objects.create()
-        with self.assertNumQueries(36):
+        with self.assertNumQueries(39):
             galaxy.rule(0)  # We want everybody here
 
 

sith/settings.py

@@ -405,9 +405,6 @@ SITH_FORUM_PAGE_LENGTH = 30
 SITH_SAS_ROOT_DIR_ID = env.int("SITH_SAS_ROOT_DIR_ID", default=4)
 SITH_SAS_IMAGES_PER_PAGE = 60
 
-SITH_BOARD_SUFFIX = "-bureau"
-SITH_MEMBER_SUFFIX = "-membres"
-
 SITH_PROFILE_DEPARTMENTS = [
     ("TC", _("TC")),
     ("IMSI", _("IMSI")),