runnable 0.10.0__py3-none-any.whl → 0.11.1__py3-none-any.whl

runnable/extensions/executor/__init__.py

@@ -1,14 +1,19 @@
 import copy
-import json
 import logging
 import os
 from abc import abstractmethod
-from typing import Dict, List, Optional
-
-from rich import print
-
-from runnable import context, defaults, exceptions, integration, parameters, utils
-from runnable.datastore import DataCatalog, JsonParameter, StepLog
+from typing import Dict, List, Optional, cast
+
+from runnable import (
+    console,
+    context,
+    defaults,
+    exceptions,
+    integration,
+    parameters,
+    utils,
+)
+from runnable.datastore import DataCatalog, JsonParameter, RunLog, StepLog
 from runnable.defaults import TypeMapVariable
 from runnable.executor import BaseExecutor
 from runnable.extensions.nodes import TaskNode
@@ -58,6 +63,7 @@ class GenericExecutor(BaseExecutor):
 
         # Update these with some from the environment variables
         params.update(parameters.get_user_set_parameters())
+        logger.debug(f"parameters as seen by executor: {params}")
         return params
 
     def _set_up_run_log(self, exists_ok=False):
@@ -69,7 +75,7 @@ class GenericExecutor(BaseExecutor):
         try:
             attempt_run_log = self._context.run_log_store.get_run_log_by_id(run_id=self._context.run_id, full=False)
 
-            logger.warning(f"The run log by id: {self._context.run_id} already exists")
+            logger.warning(f"The run log by id: {self._context.run_id} already exists, is this designed?")
             raise exceptions.RunLogExistsError(
                 f"The run log by id: {self._context.run_id} already exists and is {attempt_run_log.status}"
             )
@@ -94,6 +100,7 @@ class GenericExecutor(BaseExecutor):
 
         # Update run_config
         run_config = utils.get_run_config()
+        logger.debug(f"run_config as seen by executor: {run_config}")
         self._context.run_log_store.set_run_config(run_id=self._context.run_id, run_config=run_config)
 
     def prepare_for_graph_execution(self):
@@ -116,9 +123,6 @@ class GenericExecutor(BaseExecutor):
         integration.validate(self, self._context.secrets_handler)
         integration.configure_for_traversal(self, self._context.secrets_handler)
 
-        integration.validate(self, self._context.experiment_tracker)
-        integration.configure_for_traversal(self, self._context.experiment_tracker)
-
         self._set_up_run_log()
 
     def prepare_for_node_execution(self):
@@ -138,9 +142,6 @@ class GenericExecutor(BaseExecutor):
         integration.validate(self, self._context.secrets_handler)
         integration.configure_for_execution(self, self._context.secrets_handler)
 
-        integration.validate(self, self._context.experiment_tracker)
-        integration.configure_for_execution(self, self._context.experiment_tracker)
-
     def _sync_catalog(self, stage: str, synced_catalogs=None) -> Optional[List[DataCatalog]]:
         """
         1). Identify the catalog settings by over-riding node settings with the global settings.
@@ -166,6 +167,7 @@ class GenericExecutor(BaseExecutor):
                 "Catalog service only accepts get/put possible actions as part of node execution."
                 f"Sync catalog of the executor: {self.service_name} asks for {stage} which is not accepted"
             )
+            logger.exception(msg)
             raise Exception(msg)
 
         try:
@@ -183,10 +185,14 @@ class GenericExecutor(BaseExecutor):
         data_catalogs = []
         for name_pattern in node_catalog_settings.get(stage) or []:
             if stage == "get":
+                get_catalog_progress = self._context.progress.add_task(f"Getting from catalog {name_pattern}", total=1)
                 data_catalog = self._context.catalog_handler.get(
                     name=name_pattern, run_id=self._context.run_id, compute_data_folder=compute_data_folder
                 )
+                self._context.progress.update(get_catalog_progress, completed=True, visible=False, refresh=True)
+
             elif stage == "put":
+                put_catalog_progress = self._context.progress.add_task(f"Putting in catalog {name_pattern}", total=1)
                 data_catalog = self._context.catalog_handler.put(
                     name=name_pattern,
                     run_id=self._context.run_id,
@@ -194,7 +200,9 @@ class GenericExecutor(BaseExecutor):
                     synced_catalogs=synced_catalogs,
                 )
 
-            logger.info(f"Added data catalog: {data_catalog} to step log")
+                self._context.progress.update(put_catalog_progress, completed=True, visible=False)
+
+            logger.debug(f"Added data catalog: {data_catalog} to step log")
             data_catalogs.extend(data_catalog)
 
         return data_catalogs
@@ -256,6 +264,7 @@ class GenericExecutor(BaseExecutor):
         self._context_node = node
 
         data_catalogs_get: Optional[List[DataCatalog]] = self._sync_catalog(stage="get")
+        logger.debug(f"data_catalogs_get: {data_catalogs_get}")
 
         step_log = node.execute(
             map_variable=map_variable,
@@ -263,11 +272,16 @@ class GenericExecutor(BaseExecutor):
             mock=mock,
             **kwargs,
         )
+
         data_catalogs_put: Optional[List[DataCatalog]] = self._sync_catalog(stage="put")
+        logger.debug(f"data_catalogs_put: {data_catalogs_put}")
 
         step_log.add_data_catalogs(data_catalogs_get or [])
         step_log.add_data_catalogs(data_catalogs_put or [])
 
+        console.print(f"Summary of the step: {step_log.internal_name}")
+        console.print(step_log.get_summary(), style=defaults.info_style)
+
         self._context_node = None  # type: ignore
 
         self._context.run_log_store.add_step_log(step_log, self._context.run_id)
@@ -318,6 +332,8 @@ class GenericExecutor(BaseExecutor):
 
         self._context.run_log_store.add_step_log(step_log, self._context.run_id)
 
+        logger.info(f"Executing node: {node.get_summary()}")
+
         # Add the step log to the database as per the situation.
         # If its a terminal node, complete it now
         if node.node_type in ["success", "fail"]:
@@ -329,7 +345,8 @@ class GenericExecutor(BaseExecutor):
             node.execute_as_graph(map_variable=map_variable, **kwargs)
             return
 
-        # Executor specific way to trigger a job
+        task_name = node._resolve_map_placeholders(node.internal_name, map_variable)
+        console.print(f":runner: Executing the node {task_name} ... ", style="bold color(208)")
         self.trigger_job(node=node, map_variable=map_variable, **kwargs)
 
     def trigger_job(self, node: BaseNode, map_variable: TypeMapVariable = None, **kwargs):
@@ -405,31 +422,72 @@ class GenericExecutor(BaseExecutor):
         previous_node = None
         logger.info(f"Running the execution with {current_node}")
 
+        branch_execution_task = None
+        branch_task_name: str = ""
+        if dag.internal_branch_name:
+            branch_task_name = BaseNode._resolve_map_placeholders(
+                dag.internal_branch_name or "Graph",
+                map_variable,
+            )
+            branch_execution_task = self._context.progress.add_task(
+                f"[dark_orange]Executing {branch_task_name}",
+                total=1,
+            )
+
         while True:
             working_on = dag.get_node_by_name(current_node)
+            task_name = working_on._resolve_map_placeholders(working_on.internal_name, map_variable)
 
             if previous_node == current_node:
                 raise Exception("Potentially running in a infinite loop")
 
             previous_node = current_node
 
-            logger.info(f"Creating execution log for {working_on}")
-            self.execute_from_graph(working_on, map_variable=map_variable, **kwargs)
+            logger.debug(f"Creating execution log for {working_on}")
 
-            status, next_node_name = self._get_status_and_next_node_name(
-                current_node=working_on, dag=dag, map_variable=map_variable
-            )
+            depth = " " * ((task_name.count(".")) or 1 - 1)
 
-            if status == defaults.TRIGGERED:
-                # Some nodes go into triggered state and self traverse
-                logger.info(f"Triggered the job to execute the node {current_node}")
-                break
+            task_execution = self._context.progress.add_task(f"{depth}Executing {task_name}", total=1)
+
+            try:
+                self.execute_from_graph(working_on, map_variable=map_variable, **kwargs)
+                status, next_node_name = self._get_status_and_next_node_name(
+                    current_node=working_on, dag=dag, map_variable=map_variable
+                )
+
+                if status == defaults.SUCCESS:
+                    self._context.progress.update(
+                        task_execution,
+                        description=f"{depth}[green] {task_name} Completed",
+                        completed=True,
+                        overflow="fold",
+                    )
+                else:
+                    self._context.progress.update(
+                        task_execution, description=f"{depth}[red] {task_name} Failed", completed=True
+                    )  # type ignore
+            except Exception as e:  # noqa: E722
+                self._context.progress.update(
+                    task_execution,
+                    description=f"{depth}[red] {task_name} Errored",
+                    completed=True,
+                )
+                console.print(e, style=defaults.error_style)
+                logger.exception(e)
+                raise
+
+            console.rule(style="[dark orange]")
 
             if working_on.node_type in ["success", "fail"]:
                 break
 
             current_node = next_node_name
 
+        if branch_execution_task:
+            self._context.progress.update(
+                branch_execution_task, description=f"[green3] {branch_task_name} completed", completed=True
+            )
+
         run_log = self._context.run_log_store.get_branch_log(
             working_on._get_branch_log_name(map_variable), self._context.run_id
         )
@@ -440,10 +498,10 @@ class GenericExecutor(BaseExecutor):
 
         logger.info(f"Finished execution of the {branch} with status {run_log.status}")
 
-        # get the final run log
-        if branch == "graph":
-            run_log = self._context.run_log_store.get_run_log_by_id(run_id=self._context.run_id, full=True)
-        print(json.dumps(run_log.model_dump(), indent=4))
+        if dag == self._context.dag:
+            run_log = cast(RunLog, run_log)
+            console.print("Completed Execution, Summary:", style="bold color(208)")
+            console.print(run_log.get_summary(), style=defaults.info_style)
 
     def send_return_code(self, stage="traversal"):
         """

runnable/extensions/executor/argo/implementation.py

@@ -7,7 +7,14 @@ from abc import ABC, abstractmethod
 from collections import OrderedDict
 from typing import Any, Dict, List, Optional, Union, cast
 
-from pydantic import BaseModel, ConfigDict, Field, computed_field, field_serializer, field_validator
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    computed_field,
+    field_serializer,
+    field_validator,
+)
 from pydantic.functional_serializers import PlainSerializer
 from ruamel.yaml import YAML
 from typing_extensions import Annotated
@@ -773,9 +780,6 @@ class ArgoExecutor(GenericExecutor):
         integration.validate(self, self._context.secrets_handler)
         integration.configure_for_traversal(self, self._context.secrets_handler)
 
-        integration.validate(self, self._context.experiment_tracker)
-        integration.configure_for_traversal(self, self._context.experiment_tracker)
-
     def prepare_for_node_execution(self):
         """
         Perform any modifications to the services prior to execution of the node.

runnable/extensions/executor/local/implementation.py

@@ -35,6 +35,7 @@ class LocalExecutor(GenericExecutor):
             node (BaseNode): [description]
             map_variable (str, optional): [description]. Defaults to ''.
         """
+
         self.prepare_for_node_execution()
         self.execute_node(node=node, map_variable=map_variable, **kwargs)
 

runnable/extensions/nodes.py

@@ -5,13 +5,19 @@ import sys
 from collections import OrderedDict
 from copy import deepcopy
 from datetime import datetime
-from typing import Any, Dict, Optional, cast
-
-from pydantic import ConfigDict, Field, ValidationInfo, field_serializer, field_validator
+from typing import Any, Dict, List, Optional, Tuple, Union, cast
+
+from pydantic import (
+    ConfigDict,
+    Field,
+    ValidationInfo,
+    field_serializer,
+    field_validator,
+)
 from typing_extensions import Annotated
 
 from runnable import datastore, defaults, utils
-from runnable.datastore import JsonParameter, ObjectParameter, StepLog
+from runnable.datastore import JsonParameter, MetricParameter, ObjectParameter, StepLog
 from runnable.defaults import TypeMapVariable
 from runnable.graph import Graph, create_graph
 from runnable.nodes import CompositeNode, ExecutableNode, TerminalNode
@@ -45,6 +51,16 @@ class TaskNode(ExecutableNode):
         executable = create_task(task_config)
         return cls(executable=executable, **node_config, **task_config)
 
+    def get_summary(self) -> Dict[str, Any]:
+        summary = {
+            "name": self.name,
+            "type": self.node_type,
+            "executable": self.executable.get_summary(),
+            "catalog": self._get_catalog_settings(),
+        }
+
+        return summary
+
     def execute(
         self,
         mock=False,
@@ -63,9 +79,8 @@ class TaskNode(ExecutableNode):
         Returns:
             StepAttempt: The attempt object
         """
-        print("Executing task:", self._context.executor._context_node)
-
         step_log = self._context.run_log_store.get_step_log(self._get_step_log_name(map_variable), self._context.run_id)
+
         if not mock:
             # Do not run if we are mocking the execution, could be useful for caching and dry runs
             attempt_log = self.executable.execute_command(map_variable=map_variable)
@@ -78,6 +93,9 @@ class TaskNode(ExecutableNode):
                 attempt_number=attempt_number,
             )
 
+        logger.debug(f"attempt_log: {attempt_log}")
+        logger.info(f"Step {self.name} completed with status: {attempt_log.status}")
+
         step_log.status = attempt_log.status
 
         step_log.attempts.append(attempt_log)
@@ -96,6 +114,14 @@ class FailNode(TerminalNode):
     def parse_from_config(cls, config: Dict[str, Any]) -> "FailNode":
         return cast("FailNode", super().parse_from_config(config))
 
+    def get_summary(self) -> Dict[str, Any]:
+        summary = {
+            "name": self.name,
+            "type": self.node_type,
+        }
+
+        return summary
+
     def execute(
         self,
         mock=False,
@@ -118,7 +144,7 @@ class FailNode(TerminalNode):
         step_log = self._context.run_log_store.get_step_log(self._get_step_log_name(map_variable), self._context.run_id)
 
         attempt_log = datastore.StepAttempt(
-            status=defaults.FAIL,
+            status=defaults.SUCCESS,
             start_time=str(datetime.now()),
             end_time=str(datetime.now()),
             attempt_number=attempt_number,
@@ -148,6 +174,14 @@ class SuccessNode(TerminalNode):
     def parse_from_config(cls, config: Dict[str, Any]) -> "SuccessNode":
         return cast("SuccessNode", super().parse_from_config(config))
 
+    def get_summary(self) -> Dict[str, Any]:
+        summary = {
+            "name": self.name,
+            "type": self.node_type,
+        }
+
+        return summary
+
     def execute(
         self,
         mock=False,
@@ -207,6 +241,15 @@ class ParallelNode(CompositeNode):
     branches: Dict[str, Graph]
     is_composite: bool = Field(default=True, exclude=True)
 
+    def get_summary(self) -> Dict[str, Any]:
+        summary = {
+            "name": self.name,
+            "type": self.node_type,
+            "branches": [branch.get_summary() for branch in self.branches.values()],
+        }
+
+        return summary
+
     @field_serializer("branches")
     def ser_branches(self, branches: Dict[str, Graph]) -> Dict[str, Graph]:
         ret: Dict[str, Graph] = {}
@@ -296,6 +339,7 @@ class ParallelNode(CompositeNode):
             executor (BaseExecutor): The executor class as defined by the config
             map_variable (dict, optional): If the node is part of a map. Defaults to None.
         """
+        effective_internal_name = self._resolve_map_placeholders(self.internal_name, map_variable=map_variable)
         step_success_bool = True
         for internal_branch_name, _ in self.branches.items():
             effective_branch_name = self._resolve_map_placeholders(internal_branch_name, map_variable=map_variable)
@@ -304,7 +348,7 @@ class ParallelNode(CompositeNode):
                 step_success_bool = False
 
         # Collate all the results and update the status of the step
-        effective_internal_name = self._resolve_map_placeholders(self.internal_name, map_variable=map_variable)
+
         step_log = self._context.run_log_store.get_step_log(effective_internal_name, self._context.run_id)
 
         if step_success_bool:  #  If none failed
@@ -335,10 +379,24 @@ class MapNode(CompositeNode):
     node_type: str = Field(default="map", serialization_alias="type")
     iterate_on: str
     iterate_as: str
+    iterate_index: bool = Field(default=False)  # TODO: Need to design this
     reducer: Optional[str] = Field(default=None)
     branch: Graph
     is_composite: bool = True
 
+    def get_summary(self) -> Dict[str, Any]:
+        summary = {
+            "name": self.name,
+            "type": self.node_type,
+            "branch": self.branch.get_summary(),
+            "iterate_on": self.iterate_on,
+            "iterate_as": self.iterate_as,
+            "iterate_index": self.iterate_index,
+            "reducer": self.reducer,
+        }
+
+        return summary
+
     def get_reducer_function(self):
         if not self.reducer:
             return lambda *x: list(x)  # returns a list of the args
@@ -375,12 +433,12 @@ class MapNode(CompositeNode):
 
     @property
     def branch_returns(self):
-        branch_returns = []
+        branch_returns: List[Tuple[str, Union[ObjectParameter, MetricParameter, JsonParameter]]] = []
         for _, node in self.branch.nodes.items():
             if isinstance(node, TaskNode):
                 for task_return in node.executable.returns:
                     if task_return.kind == "json":
-                        branch_returns.append((task_return.name, JsonParameter(kind="json", value=None, reduced=False)))
+                        branch_returns.append((task_return.name, JsonParameter(kind="json", value="", reduced=False)))
                     elif task_return.kind == "object":
                         branch_returns.append(
                             (
@@ -390,7 +448,11 @@ class MapNode(CompositeNode):
                                     value="Will be reduced",
                                     reduced=False,
                                 ),
-                            )  # type: ignore
+                            )
+                        )
+                    elif task_return.kind == "metric":
+                        branch_returns.append(
+                            (task_return.name, MetricParameter(kind="metric", value="", reduced=False))
                         )
                     else:
                         raise Exception("kind should be either json or object")
@@ -513,6 +575,7 @@ class MapNode(CompositeNode):
         iterate_on = params[self.iterate_on].get_value()
         # # Find status of the branches
         step_success_bool = True
+        effective_internal_name = self._resolve_map_placeholders(self.internal_name, map_variable=map_variable)
 
         for iter_variable in iterate_on:
             effective_branch_name = self._resolve_map_placeholders(
@@ -523,7 +586,6 @@ class MapNode(CompositeNode):
                 step_success_bool = False
 
         # Collate all the results and update the status of the step
-        effective_internal_name = self._resolve_map_placeholders(self.internal_name, map_variable=map_variable)
         step_log = self._context.run_log_store.get_step_log(effective_internal_name, self._context.run_id)
 
         if step_success_bool:  #  If none failed and nothing is waiting
@@ -580,6 +642,13 @@ class DagNode(CompositeNode):
     is_composite: bool = True
     internal_branch_name: Annotated[str, Field(validate_default=True)] = ""
 
+    def get_summary(self) -> Dict[str, Any]:
+        summary = {
+            "name": self.name,
+            "type": self.node_type,
+        }
+        return summary
+
     @field_validator("internal_branch_name")
     @classmethod
     def validate_internal_branch_name(cls, internal_branch_name: str, info: ValidationInfo):
@@ -711,7 +780,15 @@ class StubNode(ExecutableNode):
     """
 
     node_type: str = Field(default="stub", serialization_alias="type")
-    model_config = ConfigDict(extra="allow")
+    model_config = ConfigDict(extra="ignore")
+
+    def get_summary(self) -> Dict[str, Any]:
+        summary = {
+            "name": self.name,
+            "type": self.node_type,
+        }
+
+        return summary
 
     @classmethod
     def parse_from_config(cls, config: Dict[str, Any]) -> "StubNode":

runnable/extensions/run_log_store/chunked_file_system/implementation.py

@@ -2,7 +2,7 @@ import json
 import logging
 from pathlib import Path
 from string import Template
-from typing import Optional, Sequence, Union
+from typing import Any, Dict, Optional, Sequence, Union
 
 from runnable import defaults, utils
 from runnable.extensions.run_log_store.generic_chunked import ChunkedRunLogStore
@@ -21,6 +21,11 @@ class ChunkedFileSystemRunLogStore(ChunkedRunLogStore):
     service_name: str = "chunked-fs"
     log_folder: str = defaults.LOG_LOCATION_FOLDER
 
+    def get_summary(self) -> Dict[str, Any]:
+        summary = {"Type": self.service_name, "Location": self.log_folder}
+
+        return summary
+
     def get_matches(self, run_id: str, name: str, multiple_allowed: bool = False) -> Optional[Union[Sequence[T], T]]:
         """
         Get contents of files matching the pattern name*

runnable/extensions/run_log_store/file_system/implementation.py

@@ -1,6 +1,7 @@
 import json
 import logging
 from pathlib import Path
+from typing import Any, Dict
 
 from runnable import defaults, exceptions, utils
 from runnable.datastore import BaseRunLogStore, RunLog
@@ -37,6 +38,11 @@ class FileSystemRunLogstore(BaseRunLogStore):
     def log_folder_name(self):
         return self.log_folder
 
+    def get_summary(self) -> Dict[str, Any]:
+        summary = {"Type": self.service_name, "Location": self.log_folder}
+
+        return summary
+
     def write_to_folder(self, run_log: RunLog):
         """
         Write the run log to the folder

runnable/graph.py

@@ -26,6 +26,17 @@ class Graph(BaseModel):
     internal_branch_name: str = Field(default="", exclude=True)
     nodes: SerializeAsAny[Dict[str, "BaseNode"]] = Field(default_factory=dict, serialization_alias="steps")
 
+    def get_summary(self) -> Dict[str, Any]:
+        """
+        Return a summary of the graph
+        """
+        return {
+            "name": self.name,
+            "description": self.description,
+            "start_at": self.start_at,
+            "nodes": [node.get_summary() for node in list(self.nodes.values())],
+        }
+
     def get_node_by_name(self, name: str) -> "BaseNode":
         """
         Return the Node object by the name

runnable/integration.py

@@ -102,7 +102,7 @@ def get_integration_handler(executor: "BaseExecutor", service: object) -> BaseIn
         raise Exception(msg)
 
     if not integrations:
-        logger.warning(
+        logger.info(
             f"Could not find an integration pattern for {executor.service_name} and {service_name} for {service_type}."
             " This implies that there is no need to change the configurations."
         )
@@ -163,7 +163,7 @@ class BufferedRunLogStore(BaseIntegration):
             "Run log generated by buffered run log store are not persisted. "
             "Re-running this run, in case of a failure, is not possible"
         )
-        logger.warning(msg)
+        logger.info(msg)
 
 
 class DoNothingCatalog(BaseIntegration):
@@ -176,7 +176,7 @@ class DoNothingCatalog(BaseIntegration):
 
     def validate(self, **kwargs):
         msg = "A do-nothing catalog does not hold any data and therefore cannot pass data between nodes."
-        logger.warning(msg)
+        logger.info(msg)
 
 
 class DoNothingSecrets(BaseIntegration):
@@ -189,17 +189,4 @@ class DoNothingSecrets(BaseIntegration):
 
     def validate(self, **kwargs):
         msg = "A do-nothing secrets does not hold any secrets and therefore cannot return you any secrets."
-        logger.warning(msg)
-
-
-class DoNothingExperimentTracker(BaseIntegration):
-    """
-    Integration between any executor and do nothing experiment tracker
-    """
-
-    service_type = "experiment_tracker"  # One of secret, catalog, datastore
-    service_provider = "do-nothing"  # The actual implementation of the service
-
-    def validate(self, **kwargs):
-        msg = "A do-nothing experiment tracker does nothing and therefore cannot track anything."
-        logger.warning(msg)
+        logger.info(msg)

runnable/nodes.py

@@ -362,6 +362,15 @@ class BaseNode(ABC, BaseModel):
         """
         ...
 
+    @abstractmethod
+    def get_summary(self) -> Dict[str, Any]:
+        """
+        Return the summary of the node
+
+        Returns:
+            Dict[str, Any]: _description_
+        """
+
 
 # --8<-- [end:docs]
 class TraversalNode(BaseNode):

runnable/parameters.py

@@ -4,6 +4,7 @@ import logging
 import os
 from typing import Any, Dict, Type
 
+import pydantic
 from pydantic import BaseModel, ConfigDict
 from typing_extensions import Callable
 
@@ -99,7 +100,7 @@ def filter_arguments_for_func(
             # default value is given in the function signature, nothing further to do.
             continue
 
-        if issubclass(value.annotation, BaseModel):
+        if type(value.annotation) in [BaseModel, pydantic._internal._model_construction.ModelMetaclass]:
             # We try to cast it as a pydantic model if asked
             named_param = params[name].get_value()
 
@@ -110,6 +111,7 @@ def filter_arguments_for_func(
             bound_model = bind_args_for_pydantic_model(named_param, value.annotation)
             bound_args[name] = bound_model
             unassigned_params = unassigned_params.difference(bound_model.model_fields.keys())
+
         elif value.annotation in [str, int, float, bool]:
             # Cast it if its a primitive type. Ensure the type matches the annotation.
             bound_args[name] = value.annotation(params[name].get_value())