digitalkin 0.2.5__tar.gz → 0.2.7__tar.gz

{digitalkin-0.2.5 → digitalkin-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 0.2.5
+Version: 0.2.7
 Summary: SDK to build kin used in DigitalKin
 Author-email: "DigitalKin.ai" <contact@digitalkin.ai>
 License: Attribution-NonCommercial-ShareAlike 4.0 International

{digitalkin-0.2.5 → digitalkin-0.2.7}/examples/modules/minimal_llm_module.py

@@ -8,7 +8,7 @@ import grpc
 import openai
 from pydantic import BaseModel
 
-from digitalkin.grpc_servers.utils.models import SecurityMode, ServerConfig, ServerMode
+from digitalkin.grpc_servers.utils.models import SecurityMode, ClientConfig, ServerMode
 from digitalkin.modules._base_module import BaseModule
 from digitalkin.services.setup.setup_strategy import SetupData
 
@@ -45,12 +45,11 @@ class OpenAIToolSecret(BaseModel):
     """Secret model defining module configuration parameters."""
 
 
-server_config = ServerConfig(
+client_config = ClientConfig(
     host="[::]",
     port=50151,
     mode=ServerMode.ASYNC,
     security=SecurityMode.INSECURE,
-    max_workers=10,
     credentials=None,
 )
 
@@ -81,11 +80,11 @@ class OpenAIToolModule(BaseModule[OpenAIToolInput, OpenAIToolOutput, OpenAIToolS
     services_config_params = {
         "storage": {
             "config": {"setups": OpenAIToolSetup},
-            "server_config": server_config,
+            "client_config": client_config,
         },
         "filesystem": {
             "config": {},
-            "server_config": server_config,
+            "client_config": client_config,
         },
     }
 

{digitalkin-0.2.5 → digitalkin-0.2.7}/examples/modules/text_transform_module.py

@@ -6,7 +6,7 @@ from typing import Any, ClassVar
 
 from pydantic import BaseModel
 
-from digitalkin.grpc_servers.utils.models import SecurityMode, ServerConfig, ServerMode
+from digitalkin.grpc_servers.utils.models import SecurityMode, ClientConfig, ServerMode
 from digitalkin.modules._base_module import BaseModule
 from digitalkin.services.setup.setup_strategy import SetupData
 from digitalkin.services.storage.storage_strategy import DataType, StorageRecord
@@ -54,12 +54,11 @@ class TextTransformStorage(BaseModel):
     ended: bool = False
 
 
-server_config = ServerConfig(
+client_config = ClientConfig(
     host="[::]",
     port=50151,
     mode=ServerMode.ASYNC,
     security=SecurityMode.INSECURE,
-    max_workers=10,
     credentials=None,
 )
 
@@ -91,8 +90,12 @@ class TextTransformModule(BaseModule[TextTransformInput, TextTransformOutput, Te
     services_config_params = {
         "storage": {
             "config": {"monitor": TextTransformStorage, "setups": TextTransformStorage},
-            "server_config": server_config,
-        }
+            "client_config": client_config,
+        },
+        "filesystem": {
+            "config": {},
+            "client_config": client_config,
+        },
     }
 
     async def initialize(self, setup_data: SetupData) -> None:

{digitalkin-0.2.5 → digitalkin-0.2.7}/pyproject.toml

@@ -12,7 +12,7 @@
 
     keywords = [ "digitalkin", "kin", "agent", "gprc", "sdk" ]
     # Version of the package automatically updated by bump2version (that is why it is separated)
-    version = "0.2.5"
+    version = "0.2.7"
 
     classifiers = [
         "Development Status :: 3 - Alpha",

{digitalkin-0.2.5 → digitalkin-0.2.7}/src/digitalkin/__version__.py

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

{digitalkin-0.2.5 → digitalkin-0.2.7}/src/digitalkin/grpc_servers/module_servicer.py

@@ -244,7 +244,7 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer):
         # Get input schema if available
         try:
             # Convert schema to proto format
-            input_schema_proto = self.module_class.get_input_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
@@ -280,7 +280,7 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer):
         # Get output schema if available
         try:
             # Convert schema to proto format
-            output_schema_proto = self.module_class.get_output_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
@@ -316,7 +316,7 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer):
         # Get setup schema if available
         try:
             # Convert schema to proto format
-            setup_schema_proto = self.module_class.get_setup_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
@@ -332,3 +332,39 @@ class ModuleServicer(module_service_pb2_grpc.ModuleServiceServicer):
             success=True,
             setup_schema=setup_format_struct,
         )
+
+    def GetModuleSecret(  # noqa: N802
+        self,
+        request: information_pb2.GetModuleSecretRequest,
+        context: grpc.ServicerContext,
+    ) -> information_pb2.GetModuleSecretResponse:
+        """Get information about the module's secrets.
+
+        Args:
+            request: The get module secret request.
+            context: The gRPC context.
+
+        Returns:
+            A response with the module's secret schema.
+        """
+        logger.info("GetModuleSecret called for module: '%s'", self.module_class.__name__)
+
+        # Get secret schema if available
+        try:
+            # Convert schema to proto 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
+                ignore_unknown_fields=True,
+            )
+        except NotImplementedError as e:
+            logger.warning(e)
+            context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+            context.set_details(e)
+            return information_pb2.GetModuleSecretResponse()
+
+        return information_pb2.GetModuleSecretResponse(
+            success=True,
+            secret_schema=secret_format_struct,
+        )

{digitalkin-0.2.5 → digitalkin-0.2.7}/src/digitalkin/modules/_base_module.py

@@ -17,6 +17,7 @@ from digitalkin.services.registry.registry_strategy import RegistryStrategy
 from digitalkin.services.services_config import ServicesConfig, ServicesStrategy
 from digitalkin.services.snapshot.snapshot_strategy import SnapshotStrategy
 from digitalkin.services.storage.storage_strategy import StorageStrategy
+from digitalkin.utils.llm_ready_schema import llm_ready_schema
 
 
 class BaseModule(ABC, Generic[InputModelT, OutputModelT, SetupModelT, SecretModelT]):
@@ -73,7 +74,7 @@ class BaseModule(ABC, Generic[InputModelT, OutputModelT, SetupModelT, SecretMode
         return self._status
 
     @classmethod
-    def get_secret_format(cls, llm_format: bool) -> str:  # noqa: FBT001
+    def get_secret_format(cls, *, llm_format: bool) -> str:
         """Get the JSON schema of the secret format model.
 
         Raises:
@@ -84,13 +85,13 @@ class BaseModule(ABC, Generic[InputModelT, OutputModelT, SetupModelT, SecretMode
         """
         if cls.secret_format is not None:
             if llm_format:
-                return json.dumps(cls.secret_format, indent=2)
+                return json.dumps(llm_ready_schema(cls.secret_format), indent=2)
             return json.dumps(cls.secret_format.model_json_schema(), indent=2)
         msg = f"{cls.__name__}' class does not define a 'secret_format'."
         raise NotImplementedError(msg)
 
     @classmethod
-    def get_input_format(cls, llm_format: bool) -> str:  # noqa: FBT001
+    def get_input_format(cls, *, llm_format: bool) -> str:
         """Get the JSON schema of the input format model.
 
         Raises:
@@ -101,13 +102,13 @@ class BaseModule(ABC, Generic[InputModelT, OutputModelT, SetupModelT, SecretMode
         """
         if cls.input_format is not None:
             if llm_format:
-                return json.dumps(cls.input_format, indent=2)
+                return json.dumps(llm_ready_schema(cls.input_format), indent=2)
             return json.dumps(cls.input_format.model_json_schema(), indent=2)
         msg = f"{cls.__name__}' class does not define an 'input_format'."
         raise NotImplementedError(msg)
 
     @classmethod
-    def get_output_format(cls, llm_format: bool) -> str:  # noqa: FBT001
+    def get_output_format(cls, *, llm_format: bool) -> str:
         """Get the JSON schema of the output format model.
 
         Raises:
@@ -118,13 +119,13 @@ class BaseModule(ABC, Generic[InputModelT, OutputModelT, SetupModelT, SecretMode
         """
         if cls.output_format is not None:
             if llm_format:
-                return json.dumps(cls.output_format, indent=2)
+                return json.dumps(llm_ready_schema(cls.output_format), indent=2)
             return json.dumps(cls.output_format.model_json_schema(), indent=2)
         msg = "'%s' class does not define an 'output_format'."
         raise NotImplementedError(msg)
 
     @classmethod
-    def get_setup_format(cls, llm_format: bool) -> str:  # noqa: FBT001
+    def get_setup_format(cls, *, llm_format: bool) -> str:
         """Gets the JSON schema of the setup format model.
 
         Raises:
@@ -135,7 +136,7 @@ class BaseModule(ABC, Generic[InputModelT, OutputModelT, SetupModelT, SecretMode
         """
         if cls.setup_format is not None:
             if llm_format:
-                return json.dumps(cls.setup_format, indent=2)
+                return json.dumps(llm_ready_schema(cls.setup_format), indent=2)
             return json.dumps(cls.setup_format.model_json_schema(), indent=2)
         msg = "'%s' class does not define an 'setup_format'."
         raise NotImplementedError(msg)

{digitalkin-0.2.5 → digitalkin-0.2.7}/src/digitalkin/services/filesystem/grpc_filesystem.py

@@ -10,7 +10,7 @@ from digitalkin_proto.digitalkin.filesystem.v2.filesystem_pb2 import FileType as
 
 from digitalkin.grpc_servers.utils.exceptions import ServerError
 from digitalkin.grpc_servers.utils.grpc_client_wrapper import GrpcClientWrapper
-from digitalkin.grpc_servers.utils.models import ServerConfig
+from digitalkin.grpc_servers.utils.models import ClientConfig
 from digitalkin.services.filesystem.filesystem_strategy import (
     FilesystemData,
     FilesystemServiceError,
@@ -28,7 +28,7 @@ class GrpcFilesystem(FilesystemStrategy, GrpcClientWrapper):
         self,
         mission_id: str,
         config: dict[str, str],
-        server_config: ServerConfig,
+        client_config: ClientConfig,
         **kwargs,  # noqa: ANN003, ARG002
     ) -> None:
         """Initialize the default filesystem strategy.
@@ -36,11 +36,11 @@ class GrpcFilesystem(FilesystemStrategy, GrpcClientWrapper):
         Args:
             mission_id: The ID of the mission this strategy is associated with
             config: A dictionary mapping names to Pydantic model classes
-            server_config: The server configuration object
+            client_config: The client configuration object
             kwargs: other optional arguments to pass to the parent class constructor
         """
         super().__init__(mission_id, config)
-        channel = self._init_channel(server_config)
+        channel = self._init_channel(client_config)
         self.stub = filesystem_service_pb2_grpc.FilesystemServiceStub(channel)
         logger.info("Channel client 'Filesystem' initialized succesfully")
 

{digitalkin-0.2.5 → digitalkin-0.2.7}/src/digitalkin/services/storage/grpc_storage.py

@@ -8,8 +8,8 @@ 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 ServerConfig
-from digitalkin.services.storage.storage_strategy import StorageRecord, StorageServiceError, StorageStrategy
+from digitalkin.grpc_servers.utils.models import ClientConfig
+from digitalkin.services.storage.storage_strategy import DataType, StorageRecord, StorageServiceError, StorageStrategy
 
 logger = logging.getLogger(__name__)
 
@@ -21,13 +21,13 @@ class GrpcStorage(StorageStrategy, GrpcClientWrapper):
         self,
         mission_id: str,
         config: dict[str, type[BaseModel]],
-        server_config: ServerConfig,
+        client_config: ClientConfig,
         **kwargs,  # noqa: ANN003, ARG002
     ) -> None:
         """Initialize the storage."""
         super().__init__(mission_id=mission_id, config=config)
 
-        channel = self._init_channel(server_config)
+        channel = self._init_channel(client_config)
         self.stub = storage_service_pb2_grpc.StorageServiceStub(channel)
         logger.info("Channel client 'storage' initialized succesfully")
 
@@ -98,7 +98,7 @@ class GrpcStorage(StorageStrategy, GrpcClientWrapper):
 
             request = data_pb2.ModifyRecordRequest(data=data_struct, mission_id=self.mission_id, name=name)
             response: data_pb2.ModifyRecordResponse = self.exec_grpc_query("ModifyRecord", request)
-            return StorageRecord(**json_format.MessageToDict(response.stored_data))
+            return self._build_record_from_proto(response.stored_data, name)
         except Exception:
             msg = f"Error while modifing record {name}"
             logger.exception(msg)
@@ -121,3 +121,36 @@ class GrpcStorage(StorageStrategy, GrpcClientWrapper):
             logger.exception(msg)
             return False
         return True
+
+    def _build_record_from_proto(self, stored_data: data_pb2.StorageRecord, default_name: str) -> StorageRecord:
+        """Helper to construire un StorageRecord complet à partir du message gRPC.
+
+        Args:
+            stored_data: Le message gRPC contenant les données stockées.
+            default_name: Le nom par défaut à utiliser si le nom n'est pas présent dans les données.
+
+        Returns:
+            StorageRecord: Un objet StorageRecord construit à partir des données stockées.
+        """
+        # Converti en dict, avec tous les champs même s'ils sont absents
+        raw = json_format.MessageToDict(
+            stored_data,
+            preserving_proto_field_name=True,
+            always_print_fields_with_no_presence=True,
+        )
+        # On récupère ou on complète les champs obligatoires
+        name = raw.get("name", default_name)
+        dtype = raw.get("data_type", DataType.OUTPUT.name)
+        payload = raw.get("data", {})
+
+        # Valide le modèle pydantic pour le champ `data`
+        validated = self._validate_data(name, payload)
+
+        return StorageRecord(
+            mission_id=self.mission_id,
+            name=name,
+            data_type=DataType[dtype],
+            data=validated,
+            creation_date=raw.get("creation_date"),
+            update_date=raw.get("update_date"),
+        )

digitalkin-0.2.7/src/digitalkin/utils/llm_ready_schema.py

@@ -0,0 +1,75 @@
+"""LLM format schema for Pydantic models.
+
+This module provides functionality to generate JSON schemas for Pydantic models ready for LLMs.
+"""
+
+import copy
+from typing import Any
+
+from pydantic import BaseModel
+from pydantic.json_schema import GenerateJsonSchema, JsonSchemaValue
+
+
+class CustomOrderSchema(GenerateJsonSchema):
+    """Custom schema generator to sort keys in a specific order."""
+
+    def sort(self, value: JsonSchemaValue, parent_key: str | None = None) -> JsonSchemaValue:  # noqa: ARG002
+        """Sort the keys of the schema in a specific order.
+
+        Args:
+            value: The schema value to sort.
+            parent_key: The parent key of the schema value.
+
+        Returns:
+            The sorted schema value.
+        """
+        if isinstance(value, dict):
+            # Define your preferred order
+            preferred = ["title", "description", "type", "examples", "properties"]
+            # Collect all keys, putting preferred ones first
+            keys = preferred + [k for k in value if k not in preferred]
+            # Recurse for each value
+            return {k: self.sort(value[k], k) for k in keys if k in value}
+        if isinstance(value, list):
+            return [self.sort(v) for v in value]
+        return value
+
+
+def inline_refs(schema: dict) -> dict:
+    """Recursively resolve and inline all $ref in the schema.
+
+    Args:
+        schema: The JSON schema to inline.
+
+    Returns:
+        The inlined JSON schema.
+    """
+    schema = copy.deepcopy(schema)
+    defs = schema.pop("$defs", {})
+
+    def _resolve(obj: Any) -> Any:  # noqa: ANN401
+        if isinstance(obj, dict):
+            if "$ref" in obj:
+                ref = obj["$ref"]
+                if ref.startswith("#/$defs/"):
+                    key = ref.split("/")[-1]
+                    return _resolve(defs[key])
+            return {k: _resolve(v) for k, v in obj.items()}
+        if isinstance(obj, list):
+            return [_resolve(item) for item in obj]
+        return obj
+
+    return _resolve(schema)
+
+
+def llm_ready_schema(model: type[BaseModel]) -> dict:
+    """Convert a Pydantic model to a JSON schema ready for LLMs.
+
+    Args:
+        model: The Pydantic model to convert.
+
+    Returns:
+        The JSON schema as a dictionary.
+    """
+    schema = model.model_json_schema(schema_generator=CustomOrderSchema)
+    return inline_refs(schema)

{digitalkin-0.2.5 → digitalkin-0.2.7}/src/digitalkin.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 0.2.5
+Version: 0.2.7
 Summary: SDK to build kin used in DigitalKin
 Author-email: "DigitalKin.ai" <contact@digitalkin.ai>
 License: Attribution-NonCommercial-ShareAlike 4.0 International

{digitalkin-0.2.5 → digitalkin-0.2.7}/src/digitalkin.egg-info/SOURCES.txt

@@ -78,4 +78,5 @@ src/digitalkin/services/storage/default_storage.py
 src/digitalkin/services/storage/grpc_storage.py
 src/digitalkin/services/storage/storage_strategy.py
 src/digitalkin/utils/__init__.py
-src/digitalkin/utils/arg_parser.py
+src/digitalkin/utils/arg_parser.py
+src/digitalkin/utils/llm_ready_schema.py