runnable 0.28.8__py3-none-any.whl → 0.30.0__py3-none-any.whl

extensions/pipeline_executor/__init__.py

@@ -198,7 +198,6 @@ class GenericPipelineExecutor(BasePipelineExecutor):
         node: BaseNode,
         map_variable: TypeMapVariable = None,
         mock: bool = False,
-        **kwargs,
     ):
         """
         This is the entry point when we do the actual execution of the function.
@@ -232,7 +231,6 @@ class GenericPipelineExecutor(BasePipelineExecutor):
             map_variable=map_variable,
             attempt_number=self.step_attempt_number,
             mock=mock,
-            **kwargs,
         )
 
         data_catalogs_put: Optional[List[DataCatalog]] = self._sync_catalog(stage="put")
@@ -248,7 +246,7 @@ class GenericPipelineExecutor(BasePipelineExecutor):
 
         self._context.run_log_store.add_step_log(step_log, self._context.run_id)
 
-    def add_code_identities(self, node: BaseNode, step_log: StepLog, **kwargs):
+    def add_code_identities(self, node: BaseNode, step_log: StepLog):
         """
         Add code identities specific to the implementation.
 
@@ -260,9 +258,7 @@ class GenericPipelineExecutor(BasePipelineExecutor):
         """
         step_log.code_identities.append(utils.get_git_code_identity())
 
-    def execute_from_graph(
-        self, node: BaseNode, map_variable: TypeMapVariable = None, **kwargs
-    ):
+    def execute_from_graph(self, node: BaseNode, map_variable: TypeMapVariable = None):
         """
         This is the entry point to from the graph execution.
 
@@ -303,12 +299,12 @@ class GenericPipelineExecutor(BasePipelineExecutor):
         # 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"]:
-            self._execute_node(node, map_variable=map_variable, **kwargs)
+            self._execute_node(node, map_variable=map_variable)
             return
 
         # We call an internal function to iterate the sub graphs and execute them
         if node.is_composite:
-            node.execute_as_graph(map_variable=map_variable, **kwargs)
+            node.execute_as_graph(map_variable=map_variable)
             return
 
         task_console.export_text(clear=True)
@@ -317,10 +313,10 @@ class GenericPipelineExecutor(BasePipelineExecutor):
         console.print(
             f":runner: Executing the node {task_name} ... ", style="bold color(208)"
         )
-        self.trigger_node_execution(node=node, map_variable=map_variable, **kwargs)
+        self.trigger_node_execution(node=node, map_variable=map_variable)
 
     def trigger_node_execution(
-        self, node: BaseNode, map_variable: TypeMapVariable = None, **kwargs
+        self, node: BaseNode, map_variable: TypeMapVariable = None
     ):
         """
         Call this method only if we are responsible for traversing the graph via
@@ -376,7 +372,7 @@ class GenericPipelineExecutor(BasePipelineExecutor):
 
         return step_log.status, next_node_name
 
-    def execute_graph(self, dag: Graph, map_variable: TypeMapVariable = None, **kwargs):
+    def execute_graph(self, dag: Graph, map_variable: TypeMapVariable = None):
         """
         The parallelization is controlled by the nodes and not by this function.
 
@@ -430,7 +426,7 @@ class GenericPipelineExecutor(BasePipelineExecutor):
             )
 
             try:
-                self.execute_from_graph(working_on, map_variable=map_variable, **kwargs)
+                self.execute_from_graph(working_on, map_variable=map_variable)
                 status, next_node_name = self._get_status_and_next_node_name(
                     current_node=working_on, dag=dag, map_variable=map_variable
                 )
@@ -593,7 +589,7 @@ class GenericPipelineExecutor(BasePipelineExecutor):
         step_log.status = defaults.PROCESSING
         self._context.run_log_store.add_step_log(step_log, self._context.run_id)
 
-        node.fan_out(executor=self, map_variable=map_variable)
+        node.fan_out(map_variable=map_variable)
 
     def fan_in(self, node: BaseNode, map_variable: TypeMapVariable = None):
         """
@@ -614,7 +610,7 @@ class GenericPipelineExecutor(BasePipelineExecutor):
             map_variable (dict, optional): If the node if of a map state,.Defaults to None.
 
         """
-        node.fan_in(executor=self, map_variable=map_variable)
+        node.fan_in(map_variable=map_variable)
 
         step_log = self._context.run_log_store.get_step_log(
             node._get_step_log_name(map_variable=map_variable), self._context.run_id

extensions/pipeline_executor/argo.py

@@ -27,6 +27,7 @@ from extensions.nodes.nodes import (
     SuccessNode,
     TaskNode,
 )
+from extensions.nodes.torch import TorchNode
 from extensions.pipeline_executor import GenericPipelineExecutor
 from runnable import defaults, utils
 from runnable.defaults import TypeMapVariable
@@ -370,6 +371,89 @@ class CustomVolume(BaseModelWIthConfig):
 
 
 class ArgoExecutor(GenericPipelineExecutor):
+    """
+    Executes the pipeline using Argo Workflows.
+
+    The defaults configuration is kept similar to the
+    [Argo Workflow spec](https://argo-workflows.readthedocs.io/en/latest/fields/#workflow).
+
+    Configuration:
+
+    ```yaml
+    pipeline-executor:
+      type: argo
+      config:
+        pvc_for_runnable: "my-pvc"
+        custom_volumes:
+          - mount_path: "/tmp"
+            persistent_volume_claim:
+              claim_name: "my-pvc"
+              read_only: false/true
+        expose_parameters_as_inputs: true/false
+        secrets_from_k8s:
+          - key1
+          - key2
+          - ...
+        output_file: "argo-pipeline.yaml"
+        log_level: "DEBUG"/"INFO"/"WARNING"/"ERROR"/"CRITICAL"
+        defaults:
+          image: "my-image"
+          activeDeadlineSeconds: 86400
+          failFast: true
+          nodeSelector:
+            label: value
+          parallelism: 1
+          retryStrategy:
+            backoff:
+            duration: "2m"
+            factor: 2
+            maxDuration: "1h"
+            limit: 0
+            retryPolicy: "Always"
+          timeout: "1h"
+          tolerations:
+          imagePullPolicy: "Always"/"IfNotPresent"/"Never"
+          resources:
+            limits:
+              memory: "1Gi"
+              cpu: "250m"
+              gpu: 0
+            requests:
+              memory: "1Gi"
+              cpu: "250m"
+          env:
+            - name: "MY_ENV"
+            value: "my-value"
+            - name: secret_env
+            secretName: "my-secret"
+            secretKey: "my-key"
+        overrides:
+          key1:
+            ... similar structure to defaults
+
+        argoWorkflow:
+          metadata:
+            annotations:
+              key1: value1
+              key2: value2
+            generateName: "my-workflow"
+            labels:
+              key1: value1
+
+    ```
+
+    As of now, ```runnable``` needs a pvc to store the logs and the catalog; provided by ```pvc_for_runnable```.
+    - ```custom_volumes``` can be used to mount additional volumes to the container.
+
+    - ```expose_parameters_as_inputs``` can be used to expose the initial parameters as inputs to the workflow.
+    - ```secrets_from_k8s``` can be used to expose the secrets from the k8s secret store.
+    - ```output_file``` is the file where the argo pipeline will be dumped.
+    - ```log_level``` is the log level for the containers.
+    - ```defaults``` is the default configuration for all the containers.
+
+
+    """
+
     service_name: str = "argo"
     _is_local: bool = False
     mock: bool = False
@@ -510,6 +594,7 @@ class ArgoExecutor(GenericPipelineExecutor):
             isinstance(node, TaskNode)
             or isinstance(node, StubNode)
             or isinstance(node, SuccessNode)
+            or isinstance(node, TorchNode)
         )
 
         node_override = None
@@ -522,7 +607,7 @@ class ArgoExecutor(GenericPipelineExecutor):
 
         effective_settings = self.defaults.model_dump()
         if node_override:
-            effective_settings.update(node_override.model_dump())
+            effective_settings.update(node_override.model_dump(exclude_none=True))
 
         inputs = inputs or Inputs(parameters=[])
 
@@ -792,6 +877,25 @@ class ArgoExecutor(GenericPipelineExecutor):
 
                     self._templates.append(composite_template)
 
+                case "torch":
+                    assert isinstance(working_on, TorchNode)
+                    # TODO: Need to add multi-node functionality
+
+                    template_of_container = self._create_container_template(
+                        working_on,
+                        task_name=task_name,
+                        inputs=Inputs(parameters=parameters),
+                    )
+                    assert template_of_container.container is not None
+
+                    if working_on.node_type == "task":
+                        self._expose_secrets_to_task(
+                            working_on,
+                            container_template=template_of_container.container,
+                        )
+
+                    self._templates.append(template_of_container)
+
             self._handle_failures(
                 working_on,
                 dag,
@@ -810,7 +914,6 @@ class ArgoExecutor(GenericPipelineExecutor):
         self,
         dag: Graph,
         map_variable: dict[str, str | int | float] | None = None,
-        **kwargs,
     ):
         # All the arguments set at the spec level can be referred as "{{workflow.parameters.*}}"
         # We want to use that functionality to override the parameters at the task level
@@ -886,7 +989,6 @@ class ArgoExecutor(GenericPipelineExecutor):
         self,
         node: BaseNode,
         map_variable: dict[str, str | int | float] | None = None,
-        **kwargs,
     ):
         error_on_existing_run_id = os.environ.get("error_on_existing_run_id", "false")
         exists_ok = error_on_existing_run_id == "false"
@@ -904,7 +1006,7 @@ class ArgoExecutor(GenericPipelineExecutor):
         step_log.status = defaults.PROCESSING
         self._context.run_log_store.add_step_log(step_log, self._context.run_id)
 
-        self._execute_node(node=node, map_variable=map_variable, **kwargs)
+        self._execute_node(node=node, map_variable=map_variable)
 
         # Raise exception if the step failed
         step_log = self._context.run_log_store.get_step_log(

extensions/pipeline_executor/local.py

@@ -18,8 +18,11 @@ class LocalExecutor(GenericPipelineExecutor):
     Also ensure that the local compute is good enough for the compute to happen of all the steps.
 
     Example config:
-    execution:
+
+    ```yaml
+    pipeline-executor:
       type: local
+    ```
 
     """
 
@@ -29,16 +32,14 @@ class LocalExecutor(GenericPipelineExecutor):
 
     _is_local: bool = PrivateAttr(default=True)
 
-    def execute_from_graph(
-        self, node: BaseNode, map_variable: TypeMapVariable = None, **kwargs
-    ):
+    def execute_from_graph(self, node: BaseNode, map_variable: TypeMapVariable = None):
         if not self.object_serialisation:
             self._context.object_serialisation = False
 
-        super().execute_from_graph(node=node, map_variable=map_variable, **kwargs)
+        super().execute_from_graph(node=node, map_variable=map_variable)
 
     def trigger_node_execution(
-        self, node: BaseNode, map_variable: TypeMapVariable = None, **kwargs
+        self, node: BaseNode, map_variable: TypeMapVariable = None
     ):
         """
         In this mode of execution, we prepare for the node execution and execute the node
@@ -47,11 +48,9 @@ class LocalExecutor(GenericPipelineExecutor):
             node (BaseNode): [description]
             map_variable (str, optional): [description]. Defaults to ''.
         """
-        self.execute_node(node=node, map_variable=map_variable, **kwargs)
+        self.execute_node(node=node, map_variable=map_variable)
 
-    def execute_node(
-        self, node: BaseNode, map_variable: TypeMapVariable = None, **kwargs
-    ):
+    def execute_node(self, node: BaseNode, map_variable: TypeMapVariable = None):
         """
         For local execution, we just execute the node.
 
@@ -59,4 +58,4 @@ class LocalExecutor(GenericPipelineExecutor):
             node (BaseNode): _description_
             map_variable (dict[str, str], optional): _description_. Defaults to None.
         """
-        self._execute_node(node=node, map_variable=map_variable, **kwargs)
+        self._execute_node(node=node, map_variable=map_variable)

extensions/pipeline_executor/local_container.py

@@ -3,7 +3,6 @@ from pathlib import Path
 from typing import Dict
 
 from pydantic import Field
-from rich import print
 
 from extensions.pipeline_executor import GenericPipelineExecutor
 from runnable import console, defaults, task_console, utils
@@ -20,31 +19,50 @@ class LocalContainerExecutor(GenericPipelineExecutor):
 
     Ensure that the local compute has enough resources to finish all your jobs.
 
-    The image of the run, could either be provided as default in the configuration of the execution engine
-    i.e.:
-    execution:
-      type: 'local-container'
-      config:
-        docker_image: the image you want the code to run in.
-
-    or default image could be over-ridden for a single node by providing a docker_image in the step config.
-    i.e:
-    dag:
-      steps:
-        step:
-          executor_config:
-            local-container:
-                docker_image: The image that you want that single step to run in.
-    This image would only be used for that step only.
-
-    This mode does not build the docker image with the latest code for you, it is still left for the user to build
-    and ensure that the docker image provided is the correct one.
+    Configuration options:
 
-    Example config:
-    execution:
+    ```yaml
+    pipeline-executor:
       type: local-container
       config:
-        docker_image: The default docker image to use if the node does not provide one.
+        docker_image: <required>
+        auto_remove_container: true/false
+        environment:
+          key: value
+        overrides:
+          alternate_config:
+            docker_image: <required>
+            auto_remove_container: true/false
+            environment:
+              key: value
+    ```
+
+    - ```docker_image```: The default docker image to use for all the steps.
+    - ```auto_remove_container```: Remove container after execution
+    - ```environment```: Environment variables to pass to the container
+
+    Overrides give you the ability to override the default docker image for a single step.
+    A step can then then refer to the alternate_config in the task definition.
+
+    Example:
+
+    ```python
+    from runnable import PythonTask
+
+    task = PythonTask(
+        name="alt_task",
+        overrides={
+            "local-container": "alternate_config"
+            }
+        )
+    ```
+
+    In the above example, ```alt_task``` will run in the docker image/configuration
+    as defined in the alternate_config.
+
+    ```runnable``` does not build the docker image for you, it is still left for the user to build
+    and ensure that the docker image provided is the correct one.
+
     """
 
     service_name: str = "local-container"
@@ -59,7 +77,7 @@ class LocalContainerExecutor(GenericPipelineExecutor):
     _container_secrets_location = "/tmp/dotenv"
     _volumes: Dict[str, Dict[str, str]] = {}
 
-    def add_code_identities(self, node: BaseNode, step_log: StepLog, **kwargs):
+    def add_code_identities(self, node: BaseNode, step_log: StepLog):
         """
         Call the Base class to add the git code identity and add docker identity
 
@@ -86,18 +104,18 @@ class LocalContainerExecutor(GenericPipelineExecutor):
             code_id.code_identifier_url = "local docker host"
             step_log.code_identities.append(code_id)
 
-    def execute_node(
-        self, node: BaseNode, map_variable: TypeMapVariable = None, **kwargs
-    ):
+    def execute_node(self, node: BaseNode, map_variable: TypeMapVariable = None):
         """
         We are already in the container, we just execute the node.
         The node is already prepared for execution.
         """
         self._use_volumes()
-        return self._execute_node(node, map_variable, **kwargs)
+        return self._execute_node(node, map_variable)
 
     def execute_from_graph(
-        self, node: BaseNode, map_variable: TypeMapVariable = None, **kwargs
+        self,
+        node: BaseNode,
+        map_variable: TypeMapVariable = None,
     ):
         """
         This is the entry point to from the graph execution.
@@ -139,12 +157,12 @@ class LocalContainerExecutor(GenericPipelineExecutor):
         # 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"]:
-            self._execute_node(node, map_variable=map_variable, **kwargs)
+            self._execute_node(node, map_variable=map_variable)
             return
 
         # We call an internal function to iterate the sub graphs and execute them
         if node.is_composite:
-            node.execute_as_graph(map_variable=map_variable, **kwargs)
+            node.execute_as_graph(map_variable=map_variable)
             return
 
         task_console.export_text(clear=True)
@@ -153,10 +171,10 @@ class LocalContainerExecutor(GenericPipelineExecutor):
         console.print(
             f":runner: Executing the node {task_name} ... ", style="bold color(208)"
         )
-        self.trigger_node_execution(node=node, map_variable=map_variable, **kwargs)
+        self.trigger_node_execution(node=node, map_variable=map_variable)
 
     def trigger_node_execution(
-        self, node: BaseNode, map_variable: TypeMapVariable = None, **kwargs
+        self, node: BaseNode, map_variable: TypeMapVariable = None
     ):
         """
         We come into this step via execute from graph, use trigger job to spin up the container.
@@ -181,7 +199,6 @@ class LocalContainerExecutor(GenericPipelineExecutor):
             command=command,
             map_variable=map_variable,
             auto_remove_container=auto_remove_container,
-            **kwargs,
         )
 
         step_log = self._context.run_log_store.get_step_log(
@@ -203,7 +220,6 @@ class LocalContainerExecutor(GenericPipelineExecutor):
         command: str,
         map_variable: TypeMapVariable = None,
         auto_remove_container: bool = True,
-        **kwargs,
     ):
         """
         During the flow run, we have to spin up a container with the docker image mentioned
@@ -223,7 +239,6 @@ class LocalContainerExecutor(GenericPipelineExecutor):
 
         try:
             logger.info(f"Running the command {command}")
-            print(command)
             #  Overrides global config with local
             executor_config = self._resolve_executor_config(node)
 

extensions/pipeline_executor/mocked.py

@@ -36,9 +36,7 @@ class MockedExecutor(GenericPipelineExecutor):
     def _context(self):
         return context.run_context
 
-    def execute_from_graph(
-        self, node: BaseNode, map_variable: TypeMapVariable = None, **kwargs
-    ):
+    def execute_from_graph(self, node: BaseNode, map_variable: TypeMapVariable = None):
         """
         This is the entry point to from the graph execution.
 
@@ -80,18 +78,18 @@ class MockedExecutor(GenericPipelineExecutor):
         # If its a terminal node, complete it now
         if node.node_type in ["success", "fail"]:
             self._context.run_log_store.add_step_log(step_log, self._context.run_id)
-            self._execute_node(node, map_variable=map_variable, **kwargs)
+            self._execute_node(node, map_variable=map_variable)
             return
 
         # We call an internal function to iterate the sub graphs and execute them
         if node.is_composite:
             self._context.run_log_store.add_step_log(step_log, self._context.run_id)
-            node.execute_as_graph(map_variable=map_variable, **kwargs)
+            node.execute_as_graph(map_variable=map_variable)
             return
 
         if node.name not in self.patches:
             # node is not patched, so mock it
-            self._execute_node(node, map_variable=map_variable, mock=True, **kwargs)
+            self._execute_node(node, map_variable=map_variable, mock=True)
         else:
             # node is patched
             # command as the patch value
@@ -103,9 +101,7 @@ class MockedExecutor(GenericPipelineExecutor):
                 node_name=node.name,
             )
             node_to_send.executable = executable
-            self._execute_node(
-                node_to_send, map_variable=map_variable, mock=False, **kwargs
-            )
+            self._execute_node(node_to_send, map_variable=map_variable, mock=False)
 
     def _resolve_executor_config(self, node: BaseNode):
         """
@@ -144,9 +140,7 @@ class MockedExecutor(GenericPipelineExecutor):
 
         return effective_node_config
 
-    def execute_node(
-        self, node: BaseNode, map_variable: TypeMapVariable = None, **kwargs
-    ):
+    def execute_node(self, node: BaseNode, map_variable: TypeMapVariable = None):
         """
         The entry point for all executors apart from local.
         We have already prepared for node execution.

extensions/pipeline_executor/retry.py

@@ -63,9 +63,7 @@ class RetryExecutor(GenericPipelineExecutor):
         # Should the parameters be copied from previous execution
         # self._set_up_for_re_run(params=params)
 
-    def execute_from_graph(
-        self, node: BaseNode, map_variable: TypeMapVariable = None, **kwargs
-    ):
+    def execute_from_graph(self, node: BaseNode, map_variable: TypeMapVariable = None):
         """
         This is the entry point to from the graph execution.
 
@@ -103,7 +101,7 @@ class RetryExecutor(GenericPipelineExecutor):
         # If its a terminal node, complete it now
         if node.node_type in ["success", "fail"]:
             self._context.run_log_store.add_step_log(step_log, self._context.run_id)
-            self._execute_node(node, map_variable=map_variable, **kwargs)
+            self._execute_node(node, map_variable=map_variable)
             return
 
         # In retry step
@@ -118,12 +116,12 @@ class RetryExecutor(GenericPipelineExecutor):
         # We call an internal function to iterate the sub graphs and execute them
         if node.is_composite:
             self._context.run_log_store.add_step_log(step_log, self._context.run_id)
-            node.execute_as_graph(map_variable=map_variable, **kwargs)
+            node.execute_as_graph(map_variable=map_variable)
             return
 
         # Executor specific way to trigger a job
         self._context.run_log_store.add_step_log(step_log, self._context.run_id)
-        self.execute_node(node=node, map_variable=map_variable, **kwargs)
+        self.execute_node(node=node, map_variable=map_variable)
 
     def _is_step_eligible_for_rerun(
         self, node: BaseNode, map_variable: TypeMapVariable = None
@@ -174,7 +172,5 @@ class RetryExecutor(GenericPipelineExecutor):
         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_node(self, node: BaseNode, map_variable: TypeMapVariable = None):
+        self._execute_node(node, map_variable=map_variable)

extensions/run_log_store/generic_chunked.py

@@ -318,7 +318,6 @@ class ChunkedRunLogStore(BaseRunLogStore):
         tag: str = "",
         original_run_id: str = "",
         status: str = defaults.CREATED,
-        **kwargs,
     ):
         """
         Creates a Run Log object by using the config
@@ -549,7 +548,7 @@ class ChunkedRunLogStore(BaseRunLogStore):
         )
 
     def get_branch_log(
-        self, internal_branch_name: str, run_id: str, **kwargs
+        self, internal_branch_name: str, run_id: str
     ) -> Union[BranchLog, RunLog]:
         """
         Returns the branch log by the internal branch name for the run id

extensions/secrets/dotenv.py

@@ -37,7 +37,7 @@ class DotEnvSecrets(BaseSecrets):
         """
         self.secrets = dotenv_values(self.secrets_location)
 
-    def get(self, name: str = "", **kwargs) -> str:
+    def get(self, name: str = "") -> str:
         """
         Get a secret of name from the secrets file.
 

runnable/__init__.py

@@ -31,6 +31,7 @@ from runnable.sdk import (  # noqa
     ShellTask,
     Stub,
     Success,
+    Torch,
     metric,
     pickled,
 )

runnable/executor.py

@@ -107,7 +107,7 @@ class BaseJobExecutor(BaseExecutor):
         ...
 
     @abstractmethod
-    def add_code_identities(self, job_log: JobLog, **kwargs):
+    def add_code_identities(self, job_log: JobLog):
         """
         Add code identities specific to the implementation.
 
@@ -156,12 +156,12 @@ class BaseJobExecutor(BaseExecutor):
 # TODO: Consolidate execute_node, trigger_node_execution, _execute_node
 class BasePipelineExecutor(BaseExecutor):
     service_type: str = "pipeline_executor"
-    overrides: dict = {}
+    overrides: dict[str, Any] = {}
 
     _context_node: Optional[BaseNode] = PrivateAttr(default=None)
 
     @abstractmethod
-    def add_code_identities(self, node: BaseNode, step_log: StepLog, **kwargs):
+    def add_code_identities(self, node: BaseNode, step_log: StepLog):
         """
         Add code identities specific to the implementation.
 
@@ -204,7 +204,6 @@ class BasePipelineExecutor(BaseExecutor):
         node: BaseNode,
         map_variable: TypeMapVariable = None,
         mock: bool = False,
-        **kwargs,
     ):
         """
         This is the entry point when we do the actual execution of the function.
@@ -227,9 +226,7 @@ class BasePipelineExecutor(BaseExecutor):
         ...
 
     @abstractmethod
-    def execute_node(
-        self, node: BaseNode, map_variable: TypeMapVariable = None, **kwargs
-    ):
+    def execute_node(self, node: BaseNode, map_variable: TypeMapVariable = None):
         """
         The entry point for all executors apart from local.
         We have already prepared for node execution.
@@ -244,9 +241,7 @@ class BasePipelineExecutor(BaseExecutor):
         ...
 
     @abstractmethod
-    def execute_from_graph(
-        self, node: BaseNode, map_variable: TypeMapVariable = None, **kwargs
-    ):
+    def execute_from_graph(self, node: BaseNode, map_variable: TypeMapVariable = None):
         """
         This is the entry point to from the graph execution.
 
@@ -294,7 +289,7 @@ class BasePipelineExecutor(BaseExecutor):
         ...
 
     @abstractmethod
-    def execute_graph(self, dag: Graph, map_variable: TypeMapVariable = None, **kwargs):
+    def execute_graph(self, dag: Graph, map_variable: TypeMapVariable = None):
         """
         The parallelization is controlled by the nodes and not by this function.
 
@@ -395,7 +390,7 @@ class BasePipelineExecutor(BaseExecutor):
 
     @abstractmethod
     def trigger_node_execution(
-        self, node: BaseNode, map_variable: TypeMapVariable = None, **kwargs
+        self, node: BaseNode, map_variable: TypeMapVariable = None
     ):
         """
         Executor specific way of triggering jobs when runnable does both traversal and execution