model-compose 0.4.14__tar.gz → 0.4.16__tar.gz

{model_compose-0.4.14/src/model_compose.egg-info → model_compose-0.4.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.4.14
+Version: 0.4.16
 Summary: model-compose: Declarative AI Workflow Orchestrator
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT

{model_compose-0.4.14 → model_compose-0.4.16}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.4.14"
+version = "0.4.16"
 description = "model-compose: Declarative AI Workflow Orchestrator"
 authors = [
     { name = "Hanyeol Cho", email = "hanyeol.cho@gmail.com" }

{model_compose-0.4.14 → model_compose-0.4.16}/src/mindor/cli/compose.py

@@ -14,6 +14,12 @@ def _load_compose_config(config_files: List[Path], env_files: List[Path], env_da
 
     return load_compose_config(".", config_files, env)
 
+def _get_version() -> str:
+    try:
+        return importlib.metadata.version("model-compose")
+    except importlib.metadata.PackageNotFoundError:
+        return "latest"
+
 @click.group()
 @click.option(
     "--file", "-f", "config_files", multiple=True,
@@ -21,7 +27,7 @@ def _load_compose_config(config_files: List[Path], env_files: List[Path], env_da
     help="Compose configuration files."
 )
 @click.version_option(
-    version=importlib.metadata.version("model-compose"),
+    version=_get_version(),
     message="%(prog)s %(version)s"
 )
 @click.pass_context

{model_compose-0.4.14 → model_compose-0.4.16}/src/mindor/core/component/services/vector_store/drivers/chroma.py

@@ -5,6 +5,7 @@ from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annot
 from mindor.dsl.schema.component import VectorStoreComponentConfig
 from mindor.dsl.schema.action import VectorStoreActionConfig, ChromaVectorStoreActionConfig, VectorStoreActionMethod, VectorStoreFilterCondition, VectorStoreFilterOperator
 from mindor.core.utils.streamer import AsyncStreamer
+from mindor.core.utils.time import parse_duration
 from mindor.core.logger import logging
 from ..base import VectorStoreService, VectorStoreDriver, register_vector_store_service
 from ..base import ComponentActionContext
@@ -255,7 +256,8 @@ class ChromaVectorStoreService(VectorStoreService):
 
             return HttpClient(
                 **self._resolve_connection_params(),
-                **self._resolve_database_params()
+                **self._resolve_database_params(),
+                timeout=parse_duration(self.config.timeout).total_seconds()
             )
 
         if self.config.mode == "local":

{model_compose-0.4.14 → model_compose-0.4.16}/src/mindor/core/component/services/vector_store/drivers/milvus.py

@@ -5,6 +5,7 @@ from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annot
 from mindor.dsl.schema.component import VectorStoreComponentConfig
 from mindor.dsl.schema.action import VectorStoreActionConfig, MilvusVectorStoreActionConfig, VectorStoreActionMethod, VectorStoreFilterCondition, VectorStoreFilterOperator
 from mindor.core.utils.streamer import AsyncStreamer
+from mindor.core.utils.time import parse_duration
 from mindor.core.logger import logging
 from ..base import VectorStoreService, VectorStoreDriver, register_vector_store_service
 from ..base import ComponentActionContext
@@ -315,7 +316,7 @@ class MilvusVectorStoreService(VectorStoreService):
             user=self.config.user or "",
             password=self.config.password or "",
             db_name=self.config.database or "",
-            timeout=self.config.timeout
+            timeout=parse_duration(self.config.timeout).total_seconds()
         )
 
     async def _shutdown(self) -> None:

{model_compose-0.4.14 → model_compose-0.4.16}/src/mindor/core/gateway/services/ssh_tunnel.py

@@ -2,10 +2,11 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Iterator, Any
-from mindor.dsl.schema.gateway import SshTunnelGatewayConfig
-from ..base import GatewayService, GatewayType, register_gateway
-from mindor.core.utils.ssh_client import SshClient
+from mindor.dsl.schema.gateway import SshTunnelGatewayConfig, SshConnectionConfig, SshAuthConfig
+from mindor.core.utils.ssh_client import SshClient, SshConnectionParams, SshAuthParams, SshKeyfileAuthParams, SshPasswordAuthParams
+from mindor.core.utils.time import parse_duration
 from mindor.core.logger import logging
+from ..base import GatewayService, GatewayType, register_gateway
 import asyncio
 
 if TYPE_CHECKING:
@@ -42,7 +43,7 @@ class SshTunnelGateway(GatewayService):
 
         self._shutdown_event = asyncio.Event()
 
-        self.client = SshClient(self.config.connection)
+        self.client = SshClient(self._build_connection_params(self.config.connection))
         await self.client.connect()
 
         # Start remote port forwarding for each port mapping
@@ -62,6 +63,29 @@ class SshTunnelGateway(GatewayService):
         # Keep the SSH connection alive until shutdown event is set
         await self._shutdown_event.wait()
 
+    def _build_connection_params(self, config: SshConnectionConfig) -> SshConnectionParams:
+        return SshConnectionParams(
+            host=config.host,
+            port=config.port,
+            auth=self._build_auth_params(config.auth),
+            keepalive_interval=int(parse_duration(config.keepalive_interval).total_seconds())
+        )
+    
+    def _build_auth_params(self, config: SshAuthConfig) -> SshAuthParams:
+        if config.type.value == "keyfile":
+            return SshKeyfileAuthParams(
+                username=config.username,
+                keyfile=config.keyfile
+            )
+        
+        if config.type.value == "password":
+            return SshPasswordAuthParams(
+                username=config.username,
+                password=config.password
+            )
+
+        raise ValueError(f"Unknown SSH auth type: {config.type}")
+
     async def _shutdown(self) -> None:
         """Stop SSH tunnel and cleanup"""
         # Signal the _serve task to stop

{model_compose-0.4.14 → model_compose-0.4.16}/src/mindor/core/runtime/env.py

@@ -1,6 +1,7 @@
 from typing import Union, Dict, List
 from pathlib import Path
 from dotenv import dotenv_values
+import os
 
 def load_env_files(work_dir: Union[ str, Path ], env_files: List[Union[ str, Path ]]) -> Dict[str, str]:
     if len(env_files) == 0:
@@ -19,6 +20,9 @@ def load_env_files(work_dir: Union[ str, Path ], env_files: List[Union[ str, Pat
     return merged_env
 
 def merge_env_data(env: Dict[str, str], env_data: List[str]) -> Dict[str, str]:
+    # Merge current shell environment variables (overrides .env file values)
+    env.update(os.environ)
+
     for env_entry in env_data:
         if "=" not in env_entry:
             raise ValueError(f"Invalid env entry: {env_entry}")

{model_compose-0.4.14 → model_compose-0.4.16}/src/mindor/core/utils/ssh_client.py

@@ -1,20 +1,83 @@
 from __future__ import annotations
-from typing import TYPE_CHECKING, Optional, Dict, List, Tuple, Any
-from mindor.dsl.schema.transport.ssh import SshConnectionConfig, SshKeyfileAuthConfig, SshPasswordAuthConfig
+from typing import TYPE_CHECKING, Optional, Dict, List, Tuple, Union, Any
 from mindor.core.logger import logging
 import asyncio
 import os
 import threading
+from enum import Enum
+from dataclasses import dataclass
 
 if TYPE_CHECKING:
     import paramiko
 
+class SshAuthType(str, Enum):
+    """SSH authentication type"""
+    KEYFILE = "keyfile"
+    PASSWORD = "password"
+
+@dataclass
+class SshAuthParams:
+    """Base SSH authentication parameters"""
+    type: SshAuthType
+
+    def to_params(self) -> Dict[str, Any]:
+        raise NotImplementedError("Subclasses must implement to_params()")
+
+@dataclass
+class SshKeyfileAuthParams(SshAuthParams):
+    """SSH keyfile authentication parameters"""
+    username: str
+    keyfile: str
+
+    def __init__(self, username: str, keyfile: str):
+        self.type = SshAuthType.KEYFILE
+        self.username = username
+        self.keyfile = keyfile
+
+    def to_params(self) -> Dict[str, Any]:
+        return {
+            "username": self.username,
+            "key_filename": os.path.expanduser(self.keyfile)
+        }
+
+@dataclass
+class SshPasswordAuthParams(SshAuthParams):
+    """SSH password authentication parameters"""
+    username: str
+    password: str
+
+    def __init__(self, username: str, password: str):
+        self.type = SshAuthType.PASSWORD
+        self.username = username
+        self.password = password
+
+    def to_params(self) -> Dict[str, Any]:
+        return {
+            "username": self.username,
+            "password": self.password
+        }
+
+@dataclass
+class SshConnectionParams:
+    """SSH connection parameters"""
+    host: str
+    auth: Union[SshKeyfileAuthParams, SshPasswordAuthParams]
+    port: int = 22
+    keepalive_interval: int = 0  # Send keepalive every N seconds (0 to disable)
+
+    def to_params(self) -> Dict[str, Any]:
+        return {
+            "hostname": self.host,
+            "port": self.port,
+            **self.auth.to_params()
+        }
+
 class SshClient:
     """SSH client with remote port forwarding support"""
     shared_instance: Optional["SshClient"] = None
 
-    def __init__(self, config: SshConnectionConfig):
-        self.config: SshConnectionConfig = config
+    def __init__(self, params: SshConnectionParams):
+        self.params: SshConnectionParams = params
         self.client: Optional[paramiko.SSHClient] = None
         self.transport: Optional[paramiko.Transport] = None
         self.port_forwards: List[Tuple[int, int]] = []
@@ -36,16 +99,16 @@ class SshClient:
             client = paramiko.SSHClient()
             client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
 
-            connect_params = {
-                "hostname": self.config.host,
-                "port": self.config.port,
-                "username": self.config.auth.username,
-            }
-            self._configure_auth(connect_params)
+            logging.debug(f"Connecting to {self.params.host}:{self.params.port}...")
+            client.connect(**self.params.to_params())
+
+            # Set keepalive if enabled
+            if self.params.keepalive_interval > 0:
+                transport = client.get_transport()
+                transport.set_keepalive(self.params.keepalive_interval)
+                logging.debug(f"SSH keepalive enabled: {self.params.keepalive_interval}s interval")
 
-            logging.debug(f"Connecting to {self.config.host}:{self.config.port}...")
-            client.connect(**connect_params)
-            logging.debug(f"SSH connection established to {self.config.host}:{self.config.port}")
+            logging.debug(f"SSH connection established to {self.params.host}:{self.params.port}")
 
             return client
 
@@ -53,16 +116,6 @@ class SshClient:
         self.transport = self.client.get_transport()
         self._shutdown_event = threading.Event()
 
-    def _configure_auth(self, connect_params: Dict[str, Any]) -> None:
-        if isinstance(self.config.auth, SshKeyfileAuthConfig):
-            keyfile_path = os.path.expanduser(self.config.auth.keyfile)
-            connect_params["key_filename"] = keyfile_path
-            return
-
-        if isinstance(self.config.auth, SshPasswordAuthConfig):
-            connect_params["password"] = self.config.auth.password
-            return
-
     async def start_remote_port_forwarding(
         self,
         remote_port: int,
@@ -89,7 +142,7 @@ class SshClient:
             )
 
             logging.debug(
-                f"Remote port forwarding: {self.config.host}:{actual_remote_port} -> "
+                f"Remote port forwarding: {self.params.host}:{actual_remote_port} -> "
                 f"{local_host}:{local_port}"
             )
 
@@ -183,7 +236,7 @@ class SshClient:
 
             if self.client:
                 self.client.close()
-                logging.debug(f"SSH connection closed to {self.config.host}:{self.config.port}")
+                logging.debug(f"SSH connection closed to {self.params.host}:{self.params.port}")
 
         if self.client:
             await asyncio.to_thread(_close)
@@ -199,8 +252,8 @@ class SshClient:
         return self.client is not None and self.transport is not None and self.transport.is_active()
 
     @classmethod
-    def get_shared_instance(cls, config: SshConnectionConfig) -> "SshClient":
+    def get_shared_instance(cls, params: SshConnectionParams) -> "SshClient":
         """Get or create shared SSH client instance"""
         if not cls.shared_instance:
-            cls.shared_instance = SshClient(config)
+            cls.shared_instance = SshClient(params)
         return cls.shared_instance

{model_compose-0.4.14 → model_compose-0.4.16}/src/mindor/dsl/schema/component/impl/vector_store/impl/chroma.py

@@ -15,7 +15,7 @@ class ChromaVectorStoreComponentConfig(CommonVectorStoreComponentConfig):
     protocol: Literal[ "http", "https" ] = Field(default="http", description="Connection protocol.")
     tenant: Optional[str] = Field(default=None, description="Target tenant name.")
     database: Optional[str] = Field(default=None, description="Target database name.")
-    timeout: float = Field(default=30.0, description="Client operation timeout in seconds.")
+    timeout: str = Field(default="30s", description="Client operation timeout.")
     actions: List[ChromaVectorStoreActionConfig] = Field(default_factory=list)
 
     @model_validator(mode="before")

{model_compose-0.4.14 → model_compose-0.4.16}/src/mindor/dsl/schema/component/impl/vector_store/impl/milvus.py

@@ -14,7 +14,7 @@ class MilvusVectorStoreComponentConfig(CommonVectorStoreComponentConfig):
     user: Optional[str] = Field(default=None, description="Username for authentication.")
     password: Optional[str] = Field(default=None, description="Password for authentication.")
     database: Optional[str] = Field(default=None, description="Target database name.")
-    timeout: float = Field(default=30.0, description="Client operation timeout in seconds.")
+    timeout: str = Field(default="30s", description="Client operation timeout.")
     actions: List[MilvusVectorStoreActionConfig] = Field(default_factory=list)
 
     @model_validator(mode="before")

{model_compose-0.4.14 → model_compose-0.4.16}/src/mindor/dsl/schema/component/impl/vector_store/impl/qdrant.py

@@ -13,7 +13,7 @@ class QdrantVectorStoreComponentConfig(CommonVectorStoreComponentConfig):
     https: bool = Field(default=False, description="Use HTTPS for connections.")
     api_key: Optional[str] = Field(default=None, description="API key for authentication.")
     prefix: Optional[str] = Field(default=None, description="Prefix for collections.")
-    timeout: float = Field(default=5.0, description="Client operation timeout in seconds.")
+    timeout: str = Field(default="30s", description="Client operation timeout.")
     prefer_grpc: bool = Field(default=False, description="Prefer gRPC over HTTP/REST API.")
     actions: List[QdrantVectorStoreActionConfig] = Field(default_factory=list)
 

{model_compose-0.4.14 → model_compose-0.4.16}/src/mindor/dsl/schema/gateway/impl/ssh_tunnel.py

@@ -1,7 +1,7 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
 from pydantic import BaseModel, Field
 from pydantic import model_validator
-from mindor.dsl.schema.transport.ssh import SshConnectionConfig
+from mindor.dsl.schema.transport.ssh import SshConnectionConfig, SshAuthConfig
 from .common import GatewayType, CommonGatewayConfig
 
 class SshTunnelGatewayConfig(CommonGatewayConfig):

{model_compose-0.4.14 → model_compose-0.4.16}/src/mindor/dsl/schema/runtime/impl/__init__.py

@@ -1,3 +1,4 @@
 from .common import *
 from .native import *
+from .embedded import *
 from .docker import *

model_compose-0.4.16/src/mindor/dsl/schema/runtime/impl/embedded.py

@@ -0,0 +1,7 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from pydantic import BaseModel, Field
+from pydantic import model_validator
+from .common import RuntimeType, CommonRuntimeConfig
+
+class EmbeddedRuntimeConfig(CommonRuntimeConfig):
+    type: Literal[RuntimeType.EMBEDDED]

model_compose-0.4.16/src/mindor/dsl/schema/runtime/impl/types.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+class RuntimeType(str, Enum):
+    NATIVE   = "native"
+    EMBEDDED = "embedded"
+    DOCKER   = "docker"

{model_compose-0.4.14 → model_compose-0.4.16}/src/mindor/dsl/schema/runtime/runtime.py

@@ -3,10 +3,11 @@ from enum import Enum
 from pydantic import BaseModel, Field
 from .impl import *
 
-RuntimeConfig = Annotated[ 
+RuntimeConfig = Annotated[
     Union[
         NativeRuntimeConfig,
-        DockerRuntimeConfig 
+        EmbeddedRuntimeConfig,
+        DockerRuntimeConfig
     ],
     Field(discriminator="type")
 ]

{model_compose-0.4.14 → model_compose-0.4.16}/src/mindor/dsl/schema/transport/ssh.py

@@ -31,3 +31,4 @@ class SshConnectionConfig(BaseModel):
     host: str = Field(..., description="Host address of the SSH server to connect to.")
     port: int = Field(default=22, ge=1, le=65535, description="Port number used to connect to the SSH server.")
     auth: SshAuthConfig = Field(..., description="SSH authentication configuration.")
+    keepalive_interval: str = Field(default="10s", description="SSH keepalive interval. Set to '0s' to disable keepalive.")

{model_compose-0.4.14 → model_compose-0.4.16/src/model_compose.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.4.14
+Version: 0.4.16
 Summary: model-compose: Declarative AI Workflow Orchestrator
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT

{model_compose-0.4.14 → model_compose-0.4.16}/src/model_compose.egg-info/SOURCES.txt

@@ -338,6 +338,7 @@ src/mindor/dsl/schema/runtime/runtime.py
 src/mindor/dsl/schema/runtime/impl/__init__.py
 src/mindor/dsl/schema/runtime/impl/common.py
 src/mindor/dsl/schema/runtime/impl/docker.py
+src/mindor/dsl/schema/runtime/impl/embedded.py
 src/mindor/dsl/schema/runtime/impl/native.py
 src/mindor/dsl/schema/runtime/impl/types.py
 src/mindor/dsl/schema/transport/__init__.py

model_compose-0.4.14/src/mindor/dsl/schema/runtime/impl/types.py

@@ -1,5 +0,0 @@
-from enum import Enum
-
-class RuntimeType(str, Enum):
-    NATIVE = "native"
-    DOCKER = "docker"