levelapp 0.1.15__py3-none-any.whl

levelapp/workflow/config.py

@@ -0,0 +1,96 @@
+"""levelapp/workflow/config.py: Contains modular workflow configuration components."""
+from typing import List, Dict, Any, Optional
+from pydantic import BaseModel, Field
+
+from levelapp.aspects import logger
+from levelapp.endpoint.client import EndpointConfig
+from levelapp.core.schemas import WorkflowType, RepositoryType, EvaluatorType
+
+
+class ProcessConfig(BaseModel):
+    project_name: str
+    workflow_type: WorkflowType
+    evaluation_params: Dict[str, Any] = Field(default_factory=dict)
+
+
+class EvaluationConfig(BaseModel):
+    evaluators: List[EvaluatorType]
+    providers: List[str] = Field(default_factory=list)
+    metrics_map: Dict[str, str] | None = Field(default_factory=dict)
+
+
+class ReferenceDataConfig(BaseModel):
+    path: str | None
+    data: Dict[str, Any] | None = Field(default_factory=dict)
+
+
+class RepositoryConfig(BaseModel):
+    type: RepositoryType | None = None
+    project_id: str | None = None
+    database_name: str = Field(default="(default)")
+
+    class Config:
+        extra = "allow"
+
+
+class WorkflowConfig(BaseModel):
+    """
+    Static workflow configuration. Maps directly to YAML sections.
+    Supports both file-based loading and in-memory dictionary creation.
+    """
+    process: ProcessConfig
+    endpoint: EndpointConfig
+    evaluation: EvaluationConfig
+    reference_data: ReferenceDataConfig
+    repository: RepositoryConfig
+
+    class Config:
+        extra = "allow"
+
+    @classmethod
+    def load(cls, path: str | None = None) -> "WorkflowConfig":
+        """
+        Load workflow configuration from a YAML/JSON file.
+
+        Args:
+            path (str): YAML/JSON configuration file path.
+
+        Returns:
+            WorkflowConfig: An instance of WorkflowConfig.
+        """
+        from levelapp.aspects.loader import DataLoader
+
+        loader = DataLoader()
+        config_dict = loader.load_raw_data(path=path)
+        logger.info(f"[{cls.__name__}] Workflow configuration loaded from '{path}' file content")
+        return cls.model_validate(config_dict)
+
+    @classmethod
+    def from_dict(cls, content: Dict[str, Any]) -> "WorkflowConfig":
+        """
+        Load workflow configuration from an in-memory dict.
+
+        Args:
+            content (dict): Workflow configuration content.
+
+        Returns:
+            WorkflowConfig: An instance of WorkflowConfig.
+        """
+        logger.info(f"[{cls.__name__}] Workflow configuration loaded from provided content")
+        return cls.model_validate(content)
+
+    def set_reference_data(self, content: Dict[str, Any]) -> None:
+        """
+        Load referer data from an in-memory dict.
+
+        Args:
+            content (dict): Workflow configuration content.
+
+        """
+        self.reference_data.data = content
+        logger.info(f"[{self.__class__.__name__}] Reference data loaded from provided content")
+
+
+if __name__ == '__main__':
+    workflow_config = WorkflowConfig.load(path="../../src/data/workflow_config.yaml")
+    print(f"Workflow Configuration:\n{workflow_config.model_dump_json(indent=2)}")

levelapp/workflow/context.py

@@ -0,0 +1,64 @@
+"""levelapp/workflow/context.py: Builds runtime WorkflowContext from WorkflowConfig."""
+from typing import Dict, Callable
+
+from levelapp.repository.filesystem import FileSystemRepository
+from levelapp.workflow.config import WorkflowConfig
+from levelapp.core.base import BaseRepository, BaseEvaluator
+from levelapp.workflow.runtime import WorkflowContext
+from levelapp.core.schemas import EvaluatorType, RepositoryType
+
+from levelapp.repository.firestore import FirestoreRepository
+from levelapp.evaluator.evaluator import JudgeEvaluator, MetadataEvaluator
+
+
+class WorkflowContextBuilder:
+    """Builds a runtime WorkflowContext from a WorkflowConfig."""
+
+    def __init__(self, config: WorkflowConfig) -> None:
+        self.config = config
+
+        # Map repository type to constructor that accepts the WorkflowConfig
+        self.repository_map: Dict[RepositoryType, Callable[[WorkflowConfig], BaseRepository]] = {
+            RepositoryType.FIRESTORE: lambda cfg: FirestoreRepository(cfg),
+            RepositoryType.FILESYSTEM: lambda cfg: FileSystemRepository(cfg),
+        }
+
+        # Map evaluator type to constructor that accepts the WorkflowConfig
+        self.evaluator_map: Dict[EvaluatorType, Callable[[WorkflowConfig], BaseEvaluator]] = {
+            EvaluatorType.JUDGE: lambda cfg: JudgeEvaluator(config=cfg),
+            EvaluatorType.REFERENCE: lambda cfg: MetadataEvaluator(config=cfg),
+        }
+
+    def build(self) -> WorkflowContext:
+        """
+        Build a runtime WorkflowContext from the static WorkflowConfig.
+        Supports in-memory reference data if provided.
+        """
+        # Repository instance
+        repository_type = self.config.repository.type
+        repository = self.repository_map.get(repository_type)(self.config)
+
+        # Evaluator instances
+        evaluators: Dict[EvaluatorType, BaseEvaluator] = {
+            ev: self.evaluator_map.get(ev)(self.config) for ev in self.config.evaluation.evaluators
+        }
+
+        # Providers and endpoint
+        providers = self.config.evaluation.providers
+        endpoint_config = self.config.endpoint
+
+        # Inputs include reference data path or in-memory dict
+        inputs = {}
+        if self.config.reference_data.data:
+            inputs["reference_data"] = self.config.reference_data.data
+        else:
+            inputs["reference_data_path"] = self.config.reference_data.path
+
+        return WorkflowContext(
+            config=self.config,
+            repository=repository,
+            evaluators=evaluators,
+            providers=providers,
+            endpoint=endpoint_config,
+            inputs=inputs,
+        )

levelapp/workflow/factory.py

@@ -0,0 +1,42 @@
+"""levelapp/workflow/factory.py: Creates workflows using WorkflowContext."""
+from typing import Dict, Callable
+
+from levelapp.core.schemas import WorkflowType
+from levelapp.workflow.base import SimulatorWorkflow, ComparatorWorkflow, BaseWorkflow
+from levelapp.workflow.runtime import WorkflowContext
+
+
+class MainFactory:
+    """Central factory for workflows."""
+    _workflow_map: Dict[WorkflowType, Callable[[WorkflowContext], BaseWorkflow]] = {
+        WorkflowType.SIMULATOR: lambda ctx: SimulatorWorkflow(ctx),
+        WorkflowType.COMPARATOR: lambda ctx: ComparatorWorkflow(ctx),
+    }
+
+    @classmethod
+    def create_workflow(cls, context: WorkflowContext) -> BaseWorkflow:
+        """
+        Create workflow using the given runtime context.
+
+        Args:
+            context (WorkflowContext): the provided workflow context.
+
+        Returns:
+            BaseWorkflow: the built workflow instance from the provided context.
+        """
+        wf_type = context.config.process.workflow_type
+        builder = cls._workflow_map.get(wf_type)
+        if not builder:
+            raise NotImplementedError(f"Workflow '{wf_type}' not implemented")
+        return builder(context)
+
+    @classmethod
+    def register_workflow(cls, wf_type: WorkflowType, builder: Callable[[WorkflowContext], BaseWorkflow]) -> None:
+        """
+        Register a new workflow implementation.
+
+        Args:
+            wf_type (WorkflowType): the workflow type.
+            builder (Callable[[WorkflowContext], BaseWorkflow]): the workflow builder.
+        """
+        cls._workflow_map[wf_type] = builder

levelapp/workflow/registration.py

@@ -0,0 +1,6 @@
+from levelapp.core.schemas import WorkflowType
+from levelapp.workflow.factory import MainFactory
+from levelapp.workflow.base import SimulatorWorkflow, ComparatorWorkflow
+
+MainFactory.register_workflow(WorkflowType.SIMULATOR, lambda ctx: SimulatorWorkflow(ctx))
+MainFactory.register_workflow(WorkflowType.COMPARATOR, lambda ctx: ComparatorWorkflow(ctx))

levelapp/workflow/runtime.py

@@ -0,0 +1,19 @@
+"""levelapp/workflow/runtime.py: contains the workflow runtime context component."""
+from dataclasses import dataclass
+from typing import Dict, List, Any
+
+from levelapp.endpoint.client import EndpointConfig
+from levelapp.core.base import BaseRepository, BaseEvaluator
+from levelapp.workflow.config import WorkflowConfig
+from levelapp.core.schemas import EvaluatorType
+
+
+@dataclass(frozen=True)
+class WorkflowContext:
+    """Immutable data holder for workflow execution context."""
+    config: WorkflowConfig
+    endpoint: EndpointConfig
+    repository: BaseRepository
+    evaluators: Dict[EvaluatorType, BaseEvaluator]
+    providers: List[str]
+    inputs: Dict[str, Any]