digitalkin 0.3.1__py3-none-any.whl → 0.3.1.dev0__py3-none-any.whl

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/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/models/module/module_types.py

@@ -1,25 +1,11 @@
 """Types for module models."""
 
-from __future__ import annotations
-
-import copy
-import types
-import typing
 from datetime import datetime, timezone
-from typing import TYPE_CHECKING, Any, ClassVar, Generic, TypeVar, cast, get_args, get_origin
+from typing import Any, ClassVar, Generic, TypeVar, cast
 
 from pydantic import BaseModel, ConfigDict, Field, create_model
 
 from digitalkin.logger import logger
-from digitalkin.utils.dynamic_schema import (
-    DynamicField,
-    get_fetchers,
-    has_dynamic,
-    resolve_safe,
-)
-
-if TYPE_CHECKING:
-    from pydantic.fields import FieldInfo
 
 
 class DataTrigger(BaseModel):
@@ -75,50 +61,27 @@ 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. Supports dynamic schema providers for
-    runtime value generation.
-
-    Attributes:
-        model_fields: Inherited from Pydantic BaseModel, contains field definitions.
+    Optionally, the setup model can define a config option in json_schema_extra to be used to initialize the Kin.
 
-    See Also:
-        - Documentation: docs/api/dynamic_schema.md
-        - Tests: tests/modules/test_setup_model.py
+    Example:
+        class MySetup(SetupModel):
+            name: str = Field()
+            number: int = Field(..., json_schema_extra={"config": True})
     """
 
     @classmethod
-    async def get_clean_model(
-        cls,
-        *,
-        config_fields: bool,
-        hidden_fields: bool,
-        force: bool = False,
-    ) -> type[SetupModelT]:
-        """Dynamically builds and returns a new BaseModel subclass with filtered fields.
-
-        This method filters fields based on their `json_schema_extra` metadata:
-        - Fields with `{"config": True}` are included only when `config_fields=True`
-        - Fields with `{"hidden": True}` are included only when `hidden_fields=True`
-
-        When `force=True`, fields with dynamic schema providers will have their
-        providers called to fetch fresh values for schema metadata like enums.
-        This includes recursively processing nested BaseModel fields.
+    def get_clean_model(cls, *, config_fields: bool, hidden_fields: bool) -> type[SetupModelT]:  # type: ignore
+        """Dynamically builds and returns a new BaseModel subclass.
 
-        Args:
-            config_fields: If True, include fields marked with `{"config": True}`.
-                These are typically initial configuration fields.
-            hidden_fields: If True, include fields marked with `{"hidden": True}`.
-                These are typically runtime-only fields not shown in initial config.
-            force: If True, refresh dynamic schema fields by calling their providers.
-                Use this when you need up-to-date values from external sources like
-                databases or APIs. Default is False for performance.
+        containing only those fields where json_schema_extra["config"] == True.
 
         Returns:
-            A new BaseModel subclass with filtered fields.
+            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))
@@ -134,27 +97,7 @@ class SetupModel(BaseModel):
                 logger.debug("Skipping '%s' (hidden-only)", name)
                 continue
 
-            # Refresh dynamic schema fields when force=True
-            current_field_info = field_info
-            current_annotation = field_info.annotation
-
-            if force:
-                # Check if this field has DynamicField metadata
-                if has_dynamic(field_info):
-                    current_field_info = await cls._refresh_field_schema(name, field_info)
-
-                # Check if the annotation is a nested BaseModel that might have dynamic fields
-                nested_model = cls._get_base_model_type(current_annotation)
-                if nested_model is not None:
-                    refreshed_nested = await cls._refresh_nested_model(nested_model)
-                    if refreshed_nested is not nested_model:
-                        # Update annotation to use refreshed nested model
-                        current_annotation = refreshed_nested
-                        # Create new field_info with updated annotation (deep copy for safety)
-                        current_field_info = copy.deepcopy(current_field_info)
-                        setattr(current_field_info, "annotation", current_annotation)
-
-            clean_fields[name] = (current_annotation, current_field_info)
+            clean_fields[name] = (field_info.annotation, field_info)
 
         # Dynamically create a model e.g. "SetupModel"
         m = create_model(
@@ -163,231 +106,4 @@ class SetupModel(BaseModel):
             __config__=ConfigDict(arbitrary_types_allowed=True),
             **clean_fields,
         )
-        return cast("type[SetupModelT]", m)
-
-    @classmethod
-    def _get_base_model_type(cls, annotation: type | None) -> type[BaseModel] | None:
-        """Extract BaseModel type from an annotation.
-
-        Handles direct types, Optional, Union, list, dict, set, tuple, and other generics.
-
-        Args:
-            annotation: The type annotation to inspect.
-
-        Returns:
-            The BaseModel subclass if found, None otherwise.
-        """
-        if annotation is None:
-            return None
-
-        # Direct BaseModel subclass check
-        if isinstance(annotation, type) and issubclass(annotation, BaseModel):
-            return annotation
-
-        origin = get_origin(annotation)
-        if origin is None:
-            return None
-
-        args = get_args(annotation)
-        return cls._extract_base_model_from_args(origin, args)
-
-    @classmethod
-    def _extract_base_model_from_args(
-        cls,
-        origin: type,
-        args: tuple[type, ...],
-    ) -> type[BaseModel] | None:
-        """Extract BaseModel from generic type arguments.
-
-        Args:
-            origin: The generic origin type (list, dict, Union, etc.).
-            args: The type arguments.
-
-        Returns:
-            The BaseModel subclass if found, None otherwise.
-        """
-        # Union/Optional: check each arg (supports both typing.Union and types.UnionType)
-        # Python 3.10+ uses types.UnionType for X | Y syntax
-        if origin is typing.Union or origin is types.UnionType:
-            return cls._find_base_model_in_args(args)
-
-        # list, set, frozenset: check first arg
-        if origin in {list, set, frozenset} and args:
-            return cls._check_base_model(args[0])
-
-        # dict: check value type (second arg)
-        dict_value_index = 1
-        if origin is dict and len(args) > dict_value_index:
-            return cls._check_base_model(args[dict_value_index])
-
-        # tuple: check first non-ellipsis arg
-        if origin is tuple:
-            return cls._find_base_model_in_args(args, skip_ellipsis=True)
-
-        return None
-
-    @classmethod
-    def _check_base_model(cls, arg: type) -> type[BaseModel] | None:
-        """Check if arg is a BaseModel subclass.
-
-        Returns:
-            The BaseModel subclass if arg is one, None otherwise.
-        """
-        if isinstance(arg, type) and issubclass(arg, BaseModel):
-            return arg
-        return None
-
-    @classmethod
-    def _find_base_model_in_args(
-        cls,
-        args: tuple[type, ...],
-        *,
-        skip_ellipsis: bool = False,
-    ) -> type[BaseModel] | None:
-        """Find first BaseModel in args.
-
-        Returns:
-            The first BaseModel subclass found, None otherwise.
-        """
-        for arg in args:
-            if arg is type(None):
-                continue
-            if skip_ellipsis and arg is ...:
-                continue
-            result = cls._check_base_model(arg)
-            if result is not None:
-                return result
-        return None
-
-    @classmethod
-    async def _refresh_nested_model(cls, model_cls: type[BaseModel]) -> type[BaseModel]:
-        """Refresh dynamic fields in a nested BaseModel.
-
-        Creates a new model class with all DynamicField metadata resolved.
-
-        Args:
-            model_cls: The nested model class to refresh.
-
-        Returns:
-            A new model class with refreshed fields, or the original if no changes.
-        """
-        has_changes = False
-        clean_fields: dict[str, Any] = {}
-
-        for name, field_info in model_cls.model_fields.items():
-            current_field_info = field_info
-            current_annotation = field_info.annotation
-
-            # Check if field has DynamicField metadata
-            if has_dynamic(field_info):
-                current_field_info = await cls._refresh_field_schema(name, field_info)
-                has_changes = True
-
-            # Recursively check nested models
-            nested_model = cls._get_base_model_type(current_annotation)
-            if nested_model is not None:
-                refreshed_nested = await cls._refresh_nested_model(nested_model)
-                if refreshed_nested is not nested_model:
-                    current_annotation = refreshed_nested
-                    current_field_info = copy.deepcopy(current_field_info)
-                    setattr(current_field_info, "annotation", current_annotation)
-                    has_changes = True
-
-            clean_fields[name] = (current_annotation, current_field_info)
-
-        if not has_changes:
-            return model_cls
-
-        # Create new model with refreshed fields
-        logger.debug("Creating refreshed nested model for '%s'", model_cls.__name__)
-        return create_model(
-            model_cls.__name__,
-            __base__=BaseModel,
-            __config__=ConfigDict(arbitrary_types_allowed=True),
-            **clean_fields,
-        )
-
-    @classmethod
-    async def _refresh_field_schema(cls, field_name: str, field_info: FieldInfo) -> FieldInfo:
-        """Refresh a field's json_schema_extra with fresh values from dynamic providers.
-
-        This method calls all dynamic providers registered for a field (via Annotated
-        metadata) and creates a new FieldInfo with the resolved values. The original
-        field_info is not modified.
-
-        Uses `resolve_safe()` for structured error handling, allowing partial success
-        when some fetchers fail. Successfully resolved values are still applied.
-
-        Args:
-            field_name: The name of the field being refreshed (used for logging).
-            field_info: The original FieldInfo object containing the dynamic providers.
-
-        Returns:
-            A new FieldInfo object with the same attributes as the original, but with
-            `json_schema_extra` containing resolved values and Dynamic metadata removed.
-
-        Note:
-            If all fetchers fail, the original field_info is returned unchanged.
-            If some fetchers fail, successfully resolved values are still applied.
-        """
-        fetchers = get_fetchers(field_info)
-
-        if not fetchers:
-            return field_info
-
-        fetcher_keys = list(fetchers.keys())
-        logger.debug(
-            "Refreshing dynamic schema for field '%s' with fetchers: %s",
-            field_name,
-            fetcher_keys,
-            extra={"field_name": field_name, "fetcher_keys": fetcher_keys},
-        )
-
-        # Resolve all fetchers with structured error handling
-        result = await resolve_safe(fetchers)
-
-        # Log any errors that occurred with full details
-        if result.errors:
-            for key, error in result.errors.items():
-                logger.warning(
-                    "Failed to resolve '%s' for field '%s': %s: %s",
-                    key,
-                    field_name,
-                    type(error).__name__,
-                    str(error) or "(no message)",
-                    extra={
-                        "field_name": field_name,
-                        "fetcher_key": key,
-                        "error_type": type(error).__name__,
-                        "error_message": str(error),
-                        "error_repr": repr(error),
-                    },
-                )
-
-        # If no values were resolved, return original field_info
-        if not result.values:
-            logger.warning(
-                "All fetchers failed for field '%s', keeping original",
-                field_name,
-            )
-            return field_info
-
-        # Build new json_schema_extra with resolved values merged
-        extra = getattr(field_info, "json_schema_extra", {}) or {}
-        new_extra = {**extra, **result.values}
-
-        # Create a deep copy of the FieldInfo to avoid shared mutable state
-        new_field_info = copy.deepcopy(field_info)
-        setattr(new_field_info, "json_schema_extra", new_extra)
-
-        # Remove Dynamic from metadata (it's been resolved)
-        new_metadata = [m for m in new_field_info.metadata if not isinstance(m, DynamicField)]
-        setattr(new_field_info, "metadata", new_metadata)
-
-        logger.debug(
-            "Refreshed '%s' with dynamic values: %s",
-            field_name,
-            list(result.values.keys()),
-        )
-
-        return new_field_info
+        return cast("type[SetupModelT]", m)  # type: ignore

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/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/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/services/user_profile/__init__.py

@@ -1,12 +1 @@
 """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/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: