digitalkin 0.2.11__py3-none-any.whl → 0.2.13__py3-none-any.whl

digitalkin/services/cost/cost_strategy.py

@@ -1,8 +1,8 @@
 """This module contains the abstract base class for cost strategies."""
 
 from abc import ABC, abstractmethod
-from enum import Enum, auto
-from typing import Any
+from enum import Enum
+from typing import Literal
 
 from pydantic import BaseModel
 
@@ -10,36 +10,84 @@ from digitalkin.services.base_strategy import BaseStrategy
 
 
 class CostType(Enum):
-    """."""
+    """Enum defining the types of costs that can be registered."""
 
-    OTHER = auto()
-    TOKEN_INPUT = auto()
-    TOKEN_OUTPUT = auto()
-    API_CALL = auto()
-    STORAGE = auto()
-    TIME = auto()
+    OTHER = "OTHER"
+    TOKEN_INPUT = "TOKEN_INPUT"
+    TOKEN_OUTPUT = "TOKEN_OUTPUT"
+    API_CALL = "API_CALL"
+    STORAGE = "STORAGE"
+    TIME = "TIME"
+
+
+class CostConfig(BaseModel):
+    """Pydantic model that defines a cost configuration.
+
+    :param cost_name: Name of the cost (unique identifier in the service).
+    :param cost_type: The type/category of the cost.
+    :param description: A short description of the cost.
+    :param unit: The unit of measurement (e.g. token, call, MB).
+    :param rate: The cost per unit (e.g. dollars per token).
+    """
+
+    cost_name: str
+    cost_type: Literal["TOKEN_INPUT", "TOKEN_OUTPUT", "API_CALL", "STORAGE", "TIME", "OTHER"]
+    description: str | None = None
+    unit: str
+    rate: float
 
 
 class CostData(BaseModel):
-    """."""
+    """Data model for cost operations."""
 
     cost: float
     mission_id: str
     name: str
-    type: CostType
+    cost_type: CostType
     unit: str
+    rate: float
+    setup_version_id: str
+    quantity: float
+
+
+class CostServiceError(Exception):
+    """Custom exception for CostService errors."""
 
 
 class CostStrategy(BaseStrategy, ABC):
     """Abstract base class for cost strategies."""
 
+    def __init__(self, mission_id: str, setup_version_id: str, config: dict[str, CostConfig]) -> None:
+        """Initialize the strategy.
+
+        Args:
+            mission_id: The ID of the mission this strategy is associated with
+            setup_version_id: The ID of the setup version this strategy is associated with
+            config: Configuration dictionary for the strategy
+        """
+        super().__init__(mission_id, setup_version_id)
+        self.config = config
+
     @abstractmethod
-    def add_cost(self, cost_dict: dict[str, Any]) -> str:
+    def add(
+        self,
+        name: str,
+        cost_config_name: str,
+        quantity: float,
+    ) -> None:
         """Register a new cost."""
 
-    def __post_init__(self, *args, **kwargs) -> None:  # noqa: ANN002, ANN003
-        """Allow post init configuration."""
-
     @abstractmethod
-    def get(self, cost_dict: dict[str, Any]) -> list[CostData]:
+    def get(
+        self,
+        name: str,
+    ) -> list[CostData]:
         """Get a cost."""
+
+    @abstractmethod
+    def get_filtered(
+        self,
+        names: list[str] | None = None,
+        cost_types: list[Literal["TOKEN_INPUT", "TOKEN_OUTPUT", "API_CALL", "STORAGE", "TIME", "OTHER"]] | None = None,
+    ) -> list[CostData]:
+        """Get filtered costs."""

digitalkin/services/cost/default_cost.py

@@ -1,30 +1,113 @@
 """Default cost."""
 
-import logging
-from typing import Any
+from typing import Literal
 
-from digitalkin.services.cost.cost_strategy import CostData, CostStrategy
-
-logger = logging.getLogger(__name__)
+from digitalkin.logger import logger
+from digitalkin.services.cost.cost_strategy import (
+    CostConfig,
+    CostData,
+    CostServiceError,
+    CostStrategy,
+    CostType,
+)
 
 
 class DefaultCost(CostStrategy):
     """Default cost strategy."""
 
-    def add_cost(self, cost_dict: dict[str, Any]) -> str:  # noqa: PLR6301
+    def __init__(self, mission_id: str, setup_version_id: str, config: dict[str, CostConfig]) -> None:
+        """Initialize the strategy.
+
+        Args:
+            mission_id: The ID of the mission this strategy is associated with
+            setup_version_id: The ID of the setup version this strategy is associated with
+            config: The configuration dictionary for the cost
+        """
+        super().__init__(mission_id=mission_id, setup_version_id=setup_version_id, config=config)
+        self.db: dict[str, list[CostData]] = {}
+
+    def add(
+        self,
+        name: str,
+        cost_config_name: str,
+        quantity: float,
+    ) -> None:
         """Create a new record in the cost database.
 
+        Args:
+            name: The name of the cost
+            cost_config_name: The name of the cost config
+            quantity: The quantity of the cost
+
+        Raises:
+            CostServiceError: If the cost data is invalid or if the cost already exists
+        """
+        cost_config = self.config.get(cost_config_name)
+        if cost_config is None:
+            msg = f"Cost config {cost_config_name} not found in the configuration."
+            logger.error(msg)
+            raise CostServiceError(msg)
+        cost_data = CostData.model_validate({
+            "name": name,
+            "cost": cost_config.rate * quantity,
+            "unit": cost_config.unit,
+            "cost_type": getattr(CostType, cost_config.cost_type),
+            "mission_id": self.mission_id,
+            "rate": cost_config.rate,
+            "quantity": quantity,
+            "setup_version_id": self.setup_version_id,
+        })
+        if cost_data.mission_id not in self.db:
+            self.db[cost_data.mission_id] = []
+        if cost_data.name in [cost.name for cost in self.db[cost_data.mission_id]]:
+            msg = f"Cost with name {cost_data.name} already exists in mission {cost_data.mission_id}"
+            logger.error(msg)
+            raise CostServiceError(msg)
+        self.db[cost_data.mission_id].append(cost_data)
+
+    def get(self, name: str) -> list[CostData]:
+        """Get a record from the database.
+
+        Args:
+            name: The name of the cost
+
         Returns:
-            str: The ID of the new record
+            list[CostData]: The cost data
+
+        Raises:
+            CostServiceError: If the cost data is invalid or if the cost does not exist
         """
-        logger.info("Cost added with cost_dict: %s", cost_dict)
-        return ""
+        if self.mission_id not in self.db:
+            msg = f"Mission {self.mission_id} not found in the database."
+            logger.warning(msg)
+            raise CostServiceError(msg)
+
+        return [cost for cost in self.db[self.mission_id] if cost.name == name] or []
 
-    def get(self, cost_dict: dict[str, Any]) -> list[CostData]:  # noqa: PLR6301
+    def get_filtered(
+        self,
+        names: list[str] | None = None,
+        cost_types: list[Literal["TOKEN_INPUT", "TOKEN_OUTPUT", "API_CALL", "STORAGE", "TIME", "OTHER"]] | None = None,
+    ) -> list[CostData]:
         """Get records from the database.
 
+        Args:
+            names: The names of the costs
+            cost_types: The types of the costs
+
         Returns:
             list[CostData]: The list of records
+
+        Raises:
+            CostServiceError: If the cost data is invalid or if the cost does not exist
         """
-        logger.info("Costs querried with cost_dict: %s", cost_dict)
-        return []
+        if self.mission_id not in self.db:
+            msg = f"Mission {self.mission_id} not found in the database."
+            logger.warning(msg)
+            raise CostServiceError(msg)
+
+        return [
+            cost
+            for cost in self.db[self.mission_id]
+            if (names and cost.name in names) or (cost_types and cost.cost_type in cost_types)
+        ]

digitalkin/services/cost/grpc_cost.py

@@ -1,81 +1,170 @@
-"""This module implements the default Cost strategy."""
+"""This module implements the gRPC Cost strategy."""
 
-import logging
-from typing import Any
+from collections.abc import Generator
+from contextlib import contextmanager
+from typing import Any, Literal
 
 from digitalkin_proto.digitalkin.cost.v1 import cost_pb2, cost_service_pb2_grpc
 from google.protobuf import json_format
-from pydantic import ValidationError
 
+from digitalkin.grpc_servers.utils.exceptions import ServerError
 from digitalkin.grpc_servers.utils.grpc_client_wrapper import GrpcClientWrapper
-from digitalkin.grpc_servers.utils.models import ServerConfig
-from digitalkin.services.cost.cost_strategy import CostData, CostStrategy
-
-logger = logging.getLogger(__name__)
+from digitalkin.grpc_servers.utils.models import ClientConfig
+from digitalkin.logger import logger
+from digitalkin.services.cost.cost_strategy import (
+    CostConfig,
+    CostData,
+    CostServiceError,
+    CostStrategy,
+    CostType,
+)
 
 
 class GrpcCost(CostStrategy, GrpcClientWrapper):
     """This class implements the default Cost strategy."""
 
-    def _get_costs_by_name(self, cost_dict: dict[str, Any]) -> list[CostData]:
-        request = cost_pb2.GetCostsByNameRequest(
-            mission_id=cost_dict["mission_id"],
-            name=cost_dict["name"],
-        )
-        response = self.exec_grpc_query("GetCostsByName", request)
-        return [CostData(**json_format.MessageToDict(cost)) for cost in response.costs]
-
-    def _get_costs_by_mission(self, cost_dict: dict[str, Any]) -> list[CostData]:
-        request = cost_pb2.GetCostsByMissionRequest(mission_id=cost_dict["mission_id"])
-        response = self.exec_grpc_query("GetCostsByMission", request)
-        return [CostData(**json_format.MessageToDict(cost)) for cost in response.costs]
-
-    def _get_costs_by_type(self, cost_dict: dict[str, Any]) -> list[CostData]:
-        request = cost_pb2.GetCostsByTypeRequest(
-            mission_id=cost_dict["mission_id"],
-            type=cost_dict["type"],
-        )
-        response = self.exec_grpc_query("GetCostsBytype", request)
-        return [CostData(**json_format.MessageToDict(cost)) for cost in response.costs]
-
-    def __init__(self, mission_id: str, config: ServerConfig) -> None:
-        """Initialize the cost."""
-        super().__init__(mission_id)
-        channel = self._init_channel(config)
-        self.stub = cost_service_pb2_grpc.CostServiceStub(channel)
-        logger.info("Channel client 'Cost' initialized succesfully")
+    @staticmethod
+    @contextmanager
+    def _handle_grpc_errors(operation: str) -> Generator[Any, Any, Any]:
+        """Context manager for consistent gRPC error handling.
 
-    def add_cost(self, cost_dict: dict[str, Any]) -> str:
-        """Create a new record in the cost database.
+        Yields:
+            Allow error handling in context.
 
-        Required arguments:
-            data: Object representation of CostData
+        Args:
+            operation: Description of the operation being performed.
 
-        Returns:
-            str: The ID of the new record
+        Raises:
+            ValueError: Error with the model validation.
+            ServerError: from gRPC Client.
+            CostServiceError: Unexpected error.
         """
         try:
-            valid_data = CostData.model_validate(cost_dict["data"])
-        except ValidationError:
-            logger.exception("Validation failed for model StorageData")
-            return ""
-        except KeyError:
-            logger.exception("Missing mandatory 'data' in dict.")
-            return ""
+            yield
+        except CostServiceError as e:
+            msg = f"CostServiceError in {operation}: {e}"
+            logger.exception(msg)
+            raise CostServiceError(msg) from e
+        except ServerError as e:
+            msg = f"gRPC {operation} failed: {e}"
+            logger.exception(msg)
+            raise ServerError(msg) from e
+        except Exception as e:
+            msg = f"Unexpected error in {operation}"
+            logger.exception(msg)
+            raise CostServiceError(msg) from e
+
+    def __init__(
+        self,
+        mission_id: str,
+        setup_version_id: str,
+        config: dict[str, CostConfig],
+        client_config: ClientConfig,
+    ) -> None:
+        """Initialize the cost."""
+        super().__init__(mission_id=mission_id, setup_version_id=setup_version_id, config=config)
+        channel = self._init_channel(client_config)
+        self.stub = cost_service_pb2_grpc.CostServiceStub(channel)
+        logger.debug("Channel client 'Cost' initialized succesfully")
+
+    def add(
+        self,
+        name: str,
+        cost_config_name: str,
+        quantity: float,
+    ) -> None:
+        """Create a new record in the cost database.
+
+        Args:
+            name: The name of the cost
+            cost_config_name: The name of the cost config
+            quantity: The quantity of the cost
 
-        request = cost_pb2.AddCostRequest(**valid_data.model_dump())
-        return self.exec_grpc_query("AddCost", request)
+        Raises:
+            CostServiceError: If the cost config is invalid
+        """
+        with self._handle_grpc_errors("AddCost"):
+            cost_config = self.config.get(cost_config_name)
+            if cost_config is None:
+                msg = f"Cost config {cost_config_name} not found in the configuration."
+                logger.error(msg)
+                raise CostServiceError(msg)
+            valid_data = CostData.model_validate({
+                "name": name,
+                "cost": cost_config.rate * quantity,
+                "unit": cost_config.unit,
+                "cost_type": CostType[cost_config.cost_type],
+                "mission_id": self.mission_id,
+                "rate": cost_config.rate,
+                "quantity": quantity,
+                "setup_version_id": self.setup_version_id,
+            })
+            request = cost_pb2.AddCostRequest(
+                cost=valid_data.cost,
+                name=valid_data.name,
+                unit=valid_data.unit,
+                cost_type=valid_data.cost_type.name,
+                mission_id=valid_data.mission_id,
+                rate=valid_data.rate,
+                quantity=valid_data.quantity,
+                setup_version_id=valid_data.setup_version_id,
+            )
+            self.exec_grpc_query("AddCost", request)
+            logger.debug("Cost added with cost_dict: %s", valid_data.model_dump())
+
+    def get(self, name: str) -> list[CostData]:
+        """Get a record from the database.
+
+        Args:
+            name: The name of the cost
 
-    def get(self, cost_dict: dict[str, Any]) -> list[CostData]:
-        """Get records from the database.
+        Returns:
+            CostData: The cost data
+        """
+        with self._handle_grpc_errors("GetCost"):
+            request = cost_pb2.GetCostRequest(name=name, mission_id=self.mission_id)
+            response: cost_pb2.GetCostResponse = self.exec_grpc_query("GetCost", request)
+            cost_data_list = [
+                json_format.MessageToDict(
+                    cost,
+                    preserving_proto_field_name=True,
+                    always_print_fields_with_no_presence=True,
+                )
+                for cost in response.costs
+            ]
+            logger.debug("Costs retrieved with cost_dict: %s", cost_data_list)
+            return [CostData.model_validate(cost_data) for cost_data in cost_data_list]
+
+    def get_filtered(
+        self,
+        names: list[str] | None = None,
+        cost_types: list[Literal["TOKEN_INPUT", "TOKEN_OUTPUT", "API_CALL", "STORAGE", "TIME", "OTHER"]] | None = None,
+    ) -> list[CostData]:
+        """Get a list of records from the database.
+
+        Args:
+            names: The names of the costs
+            cost_types: The types of the costs
 
         Returns:
-            list[CostData]: The list of records
+            list[CostData]: The cost data
         """
-        if "mission_id" not in cost_dict:
-            return []
-        if "name" in cost_dict:
-            return self._get_costs_by_name(cost_dict)
-        if "type" in cost_dict:
-            return self._get_costs_by_type(cost_dict)
-        return self._get_costs_by_mission(cost_dict)
+        with self._handle_grpc_errors("GetCosts"):
+            request = cost_pb2.GetCostsRequest(
+                mission_id=self.mission_id,
+                filter=cost_pb2.CostFilter(
+                    names=names or [],
+                    cost_types=cost_types or [],
+                ),
+            )
+            response: cost_pb2.GetCostsResponse = self.exec_grpc_query("GetCosts", request)
+            cost_data_list = [
+                json_format.MessageToDict(
+                    cost,
+                    preserving_proto_field_name=True,
+                    always_print_fields_with_no_presence=True,
+                )
+                for cost in response.costs
+            ]
+            logger.debug("Filtered costs retrieved with cost_dict: %s", cost_data_list)
+            return [CostData.model_validate(cost_data) for cost_data in cost_data_list]

digitalkin/services/filesystem/default_filesystem.py

@@ -1,10 +1,10 @@
 """Default filesystem."""
 
-import logging
 import os
 import tempfile
 from pathlib import Path
 
+from digitalkin.logger import logger
 from digitalkin.services.filesystem.filesystem_strategy import (
     FilesystemData,
     FilesystemServiceError,
@@ -12,20 +12,19 @@ from digitalkin.services.filesystem.filesystem_strategy import (
     FileType,
 )
 
-logger = logging.getLogger(__name__)
-
 
 class DefaultFilesystem(FilesystemStrategy):
     """Default state filesystem strategy."""
 
-    def __init__(self, mission_id: str, config: dict[str, str]) -> None:
+    def __init__(self, mission_id: str, setup_version_id: str, config: dict[str, str]) -> None:
         """Initialize the default filesystem strategy.
 
         Args:
             mission_id: The ID of the mission this strategy is associated with
+            setup_version_id: The ID of the setup version this strategy is associated with
             config: A dictionary mapping names to Pydantic model classes
         """
-        super().__init__(mission_id, config)
+        super().__init__(mission_id, setup_version_id, config)
         self.temp_root: str = self.config.get("temp_root", "") or tempfile.gettempdir()
         os.makedirs(self.temp_root, exist_ok=True)
         self.db: dict[str, FilesystemData] = {}
@@ -176,7 +175,7 @@ class DefaultFilesystem(FilesystemStrategy):
         try:
             os.remove(file_path)
             del self.db[name]
-            logger.info("File %s successfully deleted.", name)
+            logger.debug("File %s successfully deleted.", name)
 
         except OSError:
             msg = f"Error deleting file {name} from filesystem"

digitalkin/services/filesystem/filesystem_strategy.py

@@ -35,14 +35,15 @@ class FilesystemData(BaseModel):
 class FilesystemStrategy(BaseStrategy, ABC):
     """Abstract base class for filesystem strategies."""
 
-    def __init__(self, mission_id: str, config: dict[str, str]) -> None:
+    def __init__(self, mission_id: str, setup_version_id: str, config: dict[str, str]) -> None:
         """Initialize the strategy.
 
         Args:
             mission_id: The ID of the mission this strategy is associated with
+            setup_version_id: The ID of the setup version this strategy is associated with
             config: configuration dictionary for the filesystem strategy
         """
-        super().__init__(mission_id)
+        super().__init__(mission_id, setup_version_id)
         self.config: dict[str, str] = config
 
     @abstractmethod

digitalkin/services/filesystem/grpc_filesystem.py

@@ -1,16 +1,21 @@
 """Grpc filesystem."""
 
-import logging
 from collections.abc import Generator
 from contextlib import contextmanager
 from typing import Any
 
-from digitalkin_proto.digitalkin.filesystem.v2 import filesystem_pb2, filesystem_service_pb2_grpc
-from digitalkin_proto.digitalkin.filesystem.v2.filesystem_pb2 import FileType as FileTypeProto
+from digitalkin_proto.digitalkin.filesystem.v2 import (
+    filesystem_pb2,
+    filesystem_service_pb2_grpc,
+)
+from digitalkin_proto.digitalkin.filesystem.v2.filesystem_pb2 import (
+    FileType as FileTypeProto,
+)
 
 from digitalkin.grpc_servers.utils.exceptions import ServerError
 from digitalkin.grpc_servers.utils.grpc_client_wrapper import GrpcClientWrapper
 from digitalkin.grpc_servers.utils.models import ClientConfig
+from digitalkin.logger import logger
 from digitalkin.services.filesystem.filesystem_strategy import (
     FilesystemData,
     FilesystemServiceError,
@@ -18,32 +23,10 @@ from digitalkin.services.filesystem.filesystem_strategy import (
     FileType,
 )
 
-logger = logging.getLogger(__name__)
-
 
 class GrpcFilesystem(FilesystemStrategy, GrpcClientWrapper):
     """Default state filesystem strategy."""
 
-    def __init__(
-        self,
-        mission_id: str,
-        config: dict[str, str],
-        client_config: ClientConfig,
-        **kwargs,  # noqa: ANN003, ARG002
-    ) -> None:
-        """Initialize the default filesystem strategy.
-
-        Args:
-            mission_id: The ID of the mission this strategy is associated with
-            config: A dictionary mapping names to Pydantic model classes
-            client_config: The client configuration object
-            kwargs: other optional arguments to pass to the parent class constructor
-        """
-        super().__init__(mission_id, config)
-        channel = self._init_channel(client_config)
-        self.stub = filesystem_service_pb2_grpc.FilesystemServiceStub(channel)
-        logger.info("Channel client 'Filesystem' initialized succesfully")
-
     @staticmethod
     @contextmanager
     def _handle_grpc_errors(operation: str) -> Generator[Any, Any, Any]:
@@ -56,7 +39,7 @@ class GrpcFilesystem(FilesystemStrategy, GrpcClientWrapper):
             operation: Description of the operation being performed.
 
         Raises:
-            ValueError: Error wiht the model validation.
+            ValueError: Error with the model validation.
             ServerError: from gRPC Client.
             FilesystemServiceError: Filesystem service internal.
         """
@@ -71,6 +54,28 @@ class GrpcFilesystem(FilesystemStrategy, GrpcClientWrapper):
             logger.exception(msg)
             raise FilesystemServiceError(msg) from e
 
+    def __init__(
+        self,
+        mission_id: str,
+        setup_version_id: str,
+        config: dict[str, str],
+        client_config: ClientConfig,
+        **kwargs,  # noqa: ANN003, ARG002
+    ) -> None:
+        """Initialize the default filesystem strategy.
+
+        Args:
+            mission_id: The ID of the mission this strategy is associated with
+            setup_version_id: The ID of the setup version this strategy is associated with
+            config: A dictionary mapping names to Pydantic model classes
+            client_config: The server configuration object
+            kwargs: other optional arguments to pass to the parent class constructor
+        """
+        super().__init__(mission_id, setup_version_id, config)
+        channel = self._init_channel(client_config)
+        self.stub = filesystem_service_pb2_grpc.FilesystemServiceStub(channel)
+        logger.info("Channel client 'Filesystem' initialized succesfully")
+
     def upload(self, content: bytes, name: str, file_type: FileType) -> FilesystemData:
         """Create a new file in the file system.
 

digitalkin/services/services_config.py

@@ -5,7 +5,7 @@ from typing import Any, ClassVar
 from pydantic import BaseModel, Field, PrivateAttr
 
 from digitalkin.services.agent import AgentStrategy, DefaultAgent
-from digitalkin.services.cost import CostStrategy, DefaultCost
+from digitalkin.services.cost import CostStrategy, DefaultCost, GrpcCost
 from digitalkin.services.filesystem import DefaultFilesystem, FilesystemStrategy, GrpcFilesystem
 from digitalkin.services.identity import DefaultIdentity, IdentityStrategy
 from digitalkin.services.registry import DefaultRegistry, RegistryStrategy
@@ -30,7 +30,7 @@ class ServicesConfig(BaseModel):
     )
     _config_storage: dict[str, Any | None] = PrivateAttr(default_factory=dict)
     _cost: ServicesStrategy[CostStrategy] = PrivateAttr(
-        default_factory=lambda: ServicesStrategy(local=DefaultCost, remote=DefaultCost)
+        default_factory=lambda: ServicesStrategy(local=DefaultCost, remote=GrpcCost)
     )
     _config_cost: dict[str, Any | None] = PrivateAttr(default_factory=dict)
     _snapshot: ServicesStrategy[SnapshotStrategy] = PrivateAttr(
@@ -111,12 +111,13 @@ class ServicesConfig(BaseModel):
         """
         return getattr(self, f"_config_{name}", {})
 
-    def init_strategy(self, name: str, mission_id: str) -> ServicesStrategy:
+    def init_strategy(self, name: str, mission_id: str, setup_version_id: str) -> ServicesStrategy:
         """Initialize a specific strategy.
 
         Args:
             name: The name of the strategy to initialize
             mission_id: The ID of the mission this strategy is associated with
+            setup_version_id: The setup version ID for the strategy
 
         Returns:
             The initialized strategy instance
@@ -129,8 +130,8 @@ class ServicesConfig(BaseModel):
             msg = f"Strategy {name} not found in ServicesConfig."
             raise ValueError(msg)
 
-        # Instantiate the strategy with the mission ID and configuration
-        return strategy_type(mission_id, **self.get_strategy_config(name) or {})
+        # Instantiate the strategy with the mission ID, setup version ID, and configuration
+        return strategy_type(mission_id, setup_version_id, **self.get_strategy_config(name) or {})
 
     @property
     def storage(self) -> type[StorageStrategy]:

digitalkin/services/setup/__init__.py

@@ -0,0 +1 @@
+"""This module is responsible for handling the setup service."""