runnable 0.11.1__tar.gz → 0.11.3__tar.gz

{runnable-0.11.1 → runnable-0.11.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: runnable
-Version: 0.11.1
+Version: 0.11.3
 Summary: A Compute agnostic pipelining software
 Home-page: https://github.com/vijayvammi/runnable
 License: Apache-2.0

{runnable-0.11.1 → runnable-0.11.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "runnable"
-version = "0.11.1"
+version = "0.11.3"
 description = "A Compute agnostic pipelining software"
 authors = ["Vijay Vammi <mesanthu@gmail.com>"]
 license = "Apache-2.0"
@@ -53,6 +53,10 @@ matplotlib = "^3.8.3"
 [tool.poetry.group.release.dependencies]
 python-semantic-release = "^9.4.2"
 
+
+[tool.poetry.group.examples.dependencies]
+pandas = "^2.2.2"
+
 [tool.poetry.extras]
 docker = ['docker']
 notebook = ['ploomber-engine']
@@ -93,7 +97,6 @@ runnable = 'runnable.cli:cli'
 [tool.poetry.plugins."secrets"]
 "do-nothing" = "runnable.secrets:DoNothingSecretManager"
 "dotenv" = "runnable.extensions.secrets.dotenv.implementation:DotEnvSecrets"
-"env-secrets-manager" = "runnable.extensions.secrets.env_secrets.implementation:EnvSecretsManager"
 
 # Plugins for Run Log store
 [tool.poetry.plugins."run_log_store"]
@@ -203,7 +206,7 @@ tag_format = "{version}"
 env = "GH_TOKEN"
 
 [tool.semantic_release.branches.main]
-match = "main"
+match = ""
 
 [tool.semantic_release.remote]
 ignore_token_for_push = true

{runnable-0.11.1 → runnable-0.11.3}/runnable/__init__.py

@@ -2,6 +2,7 @@
 
 # TODO: Might need to add Rich to pyinstaller part
 import logging
+import os
 from logging.config import dictConfig
 
 from rich.console import Console
@@ -29,6 +30,8 @@ from runnable.sdk import (  # noqa
     pickled,
 )
 
+os.environ["_PLOOMBER_TELEMETRY_DEBUG"] = "false"
+
 ## TODO: Summary should be a bit better for catalog.
 ## If the execution fails, hint them about the retry executor.
 # Make the retry executor loose!

{runnable-0.11.1 → runnable-0.11.3}/runnable/datastore.py

@@ -312,8 +312,10 @@ class RunLog(BaseModel):
         summary["Catalog Location"] = _context.catalog_handler.get_summary()
         summary["Full Run log present at: "] = _context.run_log_store.get_summary()
 
-        summary["Final Parameters"] = {p: v.description for p, v in self.parameters.items()}
-        summary["Collected metrics"] = {p: v.description for p, v in self.parameters.items() if v.kind == "metric"}
+        run_log = _context.run_log_store.get_run_log_by_id(run_id=_context.run_id, full=True)
+
+        summary["Final Parameters"] = {p: v.description for p, v in run_log.parameters.items()}
+        summary["Collected metrics"] = {p: v.description for p, v in run_log.parameters.items() if v.kind == "metric"}
 
         return summary
 
@@ -400,7 +402,10 @@ class RunLog(BaseModel):
         """
         dot_path = i_name.split(".")
         if len(dot_path) == 1:
-            return self.steps[i_name], None
+            try:
+                return self.steps[i_name], None
+            except KeyError as e:
+                raise exceptions.StepLogNotFoundError(self.run_id, i_name) from e
 
         current_steps = self.steps
         current_step = None

{runnable-0.11.1 → runnable-0.11.3}/runnable/entrypoints.py

@@ -60,6 +60,8 @@ def prepare_configurations(
     variables = utils.gather_variables()
 
     templated_configuration = {}
+    configuration_file = os.environ.get("RUNNABLE_CONFIGURATION_FILE", configuration_file)
+
     if configuration_file:
         templated_configuration = utils.load_yaml(configuration_file) or {}
 
@@ -144,8 +146,8 @@ def prepare_configurations(
 
 
 def execute(
-    configuration_file: str,
     pipeline_file: str,
+    configuration_file: str = "",
     tag: str = "",
     run_id: str = "",
     parameters_file: str = "",
@@ -196,6 +198,10 @@ def execute(
             run_context.progress = progress
             executor.execute_graph(dag=run_context.dag)  # type: ignore
 
+            if not executor._local:
+                executor.send_return_code(stage="traversal")
+                return
+
             run_log = run_context.run_log_store.get_run_log_by_id(run_id=run_context.run_id, full=False)
 
             if run_log.status == defaults.SUCCESS:
@@ -205,6 +211,10 @@ def execute(
         except Exception as e:  # noqa: E722
             console.print(e, style=defaults.error_style)
             progress.update(pipeline_execution_task, description="[red] Errored execution", completed=True)
+            run_log = run_context.run_log_store.get_run_log_by_id(run_id=run_context.run_id, full=False)
+            run_log.status = defaults.FAIL
+            run_context.run_log_store.add_branch_log(run_log, run_context.run_id)
+            raise e
 
     executor.send_return_code()
 
@@ -235,6 +245,8 @@ def execute_single_node(
     """
     from runnable import nodes
 
+    configuration_file = os.environ.get("RUNNABLE_CONFIGURATION_FILE", configuration_file)
+
     run_context = prepare_configurations(
         configuration_file=configuration_file,
         pipeline_file=pipeline_file,
@@ -422,6 +434,8 @@ def fan(
     """
     from runnable import nodes
 
+    configuration_file = os.environ.get("RUNNABLE_CONFIGURATION_FILE", configuration_file)
+
     run_context = prepare_configurations(
         configuration_file=configuration_file,
         pipeline_file=pipeline_file,

{runnable-0.11.1 → runnable-0.11.3}/runnable/extensions/catalog/file_system/implementation.py

@@ -226,7 +226,7 @@ class FileSystemCatalog(BaseCatalog):
         for cataloged_file in cataloged_files:
             if str(cataloged_file).endswith("execution.log"):
                 continue
-            print(cataloged_file.name)
+
             if cataloged_file.is_file():
                 shutil.copy(cataloged_file, run_catalog / cataloged_file.name)
             else:

{runnable-0.11.1 → runnable-0.11.3}/runnable/extensions/executor/__init__.py

@@ -185,14 +185,11 @@ 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,
@@ -200,8 +197,6 @@ class GenericExecutor(BaseExecutor):
                     synced_catalogs=synced_catalogs,
                 )
 
-                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)
 

{runnable-0.11.1 → runnable-0.11.3}/runnable/extensions/executor/argo/implementation.py

@@ -1033,6 +1033,9 @@ class ArgoExecutor(GenericExecutor):
             if working_on.node_type not in ["success", "fail"] and working_on._get_on_failure_node():
                 failure_node = dag.get_node_by_name(working_on._get_on_failure_node())
 
+                render_obj = get_renderer(working_on)(executor=self, node=failure_node)
+                render_obj.render(list_of_iter_values=list_of_iter_values.copy())
+
                 failure_template_name = self.get_clean_name(failure_node)
                 # If a task template for clean name exists, retrieve it
                 failure_template = templates.get(
@@ -1040,7 +1043,6 @@ class ArgoExecutor(GenericExecutor):
                     DagTaskTemplate(name=failure_template_name, template=failure_template_name),
                 )
                 failure_template.depends.append(f"{clean_name}.Failed")
-
                 templates[failure_template_name] = failure_template
 
             # If we are in a map node, we need to add the values as arguments

{runnable-0.11.1 → runnable-0.11.3}/runnable/extensions/executor/local_container/implementation.py

@@ -5,7 +5,7 @@ from typing import Dict, cast
 from pydantic import Field
 from rich import print
 
-from runnable import defaults, integration, utils
+from runnable import defaults, utils
 from runnable.datastore import StepLog
 from runnable.defaults import TypeMapVariable
 from runnable.extensions.executor import GenericExecutor
@@ -145,16 +145,6 @@ class LocalContainerExecutor(GenericExecutor):
         logger.debug("Here is the resolved executor config")
         logger.debug(executor_config)
 
-        if executor_config.get("run_in_local", False):
-            # Do not change config but only validate the configuration.
-            # Trigger the job on local system instead of a container
-            integration.validate(self, self._context.run_log_store)
-            integration.validate(self, self._context.catalog_handler)
-            integration.validate(self, self._context.secrets_handler)
-
-            self.execute_node(node=node, map_variable=map_variable, **kwargs)
-            return
-
         command = utils.get_node_execution_command(node, map_variable=map_variable)
 
         self._spin_container(
@@ -172,7 +162,7 @@ class LocalContainerExecutor(GenericExecutor):
                 "Note: If you do not see any docker issue from your side and the code works properly on local execution"
                 "please raise a bug report."
             )
-            logger.warning(msg)
+            logger.error(msg)
             step_log.status = defaults.FAIL
             self._context.run_log_store.add_step_log(step_log, self._context.run_id)
 
@@ -212,6 +202,7 @@ class LocalContainerExecutor(GenericExecutor):
                     f"Please provide a docker_image using executor_config of the step {node.name} or at global config"
                 )
 
+            print("container", self._volumes)
             # TODO: Should consider using getpass.getuser() when running the docker container? Volume permissions
             container = client.containers.create(
                 image=docker_image,
@@ -260,7 +251,9 @@ class LocalContainerComputeFileSystemRunLogstore(BaseIntegration):
     service_provider = "file-system"  # The actual implementation of the service
 
     def configure_for_traversal(self, **kwargs):
-        from runnable.extensions.run_log_store.file_system.implementation import FileSystemRunLogstore
+        from runnable.extensions.run_log_store.file_system.implementation import (
+            FileSystemRunLogstore,
+        )
 
         self.executor = cast(LocalContainerExecutor, self.executor)
         self.service = cast(FileSystemRunLogstore, self.service)
@@ -272,7 +265,9 @@ class LocalContainerComputeFileSystemRunLogstore(BaseIntegration):
         }
 
     def configure_for_execution(self, **kwargs):
-        from runnable.extensions.run_log_store.file_system.implementation import FileSystemRunLogstore
+        from runnable.extensions.run_log_store.file_system.implementation import (
+            FileSystemRunLogstore,
+        )
 
         self.executor = cast(LocalContainerExecutor, self.executor)
         self.service = cast(FileSystemRunLogstore, self.service)
@@ -280,6 +275,40 @@ class LocalContainerComputeFileSystemRunLogstore(BaseIntegration):
         self.service.log_folder = self.executor._container_log_location
 
 
+class LocalContainerComputeChunkedFS(BaseIntegration):
+    """
+    Integration pattern between Local container and File System catalog
+    """
+
+    executor_type = "local-container"
+    service_type = "run_log_store"  # One of secret, catalog, datastore
+    service_provider = "chunked-fs"  # The actual implementation of the service
+
+    def configure_for_traversal(self, **kwargs):
+        from runnable.extensions.run_log_store.chunked_file_system.implementation import (
+            ChunkedFileSystemRunLogStore,
+        )
+
+        self.executor = cast(LocalContainerExecutor, self.executor)
+        self.service = cast(ChunkedFileSystemRunLogStore, self.service)
+
+        write_to = self.service.log_folder
+        self.executor._volumes[str(Path(write_to).resolve())] = {
+            "bind": f"{self.executor._container_log_location}",
+            "mode": "rw",
+        }
+
+    def configure_for_execution(self, **kwargs):
+        from runnable.extensions.run_log_store.chunked_file_system.implementation import (
+            ChunkedFileSystemRunLogStore,
+        )
+
+        self.executor = cast(LocalContainerExecutor, self.executor)
+        self.service = cast(ChunkedFileSystemRunLogStore, self.service)
+
+        self.service.log_folder = self.executor._container_log_location
+
+
 class LocalContainerComputeFileSystemCatalog(BaseIntegration):
     """
     Integration pattern between Local container and File System catalog
@@ -290,7 +319,9 @@ class LocalContainerComputeFileSystemCatalog(BaseIntegration):
     service_provider = "file-system"  # The actual implementation of the service
 
     def configure_for_traversal(self, **kwargs):
-        from runnable.extensions.catalog.file_system.implementation import FileSystemCatalog
+        from runnable.extensions.catalog.file_system.implementation import (
+            FileSystemCatalog,
+        )
 
         self.executor = cast(LocalContainerExecutor, self.executor)
         self.service = cast(FileSystemCatalog, self.service)
@@ -302,7 +333,9 @@ class LocalContainerComputeFileSystemCatalog(BaseIntegration):
         }
 
     def configure_for_execution(self, **kwargs):
-        from runnable.extensions.catalog.file_system.implementation import FileSystemCatalog
+        from runnable.extensions.catalog.file_system.implementation import (
+            FileSystemCatalog,
+        )
 
         self.executor = cast(LocalContainerExecutor, self.executor)
         self.service = cast(FileSystemCatalog, self.service)

{runnable-0.11.1 → runnable-0.11.3}/runnable/extensions/executor/mocked/implementation.py

@@ -18,7 +18,7 @@ def create_executable(params: Dict[str, Any], model: Type[BaseTaskType], node_na
     class EasyModel(model):  # type: ignore
         model_config = ConfigDict(extra="ignore")
 
-    swallow_all = EasyModel(**params, node_name=node_name)
+    swallow_all = EasyModel(node_name=node_name, **params)
     return swallow_all
 
 
@@ -26,6 +26,8 @@ class MockedExecutor(GenericExecutor):
     service_name: str = "mocked"
     _local_executor: bool = True
 
+    model_config = ConfigDict(extra="ignore")
+
     patches: Dict[str, Any] = Field(default_factory=dict)
 
     @property
@@ -64,6 +66,10 @@ class MockedExecutor(GenericExecutor):
         step_log.step_type = node.node_type
         step_log.status = defaults.PROCESSING
 
+        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"]:
@@ -132,3 +138,17 @@ class MockedExecutor(GenericExecutor):
 
     def execute_job(self, node: TaskNode):
         pass
+
+    def execute_node(self, node: BaseNode, map_variable: TypeMapVariable = None, **kwargs):
+        """
+        The entry point for all executors apart from local.
+        We have already prepared for node execution.
+
+        Args:
+            node (BaseNode): The node to execute
+            map_variable (dict, optional): If the node is part of a map, send in the map dictionary. Defaults to None.
+
+        Raises:
+            NotImplementedError: _description_
+        """
+        ...

{runnable-0.11.1 → runnable-0.11.3}/runnable/extensions/executor/retry/implementation.py

@@ -6,6 +6,7 @@ from runnable import context, defaults, exceptions
 from runnable.datastore import RunLog
 from runnable.defaults import TypeMapVariable
 from runnable.extensions.executor import GenericExecutor
+from runnable.extensions.nodes import TaskNode
 from runnable.nodes import BaseNode
 
 logger = logging.getLogger(defaults.LOGGER_NAME)
@@ -31,6 +32,7 @@ class RetryExecutor(GenericExecutor):
 
     _local: bool = True
     _original_run_log: Optional[RunLog] = None
+    _restart_initiated: bool = False
 
     @property
     def _context(self):
@@ -38,7 +40,7 @@ class RetryExecutor(GenericExecutor):
 
     @cached_property
     def original_run_log(self):
-        self.original_run_log = self._context.run_log_store.get_run_log_by_id(
+        return self._context.run_log_store.get_run_log_by_id(
             run_id=self.run_id,
             full=True,
         )
@@ -140,10 +142,14 @@ class RetryExecutor(GenericExecutor):
         node_step_log_name = node._get_step_log_name(map_variable=map_variable)
         logger.info(f"Scanning previous run logs for node logs of: {node_step_log_name}")
 
+        if self._restart_initiated:
+            return True
+
         try:
             previous_attempt_log, _ = self.original_run_log.search_step_by_internal_name(node_step_log_name)
         except exceptions.StepLogNotFoundError:
             logger.warning(f"Did not find the node {node.name} in previous run log")
+            self._restart_initiated = True
             return True  # We should re-run the node.
 
         logger.info(f"The original step status: {previous_attempt_log.status}")
@@ -152,7 +158,11 @@ class RetryExecutor(GenericExecutor):
             return False  # We need not run the node
 
         logger.info(f"The new execution should start executing graph from this node {node.name}")
+        self._restart_initiated = True
         return True
 
     def execute_node(self, node: BaseNode, map_variable: TypeMapVariable = None, **kwargs):
         self._execute_node(node, map_variable=map_variable, **kwargs)
+
+    def execute_job(self, node: TaskNode):
+        pass

{runnable-0.11.1 → runnable-0.11.3}/runnable/extensions/nodes.py

@@ -5,7 +5,7 @@ import sys
 from collections import OrderedDict
 from copy import deepcopy
 from datetime import datetime
-from typing import Any, Dict, List, Optional, Tuple, Union, cast
+from typing import Annotated, Any, Callable, Dict, List, Optional, Tuple, Union, cast
 
 from pydantic import (
     ConfigDict,
@@ -14,10 +14,15 @@ from pydantic import (
     field_serializer,
     field_validator,
 )
-from typing_extensions import Annotated
 
 from runnable import datastore, defaults, utils
-from runnable.datastore import JsonParameter, MetricParameter, ObjectParameter, StepLog
+from runnable.datastore import (
+    JsonParameter,
+    MetricParameter,
+    ObjectParameter,
+    Parameter,
+    StepLog,
+)
 from runnable.defaults import TypeMapVariable
 from runnable.graph import Graph, create_graph
 from runnable.nodes import CompositeNode, ExecutableNode, TerminalNode
@@ -46,8 +51,6 @@ class TaskNode(ExecutableNode):
         task_config = {k: v for k, v in config.items() if k not in TaskNode.model_fields.keys()}
         node_config = {k: v for k, v in config.items() if k in TaskNode.model_fields.keys()}
 
-        task_config["node_name"] = config.get("name")
-
         executable = create_task(task_config)
         return cls(executable=executable, **node_config, **task_config)
 
@@ -505,7 +508,7 @@ class MapNode(CompositeNode):
             for _, v in map_variable.items():
                 for branch_return in self.branch_returns:
                     param_name, param_type = branch_return
-                    raw_parameters[f"{param_name}_{v}"] = param_type.copy()
+                    raw_parameters[f"{v}_{param_name}"] = param_type.copy()
         else:
             for branch_return in self.branch_returns:
                 param_name, param_type = branch_return
@@ -543,10 +546,14 @@ class MapNode(CompositeNode):
         iterate_on = None
         try:
             iterate_on = self._context.run_log_store.get_parameters(self._context.run_id)[self.iterate_on].get_value()
-        except KeyError:
+        except KeyError as e:
             raise Exception(
-                f"Expected parameter {self.iterate_on} not present in Run Log parameters, was it ever set before?"
-            )
+                (
+                    f"Expected parameter {self.iterate_on}",
+                    "not present in Run Log parameters",
+                    "was it ever set before?",
+                )
+            ) from e
 
         if not isinstance(iterate_on, list):
             raise Exception("Only list is allowed as a valid iterator type")
@@ -599,29 +606,44 @@ class MapNode(CompositeNode):
         # The final value of the parameter is the result of the reduce function.
         reducer_f = self.get_reducer_function()
 
-        if map_variable:
-            # If we are in a map state already, the param should have an index of the map variable.
-            for _, v in map_variable.items():
-                for branch_return in self.branch_returns:
-                    param_name, _ = branch_return
-                    to_reduce = []
-                    for iter_variable in iterate_on:
-                        to_reduce.append(params[f"{param_name}_{iter_variable}"].get_value())
-
-                    param_name = f"{param_name}_{v}"
-                    params[param_name].value = reducer_f(to_reduce)
-                    params[param_name].reduced = True
-        else:
+        def update_param(params: Dict[str, Parameter], reducer_f: Callable, map_prefix: str = ""):
+            from runnable.extensions.executor.mocked.implementation import (
+                MockedExecutor,
+            )
+
             for branch_return in self.branch_returns:
                 param_name, _ = branch_return
 
                 to_reduce = []
                 for iter_variable in iterate_on:
-                    to_reduce.append(params[f"{param_name}_{iter_variable}"].get_value())
-
-                params[param_name].value = reducer_f(*to_reduce)
+                    try:
+                        to_reduce.append(params[f"{iter_variable}_{param_name}"].get_value())
+                    except KeyError as e:
+                        if isinstance(self._context.executor, MockedExecutor):
+                            pass
+                        else:
+                            raise Exception(
+                                (
+                                    f"Expected parameter {iter_variable}_{param_name}",
+                                    "not present in Run Log parameters",
+                                    "was it ever set before?",
+                                )
+                            ) from e
+
+                param_name = f"{map_prefix}{param_name}"
+                if to_reduce:
+                    params[param_name].value = reducer_f(*to_reduce)
+                else:
+                    params[param_name].value = ""
                 params[param_name].reduced = True
 
+        if map_variable:
+            # If we are in a map state already, the param should have an index of the map variable.
+            for _, v in map_variable.items():
+                update_param(params, reducer_f, map_prefix=f"{v}_")
+        else:
+            update_param(params, reducer_f)
+
         self._context.run_log_store.set_parameters(parameters=params, run_id=self._context.run_id)
 
 

{runnable-0.11.1 → runnable-0.11.3}/runnable/extensions/run_log_store/generic_chunked.py

@@ -7,7 +7,16 @@ from string import Template
 from typing import Any, Dict, Optional, Sequence, Union
 
 from runnable import defaults, exceptions
-from runnable.datastore import BaseRunLogStore, BranchLog, RunLog, StepLog
+from runnable.datastore import (
+    BaseRunLogStore,
+    BranchLog,
+    JsonParameter,
+    MetricParameter,
+    ObjectParameter,
+    Parameter,
+    RunLog,
+    StepLog,
+)
 
 logger = logging.getLogger(defaults.LOGGER_NAME)
 
@@ -164,7 +173,9 @@ class ChunkedRunLogStore(BaseRunLogStore):
             raise Exception(f"Name is required during retrieval for {log_type}")
 
         naming_pattern = self.naming_pattern(log_type=log_type, name=name)
+
         matches = self.get_matches(run_id=run_id, name=naming_pattern, multiple_allowed=multiple_allowed)
+
         if matches:
             if not multiple_allowed:
                 contents = self._retrieve(name=matches)  # type: ignore
@@ -370,10 +381,17 @@ class ChunkedRunLogStore(BaseRunLogStore):
         Raises:
             RunLogNotFoundError: If the run log for run_id is not found in the datastore
         """
-        parameters = {}
+        parameters: Dict[str, Parameter] = {}
         try:
             parameters_list = self.retrieve(run_id=run_id, log_type=self.LogTypes.PARAMETER, multiple_allowed=True)
-            parameters = {key: value for param in parameters_list for key, value in param.items()}
+            for param in parameters_list:
+                for key, value in param.items():
+                    if value["kind"] == "json":
+                        parameters[key] = JsonParameter(**value)
+                    if value["kind"] == "metric":
+                        parameters[key] = MetricParameter(**value)
+                    if value["kind"] == "object":
+                        parameters[key] = ObjectParameter(**value)
         except EntityNotFoundError:
             # No parameters are set
             pass
@@ -401,7 +419,7 @@ class ChunkedRunLogStore(BaseRunLogStore):
             self.store(
                 run_id=run_id,
                 log_type=self.LogTypes.PARAMETER,
-                contents={key: value},
+                contents={key: value.model_dump(by_alias=True)},
                 name=key,
             )
 

{runnable-0.11.1 → runnable-0.11.3}/runnable/graph.py

@@ -74,6 +74,7 @@ class Graph(BaseModel):
         for _, value in self.nodes.items():
             if value.internal_name == internal_name:
                 return value
+        print("graph", internal_name)
         raise exceptions.NodeNotFoundError(internal_name)
 
     def __str__(self):  # pragma: no cover

{runnable-0.11.1 → runnable-0.11.3}/runnable/parameters.py

@@ -36,7 +36,7 @@ def get_user_set_parameters(remove: bool = False) -> Dict[str, JsonParameter]:
             try:
                 parameters[key.lower()] = JsonParameter(kind="json", value=json.loads(value))
             except json.decoder.JSONDecodeError:
-                logger.error(f"Parameter {key} could not be JSON decoded, adding the literal value")
+                logger.warning(f"Parameter {key} could not be JSON decoded, adding the literal value")
                 parameters[key.lower()] = JsonParameter(kind="json", value=value)
 
             if remove: