model-compose 0.2.7__tar.gz → 0.2.9__tar.gz

{model_compose-0.2.7/src/model_compose.egg-info → model_compose-0.2.9}/PKG-INFO

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

{model_compose-0.2.7 → model_compose-0.2.9}/pyproject.toml

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

{model_compose-0.2.7 → model_compose-0.2.9}/src/mindor/core/component/base.py

@@ -57,9 +57,9 @@ class ComponentService(AsyncService):
         if self.config.max_concurrent_count > 0:
             self.queue = WorkQueue(self.config.max_concurrent_count, self._run)
 
-    async def run(self, action_id: Union[str, None], call_id: str, input: Dict[str, Any]) -> Dict[str, Any]:
+    async def run(self, action_id: Union[str, None], run_id: str, input: Dict[str, Any]) -> Dict[str, Any]:
         _, action = ActionResolver(self.config.actions).resolve(action_id)
-        context = ComponentActionContext(call_id, input)
+        context = ComponentActionContext(run_id, input)
 
         if self.queue:
             return await (await self.queue.schedule(action, context))

{model_compose-0.2.7 → model_compose-0.2.9}/src/mindor/core/component/context.py

@@ -3,10 +3,10 @@ from mindor.core.utils.renderer import VariableRenderer
 from mindor.core.gateway import find_gateway_by_port
 
 class ComponentActionContext:
-    def __init__(self, call_id: str, input: Dict[str, Any]):
-        self.call_id: str = call_id
+    def __init__(self, run_id: str, input: Dict[str, Any]):
+        self.run_id: str = run_id
         self.input: Dict[str, Any] = input
-        self.context: Dict[str, Any] = { "call_id": call_id }
+        self.context: Dict[str, Any] = { "run_id": run_id }
         self.sources: Dict[str, Any] = {}
         self.renderer: VariableRenderer = VariableRenderer(self._resolve_source)
 

{model_compose-0.2.7 → model_compose-0.2.9}/src/mindor/core/component/services/workflow.py

@@ -17,7 +17,7 @@ class WorkflowAction:
         input = await context.render_variable(self.config.input)
 
         workflow = self._create_workflow(workflow_id)
-        output = await workflow.run(context.call_id, input)
+        output = await workflow.run(context.run_id, input)
         context.register_source("output", output)
 
         return (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else output

{model_compose-0.2.7 → model_compose-0.2.9}/src/mindor/core/controller/base.py

@@ -5,7 +5,7 @@ from mindor.dsl.schema.controller import ControllerConfig, ControllerType
 from mindor.dsl.schema.component import ComponentConfig
 from mindor.dsl.schema.listener import ListenerConfig
 from mindor.dsl.schema.gateway import GatewayConfig
-from mindor.dsl.schema.logger import LoggerConfig
+from mindor.dsl.schema.logger import LoggerConfig, LoggerType, ConsoleLoggerConfig
 from mindor.dsl.schema.workflow import WorkflowConfig
 from mindor.core.services import AsyncService
 from mindor.core.component import ComponentService, ComponentGlobalConfigs, create_component
@@ -166,7 +166,7 @@ class ControllerService(AsyncService):
         return [ create_component(component_id, config, global_configs, self.daemon) for component_id, config in self.components.items() ]
     
     def _create_loggers(self) -> List[LoggerService]:
-        return [ create_logger(f"logger-{index}", config, self.daemon) for index, config in enumerate(self.loggers) ]
+        return [ create_logger(f"logger-{index}", config, self.daemon) for index, config in enumerate(self.loggers or [ self._get_default_logger_config() ]) ]
 
     def _create_webui(self) -> ControllerWebUI:
         return ControllerWebUI(self.config.webui, self.config, self.components, self.workflows, self.daemon)
@@ -178,6 +178,9 @@ class ControllerService(AsyncService):
     def _get_component_global_configs(self) -> ComponentGlobalConfigs:
         return ComponentGlobalConfigs(self.components, self.listeners, self.gateways, self.workflows)
 
+    def _get_default_logger_config(self) -> LoggerConfig:
+        return ConsoleLoggerConfig(type=LoggerType.CONSOLE)
+
 def register_controller(type: ControllerType):
     def decorator(cls: Type[ControllerService]) -> Type[ControllerService]:
         ControllerRegistry[type] = cls

{model_compose-0.2.7 → model_compose-0.2.9}/src/mindor/core/controller/webui/webui.py

@@ -6,9 +6,8 @@ from mindor.core.controller.runner import ControllerRunner
 from mindor.core.workflow.schema import create_workflow_schema
 from mindor.core.services import AsyncService
 from .gradio import GradioWebUIBuilder
-
-from fastapi import FastAPI
 from gradio import mount_gradio_app
+from fastapi import FastAPI
 import uvicorn, gradio
 
 class ControllerWebUI(AsyncService):

{model_compose-0.2.7 → model_compose-0.2.9}/src/mindor/core/logger/services/console.py

@@ -1,6 +1,7 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Iterator, Any
 from mindor.dsl.schema.logger import ConsoleLoggerConfig
 from ..base import LoggerService, LoggerType, LoggingLevel, register_logger
+from uvicorn.logging import ColourizedFormatter
 import logging
 
 _level_map = {
@@ -17,7 +18,7 @@ class ConsoleLogger(LoggerService):
         super().__init__(id, config, daemon)
 
         self.logger: logging.Logger = logging.getLogger(id)
-        self.formatter: logging.Formatter = logging.Formatter("%(levelname)s: %(message)s")
+        self.formatter: logging.Formatter = ColourizedFormatter("%(levelprefix)s %(message)s")
         self.handler: logging.StreamHandler = None
 
         self._configure_logger()

{model_compose-0.2.7 → model_compose-0.2.9}/src/mindor/core/utils/time.py

@@ -2,6 +2,16 @@ from typing import Union, Optional
 from datetime import timedelta, datetime
 import zoneinfo
 
+class TimeTracker:
+    def __init__(self):
+        self._start = datetime.now()
+
+    def elapsed(self) -> float:
+        return (datetime.now() - self._start).total_seconds()
+
+    def reset(self) -> None:
+        self._start = datetime.now()
+
 def parse_duration(value: Union[str, float, int]) -> timedelta:
     if isinstance(value, (float, int)):
         return timedelta(seconds=value)

{model_compose-0.2.7 → model_compose-0.2.9}/src/mindor/core/workflow/job/impl/action.py

@@ -2,7 +2,10 @@ from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annot
 from mindor.dsl.schema.job import ActionJobConfig, JobType
 from mindor.dsl.schema.component import ComponentConfig
 from mindor.core.component import ComponentService, ComponentGlobalConfigs, ComponentResolver, create_component
+from mindor.core.utils.time import TimeTracker
+from mindor.core.logger import logging
 from ..base import Job, JobType, WorkflowContext, register_job
+from datetime import datetime
 import asyncio, ulid
 
 @register_job(JobType.ACTION)
@@ -20,10 +23,16 @@ class ActionJob(Job):
         outputs = []
 
         async def _run_once():
-            call_id = ulid.ulid()
-            output = await component.run(await context.render_variable(self.config.action), call_id, input)
+            run_id: str = ulid.ulid()
+
+            job_time_tracker = TimeTracker()
+            logging.debug("[task-%s] Action 'run-%s' started for job '%s'", context.task_id, run_id, self.id)
+
+            output = await component.run(await context.render_variable(self.config.action), run_id, input)
             context.register_source("output", output)
 
+            logging.debug("[task-%s] Action 'run-%s' completed in %.2f seconds.", context.task_id, run_id, job_time_tracker.elapsed())
+
             output = (await context.render_variable(self.config.output, ignore_files=True)) if self.config.output else output
             outputs.append(output)
 

{model_compose-0.2.7 → model_compose-0.2.9}/src/mindor/core/workflow/job/impl/delay.py

@@ -1,9 +1,10 @@
 from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annotated, Callable, Any
 from mindor.dsl.schema.job import DelayJobConfig, DelayJobMode
 from mindor.dsl.schema.component import ComponentConfig
-from mindor.core.utils.time import parse_duration, parse_datetime
+from mindor.core.utils.time import parse_duration, parse_datetime, TimeTracker
+from mindor.core.logger import logging
 from ..base import Job, JobType, WorkflowContext, register_job
-from datetime import datetime
+from datetime import datetime, timedelta
 import asyncio
 
 @register_job(JobType.DELAY)
@@ -24,9 +25,14 @@ class DelayJob(Job):
         duration = parse_duration((await context.render_variable(self.config.duration)) or 0.0)
         duration = duration.total_seconds()
         
+        job_time_tracker = TimeTracker()
+        logging.debug("[task-%s] Delay started for time interval: %d seconds.", context.task_id, int(duration))
+
         if duration > 0.0:
             await asyncio.sleep(duration)
 
+        logging.debug("[task-%s] Delay completed in %.2f seconds.", context.task_id, job_time_tracker.elapsed())
+
         return None
 
     async def _delay_until_specific_time(self, context: WorkflowContext) -> Any:
@@ -34,9 +40,14 @@ class DelayJob(Job):
         time = parse_datetime((await context.render_variable(self.config.time)) or datetime(2000, 1, 1, 0, 0, 0), timezone)
         
         now = datetime.now(tz=time.tzinfo)
-        duration = (time - now).total_seconds()
+        duration = max((time - now).total_seconds(), 0.0)
+
+        job_time_tracker = TimeTracker()
+        logging.debug("[task-%s] Delay started, waiting until %s", context.task_id, time)
 
         if duration > 0.0:
             await asyncio.sleep(duration)
 
+        logging.debug("[task-%s] Delay completed in %.2f seconds.", context.task_id, job_time_tracker.elapsed())
+
         return None

{model_compose-0.2.7 → model_compose-0.2.9}/src/mindor/core/workflow/workflow.py

@@ -2,9 +2,11 @@ from typing import Type, Union, Literal, Optional, Dict, List, Tuple, Set, Annot
 from mindor.dsl.schema.workflow import WorkflowConfig, JobConfig
 from mindor.dsl.schema.component import ComponentConfig
 from mindor.core.component import ComponentGlobalConfigs
+from mindor.core.utils.time import TimeTracker
 from mindor.core.logger import logging
 from .context import WorkflowContext
 from .job import Job, create_job
+from datetime import datetime
 import asyncio
 
 class JobGraphValidator:
@@ -85,19 +87,23 @@ class WorkflowRunner:
         running_job_ids: Set[str] = set()
         completed_job_ids: Set[str] = set()
         scheduled_job_tasks: Dict[str, asyncio.Task] = {}
+        job_time_trackers: Dict[str, TimeTracker] = {}
         output: Any = None
 
-        logging.debug("[task-%s] Workflow '%s' started.", context.task_id, self.id)
+        workflow_time_tracker = TimeTracker()
+        logging.info("[task-%s] Workflow '%s' started.", context.task_id, self.id)
 
         while pending_jobs:
             runnable_jobs = [ job for job in pending_jobs.values() if self._can_run_job(job, running_job_ids, completed_job_ids) ]
 
             for job in runnable_jobs:
                 if job.id not in scheduled_job_tasks:
-                    logging.debug("[task-%s] Scheduling job: '%s'", context.task_id, job.id)
                     scheduled_job_tasks[job.id] = asyncio.create_task(job.run(context))
                     running_job_ids.add(job.id)
 
+                    job_time_trackers[job.id] = TimeTracker()
+                    logging.info("[task-%s] Job '%s' started.", context.task_id, job.id)
+
             if not scheduled_job_tasks:
                 raise RuntimeError("No runnable jobs but pending jobs remain.")
 
@@ -109,7 +115,7 @@ class WorkflowRunner:
                 completed_job_output = await completed_job_task
                 context.complete_job(completed_job_id, completed_job_output)
 
-                logging.debug("[task-%s] Job completed: '%s'", context.task_id, completed_job_id)
+                logging.info("[task-%s] Job '%s' completed in %.2f seconds.", context.task_id, completed_job_id, job_time_trackers[completed_job_id].elapsed())
 
                 if self._is_terminal_job(completed_job_id):
                     if isinstance(output, dict) and isinstance(completed_job_output, dict):
@@ -122,7 +128,7 @@ class WorkflowRunner:
                 del pending_jobs[completed_job_id]
                 del scheduled_job_tasks[completed_job_id]
 
-        logging.debug("[task-%s] Workflow '%s' run completed.", context.task_id, self.id)
+        logging.info("[task-%s] Workflow '%s' completed in %.2f seconds.", context.task_id, self.id, workflow_time_tracker.elapsed())
 
         return output
 

{model_compose-0.2.7 → model_compose-0.2.9/src/model_compose.egg-info}/PKG-INFO

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