digitalkin 0.2.25rc0__py3-none-any.whl → 0.3.2.dev14__py3-none-any.whl

digitalkin/services/setup/grpc_setup.py

@@ -5,7 +5,7 @@ from contextlib import contextmanager
 from typing import Any
 
 import grpc
-from digitalkin_proto.digitalkin.setup.v2 import (
+from agentic_mesh_protocol.setup.v1 import (
     setup_pb2,
     setup_service_pb2_grpc,
 )
@@ -15,8 +15,8 @@ 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 ClientConfig
 from digitalkin.logger import logger
+from digitalkin.models.grpc_servers.models import ClientConfig
 from digitalkin.services.setup.setup_strategy import SetupData, SetupServiceError, SetupStrategy, SetupVersionData
 
 
@@ -30,10 +30,10 @@ class GrpcSetup(SetupStrategy, GrpcClientWrapper):
         """
         channel = self._init_channel(config)
         self.stub = setup_service_pb2_grpc.SetupServiceStub(channel)
-        logger.debug("Channel client 'setup' initialized succesfully")
+        logger.debug("Channel client 'setup' initialized successfully")
 
     @contextmanager
-    def _handle_grpc_errors(self, operation: str) -> Generator[Any, Any, Any]:  # noqa: PLR6301
+    def handle_grpc_errors(self, operation: str) -> Generator[Any, Any, Any]:  # noqa: PLR6301
         """Context manager for consistent gRPC error handling.
 
         Yields:
@@ -76,7 +76,7 @@ class GrpcSetup(SetupStrategy, GrpcClientWrapper):
             ServerError: If gRPC operation fails.
             SetupServiceError: For any unexpected internal error.
         """
-        with self._handle_grpc_errors("Setup Creation"):
+        with self.handle_grpc_errors("Setup Creation"):
             valid_data = SetupData.model_validate(setup_dict)
 
             request = setup_pb2.CreateSetupRequest(
@@ -104,7 +104,7 @@ class GrpcSetup(SetupStrategy, GrpcClientWrapper):
             ServerError: If gRPC operation fails.
             SetupServiceError: For any unexpected internal error.
         """
-        with self._handle_grpc_errors("Get Setup"):
+        with self.handle_grpc_errors("Get Setup"):
             if "setup_id" not in setup_dict:
                 msg = "Setup name is required"
                 raise ValidationError(msg)
@@ -132,7 +132,7 @@ class GrpcSetup(SetupStrategy, GrpcClientWrapper):
         """
         current_setup_version = None
 
-        with self._handle_grpc_errors("Setup Update"):
+        with self.handle_grpc_errors("Setup Update"):
             valid_data = SetupData.model_validate(setup_dict)
 
             if valid_data.current_setup_version is not None:
@@ -162,7 +162,7 @@ class GrpcSetup(SetupStrategy, GrpcClientWrapper):
             ServerError: If gRPC operation fails.
             SetupServiceError: For any unexpected internal error.
         """
-        with self._handle_grpc_errors("Setup Deletion"):
+        with self.handle_grpc_errors("Setup Deletion"):
             setup_id = setup_dict.get("setup_id")
             if not setup_id:
                 msg = "Setup name is required for deletion"
@@ -186,7 +186,7 @@ class GrpcSetup(SetupStrategy, GrpcClientWrapper):
             ServerError: If gRPC operation fails.
             SetupServiceError: For any unexpected internal error.
         """
-        with self._handle_grpc_errors("Setup Version Creation"):
+        with self.handle_grpc_errors("Setup Version Creation"):
             valid_data = SetupVersionData.model_validate(setup_version_dict)
             content_struct = Struct()
             content_struct.update(valid_data.content)
@@ -216,14 +216,16 @@ class GrpcSetup(SetupStrategy, GrpcClientWrapper):
             ServerError: If gRPC operation fails.
             SetupServiceError: For any unexpected internal error.
         """
-        with self._handle_grpc_errors("Get Setup Version"):
+        with self.handle_grpc_errors("Get Setup Version"):
             setup_version_id = setup_version_dict.get("setup_version_id")
             if not setup_version_id:
                 msg = "Setup version id is required"
                 raise ValidationError(msg)
             request = setup_pb2.GetSetupVersionRequest(setup_version_id=setup_version_id)
             response = self.exec_grpc_query("GetSetupVersion", request)
-            return SetupVersionData(**json_format.MessageToDict(response.setup_version))
+            return SetupVersionData(
+                **json_format.MessageToDict(response.setup_version, preserving_proto_field_name=True)
+            )
 
     def search_setup_versions(self, setup_version_dict: dict[str, Any]) -> list[SetupVersionData]:
         """Search for setup versions based on filters.
@@ -239,7 +241,7 @@ class GrpcSetup(SetupStrategy, GrpcClientWrapper):
             SetupServiceError: For any unexpected internal error.
             ValidationError: If both name and version are not provided.
         """
-        with self._handle_grpc_errors("Search Setup Versions"):
+        with self.handle_grpc_errors("Search Setup Versions"):
             if "name" not in setup_version_dict and "version" not in setup_version_dict:
                 msg = "Either name or version must be provided"
                 raise ValidationError(msg)
@@ -248,7 +250,10 @@ class GrpcSetup(SetupStrategy, GrpcClientWrapper):
                 version=setup_version_dict.get("version", ""),
             )
             response = self.exec_grpc_query("SearchSetupVersions", request)
-            return [SetupVersionData(**json_format.MessageToDict(sv)) for sv in response.setup_versions]
+            return [
+                SetupVersionData(**json_format.MessageToDict(sv, preserving_proto_field_name=True))
+                for sv in response.setup_versions
+            ]
 
     def update_setup_version(self, setup_version_dict: dict[str, Any]) -> bool:
         """Update an existing setup version.
@@ -264,7 +269,7 @@ class GrpcSetup(SetupStrategy, GrpcClientWrapper):
             ServerError: If gRPC operation fails.
             SetupServiceError: For any unexpected internal error.
         """
-        with self._handle_grpc_errors("Setup Version Update"):
+        with self.handle_grpc_errors("Setup Version Update"):
             valid_data = SetupVersionData.model_validate(setup_version_dict)
             content_struct = Struct()
             content_struct.update(valid_data.content)
@@ -295,7 +300,7 @@ class GrpcSetup(SetupStrategy, GrpcClientWrapper):
             ServerError: If gRPC operation fails.
             SetupServiceError: For any unexpected internal error.
         """
-        with self._handle_grpc_errors("Setup Version Deletion"):
+        with self.handle_grpc_errors("Setup Version Deletion"):
             setup_version_id = setup_version_dict.get("setup_version_id")
             if not setup_version_id:
                 msg = "Setup version id is required for deletion"
@@ -304,3 +309,35 @@ class GrpcSetup(SetupStrategy, GrpcClientWrapper):
             response = self.exec_grpc_query("DeleteSetupVersion", request)
             logger.debug("Setup Version '%s' query sent successfully", setup_version_id)
             return getattr(response, "success", False)
+
+    def list_setups(self, list_dict: dict[str, Any]) -> dict[str, Any]:
+        """List setups with optional filtering and pagination.
+
+        Args:
+            list_dict: Dictionary with optional filters:
+                - organisation_id: Filter by organisation
+                - owner_id: Filter by owner
+                - limit: Maximum number of results
+                - offset: Number of results to skip
+
+        Returns:
+            dict[str, Any]: Dictionary with 'setups' list and 'total_count'.
+
+        Raises:
+            ServerError: If gRPC operation fails.
+            SetupServiceError: For any unexpected internal error.
+        """
+        with self.handle_grpc_errors("List Setups"):
+            request = setup_pb2.ListSetupsRequest(
+                organisation_id=list_dict.get("organisation_id", ""),
+                owner_id=list_dict.get("owner_id", ""),
+                limit=list_dict.get("limit", 0),
+                offset=list_dict.get("offset", 0),
+            )
+            response = self.exec_grpc_query("ListSetups", request)
+            return {
+                "setups": [
+                    json_format.MessageToDict(setup, preserving_proto_field_name=True) for setup in response.setups
+                ],
+                "total_count": response.total_count,
+            }

digitalkin/services/storage/grpc_storage.py

@@ -1,13 +1,13 @@
 """This module implements the default storage strategy."""
 
-from digitalkin_proto.digitalkin.storage.v2 import data_pb2, storage_service_pb2_grpc
+from agentic_mesh_protocol.storage.v1 import data_pb2, storage_service_pb2_grpc
 from google.protobuf import json_format
 from google.protobuf.struct_pb2 import Struct
 from pydantic import BaseModel
 
 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.models.grpc_servers.models import ClientConfig
 from digitalkin.services.storage.storage_strategy import (
     DataType,
     StorageRecord,
@@ -128,7 +128,7 @@ class GrpcStorage(StorageStrategy, GrpcClientWrapper):
             resp = self.exec_grpc_query("UpdateRecord", req)
             return self._build_record_from_proto(resp.stored_data)
         except Exception:
-            logger.exception("gRPC UpdateRecord failed for %s:%s", collection, record_id)
+            logger.warning("gRPC UpdateRecord failed for %s:%s", collection, record_id)
             return None
 
     def _remove(self, collection: str, record_id: str) -> bool:
@@ -211,4 +211,4 @@ class GrpcStorage(StorageStrategy, GrpcClientWrapper):
 
         channel = self._init_channel(client_config)
         self.stub = storage_service_pb2_grpc.StorageServiceStub(channel)
-        logger.debug("Channel client 'storage' initialized succesfully")
+        logger.debug("Channel client 'storage' initialized successfully")

digitalkin/services/user_profile/__init__.py

@@ -0,0 +1,12 @@
+"""UserProfile service package."""
+
+from digitalkin.services.user_profile.default_user_profile import DefaultUserProfile
+from digitalkin.services.user_profile.grpc_user_profile import GrpcUserProfile
+from digitalkin.services.user_profile.user_profile_strategy import UserProfileServiceError, UserProfileStrategy
+
+__all__ = [
+    "DefaultUserProfile",
+    "GrpcUserProfile",
+    "UserProfileServiceError",
+    "UserProfileStrategy",
+]

digitalkin/services/user_profile/default_user_profile.py

@@ -0,0 +1,55 @@
+"""Default user profile implementation."""
+
+from typing import Any
+
+from digitalkin.logger import logger
+from digitalkin.services.user_profile.user_profile_strategy import (
+    UserProfileServiceError,
+    UserProfileStrategy,
+)
+
+
+class DefaultUserProfile(UserProfileStrategy):
+    """Default user profile strategy with in-memory storage."""
+
+    def __init__(
+        self,
+        mission_id: str,
+        setup_id: str,
+        setup_version_id: str,
+    ) -> None:
+        """Initialize the strategy.
+
+        Args:
+            mission_id: The ID of the mission this strategy is associated with
+            setup_id: The ID of the setup
+            setup_version_id: The ID of the setup version
+        """
+        super().__init__(mission_id=mission_id, setup_id=setup_id, setup_version_id=setup_version_id)
+        self.db: dict[str, dict[str, Any]] = {}
+
+    def get_user_profile(self) -> dict[str, Any]:
+        """Get user profile from in-memory storage.
+
+        Returns:
+            dict[str, Any]: User profile data
+
+        Raises:
+            UserProfileServiceError: If the user profile is not found
+        """
+        if self.mission_id not in self.db:
+            msg = f"User profile for mission {self.mission_id} not found in the database."
+            logger.warning(msg)
+            raise UserProfileServiceError(msg)
+
+        logger.debug(f"Retrieved user profile for mission_id: {self.mission_id}")
+        return self.db[self.mission_id]
+
+    def add_user_profile(self, user_profile_data: dict[str, Any]) -> None:
+        """Add a user profile to the in-memory database (helper for testing).
+
+        Args:
+            user_profile_data: Dictionary containing user profile data
+        """
+        self.db[self.mission_id] = user_profile_data
+        logger.debug(f"Added user profile for mission_id: {self.mission_id}")

digitalkin/services/user_profile/grpc_user_profile.py

@@ -0,0 +1,69 @@
+"""Digital Kin UserProfile Service gRPC Client."""
+
+from typing import Any
+
+from agentic_mesh_protocol.user_profile.v1 import (
+    user_profile_pb2,
+    user_profile_service_pb2_grpc,
+)
+from google.protobuf import json_format
+
+from digitalkin.grpc_servers.utils.grpc_client_wrapper import GrpcClientWrapper
+from digitalkin.grpc_servers.utils.grpc_error_handler import GrpcErrorHandlerMixin
+from digitalkin.logger import logger
+from digitalkin.models.grpc_servers.models import ClientConfig
+from digitalkin.services.user_profile.user_profile_strategy import UserProfileServiceError, UserProfileStrategy
+
+
+class GrpcUserProfile(UserProfileStrategy, GrpcClientWrapper, GrpcErrorHandlerMixin):
+    """This class implements the gRPC user profile service."""
+
+    def __init__(
+        self,
+        mission_id: str,
+        setup_id: str,
+        setup_version_id: str,
+        client_config: ClientConfig,
+    ) -> None:
+        """Initialize the user profile service.
+
+        Args:
+            mission_id: The ID of the mission this strategy is associated with
+            setup_id: The ID of the setup
+            setup_version_id: The ID of the setup version
+            client_config: Client configuration for gRPC connection
+        """
+        super().__init__(mission_id=mission_id, setup_id=setup_id, setup_version_id=setup_version_id)
+        channel = self._init_channel(client_config)
+        self.stub = user_profile_service_pb2_grpc.UserProfileServiceStub(channel)
+        logger.debug("Channel client 'UserProfile' initialized successfully")
+
+    def get_user_profile(self) -> dict[str, Any]:
+        """Get user profile by mission_id (which maps to user_id).
+
+        Returns:
+            dict[str, Any]: User profile data
+
+        Raises:
+            UserProfileServiceError: If the user profile cannot be retrieved
+            ServerError: If gRPC operation fails
+        """
+        with self.handle_grpc_errors("GetUserProfile", UserProfileServiceError):
+            # mission_id typically contains user context
+            request = user_profile_pb2.GetUserProfileRequest(mission_id=self.mission_id)
+            response = self.exec_grpc_query("GetUserProfile", request)
+
+            if not response.success:
+                msg = f"Failed to get user profile for mission_id: {self.mission_id}"
+                logger.error(msg)
+                raise UserProfileServiceError(msg)
+
+            # Convert proto to dict
+            user_profile_dict = json_format.MessageToDict(
+                response.user_profile,
+                preserving_proto_field_name=True,
+                always_print_fields_with_no_presence=True,
+            )
+
+            logger.debug(f"Retrieved user profile for mission_id: {self.mission_id}")
+            return user_profile_dict

digitalkin/services/user_profile/user_profile_strategy.py

@@ -0,0 +1,25 @@
+"""This module contains the abstract base class for UserProfile strategies."""
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+from digitalkin.services.base_strategy import BaseStrategy
+
+
+class UserProfileServiceError(Exception):
+    """Base exception for UserProfile service errors."""
+
+
+class UserProfileStrategy(BaseStrategy, ABC):
+    """Abstract base class for UserProfile strategies."""
+
+    @abstractmethod
+    def get_user_profile(self) -> dict[str, Any]:
+        """Get user profile data.
+
+        Returns:
+            dict[str, Any]: User profile data
+
+        Raises:
+            UserProfileServiceError: If the user profile cannot be retrieved
+        """

digitalkin/utils/__init__.py

@@ -1 +1,29 @@
 """General utils folder."""
+
+from digitalkin.utils.dynamic_schema import (
+    DEFAULT_TIMEOUT,
+    DynamicField,
+    Fetcher,
+    ResolveResult,
+    get_dynamic_metadata,
+    get_fetchers,
+    has_dynamic,
+    resolve,
+    resolve_safe,
+)
+
+# Alias for cleaner API: `Dynamic` is shorter than `DynamicField`
+Dynamic = DynamicField
+
+__all__ = [
+    "DEFAULT_TIMEOUT",
+    "Dynamic",
+    "DynamicField",
+    "Fetcher",
+    "ResolveResult",
+    "get_dynamic_metadata",
+    "get_fetchers",
+    "has_dynamic",
+    "resolve",
+    "resolve_safe",
+]

digitalkin/utils/arg_parser.py

@@ -55,7 +55,7 @@ class ArgParser:
     """
 
     class HelpAction(_HelpAction):
-        """."""
+        """Custom HelpAction to display subparsers helps too."""
 
         def __call__(
             self,

digitalkin/utils/development_mode_action.py

@@ -13,7 +13,7 @@ logger.setLevel(logging.INFO)
 
 
 class DevelopmentModeMappingAction(Action):
-    """."""
+    """ArgParse Action to map an environment variable to a ServicesMode enum."""
 
     def __init__(
         self,
@@ -22,7 +22,7 @@ class DevelopmentModeMappingAction(Action):
         default: str | None = None,
         **kwargs: dict[str, Any],
     ) -> None:
-        """."""
+        """Initialize the DevelopmentModeMappingAction."""
         default = ServicesMode(os.environ.get(env_var, default))
 
         if required and default: