digitalkin 0.2.4__py3-none-any.whl → 0.2.5__py3-none-any.whl

digitalkin/__version__.py

@@ -5,4 +5,4 @@ from importlib.metadata import PackageNotFoundError, version
 try:
     __version__ = version("digitalkin")
 except PackageNotFoundError:
-    __version__ = "0.2.4"
+    __version__ = "0.2.5"

digitalkin/grpc_servers/module_server.py

@@ -1,6 +1,7 @@
 """Module gRPC server implementation for DigitalKin."""
 
 import logging
+from pathlib import Path
 import uuid
 
 import grpc
@@ -8,7 +9,11 @@ import grpc
 from digitalkin.grpc_servers._base_server import BaseServer
 from digitalkin.grpc_servers.module_servicer import ModuleServicer
 from digitalkin.grpc_servers.utils.exceptions import ServerError
-from digitalkin.grpc_servers.utils.models import ModuleServerConfig, SecurityMode
+from digitalkin.grpc_servers.utils.models import (
+    ClientConfig,
+    ModuleServerConfig,
+    SecurityMode,
+)
 from digitalkin.modules._base_module import BaseModule
 
 from digitalkin_proto.digitalkin.module.v2 import (
@@ -32,14 +37,16 @@ class ModuleServer(BaseServer):
 
     Attributes:
         module: The module instance being served.
-        config: Server configuration.
+        server_config: Server configuration.
+        client_config: Setup client configuration.
         module_servicer: The gRPC servicer handling module requests.
     """
 
     def __init__(
         self,
         module_class: type[BaseModule],
-        config: ModuleServerConfig,
+        server_config: ModuleServerConfig,
+        client_config: ClientConfig | None = None,
     ) -> None:
         """Initialize the module server.
 
@@ -47,9 +54,10 @@ class ModuleServer(BaseServer):
             module_class: The module instance to be served.
             config: Server configuration including registry address if auto-registration is desired.
         """
-        super().__init__(config)
+        super().__init__(server_config)
         self.module_class = module_class
-        self.config = config
+        self.server_config = server_config
+        self.client_config = client_config
         self.module_servicer: ModuleServicer | None = None
 
     def _register_servicers(self) -> None:
@@ -73,34 +81,46 @@ class ModuleServer(BaseServer):
 
     def start(self) -> None:
         """Start the module server and register with the registry if configured."""
-        logger.critical(self.config)
+        logger.critical(self.server_config)
         super().start()
 
-        logger.critical(self.config)
+        logger.critical(self.server_config)
         # If a registry address is provided, register the module
-        if self.config.registry_address:
+        if self.server_config.registry_address:
             try:
                 self._register_with_registry()
             except Exception:
                 logger.exception("Failed to register with registry")
 
+        if self.module_servicer is not None:
+            logger.critical(
+                "Setup post init started with config: %s", self.client_config
+            )
+            self.module_servicer.setup.__post_init__(self.client_config)
+
     async def start_async(self) -> None:
         """Start the module server and register with the registry if configured."""
-        logger.critical(self.config)
+        logger.critical(self.server_config)
         await super().start_async()
 
-        logger.critical(self.config)
+        logger.critical(self.server_config)
         # If a registry address is provided, register the module
-        if self.config.registry_address:
+        if self.server_config.registry_address:
             try:
                 self._register_with_registry()
             except Exception:
                 logger.exception("Failed to register with registry")
 
+        if self.module_servicer is not None:
+            logger.critical(
+                "Setup post init started with config: %s", self.client_config
+            )
+            self.module_servicer.setup.__post_init__(self.client_config)
+
     def stop(self, grace: float | None = None) -> None:
         """Stop the module server and deregister from the registry if needed."""
         # If registered with a registry, deregister
-        if self.config.registry_address:
+        if self.server_config.registry_address:
             try:
                 self._deregister_from_registry()
             except ServerError:
@@ -115,7 +135,8 @@ class ModuleServer(BaseServer):
             ServerError: If communication with the registry server fails.
         """
         logger.info(
-            "Registering module with registry at %s", self.config.registry_address
+            "Registering module with registry at %s",
+            self.server_config.registry_address,
         )
 
         # Create appropriate channel based on security mode
@@ -145,7 +166,7 @@ class ModuleServer(BaseServer):
                 module_id=self.module_class.metadata["module_id"],
                 version=self.module_class.metadata["version"],
                 module_type=module_type,
-                address=self.config.address,
+                address=self.server_config.address,
                 metadata=metadata,
             )
 
@@ -173,7 +194,8 @@ class ModuleServer(BaseServer):
             ServerError: If communication with the registry server fails.
         """
         logger.info(
-            "Deregistering module from registry at %s", self.config.registry_address
+            "Deregistering module from registry at %s",
+            self.server_config.registry_address,
         )
 
         # Create appropriate channel based on security mode
@@ -208,29 +230,42 @@ class ModuleServer(BaseServer):
         Raises:
             ValueError: If credentials are required but not provided.
         """
-        if self.config.security == SecurityMode.SECURE and self.config.credentials:
+        if (
+            self.client_config is not None
+            and self.client_config.security == SecurityMode.SECURE
+            and self.client_config.credentials
+        ):
             # Secure channel
-            """TODO: use Path(self.config.credentials.server_cert_path).read_bytes()"""
-            with open(self.config.credentials.server_cert_path, "rb") as cert_file:  # noqa: FURB101
-                certificate_chain = cert_file.read()
-
-            root_certificates = None
-            if self.config.credentials.root_cert_path:
-                with open(
-                    self.config.credentials.root_cert_path, "rb"
-                ) as root_cert_file:  # noqa: FURB101
-                    root_certificates = root_cert_file.read()
+            # Secure channel
+            root_certificates = Path(
+                self.client_config.credentials.root_cert_path
+            ).read_bytes()
+
+            # mTLS channel
+            private_key = None
+            certificate_chain = None
+            if (
+                self.client_config.credentials.client_cert_path is not None
+                and self.client_config.credentials.client_key_path is not None
+            ):
+                private_key = Path(
+                    self.client_config.credentials.client_key_path
+                ).read_bytes()
+                certificate_chain = Path(
+                    self.client_config.credentials.client_cert_path
+                ).read_bytes()
 
             # Create channel credentials
             channel_credentials = grpc.ssl_channel_credentials(
-                root_certificates=root_certificates or certificate_chain
+                root_certificates=root_certificates,
+                certificate_chain=certificate_chain,
+                private_key=private_key,
             )
-
             return grpc.secure_channel(
-                self.config.registry_address, channel_credentials
+                self.server_config.registry_address, channel_credentials
             )
         # Insecure channel
-        return grpc.insecure_channel(self.config.registry_address)
+        return grpc.insecure_channel(self.server_config.registry_address)
 
     def _determine_module_type(self) -> str:
         """Determine the module type based on its class.

digitalkin/grpc_servers/module_servicer.py

@@ -102,7 +102,8 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer):
 
         while module.status == ModuleStatus.RUNNING or not self.queue.empty():
             output_data: dict = await self.queue.get()
-            if job_id not in output_data or output_data[job_id] not in self.job_manager.modules:
+
+            if job_id not in output_data or job_id not in self.job_manager.modules:
                 message = f"Job {job_id} not found"
                 logger.warning(message)
                 context.set_code(grpc.StatusCode.NOT_FOUND)

digitalkin/grpc_servers/utils/grpc_client_wrapper.py

@@ -1,12 +1,13 @@
 """Client wrapper to ease channel creation with specific ServerConfig."""
 
 import logging
+from pathlib import Path
 from typing import Any
 
 import grpc
 
 from digitalkin.grpc_servers.utils.exceptions import ServerError
-from digitalkin.grpc_servers.utils.models import SecurityMode, ServerConfig
+from digitalkin.grpc_servers.utils.models import ClientConfig, SecurityMode
 
 logger = logging.getLogger(__name__)
 
@@ -17,7 +18,7 @@ class GrpcClientWrapper:
     stub: Any
 
     @staticmethod
-    def _init_channel(config: ServerConfig) -> grpc.Channel:
+    def _init_channel(config: ClientConfig) -> grpc.Channel:
         """Create an appropriate channel to the registry server.
 
         Returns:
@@ -26,22 +27,27 @@ class GrpcClientWrapper:
         Raises:
             ValueError: If credentials are required but not provided.
         """
-        if config.security == SecurityMode.SECURE and config.credentials:
+        if config.security == SecurityMode.SECURE and config.credentials is not None:
             # Secure channel
-            with open(config.credentials.server_cert_path, "rb") as cert_file:  # noqa: FURB101
-                certificate_chain = cert_file.read()
+            root_certificates = Path(config.credentials.root_cert_path).read_bytes()
 
-            root_certificates = None
-            if config.credentials.root_cert_path:
-                with open(config.credentials.root_cert_path, "rb") as root_cert_file:  # noqa: FURB101
-                    root_certificates = root_cert_file.read()
+            # mTLS channel
+            private_key = None
+            certificate_chain = None
+            if config.credentials.client_cert_path is not None and config.credentials.client_key_path is not None:
+                private_key = Path(config.credentials.client_key_path).read_bytes()
+                certificate_chain = Path(config.credentials.client_cert_path).read_bytes()
 
             # Create channel credentials
-            channel_credentials = grpc.ssl_channel_credentials(root_certificates=root_certificates or certificate_chain)
+            channel_credentials = grpc.ssl_channel_credentials(
+                root_certificates=root_certificates,
+                certificate_chain=certificate_chain,
+                private_key=private_key,
+            )
 
-            return grpc.secure_channel(f"{config.host}:{config.port}", channel_credentials)
+            return grpc.secure_channel(config.address, channel_credentials)
         # Insecure channel
-        return grpc.insecure_channel(f"{config.host}:{config.port}")
+        return grpc.insecure_channel(config.address)
 
     def exec_grpc_query(self, query_endpoint: str, request: Any) -> Any:  # noqa: ANN401
         """Execute a gRPC query with from the query's rpc endpoint name.

digitalkin/grpc_servers/utils/models.py

@@ -65,29 +65,18 @@ class ServerCredentials(BaseModel):
         return v
 
 
-class ServerConfig(BaseModel):
-    """Base configuration for gRPC servers.
+class ClientCredentials(BaseModel):
+    """Model for client credentials in secure mode.
 
     Attributes:
-        host: Host address to bind the server to
-        port: Port to listen on
-        max_workers: Maximum number of workers for sync mode
-        mode: Server operation mode (sync/async)
-        security: Security mode (secure/insecure)
-        credentials: Server credentials for secure mode
-        server_options: Additional server options
-        enable_reflection: Enable reflection for the server
+        root_cert_path: path to the root certificate
+        client_key_path: Path to the client private key
+        client_cert_path: Path to the client certificate
     """
 
-    host: str = Field("0.0.0.0", description="Host address to bind the server to")  # noqa: S104
-    port: int = Field(50051, description="Port to listen on")
-    max_workers: int = Field(10, description="Maximum number of workers for sync mode")
-    mode: ServerMode = Field(ServerMode.SYNC, description="Server operation mode (sync/async)")
-    security: SecurityMode = Field(SecurityMode.INSECURE, description="Security mode (secure/insecure)")
-    credentials: ServerCredentials | None = Field(None, description="Server credentials for secure mode")
-    server_options: list[tuple[str, Any]] = Field(default_factory=list, description="Additional server options")
-    enable_reflection: bool = Field(default=True, description="Enable reflection for the server")
-    enable_health_check: bool = Field(default=True, description="Enable health check service")
+    root_cert_path: Path = Field(..., description="Path to the root certificate")
+    client_key_path: Path | None = Field(None, description="Path to the client private key | mTLS enable")
+    client_cert_path: Path | None = Field(None, description="Path to the client certificate | mTLS enable")
 
     # Enable __slots__ for memory efficiency
     model_config = {
@@ -95,31 +84,53 @@ class ServerConfig(BaseModel):
         "arbitrary_types_allowed": True,
         "validate_assignment": True,
         "use_enum_values": True,
+        "frozen": True,  # Make immutable
     }
 
-    @field_validator("credentials")
+    @field_validator("client_key_path", "client_cert_path", "root_cert_path")
     @classmethod
-    def validate_credentials(cls, v: ServerCredentials | None, info: ValidationInfo) -> ServerCredentials | None:
-        """Validate that credentials are provided when in secure mode.
+    def check_path_exists(cls, v: Path | None) -> Path | None:
+        """Validate that the file path exists.
 
         Args:
-            v: The credentials value
-            info: ValidationInfo containing other field values
+            v: Path to validate
 
         Returns:
-            The validated credentials
+            The validated path
 
         Raises:
-            ConfigurationError: If credentials are missing in secure mode
+            SecurityError: If the path does not exist
         """
-        # Access security mode from the info.data dictionary
-        security = info.data.get("security")
-
-        if security == SecurityMode.SECURE and v is None:
-            msg = "Credentials must be provided when using secure mode"
-            raise ConfigurationError(msg)
+        if v is not None and not v.exists():
+            msg = f"File not found: {v}"
+            raise SecurityError(msg)
         return v
 
+
+class ChannelConfig(BaseModel):
+    """Base configuration for gRPC channels.
+
+    Attributes:
+        host: Host address
+        port: Port to listen on
+        mode: communication operation mode (sync/async)
+        security: Security mode (secure/insecure)
+        credentials: Client credentials for secure mode
+    """
+
+    host: str = Field("0.0.0.0", description="Host address to bind the client to")  # noqa: S104
+    port: int = Field(50051, description="Port to listen on")
+    mode: ServerMode = Field(ServerMode.SYNC, description="Client operation mode (sync/async)")
+    security: SecurityMode = Field(SecurityMode.INSECURE, description="Security mode (secure/insecure)")
+
+    # Enable __slots__ for memory efficiency
+    model_config = {
+        "extra": "forbid",
+        "arbitrary_types_allowed": True,
+        "validate_assignment": True,
+        "use_enum_values": True,
+    }
+
     @field_validator("port")
     @classmethod
     def validate_port(cls, v: int) -> int:
@@ -149,6 +160,87 @@ class ServerConfig(BaseModel):
         return f"{self.host}:{self.port}"
 
 
+class ClientConfig(ChannelConfig):
+    """Base configuration for gRPC clients.
+
+    Attributes:
+        host: Host address to bind the client to
+        port: Port to listen on
+        mode: Client operation mode (sync/async)
+        security: Security mode (secure/insecure)
+        credentials: Client credentials for secure mode
+    """
+
+    credentials: ClientCredentials | None = Field(None, description="Client credentials for secure mode")
+
+    @field_validator("credentials")
+    @classmethod
+    def validate_credentials(cls, v: ClientCredentials | None, info: ValidationInfo) -> ClientCredentials | None:
+        """Validate that credentials are provided when in secure mode.
+
+        Args:
+            v: The credentials value
+            info: ValidationInfo containing other field values
+
+        Returns:
+            The validated credentials
+
+        Raises:
+            ConfigurationError: If credentials are missing in secure mode
+        """
+        # Access security mode from the info.data dictionary
+        security = info.data.get("security")
+
+        if security == SecurityMode.SECURE and v is None:
+            msg = "Credentials must be provided when using secure mode"
+            raise ConfigurationError(msg)
+        return v
+
+
+class ServerConfig(ChannelConfig):
+    """Base configuration for gRPC servers.
+
+    Attributes:
+        host: Host address to bind the server to
+        port: Port to listen on
+        max_workers: Maximum number of workers for sync mode
+        mode: Server operation mode (sync/async)
+        security: Security mode (secure/insecure)
+        credentials: Server credentials for secure mode
+        server_options: Additional server options
+        enable_reflection: Enable reflection for the server
+    """
+
+    max_workers: int = Field(10, description="Maximum number of workers for sync mode")
+    credentials: ServerCredentials | None = Field(None, description="Server credentials for secure mode")
+    server_options: list[tuple[str, Any]] = Field(default_factory=list, description="Additional server options")
+    enable_reflection: bool = Field(default=True, description="Enable reflection for the server")
+    enable_health_check: bool = Field(default=True, description="Enable health check service")
+
+    @field_validator("credentials")
+    @classmethod
+    def validate_credentials(cls, v: ServerCredentials | None, info: ValidationInfo) -> ServerCredentials | None:
+        """Validate that credentials are provided when in secure mode.
+
+        Args:
+            v: The credentials value
+            info: ValidationInfo containing other field values
+
+        Returns:
+            The validated credentials
+
+        Raises:
+            ConfigurationError: If credentials are missing in secure mode
+        """
+        # Access security mode from the info.data dictionary
+        security = info.data.get("security")
+
+        if security == SecurityMode.SECURE and v is None:
+            msg = "Credentials must be provided when using secure mode"
+            raise ConfigurationError(msg)
+        return v
+
+
 class ModuleServerConfig(ServerConfig):
     """Configuration for Module gRPC server.
 

digitalkin/services/setup/grpc_setup.py

@@ -16,7 +16,7 @@ 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.grpc_servers.utils.models import ClientConfig
 from digitalkin.services.setup.setup_strategy import SetupData, SetupServiceError, SetupStrategy, SetupVersionData
 
 logger = logging.getLogger(__name__)
@@ -25,7 +25,7 @@ logger = logging.getLogger(__name__)
 class GrpcSetup(SetupStrategy, GrpcClientWrapper):
     """This class implements the gRPC setup service."""
 
-    def __post_init__(self, config: ServerConfig) -> None:
+    def __post_init__(self, config: ClientConfig) -> None:
         """Init the channel from a config file.
 
         Need to be call if the user register a gRPC channel.

{digitalkin-0.2.4.dist-info → digitalkin-0.2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 0.2.4
+Version: 0.2.5
 Summary: SDK to build kin used in DigitalKin
 Author-email: "DigitalKin.ai" <contact@digitalkin.ai>
 License: Attribution-NonCommercial-ShareAlike 4.0 International
@@ -456,6 +456,7 @@ Requires-Dist: digitalkin-proto>=0.1.7
 Requires-Dist: grpcio-health-checking>=1.71.0
 Requires-Dist: grpcio-reflection>=1.71.0
 Requires-Dist: grpcio-status>=1.71.0
+Requires-Dist: openai>=1.70.0
 Requires-Dist: pydantic>=2.11.3
 Provides-Extra: dev
 Requires-Dist: pytest>=8.3.4; extra == "dev"

{digitalkin-0.2.4.dist-info → digitalkin-0.2.5.dist-info}/RECORD

@@ -7,19 +7,19 @@ base_server/mock/__init__.py,sha256=YZFT-F1l_TpvJYuIPX-7kTeE1CfOjhx9YmNRXVoi-jQ,
 base_server/mock/mock_pb2.py,sha256=sETakcS3PAAm4E-hTCV1jIVaQTPEAIoVVHupB8Z_k7Y,1843
 base_server/mock/mock_pb2_grpc.py,sha256=BbOT70H6q3laKgkHfOx1QdfmCS_HxCY4wCOX84YAdG4,3180
 digitalkin/__init__.py,sha256=7LLBAba0th-3SGqcpqFO-lopWdUkVLKzLZiMtB-mW3M,162
-digitalkin/__version__.py,sha256=mR_bGYOQA3eO6IjqeeDDhhBptzMqVTzT6k-jTNiddLY,190
+digitalkin/__version__.py,sha256=rNDXhMY4crjuy0nWOXRh9ypmALKFI7DzYaHCTDZkRl8,190
 digitalkin/logger.py,sha256=9cDgyJV2QXXT8F--xRODFlZyDgjuTTXNdpCU3GdqCsk,382
 digitalkin/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 digitalkin/grpc_servers/__init__.py,sha256=0cJBlwipSmFdXkyH3T0i6OJ1WpAtNsZgYX7JaSnkbtg,804
 digitalkin/grpc_servers/_base_server.py,sha256=ec4xmgAuOMVg45a63O_PEa2T7mI4tJ6boxcXauFyZ5g,18649
-digitalkin/grpc_servers/module_server.py,sha256=23Q6F9mSO9bCu2MmsLqM9WeviIzwfhDiBFrVspy0PCI,9065
-digitalkin/grpc_servers/module_servicer.py,sha256=FMzB2E1dQZck34vGWf9OXNXEIfu_KhTdZ_Kn79XEowc,12306
+digitalkin/grpc_servers/module_server.py,sha256=0jC5MN-H4MGA9O9J87gnlM8EHcbrkb0chuCm8yZh7gI,10232
+digitalkin/grpc_servers/module_servicer.py,sha256=byqRpp9m8HS3NUUtKBWFXOncpUWGDW_xsyddA2qwaW4,12294
 digitalkin/grpc_servers/registry_server.py,sha256=PmWaH4Xmg5Sj7NtFVLBNTOzkOfqo7dw_qyVBnaW4jy4,2238
 digitalkin/grpc_servers/registry_servicer.py,sha256=mCAjNhdMq5DozZMEPsJK__DIxePEYxSWV-gAq-Xctk4,16469
 digitalkin/grpc_servers/utils/exceptions.py,sha256=I00OM8p8up20He4dU1fiHsvdLj1DymjR_UmoeUm2MSA,785
 digitalkin/grpc_servers/utils/factory.py,sha256=jm6rFjiqmtSv7BIHNAOxsG9xXtSvWpx9TfzSQiX97MQ,5899
-digitalkin/grpc_servers/utils/grpc_client_wrapper.py,sha256=y9zGzmeESAhrzzQcekA8rE_P9gyPvOjxWwnZAc3fpx4,2435
-digitalkin/grpc_servers/utils/models.py,sha256=AXv4FQ3RRmcr5sZaaZc72ED1LtGJEaxmFIZP0Xlo-PY,5483
+digitalkin/grpc_servers/utils/grpc_client_wrapper.py,sha256=6gj98T2_siZNlsamfz2Qkg89ebv4rS8Gm_X2FpE6Iow,2613
+digitalkin/grpc_servers/utils/models.py,sha256=80F5oHiv8MOqMoDZJBXmJSRoVYJRyhaVcijQ2LinAig,8428
 digitalkin/grpc_servers/utils/types.py,sha256=rQ78s4nAet2jy-NIDj_PUWriT0kuGHr_w6ELjmjgBao,539
 digitalkin/models/__init__.py,sha256=hDHtUfswaNh8wo4NZaBItg9JqC0uNSRqXArNWSrGynY,163
 digitalkin/models/module/__init__.py,sha256=ihvRlemJuFvU4armZIL-Vq-zaJx9UrjDoJAVPbEG8jw,345
@@ -56,7 +56,7 @@ digitalkin/services/registry/__init__.py,sha256=Zl4QAkCe9tOmmKGBWVuLQVFepdZiL0ec
 digitalkin/services/registry/default_registry.py,sha256=VnWkF6nHpFxUKuUbZLPqzXqdA6oXmyV_ySpeuOCf_ko,277
 digitalkin/services/registry/registry_strategy.py,sha256=uBXgZIv25jeXbeVO8vWvlNPxxNYu7_KiCw2PoE6AWr8,423
 digitalkin/services/setup/default_setup.py,sha256=x1J6trXhyLC7V2OTe5pRY5mIFkQ4oyi3-aG50a1G1U4,8253
-digitalkin/services/setup/grpc_setup.py,sha256=Bo84gLZSK8DKqHAVSVFOQdtZQkfpp78eNgjJnGhXQfU,12449
+digitalkin/services/setup/grpc_setup.py,sha256=4rLra3Ao0cwVX1L380VYwmGactoIk8gmcNHGlkrpEo8,12449
 digitalkin/services/setup/setup_strategy.py,sha256=ZnJ_HwWCkHCPrqKekSD5L9y3p8wMwfjQ8sj2hLZq6go,4004
 digitalkin/services/snapshot/__init__.py,sha256=Uzlnzo0CYlSpVsdiI37hW7xQk8hu3YA1fOI6O6MSzB0,270
 digitalkin/services/snapshot/default_snapshot.py,sha256=Mb8QwWRsHh9I_tN0ln_ZiFa1QCZxOVWmuVLemQOTWpc,1058
@@ -67,12 +67,12 @@ digitalkin/services/storage/grpc_storage.py,sha256=BqWLK9w_03BEjlJCVbdrlbMvh2szG
 digitalkin/services/storage/storage_strategy.py,sha256=vGo4aYkEp_GZV11m7vd-xY_Z3gVa5K0gMTzbj2Au_3o,6600
 digitalkin/utils/__init__.py,sha256=sJnY-ZUgsjMfojAjONC1VN14mhgIDnzyOlGkw21rRnM,28
 digitalkin/utils/arg_parser.py,sha256=3YyI6oZhhrlTmPTrzlwpQzbCNWDFAT3pggcLxNtJoc0,4388
-digitalkin-0.2.4.dist-info/licenses/LICENSE,sha256=Ies4HFv2r2hzDRakJYxk3Y60uDFLiG-orIgeTpstnIo,20327
+digitalkin-0.2.5.dist-info/licenses/LICENSE,sha256=Ies4HFv2r2hzDRakJYxk3Y60uDFLiG-orIgeTpstnIo,20327
 modules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 modules/minimal_llm_module.py,sha256=i9KTbv8w1ekzRYWDiRsxD6xLCoZ3uDjD_hWgfY2PRys,5637
 modules/storage_module.py,sha256=bu52lW4RFcWB8VFDhrpBFfCaTSkVL6so3zrkfW4LO9E,6270
 modules/text_transform_module.py,sha256=fAC6r_Ujca1Tz1qdWL4hTPZFn3gFWIVNj5-rytQMObE,7191
-digitalkin-0.2.4.dist-info/METADATA,sha256=h_9hJnMdGTJZwkr0b5IZwSEO5l70sbtJmd5PNZhY0VI,29095
-digitalkin-0.2.4.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-digitalkin-0.2.4.dist-info/top_level.txt,sha256=5_5e35inSM5YfWNZE21p5wGBojiVtQQML_WzbEk4BRU,31
-digitalkin-0.2.4.dist-info/RECORD,,
+digitalkin-0.2.5.dist-info/METADATA,sha256=GLLOO0md8f6VLKykUxBJwZ2wTh3NEpBcKdi-V5wKvx8,29125
+digitalkin-0.2.5.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+digitalkin-0.2.5.dist-info/top_level.txt,sha256=5_5e35inSM5YfWNZE21p5wGBojiVtQQML_WzbEk4BRU,31
+digitalkin-0.2.5.dist-info/RECORD,,