digitalkin 0.3.1__tar.gz → 0.3.1.dev1__tar.gz

{digitalkin-0.3.1 → digitalkin-0.3.1.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 0.3.1
+Version: 0.3.1.dev1
 Summary: SDK to build kin used in DigitalKin
 Author-email: "DigitalKin.ai" <contact@digitalkin.ai>
 License: Attribution-NonCommercial-ShareAlike 4.0 International
@@ -452,17 +452,17 @@ Classifier: License :: Other/Proprietary License
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: digitalkin-proto==0.2.0
+Requires-Dist: digitalkin-proto==0.2.0.dev4
 Requires-Dist: grpcio-health-checking>=1.76.0
 Requires-Dist: grpcio-reflection>=1.76.0
 Requires-Dist: grpcio-status>=1.76.0
-Requires-Dist: pydantic>=2.12.5
+Requires-Dist: pydantic>=2.12.4
 Requires-Dist: surrealdb>=1.0.6
 Provides-Extra: taskiq
 Requires-Dist: rstream>=0.40.0; extra == "taskiq"
 Requires-Dist: taskiq-aio-pika>=0.5.0; extra == "taskiq"
 Requires-Dist: taskiq-redis>=1.1.2; extra == "taskiq"
-Requires-Dist: taskiq[reload]>=0.12.0; extra == "taskiq"
+Requires-Dist: taskiq[reload]>=0.11.20; extra == "taskiq"
 Dynamic: license-file
 
 # DigitalKin Python SDK

{digitalkin-0.3.1 → digitalkin-0.3.1.dev1}/pyproject.toml

@@ -12,7 +12,7 @@
 
     keywords = [ "digitalkin", "kin", "agent", "gprc", "sdk" ]
 
-    version = "0.3.1"
+    version = "0.3.1.dev1"
     classifiers = [
         "Development Status :: 3 - Alpha",
         "Intended Audience :: Developers",
@@ -28,11 +28,11 @@
     ]
 
     dependencies = [
-        "digitalkin-proto==0.2.0",
+        "digitalkin-proto==0.2.0.dev4",
         "grpcio-health-checking>=1.76.0",
         "grpcio-reflection>=1.76.0",
         "grpcio-status>=1.76.0",
-        "pydantic>=2.12.5",
+        "pydantic>=2.12.4",
         "surrealdb>=1.0.6",
     ]
 
@@ -41,7 +41,7 @@
             "rstream>=0.40.0",
             "taskiq-aio-pika>=0.5.0",
             "taskiq-redis>=1.1.2",
-            "taskiq[reload]>=0.12.0",
+            "taskiq[reload]>=0.11.20",
         ]
 
     [project.urls]
@@ -55,9 +55,9 @@
 
 [dependency-groups]
     dev = [
-        "typos>=1.40.0",
-        "ruff>=0.14.7",
-        "mypy>=1.19.0",
+        "typos>=1.39.2",
+        "ruff>=0.14.6",
+        "mypy>=1.18.2",
         "pyright>=1.1.407",
         "pre-commit>=4.5.0",
         "bump-my-version>=1.2.4",
@@ -66,7 +66,7 @@
         "cryptography>=46.0.3",
     ]
     tests = [
-        "freezegun>=1.5.5",
+        "freezegun>=1.5.3",
         "hdrhistogram>=0.10.3",
         "grpcio-testing>=1.76.0",
         "psutil>=7.1.3",
@@ -75,17 +75,17 @@
         "pytest-cov>=7.0.0",
         "pytest-html==4.1.1",
         "pytest-json-report==1.5.0",
-        "pytest-timeout>=2.4.0",
+        "pytest-timeout>=2.3.1",
     ]
     docs = [
         "mike>=2.1.3",
-        "markdown-callouts>=0.4.0",
+        "markdown-callouts>=0.4",
         "markdown-exec>=1.12.1",
-        "mkdocs>=1.6.1",
+        "mkdocs>=1.6",
         "mkdocs-coverage>=2.0.0",
         "mkdocs-llmstxt>=0.5.0",
-        "mkdocs-redirects>=1.2.2",
-        "mkdocstrings>=1.0.0",
+        "mkdocs-redirects>=1.2",
+        "mkdocstrings>=0.29",
         "griffe-inherited-docstrings>=1.1.2",
         "mkdocs-autorefs>=1.4.3",
         "mkdocs-awesome-pages-plugin>=2.10.1",
@@ -97,7 +97,8 @@
         "mkdocs-material[imaging]>=9.7.0",
         "mkdocs-minify-plugin>=0.8.0",
         "mkdocs-section-index>=0.3.10",
-        "mkdocstrings-python>=2.0.0",
+        "mkdocstrings>=0.30.1",
+        "mkdocstrings-python>=1.19.0",
         "mkdocs-open-in-new-tab>=1.0.8",
         "tomli>=2.3.0",
     ]

{digitalkin-0.3.1 → digitalkin-0.3.1.dev1}/src/digitalkin/__version__.py

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

{digitalkin-0.3.1 → digitalkin-0.3.1.dev1}/src/digitalkin/core/job_manager/taskiq_broker.py

@@ -208,7 +208,7 @@ async def run_start_module(
         # Reconstruct Pydantic models from dicts for type safety
         try:
             input_model = module_class.create_input_model(input_data)
-            setup_model = await module_class.create_setup_model(setup_data)
+            setup_model = module_class.create_setup_model(setup_data)
         except Exception as e:
             logger.error("Failed to reconstruct models for job %s: %s", job_id, e, exc_info=True)
             raise

{digitalkin-0.3.1 → digitalkin-0.3.1.dev1}/src/digitalkin/core/task_manager/task_session.py

@@ -49,24 +49,14 @@ class TaskSession:
         db: SurrealDBConnection,
         module: BaseModule,
         heartbeat_interval: datetime.timedelta = datetime.timedelta(seconds=2),
-        queue_maxsize: int = 1000,
     ) -> None:
-        """Initialize Task Session.
-
-        Args:
-            task_id: Unique task identifier
-            mission_id: Mission identifier
-            db: SurrealDB connection
-            module: Module instance
-            heartbeat_interval: Interval between heartbeats
-            queue_maxsize: Maximum size for the queue (0 = unlimited)
-        """
+        """Initialize Task Session."""
         self.db = db
         self.module = module
 
         self.status = TaskStatus.PENDING
         # Bounded queue to prevent unbounded memory growth (max 1000 items)
-        self.queue: asyncio.Queue = asyncio.Queue(maxsize=queue_maxsize)
+        self.queue: asyncio.Queue = asyncio.Queue(maxsize=1000)
 
         self.task_id = task_id
         self.mission_id = mission_id

{digitalkin-0.3.1 → digitalkin-0.3.1.dev1}/src/digitalkin/grpc_servers/module_servicer.py

@@ -112,7 +112,7 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer, ArgParser):
         # TODO: Secret should be used here as well
         setup_version = request.setup_version
         config_setup_data = self.module_class.create_config_setup_model(json_format.MessageToDict(request.content))
-        setup_version_data = await self.module_class.create_setup_model(
+        setup_version_data = self.module_class.create_setup_model(
             json_format.MessageToDict(request.setup_version.content),
             config_fields=True,
         )
@@ -185,7 +185,7 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer, ArgParser):
             msg = "No setup data returned."
             raise ServicerError(msg)
 
-        setup_data = await self.module_class.create_setup_model(setup_data_class.current_setup_version.content)
+        setup_data = self.module_class.create_setup_model(setup_data_class.current_setup_version.content)
 
         # create a task to run the module in background
         job_id = await self.job_manager.create_module_instance_job(
@@ -350,9 +350,7 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer, ArgParser):
         # Get input schema if available
         try:
             # Convert schema to proto format
-            input_schema_proto = await self.module_class.get_input_format(
-                llm_format=request.llm_format,
-            )
+            input_schema_proto = self.module_class.get_input_format(llm_format=request.llm_format)
             input_format_struct = json_format.Parse(
                 text=input_schema_proto,
                 message=struct_pb2.Struct(),  # pylint: disable=no-member
@@ -388,9 +386,7 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer, ArgParser):
         # Get output schema if available
         try:
             # Convert schema to proto format
-            output_schema_proto = await self.module_class.get_output_format(
-                llm_format=request.llm_format,
-            )
+            output_schema_proto = self.module_class.get_output_format(llm_format=request.llm_format)
             output_format_struct = json_format.Parse(
                 text=output_schema_proto,
                 message=struct_pb2.Struct(),  # pylint: disable=no-member
@@ -426,7 +422,7 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer, ArgParser):
         # Get setup schema if available
         try:
             # Convert schema to proto format
-            setup_schema_proto = await self.module_class.get_setup_format(llm_format=request.llm_format)
+            setup_schema_proto = self.module_class.get_setup_format(llm_format=request.llm_format)
             setup_format_struct = json_format.Parse(
                 text=setup_schema_proto,
                 message=struct_pb2.Struct(),  # pylint: disable=no-member
@@ -443,7 +439,7 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer, ArgParser):
             setup_schema=setup_format_struct,
         )
 
-    async def GetModuleSecret(  # noqa: N802
+    def GetModuleSecret(  # noqa: N802
         self,
         request: information_pb2.GetModuleSecretRequest,
         context: grpc.ServicerContext,
@@ -462,7 +458,7 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer, ArgParser):
         # Get secret schema if available
         try:
             # Convert schema to proto format
-            secret_schema_proto = await self.module_class.get_secret_format(llm_format=request.llm_format)
+            secret_schema_proto = self.module_class.get_secret_format(llm_format=request.llm_format)
             secret_format_struct = json_format.Parse(
                 text=secret_schema_proto,
                 message=struct_pb2.Struct(),  # pylint: disable=no-member
@@ -498,7 +494,7 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer, ArgParser):
         # Get setup schema if available
         try:
             # Convert schema to proto format
-            config_setup_schema_proto = await self.module_class.get_config_setup_format(llm_format=request.llm_format)
+            config_setup_schema_proto = self.module_class.get_config_setup_format(llm_format=request.llm_format)
             config_setup_format_struct = json_format.Parse(
                 text=config_setup_schema_proto,
                 message=struct_pb2.Struct(),  # pylint: disable=no-member

{digitalkin-0.3.1 → digitalkin-0.3.1.dev1}/src/digitalkin/models/grpc_servers/models.py

@@ -175,8 +175,8 @@ class ClientConfig(ChannelConfig):
     credentials: ClientCredentials | None = Field(None, description="Client credentials for secure mode")
     channel_options: list[tuple[str, Any]] = Field(
         default_factory=lambda: [
-            ("grpc.max_receive_message_length", 100 * 1024 * 1024),  # 100MB
-            ("grpc.max_send_message_length", 100 * 1024 * 1024),  # 100MB
+            ("grpc.max_receive_message_length", 50 * 1024 * 1024),  # 50MB
+            ("grpc.max_send_message_length", 50 * 1024 * 1024),  # 50MB
         ],
         description="Additional channel options",
     )
@@ -223,8 +223,8 @@ class ServerConfig(ChannelConfig):
     credentials: ServerCredentials | None = Field(None, description="Server credentials for secure mode")
     server_options: list[tuple[str, Any]] = Field(
         default_factory=lambda: [
-            ("grpc.max_receive_message_length", 100 * 1024 * 1024),  # 100MB
-            ("grpc.max_send_message_length", 100 * 1024 * 1024),  # 100MB
+            ("grpc.max_receive_message_length", 50 * 1024 * 1024),  # 50MB
+            ("grpc.max_send_message_length", 50 * 1024 * 1024),  # 50MB
         ],
         description="Additional server options",
     )

{digitalkin-0.3.1 → digitalkin-0.3.1.dev1}/src/digitalkin/models/module/module_context.py

@@ -10,7 +10,6 @@ from digitalkin.services.identity.identity_strategy import IdentityStrategy
 from digitalkin.services.registry.registry_strategy import RegistryStrategy
 from digitalkin.services.snapshot.snapshot_strategy import SnapshotStrategy
 from digitalkin.services.storage.storage_strategy import StorageStrategy
-from digitalkin.services.user_profile.user_profile_strategy import UserProfileStrategy
 
 
 class Session(SimpleNamespace):
@@ -90,7 +89,6 @@ class ModuleContext:
     registry: RegistryStrategy
     snapshot: SnapshotStrategy
     storage: StorageStrategy
-    user_profile: UserProfileStrategy
 
     session: Session
     callbacks: SimpleNamespace
@@ -107,7 +105,6 @@ class ModuleContext:
         registry: RegistryStrategy,
         snapshot: SnapshotStrategy,
         storage: StorageStrategy,
-        user_profile: UserProfileStrategy,
         session: dict[str, Any],
         metadata: dict[str, Any] = {},
         helpers: dict[str, Any] = {},
@@ -123,7 +120,6 @@ class ModuleContext:
             registry: RegistryStrategy.
             snapshot: SnapshotStrategy.
             storage: StorageStrategy.
-            user_profile: UserProfileStrategy.
             metadata: dict defining differents Module metadata.
             helpers: dict different user defined helpers.
             session: dict referring the session IDs or informations.
@@ -137,7 +133,6 @@ class ModuleContext:
         self.registry = registry
         self.snapshot = snapshot
         self.storage = storage
-        self.user_profile = user_profile
 
         self.metadata = SimpleNamespace(**metadata)
         self.session = Session(**session)

digitalkin-0.3.1.dev1/src/digitalkin/models/module/module_types.py

@@ -0,0 +1,109 @@
+"""Types for module models."""
+
+from datetime import datetime, timezone
+from typing import Any, ClassVar, Generic, TypeVar, cast
+
+from pydantic import BaseModel, ConfigDict, Field, create_model
+
+from digitalkin.logger import logger
+
+
+class DataTrigger(BaseModel):
+    """Defines the root input/output model exposing the protocol.
+
+    The mandatory protocol is important to define the module beahvior following the user or agent input/output.
+
+    Example:
+        class MyInput(DataModel):
+            root: DataTrigger
+            user_define_data: Any
+
+        # Usage
+        my_input = MyInput(root=DataTrigger(protocol="message"))
+        print(my_input.root.protocol)  # Output: message
+    """
+
+    protocol: ClassVar[str]
+    created_at: str = Field(
+        default_factory=lambda: datetime.now(tz=timezone.utc).isoformat(),
+        title="Created At",
+        description="Timestamp when the payload was created.",
+    )
+
+
+DataTriggerT = TypeVar("DataTriggerT", bound=DataTrigger)
+
+
+class DataModel(BaseModel, Generic[DataTriggerT]):
+    """Base definition of input/output model showing mandatory root fields.
+
+    The Model define the Module Input/output, usually referring to multiple input/output type defined by an union.
+
+    Example:
+        class ModuleInput(DataModel):
+            root: FileInput | MessageInput
+    """
+
+    root: DataTriggerT
+    annotations: dict[str, str] = Field(
+        default={},
+        title="Annotations",
+        description="Additional metadata or annotations related to the output. ex {'role': 'user'}",
+    )
+
+
+InputModelT = TypeVar("InputModelT", bound=DataModel)
+OutputModelT = TypeVar("OutputModelT", bound=DataModel)
+SecretModelT = TypeVar("SecretModelT", bound=BaseModel)
+SetupModelT = TypeVar("SetupModelT", bound="SetupModel")
+
+
+class SetupModel(BaseModel):
+    """Base definition of setup model showing mandatory root fields.
+
+    Optionally, the setup model can define a config option in json_schema_extra to be used to initialize the Kin.
+
+    Example:
+        class MySetup(SetupModel):
+            name: str = Field()
+            number: int = Field(..., json_schema_extra={"config": True})
+    """
+
+    @classmethod
+    def get_clean_model(cls, *, config_fields: bool, hidden_fields: bool) -> type[SetupModelT]:  # type: ignore
+        """Dynamically builds and returns a new BaseModel subclass.
+
+        containing only those fields where json_schema_extra["config"] == True.
+
+        Returns:
+            Type[BaseModel]: A new BaseModel subclass with the filtered fields.
+
+        Raises:
+            ValueError: If both config_fields and hidden_fields are set to True.
+        """
+        clean_fields: dict[str, Any] = {}
+        for name, field_info in cls.model_fields.items():
+            extra = getattr(field_info, "json_schema_extra", {}) or {}
+            is_config = bool(extra.get("config", False))
+            is_hidden = bool(extra.get("hidden", False))
+
+            # Skip config unless explicitly included
+            if is_config and not config_fields:
+                logger.debug("Skipping '%s' (config-only)", name)
+                continue
+
+            # Skip hidden unless explicitly included
+            if is_hidden and not hidden_fields:
+                logger.debug("Skipping '%s' (hidden-only)", name)
+                continue
+
+            clean_fields[name] = (field_info.annotation, field_info)
+
+        # Dynamically create a model e.g. "SetupModel"
+        m = create_model(
+            f"{cls.__name__}",
+            __base__=BaseModel,
+            __config__=ConfigDict(arbitrary_types_allowed=True),
+            **clean_fields,
+        )
+        return cast("type[SetupModelT]", m)  # type: ignore

{digitalkin-0.3.1 → digitalkin-0.3.1.dev1}/src/digitalkin/modules/_base_module.py

@@ -107,18 +107,14 @@ class BaseModule(  # noqa: PLR0904
         return self._status
 
     @classmethod
-    async def get_secret_format(cls, *, llm_format: bool) -> str:
+    def get_secret_format(cls, *, llm_format: bool) -> str:
         """Get the JSON schema of the secret format model.
 
-        Args:
-            llm_format: If True, return LLM-optimized schema format with inlined
-                references and simplified structure.
+        Raises:
+            NotImplementedError: If the `secret_format` is not defined.
 
         Returns:
-            The JSON schema of the secret format as a JSON string.
-
-        Raises:
-            NotImplementedError: If the `secret_format` class attribute is not defined.
+            The JSON schema of the secret format as a string.
         """
         if cls.secret_format is not None:
             if llm_format:
@@ -128,18 +124,14 @@ class BaseModule(  # noqa: PLR0904
         raise NotImplementedError(msg)
 
     @classmethod
-    async def get_input_format(cls, *, llm_format: bool) -> str:
+    def get_input_format(cls, *, llm_format: bool) -> str:
         """Get the JSON schema of the input format model.
 
-        Args:
-            llm_format: If True, return LLM-optimized schema format with inlined
-                references and simplified structure.
+        Raises:
+            NotImplementedError: If the `input_format` is not defined.
 
         Returns:
-            The JSON schema of the input format as a JSON string.
-
-        Raises:
-            NotImplementedError: If the `input_format` class attribute is not defined.
+            The JSON schema of the input format as a string.
         """
         if cls.input_format is not None:
             if llm_format:
@@ -149,18 +141,14 @@ class BaseModule(  # noqa: PLR0904
         raise NotImplementedError(msg)
 
     @classmethod
-    async def get_output_format(cls, *, llm_format: bool) -> str:
+    def get_output_format(cls, *, llm_format: bool) -> str:
         """Get the JSON schema of the output format model.
 
-        Args:
-            llm_format: If True, return LLM-optimized schema format with inlined
-                references and simplified structure.
+        Raises:
+            NotImplementedError: If the `output_format` is not defined.
 
         Returns:
-            The JSON schema of the output format as a JSON string.
-
-        Raises:
-            NotImplementedError: If the `output_format` class attribute is not defined.
+            The JSON schema of the output format as a string.
         """
         if cls.output_format is not None:
             if llm_format:
@@ -170,29 +158,20 @@ class BaseModule(  # noqa: PLR0904
         raise NotImplementedError(msg)
 
     @classmethod
-    async def get_config_setup_format(cls, *, llm_format: bool) -> str:
+    def get_config_setup_format(cls, *, llm_format: bool) -> str:
         """Gets the JSON schema of the config setup format model.
 
-        The config setup format is used only to initialize the module with configuration
-        data. It includes fields marked with `json_schema_extra={"config": True}` and
-        excludes hidden runtime fields.
-
-        Dynamic schema fields are always resolved when generating the schema, as this
-        method is typically called during module discovery or schema generation where
-        fresh values are needed.
+        The config setup format is used only to initialize the module with configuration data.
+        The setup format is used to initialize an run the module with setup data.
 
-        Args:
-            llm_format: If True, return LLM-optimized schema format with inlined
-                references and simplified structure.
+        Raises:
+            NotImplementedError: If the `setup_format` is not defined.
 
         Returns:
-            The JSON schema of the config setup format as a JSON string.
-
-        Raises:
-            NotImplementedError: If the `setup_format` class attribute is not defined.
+            The JSON schema of the config setup format as a string.
         """
         if cls.setup_format is not None:
-            setup_format = await cls.setup_format.get_clean_model(config_fields=True, hidden_fields=False, force=True)
+            setup_format = cls.setup_format.get_clean_model(config_fields=True, hidden_fields=False)
             if llm_format:
                 return json.dumps(llm_ready_schema(setup_format), indent=2)
             return json.dumps(setup_format.model_json_schema(), indent=2)
@@ -200,28 +179,17 @@ class BaseModule(  # noqa: PLR0904
         raise NotImplementedError(msg)
 
     @classmethod
-    async def get_setup_format(cls, *, llm_format: bool) -> str:
+    def get_setup_format(cls, *, llm_format: bool) -> str:
         """Gets the JSON schema of the setup format model.
 
-        The setup format is used at runtime and includes hidden fields but excludes
-        config-only fields. This is the schema used when running the module.
-
-        Dynamic schema fields are always resolved when generating the schema, as this
-        method is typically called during module discovery or schema generation where
-        fresh values are needed.
-
-        Args:
-            llm_format: If True, return LLM-optimized schema format with inlined
-                references and simplified structure.
+        Raises:
+            NotImplementedError: If the `setup_format` is not defined.
 
         Returns:
-            The JSON schema of the setup format as a JSON string.
-
-        Raises:
-            NotImplementedError: If the `setup_format` class attribute is not defined.
+            The JSON schema of the setup format as a string.
         """
         if cls.setup_format is not None:
-            setup_format = await cls.setup_format.get_clean_model(config_fields=False, hidden_fields=True, force=True)
+            setup_format = cls.setup_format.get_clean_model(config_fields=False, hidden_fields=True)
             if llm_format:
                 return json.dumps(llm_ready_schema(setup_format), indent=2)
             return json.dumps(setup_format.model_json_schema(), indent=2)
@@ -253,22 +221,17 @@ class BaseModule(  # noqa: PLR0904
         return cls.input_format(**input_data)
 
     @classmethod
-    async def create_setup_model(cls, setup_data: dict[str, Any], *, config_fields: bool = False) -> SetupModelT:
+    def create_setup_model(cls, setup_data: dict[str, Any], *, config_fields: bool = False) -> SetupModelT:
         """Create the setup model from the setup data.
 
-        Creates a filtered setup model instance based on the provided data.
-        Uses `get_clean_model()` internally to get the appropriate model class
-        with field filtering applied.
-
         Args:
             setup_data: The setup data to create the model from.
             config_fields: If True, include only fields with json_schema_extra["config"] == True.
 
         Returns:
-            An instance of the setup model with the provided data.
+            The setup model.
         """
-        model_cls = await cls.setup_format.get_clean_model(config_fields=config_fields, hidden_fields=True)
-        return model_cls(**setup_data)
+        return cls.setup_format.get_clean_model(config_fields=config_fields, hidden_fields=True)(**setup_data)
 
     @classmethod
     def create_secret_model(cls, secret_data: dict[str, Any]) -> SecretModelT:
@@ -473,8 +436,7 @@ class BaseModule(  # noqa: PLR0904
 
             wrapper = config_setup_data.model_dump()
             wrapper["content"] = content.model_dump()
-            setup_model = await self.create_setup_model(wrapper)
-            await callback(setup_model)
+            await callback(self.create_setup_model(wrapper))
             self._status = ModuleStatus.STOPPING
         except Exception:
             logger.error("Error during module lifecyle")

{digitalkin-0.3.1 → digitalkin-0.3.1.dev1}/src/digitalkin/services/services_config.py

@@ -12,7 +12,6 @@ from digitalkin.services.registry import DefaultRegistry, RegistryStrategy
 from digitalkin.services.services_models import ServicesMode, ServicesStrategy
 from digitalkin.services.snapshot import DefaultSnapshot, SnapshotStrategy
 from digitalkin.services.storage import DefaultStorage, GrpcStorage, StorageStrategy
-from digitalkin.services.user_profile import DefaultUserProfile, GrpcUserProfile, UserProfileStrategy
 
 
 class ServicesConfig(BaseModel):
@@ -54,10 +53,6 @@ class ServicesConfig(BaseModel):
         default_factory=lambda: ServicesStrategy(local=DefaultIdentity, remote=DefaultIdentity)
     )
     _config_identity: dict[str, Any | None] = PrivateAttr(default_factory=dict)
-    _user_profile: ServicesStrategy[UserProfileStrategy] = PrivateAttr(
-        default_factory=lambda: ServicesStrategy(local=DefaultUserProfile, remote=GrpcUserProfile)
-    )
-    _config_user_profile: dict[str, Any | None] = PrivateAttr(default_factory=dict)
 
     # List of valid strategy names for validation
     _valid_strategy_names: ClassVar[set[str]] = {
@@ -68,7 +63,6 @@ class ServicesConfig(BaseModel):
         "filesystem",
         "agent",
         "identity",
-        "user_profile",
     }
 
     def __init__(
@@ -175,11 +169,6 @@ class ServicesConfig(BaseModel):
         """Get the identity service strategy class based on the current mode."""
         return self._identity[self.mode.value]
 
-    @property
-    def user_profile(self) -> type[UserProfileStrategy]:
-        """Get the user_profile service strategy class based on the current mode."""
-        return self._user_profile[self.mode.value]
-
     def update_mode(self, mode: ServicesMode) -> None:
         """Update the strategy mode.
 

{digitalkin-0.3.1 → digitalkin-0.3.1.dev1}/src/digitalkin/services/services_models.py

@@ -13,7 +13,6 @@ from digitalkin.services.identity import IdentityStrategy
 from digitalkin.services.registry import RegistryStrategy
 from digitalkin.services.snapshot import SnapshotStrategy
 from digitalkin.services.storage import StorageStrategy
-from digitalkin.services.user_profile import UserProfileStrategy
 
 # Define type variables
 T = TypeVar(
@@ -24,8 +23,7 @@ T = TypeVar(
     | IdentityStrategy
     | RegistryStrategy
     | SnapshotStrategy
-    | StorageStrategy
-    | UserProfileStrategy,
+    | StorageStrategy,
 )
 
 

digitalkin-0.3.1.dev1/src/digitalkin/services/user_profile/__init__.py

@@ -0,0 +1 @@
+"""UserProfile service package."""

{digitalkin-0.3.1 → digitalkin-0.3.1.dev1}/src/digitalkin/services/user_profile/grpc_user_profile.py

@@ -49,8 +49,8 @@ class GrpcUserProfile(UserProfileStrategy, GrpcClientWrapper, GrpcErrorHandlerMi
             ServerError: If gRPC operation fails
         """
         with self.handle_grpc_errors("GetUserProfile", UserProfileServiceError):
-            # mission_id maps to the user context in the proto request
-            request = user_profile_pb2.GetUserProfileRequest(mission_id=self.mission_id)
+            # mission_id typically contains user context
+            request = user_profile_pb2.GetUserProfileRequest(user_id=self.mission_id)
             response = self.exec_grpc_query("GetUserProfile", request)
 
             if not response.success:

digitalkin-0.3.1.dev1/src/digitalkin/utils/__init__.py

@@ -0,0 +1 @@
+"""General utils folder."""