algomancy-content 0.3.12__py3-none-any.whl

algomancy_content/__init__.py

@@ -0,0 +1,45 @@
+from .backend import (
+    PlaceholderSchema,
+    PlaceholderETLFactory,
+    placeholder_input_config,
+    PlaceholderKPI,
+    PlaceholderAlgorithm,
+    PlaceholderParams,
+)
+from .pages import (
+    HomePage,
+    DataPage,
+    ScenarioPage,
+    ComparePage,
+    OverviewPage,
+    PlaceholderDataPage,
+    ShowcaseHomePage,
+    StandardHomePage,
+    StandardDataPage,
+    PlaceholderComparePage,
+    PlaceholderScenarioPage,
+    StandardOverviewPage,
+)
+from .librarymanager import LibraryManager
+
+__all__ = [
+    "LibraryManager",
+    "HomePage",
+    "DataPage",
+    "ScenarioPage",
+    "ComparePage",
+    "OverviewPage",
+    "ShowcaseHomePage",
+    "StandardHomePage",
+    "StandardDataPage",
+    "PlaceholderDataPage",
+    "PlaceholderComparePage",
+    "PlaceholderScenarioPage",
+    "StandardOverviewPage",
+    "PlaceholderETLFactory",
+    "PlaceholderSchema",
+    "placeholder_input_config",
+    "PlaceholderKPI",
+    "PlaceholderAlgorithm",
+    "PlaceholderParams",
+]

algomancy_content/backend/__init__.py

@@ -0,0 +1,13 @@
+from .placeholderetlfactory import PlaceholderETLFactory
+from .placeholderinputconfig import PlaceholderSchema, placeholder_input_config
+from .placeholderalgorithmtemplate import PlaceholderAlgorithm, PlaceholderParams
+from .placeholderkpitemplate import PlaceholderKPI
+
+__all__ = [
+    "PlaceholderETLFactory",
+    "PlaceholderSchema",
+    "placeholder_input_config",
+    "PlaceholderKPI",
+    "PlaceholderAlgorithm",
+    "PlaceholderParams",
+]

algomancy_content/backend/placeholderalgorithmtemplate.py

@@ -0,0 +1,26 @@
+from time import sleep
+
+from algomancy_data import DataSource
+from algomancy_scenario import BaseParameterSet, ScenarioResult, BaseAlgorithm
+
+
+class PlaceholderParams(BaseParameterSet):
+    def __init__(self, name: str = "As is") -> None:
+        super().__init__(name=name)
+
+    def validate(self):
+        pass
+
+
+class PlaceholderAlgorithm(BaseAlgorithm):
+    def __init__(self, params: PlaceholderParams):
+        super().__init__("As is", params)
+
+    @staticmethod
+    def initialize_parameters() -> PlaceholderParams:
+        return PlaceholderParams()
+
+    def run(self, data: DataSource) -> ScenarioResult:
+        sleep(0.5)
+        self.set_progress(100)
+        return ScenarioResult(data_id=data.id)

algomancy_content/backend/placeholderetlfactory.py

@@ -0,0 +1,26 @@
+from typing import Dict
+
+import algomancy_data as de
+from algomancy_data import File
+from algomancy_data.extractor import ExtractionSequence
+from algomancy_data.transformer import TransformationSequence
+
+
+class PlaceholderETLFactory(de.ETLFactory):
+    def __init__(self, configs, logger=None):
+        super().__init__(configs, logger)
+
+    def create_extraction_sequence(self, files: Dict[str, File]) -> ExtractionSequence:
+        # return the empty sequence
+        return ExtractionSequence(logger=self.logger)
+
+    def create_transformation_sequence(self) -> TransformationSequence:
+        # return the empty sequence
+        return TransformationSequence(logger=self.logger)
+
+    def create_validation_sequence(self) -> de.ValidationSequence:
+        # return the empty sequence
+        return de.ValidationSequence(logger=self.logger)
+
+    def create_loader(self) -> de.Loader:
+        return de.DataSourceLoader(self.logger)

algomancy_content/backend/placeholderinputconfig.py

@@ -0,0 +1,32 @@
+from typing import Dict
+
+from algomancy_data import (
+    Schema,
+    DataType,
+    SingleInputFileConfiguration,
+    FileExtension,
+)
+
+
+class PlaceholderSchema(Schema):
+    """Schema class that holds column names for placeholder data"""
+
+    @property
+    def datatypes(self) -> Dict[str, DataType]:
+        return {
+            "id": DataType.INTEGER,
+            "name": DataType.STRING,
+            "age": DataType.INTEGER,
+            "city": DataType.STRING,
+            "department": DataType.STRING,
+            "salary": DataType.INTEGER,
+            "hire_date": DataType.DATETIME,
+            "performance_score": DataType.FLOAT,
+        }
+
+
+placeholder_input_config = SingleInputFileConfiguration(
+    extension=FileExtension.CSV,
+    file_name="placeholder_data",
+    file_schema=PlaceholderSchema(),
+)

algomancy_content/backend/placeholderkpitemplate.py

@@ -0,0 +1,20 @@
+import random
+
+from algomancy_scenario import (
+    ImprovementDirection,
+    BaseKPI,
+    ScenarioResult,
+)
+from algomancy_utils import QUANTITIES, BaseMeasurement
+
+
+percent = QUANTITIES["percentage"]
+percent_percent = BaseMeasurement(percent["%"], min_digits=1, max_digits=3, decimals=1)
+
+
+class PlaceholderKPI(BaseKPI):
+    def __init__(self):
+        super().__init__("Placeholder", ImprovementDirection.HIGHER, percent_percent)
+
+    def compute(self, result: ScenarioResult) -> float:
+        return 50 * (1 + 0.5 * random.random())

algomancy_content/librarymanager.py

@@ -0,0 +1,73 @@
+from typing import Tuple, Dict
+
+from algomancy_content.pages.page import (
+    HomePage,
+    DataPage,
+    ScenarioPage,
+    ComparePage,
+    OverviewPage,
+)
+
+from algomancy_content.pages.standarddatapage import StandardDataPage
+from algomancy_content.pages.showcasehomepage import ShowcaseHomePage
+from algomancy_content.pages.standardhomepage import StandardHomePage
+from algomancy_content.pages.placeholderdatapage import PlaceholderDataPage
+from algomancy_content.pages.placeholdercomparepage import PlaceholderComparePage
+from algomancy_content.pages.placeholderscenariopage import PlaceholderScenarioPage
+from algomancy_content.pages.standardoverviewpage import StandardOverviewPage
+
+
+class LibraryManager:
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def get_pages(
+        cfg: Dict,
+    ) -> Tuple[HomePage, DataPage, ScenarioPage, ComparePage, OverviewPage]:
+        home_choices = {
+            "standard": StandardHomePage,
+            "showcase": ShowcaseHomePage,
+        }
+        home_page = LibraryManager._get_page(cfg["home_page"], "home", home_choices)
+
+        data_choices = {
+            "standard": StandardDataPage,
+            "placeholder": PlaceholderDataPage,
+        }
+        data_page = LibraryManager._get_page(cfg["data_page"], "data", data_choices)
+
+        scenario_choices = {
+            "placeholder": PlaceholderScenarioPage,
+        }
+        scenario_page = LibraryManager._get_page(
+            cfg["scenario_page"], "scenario", scenario_choices
+        )
+
+        compare_choices = {
+            "placeholder": PlaceholderComparePage,
+        }
+        compare_page = LibraryManager._get_page(
+            cfg["compare_page"], "compare", compare_choices
+        )
+
+        overview_choices = {
+            "standard": StandardOverviewPage,
+        }
+        overview_page = LibraryManager._get_page(
+            cfg["overview_page"], "overview", overview_choices
+        )
+
+        return home_page, data_page, scenario_page, compare_page, overview_page
+
+    @staticmethod
+    def _get_page(page, identifier: str, choices: Dict):
+        if isinstance(page, str):
+            found_page = choices.get(page, None)
+            if not found_page:
+                raise ValueError(
+                    f"Prepared component choices for {identifier} page are: {list(choices.keys())}"
+                )
+            return found_page
+        else:
+            return page

algomancy_content/pages/__init__.py

@@ -0,0 +1,31 @@
+from .page import (
+    HomePage,
+    DataPage,
+    ScenarioPage,
+    ComparePage,
+    OverviewPage,
+)
+
+from .standarddatapage import StandardDataPage
+from .showcasehomepage import ShowcaseHomePage
+from .standardhomepage import StandardHomePage
+from .placeholderdatapage import PlaceholderDataPage
+from .placeholdercomparepage import PlaceholderComparePage
+from .placeholderscenariopage import PlaceholderScenarioPage
+from .standardoverviewpage import StandardOverviewPage
+
+__all__ = [
+    "HomePage",
+    "DataPage",
+    "ScenarioPage",
+    "ComparePage",
+    "OverviewPage",
+    "PlaceholderDataPage",
+    "ShowcaseHomePage",
+    "StandardHomePage",
+    "StandardDataPage",
+    "PlaceholderDataPage",
+    "PlaceholderComparePage",
+    "PlaceholderScenarioPage",
+    "StandardOverviewPage",
+]

algomancy_content/pages/page.py

@@ -0,0 +1,49 @@
+from typing import Protocol, List
+from dash import html
+
+from algomancy_data import BASE_DATA_BOUND
+from algomancy_scenario import Scenario
+
+
+class BasePage(Protocol):
+    @staticmethod
+    def register_callbacks() -> None:
+        raise NotImplementedError("Abstract method")
+
+
+class HomePage(BasePage, Protocol):
+    @staticmethod
+    def create_content() -> html.Div:
+        raise NotImplementedError("Abstract method")
+
+
+class DataPage(BasePage, Protocol):
+    @staticmethod
+    def create_content(data: BASE_DATA_BOUND) -> html.Div:
+        raise NotImplementedError("Abstract method")
+
+
+class ScenarioPage(BasePage, Protocol):
+    @staticmethod
+    def create_content(scenario: Scenario) -> html.Div:
+        raise NotImplementedError("Abstract method")
+
+
+class ComparePage(BasePage, Protocol):
+    @staticmethod
+    def create_side_by_side_content(scenario: Scenario, side: str) -> html.Div:
+        raise NotImplementedError("Abstract method")
+
+    @staticmethod
+    def create_compare_section(left: Scenario, right: Scenario) -> html.Div:
+        raise NotImplementedError("Abstract method")
+
+    @staticmethod
+    def create_details_section(left: Scenario, right: Scenario) -> html.Div:
+        raise NotImplementedError("Abstract method")
+
+
+class OverviewPage(BasePage, Protocol):
+    @staticmethod
+    def create_content(scenarios: List[Scenario]) -> html.Div:
+        raise NotImplementedError("Abstract method")

algomancy_content/pages/placeholdercomparepage.py

@@ -0,0 +1,49 @@
+"""
+Placeholder content for the Compare page - Secondary Results Component
+
+This module defines the secondary results section component for the compare dashboard page.
+It creates a collapsible section that displays additional results for the selected scenarios.
+"""
+
+from dash import html
+
+from algomancy_scenario import Scenario
+
+
+class PlaceholderComparePage:
+    @staticmethod
+    def create_side_by_side_content(s: Scenario, side: str) -> html.Div:
+        return html.Div(
+            [
+                html.H5(f"{side.capitalize()} Scenario {s.tag}"),
+                html.P(f"Status: {s.status.capitalize()}"),
+                html.P(f"Algorithm: {s.algorithm_description}"),
+            ]
+        )
+
+    @staticmethod
+    def register_callbacks():
+        pass
+
+    @staticmethod
+    def create_details_section(s1: Scenario, s2: Scenario) -> html.Div:
+        page = html.Div(
+            [
+                html.H5("Selected Scenarios"),
+                html.P(f"Scenario 1: {s1.tag}"),
+                html.P(f"Scenario 2: {s2.tag}"),
+            ]
+        )
+
+        return page
+
+    @staticmethod
+    def create_compare_section(s1: Scenario, s2: Scenario) -> html.Div:
+        page = html.Div(
+            [
+                html.H5("This section compares selected scenarios"),
+                html.P(f"Scenario 1: {s1.tag}"),
+                html.P(f"Scenario 2: {s2.tag}"),
+            ]
+        )
+        return page

algomancy_content/pages/placeholderdatapage.py

@@ -0,0 +1,19 @@
+from dash import html
+
+from algomancy_data import DataSource
+
+
+class PlaceholderDataPage:
+    @staticmethod
+    def register_callbacks():
+        pass
+
+    @staticmethod
+    def create_content(data: DataSource):
+        return [
+            html.H5("Selected Dataset"),
+            html.P(f"ID: {data.id}"),
+            html.P(f"Name: {data.name}"),
+            html.Hr(),
+            html.Strong("Placeholder data view"),
+        ]

algomancy_content/pages/placeholderscenariopage.py

@@ -0,0 +1,24 @@
+from dash import html
+
+from algomancy_scenario import Scenario
+
+
+class PlaceholderScenarioPage:
+    @staticmethod
+    def register_callbacks():
+        pass
+
+    @staticmethod
+    def create_content(s: Scenario) -> html.Div:
+        page = html.Div(
+            [
+                html.H5("Selected Scenario"),
+                html.P(f"ID: {s.id}"),
+                html.P(f"Tag: {s.tag}"),
+                html.P(f"Status: {s.status}"),
+                html.P(f"Algorithm: {s.algorithm_description}"),
+                html.P(f"Dataset: {s.input_data_key}"),
+            ]
+        )
+
+        return page