Add capacity reservation breakdown for invoices (#4263)

The challenge request budget table has been updated to break down the
calculation for the capacity reservation.

Example:
<img width="600" alt="Screenshot 2025-08-25 at 11 35 06"
src="https://github.com/user-attachments/assets/7bc38c72-9394-41f9-92d5-b6cc81d36ce3"
/>


Related to DIAGNijmegen/rse-roadmap#421
Related to #3787

Author: koopmant

app/config/settings.py

@@ -144,17 +144,16 @@
 # About Flatpage
 FLATPAGE_ABOUT_URL = os.environ.get("FLATPAGE_ABOUT_URL", "/about/")
 
-# All costs exclude Tax
-COMPONENTS_TAX_RATE_PERCENT = 0.21
-if COMPONENTS_TAX_RATE_PERCENT > 1:
+COMPONENTS_TAX_RATE = 0.21
+if COMPONENTS_TAX_RATE > 1:
     raise ImproperlyConfigured("Tax rate should be less than 1")
 COMPONENTS_USD_TO_EUR = float(
     os.environ.get("COMPONENTS_USD_TO_EUR", "0.92472705")
 )
-COMPONENTS_S3_USD_MILLICENTS_PER_YEAR_PER_TB = (
+COMPONENTS_S3_USD_MILLICENTS_PER_YEAR_PER_TB_EXCLUDING_TAX = (
     12_300_000  # Last calculated 23/08/2023
 )
-COMPONENTS_ECR_USD_MILLICENTS_PER_YEAR_PER_TB = (
+COMPONENTS_ECR_USD_MILLICENTS_PER_YEAR_PER_TB_EXCLUDING_TAX = (
     39_600_000  # Last calculated 23/08/2023
 )
 
@@ -164,10 +163,8 @@
 CHALLENGE_MINIMAL_COMPUTE_AND_STORAGE_IN_EURO = int(
     os.environ.get("CHALLENGE_MINIMAL_COMPUTE_AND_STORAGE_IN_EURO", 1000)
 )
-CHALLENGE_ADDITIONAL_COMPUTE_AND_STORAGE_PACK_SIZE_IN_EURO = int(
-    os.environ.get(
-        "CHALLENGE_ADDITIONAL_COMPUTE_AND_STORAGE_PACK_SIZE_IN_EURO", 500
-    )
+CHALLENGE_CAPACITY_RESERVATION_PACK_SIZE_IN_EURO = int(
+    os.environ.get("CHALLENGE_CAPACITY_RESERVATION_PACK_SIZE_IN_EURO", 500)
 )
 CHALLENGE_NUM_SUPPORT_YEARS = int(
     os.environ.get("CHALLENGE_NUM_SUPPORT_YEARS", 5)

app/grandchallenge/algorithms/models.py

@@ -1180,7 +1180,6 @@ def init_credits_consumed(self):
         maximum_cents_per_job = (
             (self.time_limit / 3600)
             * executor.usd_cents_per_hour
-            * (1 + settings.COMPONENTS_TAX_RATE_PERCENT)
             * settings.COMPONENTS_USD_TO_EUR
         )
 

app/grandchallenge/challenges/admin.py

@@ -122,10 +122,7 @@ class ChallengeRequestAdmin(ModelAdmin):
 
     @admin.display(description="Total cost")
     def total_cost(self, obj):
-        if obj.budget:
-            return obj.budget.get("Total")
-        else:
-            return None
+        return obj.total_challenge_cost
 
     @admin.action(description="Create challenge for this request")
     def create_challenge(self, request, queryset):

app/grandchallenge/challenges/models.py

@@ -1236,39 +1236,58 @@ def total_compute_time(self):
         return self.phase_1_compute_time + self.phase_2_compute_time
 
     @property
-    def phase_1_storage_size_bytes(self):
+    def phase_1_data_storage_size_bytes(self):
         return (
             self.phase_1_number_of_test_images
             * (self.average_size_of_test_image_in_mb * settings.MEGABYTE)
             * self.number_of_tasks
         )
 
     @property
-    def phase_2_storage_size_bytes(self):
+    def phase_2_data_storage_size_bytes(self):
         return (
             self.phase_2_number_of_test_images
             * (self.average_size_of_test_image_in_mb * settings.MEGABYTE)
             * self.number_of_tasks
         )
 
     @property
-    def docker_s3_storage_size_bytes(self):
+    def num_unique_docker_images_per_team(self):
+        # A docker for a later phase should also be submitted to an earlier one.
+        return max(
+            self.phase_1_number_of_submissions_per_team,
+            self.phase_2_number_of_submissions_per_team,
+        )
+
+    @property
+    def num_unique_docker_images(self):
+        return (
+            self.num_unique_docker_images_per_team
+            * self.expected_number_of_teams
+            * self.number_of_tasks
+        )
+
+    @property
+    def docker_storage_size_gb(self):
         return (
-            # 1 unique container image per submission
-            (self.average_algorithm_container_size_in_gb * settings.GIGABYTE)
-            * self.total_num_submissions
+            self.average_algorithm_container_size_in_gb
+            * self.num_unique_docker_images
         )
 
+    @property
+    def docker_storage_size_bytes(self):
+        return self.docker_storage_size_gb * settings.GIGABYTE
+
     @property
     def total_data_and_docker_storage_bytes(self):
         return (
-            self.docker_s3_storage_size_bytes
-            + self.phase_1_storage_size_bytes
-            + self.phase_2_storage_size_bytes
+            self.docker_storage_size_bytes
+            + self.phase_1_data_storage_size_bytes
+            + self.phase_2_data_storage_size_bytes
         )
 
     @cached_property
-    def compute_euro_cents_per_hour(self):
+    def compute_costs_euro_cents_per_hour(self):
         executors = [
             import_string(settings.COMPONENTS_DEFAULT_BACKEND)(
                 job_id="",
@@ -1285,40 +1304,54 @@ def compute_euro_cents_per_hour(self):
         )
         return usd_cents_per_hour * settings.COMPONENTS_USD_TO_EUR
 
+    @property
+    def compute_costs_euros_per_hour(self):
+        return self.compute_costs_euro_cents_per_hour / 100
+
     def get_compute_costs_euros(self, duration):
-        return self.round_to_10_euros(
-            duration.total_seconds()
-            * (1 + settings.COMPONENTS_TAX_RATE_PERCENT)
-            * self.compute_euro_cents_per_hour
-            / 3600
+        return (
+            math.ceil(
+                self.compute_costs_euro_cents_per_hour
+                * duration.total_seconds()
+                / 3600
+            )
+            / 100
         )
 
-    @classmethod
-    def get_data_storage_costs_euros(cls, size_bytes):
-        return cls.round_to_10_euros(
-            size_bytes
-            * settings.CHALLENGE_NUM_SUPPORT_YEARS
-            * (1 + settings.COMPONENTS_TAX_RATE_PERCENT)
+    @property
+    def storage_costs_euros_per_gb(self):
+        return (
+            settings.CHALLENGE_NUM_SUPPORT_YEARS
+            * settings.COMPONENTS_S3_USD_MILLICENTS_PER_YEAR_PER_TB_EXCLUDING_TAX
+            * (1 + settings.COMPONENTS_TAX_RATE)
             * settings.COMPONENTS_USD_TO_EUR
-            * settings.COMPONENTS_S3_USD_MILLICENTS_PER_YEAR_PER_TB
             / 1000
+            / 100
             / settings.TERABYTE
+            * settings.GIGABYTE
         )
 
-    @classmethod
-    def round_to_10_euros(cls, cents):
-        return 10 * math.ceil(cents / 100 / 10)
+    def get_storage_costs_euros(self, size_bytes):
+        return (
+            math.ceil(
+                self.storage_costs_euros_per_gb
+                * 100
+                * size_bytes
+                / settings.GIGABYTE
+            )
+            / 100
+        )
 
     @property
-    def phase_1_data_storage_euros(self):
-        return self.get_data_storage_costs_euros(
-            self.phase_1_storage_size_bytes
+    def phase_1_data_storage_costs_euros(self):
+        return self.get_storage_costs_euros(
+            self.phase_1_data_storage_size_bytes
         )
 
     @property
-    def phase_2_data_storage_euros(self):
-        return self.get_data_storage_costs_euros(
-            self.phase_2_storage_size_bytes
+    def phase_2_data_storage_costs_euros(self):
+        return self.get_storage_costs_euros(
+            self.phase_2_data_storage_size_bytes
         )
 
     @property
@@ -1332,20 +1365,20 @@ def phase_2_compute_costs_euros(self):
     @property
     def phase_1_total_euros(self):
         return (
-            self.phase_1_data_storage_euros + self.phase_1_compute_costs_euros
+            self.phase_1_data_storage_costs_euros
+            + self.phase_1_compute_costs_euros
         )
 
     @property
     def phase_2_total_euros(self):
         return (
-            self.phase_2_data_storage_euros + self.phase_2_compute_costs_euros
+            self.phase_2_data_storage_costs_euros
+            + self.phase_2_compute_costs_euros
         )
 
     @property
     def docker_storage_costs_euros(self):
-        return self.get_data_storage_costs_euros(
-            self.docker_s3_storage_size_bytes
-        )
+        return self.get_storage_costs_euros(self.docker_storage_size_bytes)
 
     @cached_property
     def base_cost_euros(self):
@@ -1359,42 +1392,11 @@ def base_cost_euros(self):
         else:
             return settings.CHALLENGE_BASE_COST_IN_EURO
 
-    @property
-    def total_euros_storage_and_compute(self):
-        return (
-            self.phase_1_total_euros
-            + self.phase_2_total_euros
-            + self.docker_storage_costs_euros
-        )
-
-    @cached_property
-    def budget(self):
-        try:
-            return {
-                "Data storage cost for phase 1": self.phase_1_data_storage_euros,
-                "Compute costs for phase 1": self.phase_1_compute_costs_euros,
-                "Total phase 1": self.phase_1_total_euros,
-                "Data storage cost for phase 2": self.phase_2_data_storage_euros,
-                "Compute costs for phase 2": self.phase_2_compute_costs_euros,
-                "Total phase 2": self.phase_2_total_euros,
-                "Docker storage cost": self.docker_storage_costs_euros,
-                "Total across phases": self.total_euros_storage_and_compute,
-            }
-        except TypeError:
-            return None
-
-    @property
-    def storage_and_compute_cost_surplus(self):
-        return (
-            self.total_euros_storage_and_compute
-            - settings.CHALLENGE_MINIMAL_COMPUTE_AND_STORAGE_IN_EURO
-        )
-
     @property
     def total_storage_costs_euros(self):
         return (
-            self.phase_1_data_storage_euros
-            + self.phase_2_data_storage_euros
+            self.phase_1_data_storage_costs_euros
+            + self.phase_2_data_storage_costs_euros
             + self.docker_storage_costs_euros
         )
 
@@ -1404,69 +1406,73 @@ def total_compute_costs_euros(self):
             self.phase_1_compute_costs_euros + self.phase_2_compute_costs_euros
         )
 
-    def calculate_invoiced_amount(self, *, cost, ratio):
-        if self.storage_and_compute_cost_surplus <= 0:
-            # Below minimum price, add proportional shortfall
-            return round(
-                cost + ratio * abs(self.storage_and_compute_cost_surplus)
-            )
-        else:
-            # Above minimum price, allocate surplus proportionally
-            return round(
-                ratio
-                * (
-                    self.additional_compute_and_storage_costs
-                    + settings.CHALLENGE_MINIMAL_COMPUTE_AND_STORAGE_IN_EURO
-                )
-            )
-
     @property
-    def compute_cost_ratio(self):
-        return (
-            self.total_compute_costs_euros
-            / self.total_euros_storage_and_compute
-        )
+    def total_compute_and_storage_costs_euros(self):
+        return self.total_storage_costs_euros + self.total_compute_costs_euros
 
     @property
-    def total_storage_to_be_invoiced(self):
-        return self.calculate_invoiced_amount(
-            cost=self.total_storage_costs_euros,
-            ratio=1 - self.compute_cost_ratio,
+    def capacity_reservation_units(self):
+        return math.ceil(
+            max(
+                settings.CHALLENGE_MINIMAL_COMPUTE_AND_STORAGE_IN_EURO,
+                self.total_compute_and_storage_costs_euros,
+            )
+            / settings.CHALLENGE_CAPACITY_RESERVATION_PACK_SIZE_IN_EURO
         )
 
     @property
-    def total_compute_to_be_invoiced(self):
-        return self.calculate_invoiced_amount(
-            cost=self.total_compute_costs_euros,
-            ratio=self.compute_cost_ratio,
+    def capacity_reservation_euros(self):
+        return (
+            self.capacity_reservation_units
+            * settings.CHALLENGE_CAPACITY_RESERVATION_PACK_SIZE_IN_EURO
         )
 
     @property
-    def minimal_challenge_cost(self):
+    def capacity_reservation_compute_euros(self):
         return (
-            self.base_cost_euros
-            + settings.CHALLENGE_MINIMAL_COMPUTE_AND_STORAGE_IN_EURO
+            self.total_compute_costs_euros
+            / self.total_compute_and_storage_costs_euros
+            * self.capacity_reservation_euros
         )
 
     @property
-    def additional_compute_and_storage_costs(self):
-        if self.storage_and_compute_cost_surplus <= 0:
-            return 0
-        else:
-            return (
-                math.ceil(
-                    self.storage_and_compute_cost_surplus
-                    / settings.CHALLENGE_ADDITIONAL_COMPUTE_AND_STORAGE_PACK_SIZE_IN_EURO
-                )
-                * settings.CHALLENGE_ADDITIONAL_COMPUTE_AND_STORAGE_PACK_SIZE_IN_EURO
-            )
+    def capacity_reservation_storage_euros(self):
+        return (
+            self.total_storage_costs_euros
+            / self.total_compute_and_storage_costs_euros
+            * self.capacity_reservation_euros
+        )
 
     @property
     def total_challenge_cost(self):
-        return (
-            self.minimal_challenge_cost
-            + self.additional_compute_and_storage_costs
-        )
+        return self.base_cost_euros + self.capacity_reservation_euros
+
+    @cached_property
+    def costs_for_phases(self):
+        return [
+            {
+                "name": "Phase 1",
+                "number_of_submissions_per_team": self.phase_1_number_of_submissions_per_team,
+                "number_of_test_images": self.phase_1_number_of_test_images,
+                "compute_time": self.phase_1_compute_time,
+                "compute_costs_euros": self.phase_1_compute_costs_euros,
+                "data_storage_size_gb": self.phase_1_data_storage_size_bytes
+                / settings.GIGABYTE,
+                "data_storage_costs_euros": self.phase_1_data_storage_costs_euros,
+                "total_euros": self.phase_1_total_euros,
+            },
+            {
+                "name": "Phase 2",
+                "number_of_submissions_per_team": self.phase_2_number_of_submissions_per_team,
+                "number_of_test_images": self.phase_2_number_of_test_images,
+                "compute_time": self.phase_2_compute_time,
+                "compute_costs_euros": self.phase_2_compute_costs_euros,
+                "data_storage_size_gb": self.phase_2_data_storage_size_bytes
+                / settings.GIGABYTE,
+                "data_storage_costs_euros": self.phase_2_data_storage_costs_euros,
+                "total_euros": self.phase_2_total_euros,
+            },
+        ]
 
 
 class ChallengeRequestUserObjectPermission(UserObjectPermissionBase):