digitalkin 0.2.25rc0__py3-none-any.whl → 0.3.1.dev2__py3-none-any.whl

digitalkin/services/filesystem/grpc_filesystem.py

@@ -1,17 +1,15 @@
 """gRPC filesystem implementation."""
 
-from collections.abc import Generator
-from contextlib import contextmanager
 from typing import Any, Literal
 
-from digitalkin_proto.digitalkin.filesystem.v1 import filesystem_pb2, filesystem_service_pb2_grpc
+from digitalkin_proto.agentic_mesh_protocol.filesystem.v1 import filesystem_pb2, filesystem_service_pb2_grpc
 from google.protobuf import struct_pb2
 from google.protobuf.json_format import MessageToDict
 
-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.grpc_servers.utils.grpc_error_handler import GrpcErrorHandlerMixin
 from digitalkin.logger import logger
+from digitalkin.models.grpc_servers.models import ClientConfig
 from digitalkin.services.filesystem.filesystem_strategy import (
     FileFilter,
     FilesystemRecord,
@@ -21,36 +19,9 @@ from digitalkin.services.filesystem.filesystem_strategy import (
 )
 
 
-class GrpcFilesystem(FilesystemStrategy, GrpcClientWrapper):
+class GrpcFilesystem(FilesystemStrategy, GrpcClientWrapper, GrpcErrorHandlerMixin):
     """Default state filesystem strategy."""
 
-    @staticmethod
-    @contextmanager
-    def _handle_grpc_errors(operation: str) -> Generator[Any, Any, Any]:
-        """Context manager for consistent gRPC error handling.
-
-        Yields:
-            Allow error handling in context.
-
-        Args:
-            operation: Description of the operation being performed.
-
-        Raises:
-            ValueError: Error with the model validation.
-            ServerError: from gRPC Client.
-            FilesystemServiceError: Filesystem service internal.
-        """
-        try:
-            yield
-        except ServerError as e:
-            msg = f"gRPC {operation} failed: {e}"
-            logger.exception(msg)
-            raise ServerError(msg) from e
-        except Exception as e:
-            msg = f"Unexpected error in {operation}"
-            logger.exception(msg)
-            raise FilesystemServiceError(msg) from e
-
     @staticmethod
     def _file_type_to_enum(file_type: str) -> filesystem_pb2.FileType:
         """Convert a file type string to a FileType enum.
@@ -148,7 +119,7 @@ class GrpcFilesystem(FilesystemStrategy, GrpcClientWrapper):
         self.service_name = "FilesystemService"
         channel = self._init_channel(client_config)
         self.stub = filesystem_service_pb2_grpc.FilesystemServiceStub(channel)
-        logger.debug("Channel client 'Filesystem' initialized succesfully")
+        logger.debug("Channel client 'Filesystem' initialized successfully")
 
     def upload_files(
         self,
@@ -163,7 +134,7 @@ class GrpcFilesystem(FilesystemStrategy, GrpcClientWrapper):
             tuple[list[FilesystemRecord], int, int]: List of uploaded files, total uploaded count, total failed count
         """
         logger.debug("Uploading %d files", len(files))
-        with GrpcFilesystem._handle_grpc_errors("UploadFiles"):
+        with self.handle_grpc_errors("UploadFiles", FilesystemServiceError):
             upload_files: list[filesystem_pb2.UploadFileData] = []
             for file in files:
                 metadata_struct: struct_pb2.Struct | None = None
@@ -213,7 +184,7 @@ class GrpcFilesystem(FilesystemStrategy, GrpcClientWrapper):
                 context_id = self.setup_id
             case "mission":
                 context_id = self.mission_id
-        with GrpcFilesystem._handle_grpc_errors("GetFile"):
+        with self.handle_grpc_errors("GetFile", FilesystemServiceError):
             request = filesystem_pb2.GetFileRequest(
                 context=context_id,
                 file_id=file_id,
@@ -261,7 +232,7 @@ class GrpcFilesystem(FilesystemStrategy, GrpcClientWrapper):
         Raises:
             FilesystemServiceError: If there is an error during update
         """
-        with GrpcFilesystem._handle_grpc_errors("UpdateFile"):
+        with self.handle_grpc_errors("UpdateFile", FilesystemServiceError):
             request = filesystem_pb2.UpdateFileRequest(
                 context=self.mission_id,
                 file_id=file_id,
@@ -295,7 +266,7 @@ class GrpcFilesystem(FilesystemStrategy, GrpcClientWrapper):
         Returns:
             tuple[dict[str, bool], int, int]: Results per file, total deleted count, total failed count
         """
-        with GrpcFilesystem._handle_grpc_errors("DeleteFiles"):
+        with self.handle_grpc_errors("DeleteFiles", FilesystemServiceError):
             request = filesystem_pb2.DeleteFilesRequest(
                 context=self.mission_id,
                 filters=self._filter_to_proto(filters),
@@ -332,7 +303,7 @@ class GrpcFilesystem(FilesystemStrategy, GrpcClientWrapper):
                 context_id = self.setup_id
             case "mission":
                 context_id = self.mission_id
-        with GrpcFilesystem._handle_grpc_errors("GetFiles"):
+        with self.handle_grpc_errors("GetFiles", FilesystemServiceError):
             request = filesystem_pb2.GetFilesRequest(
                 context=context_id,
                 filters=self._filter_to_proto(filters),

digitalkin/services/setup/default_setup.py

@@ -7,8 +7,7 @@ from typing import Any
 from pydantic import ValidationError
 
 from digitalkin.logger import logger
-from digitalkin.services.setup.grpc_setup import SetupData, SetupVersionData
-from digitalkin.services.setup.setup_strategy import SetupServiceError, SetupStrategy
+from digitalkin.services.setup.setup_strategy import SetupData, SetupServiceError, SetupStrategy, SetupVersionData
 
 
 class DefaultSetup(SetupStrategy):
@@ -47,7 +46,7 @@ class DefaultSetup(SetupStrategy):
         )
         valid_data.id = setup_id
         self.setups[setup_id] = valid_data
-        logger.debug("CREATE SETUP DATA %s:%s succesfull", setup_id, valid_data)
+        logger.debug("CREATE SETUP DATA %s:%s successful", setup_id, valid_data)
         return setup_id
 
     def get_setup(self, setup_dict: dict[str, Any]) -> SetupData:
@@ -131,7 +130,7 @@ class DefaultSetup(SetupStrategy):
         if setup_version_dict["setup_id"] not in self.setup_versions:
             self.setup_versions[setup_version_dict["setup_id"]] = {}
         self.setup_versions[setup_version_dict["setup_id"]][valid_data.version] = valid_data
-        logger.debug("CREATE SETUP VERSION DATA %s:%s succesfull", setup_version_dict["setup_id"], valid_data)
+        logger.debug("CREATE SETUP VERSION DATA %s:%s successful", setup_version_dict["setup_id"], valid_data)
         return valid_data.version
 
     def get_setup_version(self, setup_version_dict: dict[str, Any]) -> SetupVersionData:
@@ -173,7 +172,7 @@ class DefaultSetup(SetupStrategy):
 
         return [
             value
-            for value in setup_version_dict["setup_id"].values()
+            for value in self.setup_versions[setup_version_dict["setup_id"]].values()
             if setup_version_dict["query_versions"] in value.version or setup_version_dict["name"] in value.name
         ]
 
@@ -190,7 +189,7 @@ class DefaultSetup(SetupStrategy):
             logger.debug("UPDATE setup_id = %s: setup_id DOESN'T EXIST", setup_version_dict["setup_id"])
             return False
 
-        if setup_version_dict["version"] not in self.setup_versions["setup_id"]:
+        if setup_version_dict["version"] not in self.setup_versions[setup_version_dict["setup_id"]]:
             logger.debug("UPDATE setup_id = %s: setup_id DOESN'T EXIST", setup_version_dict["setup_id"])
             return False
 

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 digitalkin_proto.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 digitalkin_proto.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 @@
+"""UserProfile service package."""

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 digitalkin_proto.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 maps to the user context in the proto request
+            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,40 @@
+"""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."""
+
+    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 this strategy is associated with
+        """
+        super().__init__(mission_id, setup_id, setup_version_id)
+
+    @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: