model-compose 0.3.4__tar.gz → 0.3.5__tar.gz

{model_compose-0.3.4/src/model_compose.egg-info → model_compose-0.3.5}/PKG-INFO

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

{model_compose-0.3.4 → model_compose-0.3.5}/pyproject.toml

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

{model_compose-0.3.4 → model_compose-0.3.5}/src/mindor/core/component/services/http_client.py

@@ -62,7 +62,7 @@ class HttpClientPollingCompletion(HttpClientCompletion):
 class HttpClientCallbackCompletion(HttpClientCompletion):
     async def run(self, context: ComponentActionContext, client: HttpClient) -> Any:
         callback_id = await context.render_variable(self.config.wait_for)
-        future: asyncio.Future = asyncio.get_event_loop().create_future()
+        future: asyncio.Future = asyncio.get_running_loop().create_future()
         HttpCallbackListener.register_pending_future(callback_id, future)
 
         return await future

{model_compose-0.3.4 → model_compose-0.3.5}/src/mindor/core/component/services/model/base.py

@@ -5,7 +5,8 @@ from mindor.dsl.schema.action import ModelActionConfig
 from mindor.core.services import AsyncService
 from ...context import ComponentActionContext
 from transformers import PreTrainedModel, PreTrainedTokenizer
-import torch
+from threading import Thread
+import torch, asyncio
 
 class ModelTaskService(AsyncService):
     def __init__(self, id: str, config: ModelComponentConfig, daemon: bool):
@@ -15,7 +16,10 @@ class ModelTaskService(AsyncService):
         self.config: ModelComponentConfig = config
 
     async def run(self, action: ModelActionConfig, context: ComponentActionContext) -> Any:
-        return await self._run(action, context)
+        async def _run():
+            return await self._run(action, context)
+
+        return await self.run_in_thread(_run)
 
     @abstractmethod
     async def _run(self, action: ModelActionConfig, context: ComponentActionContext) -> Any:

{model_compose-0.3.4 → model_compose-0.3.5}/src/mindor/core/runtime/docker/docker.py

@@ -246,7 +246,7 @@ class DockerRuntimeManager:
                 for line in container.logs(stream=True, follow=True, since=int(time.time())):
                     sys.stdout.buffer.write(line)
                     sys.stdout.flush()
-            loop = asyncio.get_event_loop()
+            loop = asyncio.get_running_loop()
             await loop.run_in_executor(None, _stream_logs_sync, container)
         except Exception as e:
             logging.error("Error while streaming logs from container '%s': %s", container.name, e)

{model_compose-0.3.4 → model_compose-0.3.5}/src/mindor/core/services/async_service.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Optional, Callable, Awaitable, Any
 from abc import ABC, abstractmethod
 from threading import Thread
 import asyncio
@@ -42,6 +42,28 @@ class AsyncService(ABC):
         if self.daemon_task:
             await self.daemon_task
 
+    def run_in_thread(self, runner: Callable[[], Awaitable[Any]]) -> asyncio.Future:
+        loop = asyncio.get_running_loop()
+        future: asyncio.Future = loop.create_future()
+
+        def _start_in_thread():
+            thread_loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(thread_loop)
+
+            async def _run_and_set_result():
+                try:
+                    result = await runner()
+                    loop.call_soon_threadsafe(future.set_result, result)
+                except Exception as e:
+                    loop.call_soon_threadsafe(future.set_exception, e)
+
+            thread_loop.run_until_complete(_run_and_set_result())
+
+        thread = Thread(target=_start_in_thread)
+        thread.start()
+
+        return future
+
     async def _start(self) -> None:
         self.started = True
 

model_compose-0.3.5/src/mindor/dsl/schema/action/impl/model/impl/common.py

@@ -0,0 +1,18 @@
+from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
+from enum import Enum
+from pydantic import BaseModel, Field
+from ...common import CommonActionConfig
+
+class ModelTaskMode(str, Enum):
+    INFERENCE = "inference"
+    TRAINING  = "training"
+
+class CommonModelActionConfig(CommonActionConfig):
+    mode: ModelTaskMode = Field(..., description="Mode for model task execution.")
+
+class CommonModelInferenceActionConfig(CommonModelActionConfig):
+    mode: ModelTaskMode = Literal[ModelTaskMode.INFERENCE]
+    stream: bool = Field(default=False, description="Whether to enable streaming responses for inference.")
+
+class CommonModelTrainingActionConfig(CommonModelActionConfig):
+    mode: ModelTaskMode = Literal[ModelTaskMode.TRAINING]

{model_compose-0.3.4 → model_compose-0.3.5}/src/mindor/dsl/schema/action/impl/model/impl/summarization.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 .common import CommonModelActionConfig
+from .common import CommonModelInferenceActionConfig
 
 class SummarizationParamsConfig(BaseModel):
     max_input_length: Union[int, str] = Field(default=1024, description="Maximum number of tokens per input text.")
@@ -13,6 +13,6 @@ class SummarizationParamsConfig(BaseModel):
     do_sample: bool = Field(default=True, description="Whether to use sampling.")
     batch_size: Union[int, str] = Field(default=32, description="Number of input texts to process in a single batch.")
 
-class SummarizationModelActionConfig(CommonModelActionConfig):
+class SummarizationModelActionConfig(CommonModelInferenceActionConfig):
     text: Union[str, List[str]] = Field(..., description="Input text to summarize.")
     params: SummarizationParamsConfig = Field(default_factory=SummarizationParamsConfig, description="Summarization configuration parameters.")

{model_compose-0.3.4 → model_compose-0.3.5}/src/mindor/dsl/schema/action/impl/model/impl/text_classification.py

@@ -1,12 +1,12 @@
 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 CommonModelActionConfig
+from .common import CommonModelInferenceActionConfig
 
 class TextClassificationParamsConfig(BaseModel):
     return_probabilities: Union[bool, str] = Field(default=False, description="Whether to return class probabilities for each prediction.")
     batch_size: Union[int, str] = Field(default=32, description="Number of input texts to process in a single batch.")
 
-class TextClassificationModelActionConfig(CommonModelActionConfig):
+class TextClassificationModelActionConfig(CommonModelInferenceActionConfig):
     text: Union[str, List[str]] = Field(..., description="Input text to classify.")
     params: TextClassificationParamsConfig = Field(default_factory=TextClassificationParamsConfig, description="Text classification configuration parameters.")

{model_compose-0.3.4 → model_compose-0.3.5}/src/mindor/dsl/schema/action/impl/model/impl/text_embedding.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 .common import CommonModelActionConfig
+from .common import CommonModelInferenceActionConfig
 
 class TextEmbeddingParamsConfig(BaseModel):
     max_input_length: Union[int, str] = Field(default=512, description="Maximum number of tokens per input text.")
@@ -9,6 +9,6 @@ class TextEmbeddingParamsConfig(BaseModel):
     normalize: Union[bool, str] = Field(default=True, description="Whether to apply L2 normalization to the output embeddings.")
     batch_size: Union[int, str] = Field(default=32, description="Number of input texts to process in a single batch.")
 
-class TextEmbeddingModelActionConfig(CommonModelActionConfig):
+class TextEmbeddingModelActionConfig(CommonModelInferenceActionConfig):
     text: Union[str, List[str]] = Field(..., description="Input text to be embedded.")
     params: TextEmbeddingParamsConfig = Field(default_factory=TextEmbeddingParamsConfig, description="Configuration parameters for embedding generation.")

{model_compose-0.3.4 → model_compose-0.3.5}/src/mindor/dsl/schema/action/impl/model/impl/text_generation.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 .common import CommonModelActionConfig
+from .common import CommonModelInferenceActionConfig
 
 class TextGenerationParamsConfig(BaseModel):
     max_output_length: Union[int, str] = Field(default=1024, description="The maximum number of tokens to generate.")
@@ -11,6 +11,6 @@ class TextGenerationParamsConfig(BaseModel):
     top_p: Union[int, str] = Field(default=0.9, description="Top-p (nucleus) sampling; restricts sampling to tokens with cumulative probability >= top_p.")
     batch_size: Union[int, str] = Field(default=32, description="Number of input texts to process in a single batch.")
 
-class TextGenerationModelActionConfig(CommonModelActionConfig):
+class TextGenerationModelActionConfig(CommonModelInferenceActionConfig):
     prompt: Union[str, List[str]] = Field(..., description="Input prompt to generate text from.")
     params: TextGenerationParamsConfig = Field(default_factory=TextGenerationParamsConfig, description="Text generation configuration parameters.")

{model_compose-0.3.4 → model_compose-0.3.5}/src/mindor/dsl/schema/action/impl/model/impl/translation.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 .common import CommonModelActionConfig
+from .common import CommonModelInferenceActionConfig
 
 class TranslationParamsConfig(BaseModel):
     max_input_length: Union[int, str] = Field(default=1024, description="Maximum number of tokens per input text.")
@@ -11,6 +11,6 @@ class TranslationParamsConfig(BaseModel):
     length_penalty: Union[float, str] = Field(default=1.0, description="Length penalty applied during beam search.")
     batch_size: Union[int, str] = Field(default=32, description="Number of input texts to process in a single batch.")
 
-class TranslationModelActionConfig(CommonModelActionConfig):
+class TranslationModelActionConfig(CommonModelInferenceActionConfig):
     text: Union[str, List[str]] = Field(..., description="Input text to translate.")
     params: TranslationParamsConfig = Field(default_factory=TranslationParamsConfig, description="Translation configuration parameters.")

{model_compose-0.3.4 → model_compose-0.3.5/src/model_compose.egg-info}/PKG-INFO

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

model_compose-0.3.4/src/mindor/dsl/schema/action/impl/model/impl/common.py

@@ -1,11 +0,0 @@
-from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Any
-from enum import Enum
-from pydantic import BaseModel, Field
-from ...common import CommonActionConfig
-
-class ModelTaskMode(str, Enum):
-    INFERENCE = "inference"
-    TRAINING  = "training"
-
-class CommonModelActionConfig(CommonActionConfig):
-    mode: ModelTaskMode = Field(default=ModelTaskMode.INFERENCE, description="")