so

return pipeline(
    [
      node(
        func=lambda: outer(inner),
        inputs=None,
        outputs="some_string",
      )
    ]
  )

or, in the case of 1 dataset input,

return pipeline(
    [
      node(
        func=lambda input1: outer(input1, func=inner),
        inputs="dataset1",
        outputs="some_string",
      )
    ]
  )

does this look like a reasonable workaround? unfortunately

node(inputs=)

only supports dataset names and param specifications (cc @Nok Lam Chan)

Maybe the whole question resulted from a (maybe)misconception of mine: I have self defined class with some init parameters (incl. functions like in my original question) and a bunch of methods. I now want to utilize kedro to create an object from that class (now solved with your help) and then triggering this classes'/object's methods in other nodes. It does not seem that kedro was created for that kind of usage, or am I missing something key?

Im trying to understand your usecase, and this is what I get from it: 1. You want to create a class object using regular

__init__

2. The

__init__

takes both strings and Callables 3. You want to call class methods of your instantiated class 4. These class methods may also take arguments --- Here is a full example I made according to those points, using 2 classes and different ways of passing your lambda methods.. Gets complex quite quickly I guess but does it do what you want @fmfreeze ? It is a runnable example.

from typing import Callable

from kedro.pipeline import node, Pipeline, pipeline

class YourCustomClass:
  """This class joins strings from multiple sources."""
  def __init__(self, a_string, a_callable):
      self.a_string = a_string
      self.a_callable = a_callable

  def create_output(self, an_extra_string):
    """Returns `a_string`, `a_callable()` and `an_extra_string` joined with spaces."""
    return " ".join([self.a_string, self.a_callable(), an_extra_string])


def create_a_string():
    return "Hello"

def create_my_class(a_string, a_callable):
    return YourCustomClass(a_string, a_callable)

def get_class_output(my_class: YourCustomClass, extra_string: str) -> str:
    result = my_class.create_output(an_extra_string=extra_string)
    print(f"Node output is:\t{result}")
    return result

def create_world_callable() -> str:
    return "World"

def kedro_community_callable() -> str:
    return "Kedro Community"

def create_kedro_callable() -> Callable:
    """Function returns a callable"""
    return kedro_community_callable

def create_smiley_string() -> str:
    return ":)"

def create_wave_string() -> str:
    """Smiley that waves"""
    return "o/"

def create_pipeline(**kwargs) -> Pipeline:
  return pipeline([
      ## Create YourClass__init__() arguments as datasets including callables
      node(func=create_a_string, inputs=None, outputs="hello_string"),
      node(func=create_kedro_callable, inputs=None, outputs="kedro_callable"),  # callable from another function
      node(func=lambda: lambda: "World", inputs=None, outputs="world_callable"),  # callable as a lambda function
      ## Create class objects
      node(
           func=create_my_class,
           inputs=dict(a_string="hello_string", a_callable="world_callable"),
           outputs="hello_world_class"
       ),
      node(
          func=create_my_class,
          inputs=dict(a_string="hello_string", a_callable="kedro_callable"),
          outputs="hello_kedro_class"
      ),
      ## Create additional input to your class methods
      node(func=create_smiley_string, inputs=None, outputs="smiley_string"),
      node(func=create_wave_string, inputs=None, outputs="wave_string"),
      ## Call class methods
      node(
          func=get_class_output,
          inputs=dict(my_class="hello_world_class", extra_string="smiley_string"),
          outputs="hello_world_output"
      ),
      node(
          func=get_class_output,
          inputs=dict(my_class="hello_kedro_class", extra_string="wave_string"),
          outputs="hello_kedro_output"
      ),
  ])

The pipeline is essentially 2 similar pipelines at the same time - see the

kedro viz

output in these screenshots:" 1. partial pipeline of just 1 class 2. the whole pipeline as defined above