digitalkin 0.3.3.dev9__tar.gz → 0.3.5.dev0__tar.gz

{digitalkin-0.3.3.dev9 → digitalkin-0.3.5.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: digitalkin
-Version: 0.3.3.dev9
+Version: 0.3.5.dev0
 Summary: SDK to build kin used in DigitalKin
 Author-email: "DigitalKin.ai" <contact@digitalkin.ai>
 License: Attribution-NonCommercial-ShareAlike 4.0 International
@@ -453,7 +453,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: agentic-mesh-protocol==0.2.3
-Requires-Dist: anyio==4.12.1
+Requires-Dist: anyio==4.13.0
 Requires-Dist: grpcio-health-checking==1.78.0
 Requires-Dist: grpcio-reflection==1.78.0
 Requires-Dist: grpcio-status==1.78.0

{digitalkin-0.3.3.dev9 → digitalkin-0.3.5.dev0}/examples/modules/archetype_with_tools_module.py

@@ -5,10 +5,11 @@ from typing import Any, ClassVar, Literal
 
 from pydantic import BaseModel, Field
 
-from digitalkin.models.grpc_servers.models import ClientConfig, SecurityMode, ServerMode
+from digitalkin.models.grpc_servers.models import ClientConfig
 from digitalkin.models.module.module_context import ModuleContext
 from digitalkin.models.module.setup_types import SetupModel
 from digitalkin.models.module.tool_reference import ToolReference
+from digitalkin.models.settings.utils.channel import ControlFlow, SecurityMode
 from digitalkin.modules._base_module import BaseModule  # noqa: PLC2701
 from digitalkin.services.services_models import ServicesStrategy
 
@@ -98,7 +99,7 @@ class ArchetypeSecret(BaseModel):
 client_config = ClientConfig(
     host="[::]",
     port=50152,
-    mode=ServerMode.ASYNC,
+    mode=ControlFlow.ASYNC,
     security=SecurityMode.INSECURE,
     credentials=None,
 )

{digitalkin-0.3.3.dev9 → digitalkin-0.3.5.dev0}/pyproject.toml

@@ -28,13 +28,13 @@
 
     dependencies = [
         "agentic-mesh-protocol==0.2.3",
-        "anyio==4.12.1",
+        "anyio==4.13.0",
         "grpcio-health-checking==1.78.0",
         "grpcio-reflection==1.78.0",
         "grpcio-status==1.78.0",
         "pydantic==2.12.5",
     ]
-    version = "0.3.3.dev9"
+    version = "0.3.5.dev0"
 
     [project.optional-dependencies]
         profiling = [
@@ -60,7 +60,7 @@
 
 [dependency-groups]
     dev = [
-        "build==1.4.0",
+        "build==1.4.1",
         "bump-my-version==1.2.7",
         "cryptography==46.0.5",
         "mypy==1.19.1",

{digitalkin-0.3.3.dev9 → digitalkin-0.3.5.dev0}/src/digitalkin/__version__.py

@@ -5,4 +5,4 @@ from importlib.metadata import PackageNotFoundError, version
 try:
     __version__ = version("digitalkin")
 except PackageNotFoundError:
-    __version__ = "0.3.3.dev9"
+    __version__ = "0.3.5.dev0"

{digitalkin-0.3.3.dev9 → digitalkin-0.3.5.dev0}/src/digitalkin/grpc_servers/_base_server.py

@@ -6,7 +6,7 @@ import os
 from collections.abc import Callable, Sequence
 from concurrent import futures
 from pathlib import Path
-from typing import Any, cast
+from typing import Any, ClassVar, cast
 
 import grpc
 from grpc import aio as grpc_aio
@@ -20,8 +20,9 @@ from digitalkin.grpc_servers.utils.exceptions import (
 )
 from digitalkin.grpc_servers.utils.grpc_client_wrapper import GrpcClientWrapper
 from digitalkin.logger import logger
-from digitalkin.models.grpc_servers.models import SecurityMode, ServerConfig, ServerMode
 from digitalkin.models.grpc_servers.types import GrpcServer, ServiceDescriptor, T
+from digitalkin.models.settings.server.server import ServerSettings
+from digitalkin.models.settings.utils.channel import ControlFlow, SecurityMode
 
 
 class BaseServer(abc.ABC):
@@ -32,25 +33,23 @@ class BaseServer(abc.ABC):
     communication modes.
 
     Attributes:
-        config: The server configuration.
         server: The gRPC server instance (either sync or async).
         _servicers: List of registered servicers.
         _service_names: List of service names for reflection.
         _health_servicer: Optional health check servicer.
     """
 
+    _server_settings: ClassVar[ServerSettings] = ServerSettings()
+
     def __init__(
         self,
-        config: ServerConfig,
         interceptors: Sequence[Any] | None = None,
     ) -> None:
         """Initialize the base gRPC server.
 
         Args:
-            config: The server configuration.
             interceptors: Optional sequence of gRPC server interceptors.
         """
-        self.config = config
         self.server: GrpcServer | None = None
         self._servicers: list[Any] = []
         self._service_names: list[str] = []  # Track service names for reflection
@@ -119,7 +118,7 @@ class BaseServer(abc.ABC):
         Raises:
             ReflectionError: If reflection initialization fails.
         """
-        if not self.config.enable_reflection or self.server is None or not self._service_names:
+        if not self._server_settings.reflection or self.server is None or not self._service_names:
             return
 
         try:
@@ -194,17 +193,17 @@ class BaseServer(abc.ABC):
             logger.warning("Failed to enable health service: %s", e)
 
     def _create_server(self) -> GrpcServer:
-        """Create a gRPC server instance based on the configuration.
+        """Create a gRPC server instance based on the server settings.
 
         Returns:
             A configured gRPC server instance.
 
         Raises:
-            ConfigurationError: If the server configuration is invalid.
+            ConfigurationError: If the server settings are invalid.
         """
         try:
             # Create the server based on mode
-            grpc_compression = self.config.compression.to_grpc()
+            grpc_compression = self._server_settings.grpc.compression.to_grpc()
 
             # Machine capabilities
             try:
@@ -215,36 +214,36 @@ class BaseServer(abc.ABC):
                 logger.info("CPU count: %d", cpu_count)
 
             # Compute defaults from machine capabilities, overridable via env vars
-            max_concurrent_rpcs = int(os.environ.get("DIGITALKIN_MAX_CONCURRENT_RPCS", str(cpu_count * 200)))
-            thread_pool_workers = int(os.environ.get("DIGITALKIN_THREAD_POOL_WORKERS", str(min(4, cpu_count))))
 
             logger.info(
-                "gRPC server config: cpus=%d, max_concurrent_rpcs=%d, thread_pool_workers=%d, mode=%s",
+                "gRPC server settings.server: cpus=%d, max_concurrent_rpcs=%d, thread_pool_workers=%d, mode=%s",
                 cpu_count,
-                max_concurrent_rpcs,
-                thread_pool_workers,
-                self.config.mode.value,
+                self._server_settings.max_concurrent_rpcs,
+                self._server_settings.thread_pool_workers,
+                self._server_settings.channel.communication_mode.value,
             )
 
-            if self.config.mode == ServerMode.ASYNC:
+            if self._server_settings.channel.communication_mode == ControlFlow.ASYNC:
                 server = grpc_aio.server(
-                    options=self.config.server_options,
+                    options=self._server_settings.grpc.options,
                     compression=grpc_compression,
                     interceptors=self._interceptors or None,
-                    maximum_concurrent_rpcs=max_concurrent_rpcs,
-                    migration_thread_pool=futures.ThreadPoolExecutor(max_workers=thread_pool_workers),
+                    maximum_concurrent_rpcs=self._server_settings.max_concurrent_rpcs,
+                    migration_thread_pool=futures.ThreadPoolExecutor(
+                        max_workers=self._server_settings.thread_pool_workers
+                    ),
                 )
             else:
                 server = grpc.server(  # type: ignore[assignment]  # sync grpc.Server assigned to GrpcServer union
-                    futures.ThreadPoolExecutor(max_workers=self.config.max_workers),
-                    options=self.config.server_options,
+                    futures.ThreadPoolExecutor(max_workers=self._server_settings.max_workers),
+                    options=self._server_settings.grpc.options,
                     compression=grpc_compression,
                     interceptors=self._interceptors or None,
-                    maximum_concurrent_rpcs=max_concurrent_rpcs,
+                    maximum_concurrent_rpcs=self._server_settings.max_concurrent_rpcs,
                 )
 
             # Add the appropriate port
-            if self.config.security == SecurityMode.SECURE:
+            if self._server_settings.channel.security == SecurityMode.SECURE:
                 self._add_secure_port(server)
             else:
                 self._add_insecure_port(server)
@@ -264,19 +263,26 @@ class BaseServer(abc.ABC):
         Raises:
             SecurityError: If credentials are not configured correctly.
         """
-        if not self.config.credentials:
+        if not self._server_settings.channel.credentials:
             msg = "Credentials must be provided for secure server"
             raise SecurityError(msg)
 
         try:
             # Read key and certificate files
-            private_key = Path(self.config.credentials.server_key_path).read_bytes()
-            certificate_chain = Path(self.config.credentials.server_cert_path).read_bytes()
+            if (
+                self._server_settings.channel.credentials.key_path
+                and self._server_settings.channel.credentials.cert_path
+            ):
+                private_key = Path(self._server_settings.channel.credentials.key_path).read_bytes()
+                certificate_chain = Path(self._server_settings.channel.credentials.cert_path).read_bytes()
+            else:
+                msg = "Key path and certificate path must be provided for secure server"
+                raise SecurityError(msg)
 
             # Read root certificate if provided
             root_certificates = None
-            if self.config.credentials.root_cert_path:
-                root_certificates = Path(self.config.credentials.root_cert_path).read_bytes()
+            if self._server_settings.channel.credentials.root_cert_path:
+                root_certificates = Path(self._server_settings.channel.credentials.root_cert_path).read_bytes()
         except OSError as e:
             msg = f"Failed to read credential files: {e}"
             raise SecurityError(msg) from e
@@ -290,16 +296,16 @@ class BaseServer(abc.ABC):
             )
 
             # Add secure port to server
-            if self.config.mode == ServerMode.ASYNC:
+            if self._server_settings.channel.communication_mode == ControlFlow.ASYNC:
                 async_server = cast("grpc_aio.Server", server)
-                async_server.add_secure_port(self.config.address, server_credentials)
+                async_server.add_secure_port(self._server_settings.channel.address, server_credentials)
             else:
                 sync_server = cast("grpc.Server", server)
-                sync_server.add_secure_port(self.config.address, server_credentials)
+                sync_server.add_secure_port(self._server_settings.channel.address, server_credentials)
 
-            logger.debug("Added secure port %s", self.config.address)
+            logger.debug("Added secure port %s", self._server_settings.channel.address)
         except Exception as e:
-            msg = f"Failed to configure secure port: {e}"
+            msg = f"Failed to configure with actual settings secure port: {e}"
             raise SecurityError(msg) from e
 
     def _add_insecure_port(self, server: GrpcServer) -> None:
@@ -312,14 +318,14 @@ class BaseServer(abc.ABC):
             ConfigurationError: If adding the insecure port fails.
         """
         try:
-            if self.config.mode == ServerMode.ASYNC:
+            if self._server_settings.channel.communication_mode == ControlFlow.ASYNC:
                 async_server = cast("grpc_aio.Server", server)
-                async_server.add_insecure_port(self.config.address)
+                async_server.add_insecure_port(self._server_settings.channel.address)
             else:
                 sync_server = cast("grpc.Server", server)
-                sync_server.add_insecure_port(self.config.address)
+                sync_server.add_insecure_port(self._server_settings.channel.address)
 
-            logger.debug("Added insecure port %s", self.config.address)
+            logger.debug("Added insecure port %s", self._server_settings.channel.address)
         except Exception as e:
             msg = f"Failed to add insecure port: {e}"
             raise ConfigurationError(msg) from e
@@ -343,9 +349,11 @@ class BaseServer(abc.ABC):
         self._add_reflection()
 
         # Start the server
-        logger.debug("Starting gRPC server on %s", self.config.address, extra={"config": self.config})
+        logger.debug(
+            "Starting gRPC server on %s", self._server_settings.channel.address, extra={"config": ServerSettings}
+        )
         try:
-            if self.config.mode == ServerMode.ASYNC:
+            if self._server_settings.channel.communication_mode == ControlFlow.ASYNC:
                 # For async server, use the event loop
                 loop = asyncio.get_event_loop()
                 if loop.is_closed():
@@ -356,7 +364,7 @@ class BaseServer(abc.ABC):
                 # For sync server, directly call start
                 sync_server = cast("grpc.Server", self.server)
                 sync_server.start()
-            logger.debug("✅ gRPC server started on %s", self.config.address)
+            logger.debug("✅ gRPC server started on %s", self._server_settings.channel.address)
         except Exception as e:
             logger.exception("❎ Error starting server")
             msg = f"Failed to start server: {e}"
@@ -393,15 +401,15 @@ class BaseServer(abc.ABC):
         self._add_reflection()
 
         # Start the server
-        logger.debug("Starting gRPC server on %s", self.config.address)
+        logger.debug("Starting gRPC server on %s", self._server_settings.channel.address)
         try:
-            if self.config.mode == ServerMode.ASYNC:
+            if self._server_settings.channel.communication_mode == ControlFlow.ASYNC:
                 await self._start_async()
             else:
                 # For sync server in async context
                 sync_server = cast("grpc.Server", self.server)
                 sync_server.start()
-            logger.debug("✅ gRPC server started on %s", self.config.address)
+            logger.debug("✅ gRPC server started on %s", self._server_settings.channel.address)
         except Exception as e:
             logger.exception("❎ Error starting server")
             msg = f"Failed to start server: {e}"
@@ -431,7 +439,7 @@ class BaseServer(abc.ABC):
             return
 
         logger.debug("Stopping gRPC server...")
-        if self.config.mode == ServerMode.ASYNC:
+        if self._server_settings.channel.communication_mode == ControlFlow.ASYNC:
             # We'll use a different approach that works whether we're in a running event loop or not
             try:
                 # Get the current event loop
@@ -507,7 +515,7 @@ class BaseServer(abc.ABC):
             return
 
         logger.debug("Stopping gRPC server asynchronously...")
-        if self.config.mode == ServerMode.ASYNC:
+        if self._server_settings.channel.communication_mode == ControlFlow.ASYNC:
             await self._stop_async(grace)
         else:
             # For sync server, we can just call stop
@@ -533,7 +541,7 @@ class BaseServer(abc.ABC):
             logger.warning("Attempted to wait for termination, but no server is running")
             return
 
-        if self.config.mode == ServerMode.SYNC:
+        if self._server_settings.channel.communication_mode == ControlFlow.SYNC:
             # For sync server
             sync_server = cast("grpc.Server", self.server)
             sync_server.wait_for_termination()
@@ -548,7 +556,7 @@ class BaseServer(abc.ABC):
 
         This method should only be used with async servers.
         """
-        if self.config.mode == ServerMode.SYNC:
+        if self._server_settings.channel.communication_mode == ControlFlow.SYNC:
             logger.warning(
                 "Called await_termination on sync server. Use wait_for_termination instead for sync servers.",
             )

{digitalkin-0.3.3.dev9 → digitalkin-0.3.5.dev0}/src/digitalkin/grpc_servers/module_server.py

@@ -13,7 +13,6 @@ from digitalkin.grpc_servers.module_servicer import ModuleServicer
 from digitalkin.logger import logger
 from digitalkin.models.grpc_servers.models import (
     ClientConfig,
-    ModuleServerConfig,
 )
 from digitalkin.modules._base_module import BaseModule
 from digitalkin.services.registry import GrpcRegistry
@@ -38,7 +37,6 @@ class ModuleServer(BaseServer):
     def __init__(
         self,
         module_class: type[BaseModule],
-        server_config: ModuleServerConfig,
         client_config: ClientConfig | None = None,
         interceptors: Sequence[Any] | None = None,
     ) -> None:
@@ -46,13 +44,11 @@ class ModuleServer(BaseServer):
 
         Args:
             module_class: The module instance to be served.
-            server_config: Server configuration.
             client_config: Client configuration used by services and registry connection.
             interceptors: Optional sequence of gRPC server interceptors.
         """
-        super().__init__(server_config, interceptors=interceptors)
+        super().__init__(interceptors=interceptors)
         self.module_class = module_class
-        self.server_config = server_config
         self.client_config = client_config
         self.module_servicer: ModuleServicer | None = None
         self.registry: RegistryStrategy | None = None
@@ -108,7 +104,7 @@ class ModuleServer(BaseServer):
         """Start the module server and register with the registry if configured."""
         import asyncio
 
-        logger.info("Starting module server", extra={"server_config": self.server_config})
+        logger.info("Starting module server", extra={"server_config": self._server_settings})
         super().start()
 
         try:
@@ -119,7 +115,7 @@ class ModuleServer(BaseServer):
 
     async def start_async(self) -> None:
         """Start the module server and register with the registry if configured."""
-        logger.info("Starting module server", extra={"server_config": self.server_config})
+        logger.info("Starting module server", extra={"server_config": self._server_settings})
         await super().start_async()
 
         # module_servicer is now set by _register_servicers() during super().start_async()
@@ -191,14 +187,14 @@ class ModuleServer(BaseServer):
             )
             return
 
-        advertise_address = self.server_config.advertise_host or self.server_config.host
+        advertise_address = self._server_settings.channel.advertise_host or self._server_settings.channel.host
 
         logger.info(
             "Attempting to register module with registry",
             extra={
                 "module_id": module_id,
                 "address": advertise_address,
-                "port": self.server_config.port,
+                "port": self._server_settings.channel.port,
                 "version": version,
             },
         )
@@ -206,7 +202,7 @@ class ModuleServer(BaseServer):
         result = await self.registry.register(
             module_id=module_id,
             address=advertise_address,
-            port=self.server_config.port,
+            port=self._server_settings.channel.port,
             version=version,
         )
 
@@ -216,7 +212,7 @@ class ModuleServer(BaseServer):
                 extra={
                     "module_id": result.module_id,
                     "address": advertise_address,
-                    "port": self.server_config.port,
+                    "port": self._server_settings.channel.port,
                 },
             )
         else:

{digitalkin-0.3.3.dev9 → digitalkin-0.3.5.dev0}/src/digitalkin/grpc_servers/utils/grpc_client_wrapper.py

@@ -11,7 +11,8 @@ import grpc.aio
 
 from digitalkin.grpc_servers.utils.exceptions import ServerError
 from digitalkin.logger import logger
-from digitalkin.models.grpc_servers.models import ClientConfig, SecurityMode
+from digitalkin.models.grpc_servers.models import ClientConfig
+from digitalkin.models.settings.utils.channel import SecurityMode
 
 
 class GrpcClientWrapper:
@@ -31,6 +32,13 @@ class GrpcClientWrapper:
     _channel_cache_key: str | None = None
     _channel_cache: ClassVar[dict[str, grpc.aio.Channel]] = {}
     _ref_counts: ClassVar[dict[str, int]] = {}
+    _RETRYABLE_CODES: ClassVar[set[grpc.StatusCode]] = {
+        grpc.StatusCode.UNAVAILABLE,
+        grpc.StatusCode.INTERNAL,
+        grpc.StatusCode.DEADLINE_EXCEEDED,
+    }
+    _QUERY_MAX_RETRIES: ClassVar[int] = int(os.environ.get("DIGITALKIN_GRPC_QUERY_MAX_RETRIES", "2"))
+    _QUERY_BACKOFF_BASE_MS: ClassVar[float] = float(os.environ.get("DIGITALKIN_GRPC_QUERY_BACKOFF_BASE_MS", "50"))
 
     @staticmethod
     def _build_channel_credentials(config: ClientConfig) -> grpc.ChannelCredentials | None:
@@ -140,14 +148,6 @@ class GrpcClientWrapper:
         cls._channel_cache.clear()
         cls._ref_counts.clear()
 
-    _RETRYABLE_CODES: ClassVar[set[grpc.StatusCode]] = {
-        grpc.StatusCode.UNAVAILABLE,
-        grpc.StatusCode.INTERNAL,
-        grpc.StatusCode.DEADLINE_EXCEEDED,
-    }
-    _QUERY_MAX_RETRIES: ClassVar[int] = int(os.environ.get("DIGITALKIN_GRPC_QUERY_MAX_RETRIES", "2"))
-    _QUERY_BACKOFF_BASE_MS: ClassVar[float] = float(os.environ.get("DIGITALKIN_GRPC_QUERY_BACKOFF_BASE_MS", "50"))
-
     async def exec_grpc_query(
         self,
         query_endpoint: str,

{digitalkin-0.3.3.dev9 → digitalkin-0.3.5.dev0}/src/digitalkin/models/grpc_servers/models.py

@@ -9,6 +9,7 @@ import grpc
 from pydantic import BaseModel, Field, ValidationInfo, field_validator
 
 from digitalkin.grpc_servers.utils.exceptions import ConfigurationError, SecurityError
+from digitalkin.models.settings.utils.channel import ControlFlow, SecurityMode
 
 
 class GrpcCompression(str, Enum):
@@ -39,61 +40,6 @@ class GrpcCompression(str, Enum):
                 return grpc.Compression.Deflate
 
 
-class ServerMode(str, Enum):
-    """Enum for server operation mode."""
-
-    SYNC = "sync"
-    ASYNC = "async"
-
-
-class SecurityMode(str, Enum):
-    """Enum for server security mode."""
-
-    SECURE = "secure"
-    INSECURE = "insecure"
-
-
-class ServerCredentials(BaseModel):
-    """Model for server credentials in secure mode.
-
-    Attributes:
-        server_key_path: Path to the server private key
-        server_cert_path: Path to the server certificate
-        root_cert_path: Optional path to the root certificate
-    """
-
-    server_key_path: Path = Field(..., description="Path to the server private key")
-    server_cert_path: Path = Field(..., description="Path to the server certificate")
-    root_cert_path: Path | None = Field(None, description="Path to the root certificate")
-
-    # Enable __slots__ for memory efficiency
-    model_config = {
-        "extra": "forbid",
-        "arbitrary_types_allowed": True,
-        "validate_assignment": True,
-        "frozen": True,
-    }
-
-    @field_validator("server_key_path", "server_cert_path", "root_cert_path")
-    @classmethod
-    def check_path_exists(cls, v: Path | None) -> Path | None:
-        """Validate that the file path exists.
-
-        Args:
-            v: Path to validate
-
-        Returns:
-            The validated path
-
-        Raises:
-            SecurityError: If the path does not exist
-        """
-        if v is not None and not v.exists():
-            msg = f"File not found: {v}"
-            raise SecurityError(msg)
-        return v
-
-
 class RetryPolicy(BaseModel):
     """gRPC retry policy configuration for resilient connections.
 
@@ -202,7 +148,7 @@ class ChannelConfig(BaseModel):
         description="Host address to bind the client to",
     )  # Bind to all interfaces by design
     port: int = Field(50051, description="Port to listen on")
-    mode: ServerMode = Field(ServerMode.SYNC, description="Client operation mode (sync/async)")
+    mode: ControlFlow = Field(ControlFlow.SYNC, description="Client operation mode (sync/async)")
     security: SecurityMode = Field(SecurityMode.INSECURE, description="Security mode (secure/insecure)")
 
     # Enable __slots__ for memory efficiency
@@ -315,101 +261,3 @@ class ClientConfig(ChannelConfig):
             Full list of gRPC channel options.
         """
         return [*self.channel_options, ("grpc.service_config", self.retry_policy.to_service_config_json())]
-
-
-class ServerConfig(ChannelConfig):
-    """Base configuration for gRPC servers.
-
-    Attributes:
-        host: Host address to bind the server to
-        port: Port to listen on
-        max_workers: Maximum number of workers for sync mode
-        mode: Server operation mode (sync/async)
-        security: Security mode (secure/insecure)
-        credentials: Server credentials for secure mode
-        server_options: Additional server options
-        enable_reflection: Enable reflection for the server
-        compression: gRPC compression algorithm for server-level compression
-    """
-
-    max_workers: int = Field(10, description="Maximum number of workers for sync mode")
-    credentials: ServerCredentials | None = Field(None, description="Server credentials for secure mode")
-    compression: GrpcCompression = Field(GrpcCompression.GZIP, description="gRPC compression algorithm")
-    server_options: list[tuple[str, Any]] = Field(
-        default_factory=lambda: [
-            ("grpc.max_receive_message_length", 100 * 1024 * 1024),
-            ("grpc.max_send_message_length", 100 * 1024 * 1024),
-            # === Server-Side Keepalive (Keeps Connections Alive Through Proxies) ===
-            # Server sends keepalive pings to detect dead clients and keep
-            # proxy connections (e.g. Railway) alive during long-running RPCs.
-            (
-                "grpc.keepalive_time_ms",
-                int(os.environ.get("DIGITALKIN_GRPC_SERVER_KEEPALIVE_TIME_MS", "120000")),
-            ),
-            (
-                "grpc.keepalive_timeout_ms",
-                int(os.environ.get("DIGITALKIN_GRPC_SERVER_KEEPALIVE_TIMEOUT_MS", "20000")),
-            ),
-            # === Keepalive Permission (Required for Client Keepalive) ===
-            # Allow clients to send keepalive pings without active RPCs
-            # Without this, server rejects client keepalives with GOAWAY
-            ("grpc.keepalive_permit_without_calls", True),
-            # Allow unlimited pings without data (required for long-running streams)
-            ("grpc.http2.max_pings_without_data", 0),
-            # Minimum interval server allows between client pings
-            # Prevents "too_many_pings" GOAWAY errors
-            # Must match or be less than client's http2.min_time_between_pings_ms
-            (
-                "grpc.http2.min_ping_interval_without_data_ms",
-                int(os.environ.get("DIGITALKIN_GRPC_SERVER_MIN_PING_INTERVAL_MS", "10000")),
-            ),
-        ],
-        description="gRPC server options with keepalive support",
-    )
-    enable_reflection: bool = Field(default=True, description="Enable reflection for the server")
-    enable_health_check: bool = Field(default=True, description="Enable health check service")
-
-    @field_validator("credentials")
-    @classmethod
-    def validate_credentials(cls, v: ServerCredentials | None, info: ValidationInfo) -> ServerCredentials | None:
-        """Validate that credentials are provided when in secure mode.
-
-        Args:
-            v: The credentials value
-            info: ValidationInfo containing other field values
-
-        Returns:
-            The validated credentials
-
-        Raises:
-            ConfigurationError: If credentials are missing in secure mode
-        """
-        # Access security mode from the info.data dictionary
-        security = info.data.get("security")
-
-        if security == SecurityMode.SECURE and v is None:
-            msg = "Credentials must be provided when using secure mode"
-            raise ConfigurationError(msg)
-        return v
-
-
-class ModuleServerConfig(ServerConfig):
-    """Configuration for Module gRPC server.
-
-    Attributes:
-        advertise_host: Public hostname/IP sent to registry for discovery. Falls back to host if not set.
-    """
-
-    advertise_host: str | None = Field(
-        None, description="Public hostname/IP sent to registry for discovery. Falls back to host if not set."
-    )
-
-
-class RegistryServerConfig(ServerConfig):
-    """Configuration for Registry gRPC server.
-
-    Attributes:
-        database_url: Database URL for registry data storage
-    """
-
-    database_url: str | None = Field(None, description="Database URL for registry data storage")

digitalkin-0.3.5.dev0/src/digitalkin/models/settings/__init__.py

@@ -0,0 +1 @@
+"""This package contain settings of sdk."""

digitalkin-0.3.5.dev0/src/digitalkin/models/settings/server/__init__.py

@@ -0,0 +1 @@
+"""Package for server settings."""