Fixed plotting (at least tests), still missing frontend

Author: bogadisa

src/backend_api/app/core/schemas/plot/input.py

@@ -39,7 +39,7 @@ class WantedModifier(_pydantic.BaseModel):
 
 
 class BasePlotQuery(_pydantic.BaseModel):
-    league: list[str] | str
+    leagueId: list[int] | int
     itemSpecifications: ItemSpecs | None = None
     baseSpecifications: BaseSpecs | None = None
     end: int | None = None

src/backend_api/app/core/schemas/plot/output.py

@@ -11,7 +11,7 @@ class Datum(_pydantic.BaseModel):
 
 
 class TimeseriesData(_pydantic.BaseModel):
-    name: str
+    name: int
     data: list[Datum]
     confidenceRating: Literal["low", "medium", "high"]
 

src/backend_api/app/plotting/plotter.py

@@ -97,7 +97,7 @@ def _init_stmt(
         select_args: list[InstrumentedAttribute[Any] | Label[Any]] = [
             item_model.itemId,
             item_model.createdHoursSinceLaunch,
-            item_model.league,
+            item_model.leagueId,
             item_model.itemBaseTypeId,
             item_model.currencyId,
             item_model.currencyAmount,
@@ -114,12 +114,12 @@ def _init_stmt(
             model_Currency, item_model.currencyId == model_Currency.currencyId
         )
 
-        if isinstance(query.league, list):
+        if isinstance(query.leagueId, list):
             stmt = stmt.where(
-                or_(*[item_model.league == league for league in query.league])
+                or_(*[item_model.leagueId == league for league in query.leagueId])
             )
         else:
-            stmt = stmt.where(model_Item.league == query.league)
+            stmt = stmt.where(model_Item.leagueId == query.leagueId)
 
         if start is not None:
             stmt = stmt.where(item_model.createdHoursSinceLaunch >= start)
@@ -223,8 +223,8 @@ def _create_plot_data(self, df: pd.DataFrame) -> PlotData:
             0, "divine"
         )  # TODO: set enum
         data = []
-        for league in df["league"].unique():
-            league_df: pd.DataFrame = df.loc[df["league"] == league]
+        for league in df["leagueId"].unique():
+            league_df: pd.DataFrame = df.loc[df["leagueId"] == league]
             league_data = league_df[
                 [
                     "hoursSinceLaunch",
@@ -443,7 +443,7 @@ def _create_plot_statement(self, query: IdentifiedPlotQuery) -> Select:
                 base_query.c.tradeName.label("mostCommonTradeName"),
                 func.count(base_query.c.tradeName).label("nameCount"),
             )
-            .group_by(base_query.c.league, base_query.c.tradeName)
+            .group_by(base_query.c.leagueId, base_query.c.tradeName)
             .order_by(desc("nameCount"))  # Can use literal_column in complex cases
             .limit(1)
             .cte("mostCommon")
@@ -486,7 +486,7 @@ def _create_plot_statement(self, query: IdentifiedPlotQuery) -> Select:
         prices = (
             select(
                 base_query.c.createdHoursSinceLaunch,
-                base_query.c.league,
+                base_query.c.leagueId,
                 (base_query.c.currencyAmount * base_query.c.valueInChaos).label(
                     "valueInChaos"
                 ),
@@ -519,7 +519,7 @@ def _create_plot_statement(self, query: IdentifiedPlotQuery) -> Select:
         filtered_prices = (
             select(
                 ranked_prices.c.createdHoursSinceLaunch,
-                ranked_prices.c.league,
+                ranked_prices.c.leagueId,
                 ranked_prices.c.valueInChaos,
                 ranked_prices.c.valueInMostCommonCurrencyUsed,
                 ranked_prices.c.mostCommonCurrencyUsed,
@@ -537,7 +537,7 @@ def _create_plot_statement(self, query: IdentifiedPlotQuery) -> Select:
         final_query = (
             select(
                 filtered_prices.c.createdHoursSinceLaunch.label("hoursSinceLaunch"),
-                filtered_prices.c.league,
+                filtered_prices.c.leagueId,
                 func.avg(filtered_prices.c.valueInChaos).label("valueInChaos"),
                 func.avg(filtered_prices.c.valueInMostCommonCurrencyUsed).label(
                     "valueInMostCommonCurrencyUsed"
@@ -548,7 +548,7 @@ def _create_plot_statement(self, query: IdentifiedPlotQuery) -> Select:
                 func.min(filtered_prices.c.confidence).label("confidence"),
             )
             .group_by(
-                filtered_prices.c.createdHoursSinceLaunch, filtered_prices.c.league
+                filtered_prices.c.createdHoursSinceLaunch, filtered_prices.c.leagueId
             )
             .order_by(filtered_prices.c.createdHoursSinceLaunch)
         )

src/backend_api/app/tests/utils/model_utils/item.py

@@ -99,7 +99,7 @@ async def generate_random_item(
 ) -> tuple[
     dict,
     Item,
-    list[dict | ItemBaseType | Currency] | None,
+    list[dict | ItemBaseType | Currency | League] | None,
 ]:
     """Generate a random item.
 

src/backend_api/app/tests/utils/model_utils/item_modifier.py

@@ -6,6 +6,7 @@
     Item,
     ItemBaseType,
     ItemModifier,
+    League,
     Modifier,
 )
 from app.core.schemas.item_modifier import ItemModifierCreate
@@ -20,7 +21,7 @@ async def create_random_item_modifier_dict(
     dict
     | tuple[
         dict,
-        list[dict | ItemBaseType | Currency | Item | Modifier] | None,
+        list[dict | ItemBaseType | Currency | League | Item | Modifier] | None,
     ]
 ):
     """Create a random item modifier dictionary.
@@ -66,7 +67,7 @@ async def generate_random_item_modifier(
 ) -> tuple[
     dict,
     ItemModifier,
-    list[dict | ItemBaseType | Currency | Item | Modifier] | None,
+    list[dict | ItemBaseType | Currency | League | Item | Modifier] | None,
 ]:
     """Generate a random item modifier.
 

src/backend_api/app/tests/utils/model_utils/plot.py

@@ -3,7 +3,7 @@
 from sqlalchemy.orm import Session
 
 from app.core.models.models import (
-    Item as model_Item,
+    League as model_League,
 )
 from app.core.models.models import (
     Modifier as model_Modifier,
@@ -24,35 +24,17 @@ async def create_minimal_random_plot_query_dict(db: Session) -> dict[str, Any]:
         db, retrieve_dependencies=True
     )
 
-    item_dep: model_Item = item_modifier_deps[-3]
+    league_dep: model_League = item_modifier_deps[-3]
     modifier_dep: model_Modifier = item_modifier_deps[-1]
 
-    item_specs = {
-        "name": None,
-        "identified": None,
-        "minIlvl": None,
-        "maxIlvl": None,
-        "rarity": None,
-        "corrupted": None,
-        "delve": None,
-        "fractured": None,
-        "synthesised": None,
-        "replica": None,
-        "influences": None,
-        "searing": None,
-        "tangled": None,
-        "foilVariation": None,
-    }
-
     wanted_modifiers = [
         {
             "modifierId": modifier_dep.modifierId,
         }
     ]
 
     plot_query = {
-        "league": item_dep.league,
-        "itemSpecifications": item_specs,
+        "leagueId": league_dep.leagueId,
         "wantedModifiers": wanted_modifiers,
     }
 

src/backend_data_retrieval/data_retrieval_app/external_data_retrieval/config.py

@@ -41,7 +41,6 @@ def CURRENT_HARDCORE_LEAGUE(self) -> str:
     MINI_BATCH_SIZE: int = 30
     N_CHECKPOINTS_PER_TRANSFORMATION: int = 10
 
-    TIME_BETWEEN_RESTART: int = 3600
     MAX_TIME_PER_MINI_BATCH: int = 3 * 60
 
     LEAGUE_LAUNCH_TIME: str

src/backend_data_retrieval/data_retrieval_app/external_data_retrieval/data_retrieval/poe_api_handler.py

@@ -84,8 +84,6 @@ def __init__(
 
         self._program_too_slow = False
         self._program_finished = False
-        self.time_of_launch = time.perf_counter()
-        self.run_program_for_n_seconds = settings.TIME_BETWEEN_RESTART
         logger.info("PoEAPIHandler successfully initialized.")
 
         self.n_checkpoints_per_transfromation = (
@@ -531,7 +529,3 @@ def dump_stream(self, track_progress: bool = True) -> Iterator[pd.DataFrame]:
                 yield df.reset_index()
                 del df
                 logger.info("Finished transformation phase")
-                current_time = time.perf_counter()
-                time_since_launch = current_time - self.time_of_launch
-                if time_since_launch > self.run_program_for_n_seconds:
-                    raise ProgramFinished