prompt: We are currently solving the following issue within our repository. Here is the issue text:
  --- BEGIN ISSUE ---
  operations: io: Fixup example
  https://github.com/intel/dffml/blob/c0946b2d212239cfe4e470e63ab3da22c9cd97c4/dffml/operation/io.py#L116
  
  copy the code here into a Python file and format it with black, then copy it back.
  
  We also want to change
  
  ```python
      ...         definition=dataflow.definitions["DataToPrint"],
      ...         parents=None,)]
  ```
  
  to
  
  ```python
      ...         definition=print_output.inputs["data"],
      ...     )
      ... ]
  ```
  
  --- END ISSUE ---
  
  Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
  --- BEGIN FILES ---
  Path: `dffml/operation/preprocess.py`
  Content:
  ```
  1 import ast
  2 from dffml.df.types import Definition
  3 from dffml.df.base import op
  4 
  5 
  6 # Definitions
  7 InputStr = Definition(name="InputStr", primitive="str")
  8 EvaluatedStr = Definition(name="EvaluatedStr", primitive="generic")
  9 
  10 
  11 @op(
  12     inputs={"str_to_eval": InputStr},
  13     outputs={"str_after_eval": EvaluatedStr},
  14     conditions=[],
  15 )
  16 async def literal_eval(str_to_eval: str):
  17     """
  18     Evaluate the input using ast.literal_eval()
  19 
  20     Parameters
  21     ++++++++++
  22     inputs : str
  23         A string to be evaluated.
  24 
  25     Returns
  26     +++++++
  27     A python literal.
  28 
  29     Examples
  30     ++++++++
  31 
  32     The following example shows how to use literal_eval.
  33 
  34     >>> dataflow = DataFlow.auto(literal_eval, GetSingle)
  35     >>> dataflow.seed.append(
  36     ...    Input(
  37     ...        value=[literal_eval.op.outputs["str_after_eval"].name,],
  38     ...        definition=GetSingle.op.inputs["spec"],
  39     ...    )
  40     ... )
  41     >>> inputs = [
  42     ...    Input(
  43     ...        value="[1,2,3]",
  44     ...        definition=literal_eval.op.inputs["str_to_eval"],
  45     ...        parents=None,
  46     ...    )
  47     ... ]
  48     >>>
  49     >>> async def main():
  50     ...     async for ctx, results in MemoryOrchestrator.run(dataflow, inputs):
  51     ...         print(results)
  52     >>>
  53     >>> asyncio.run(main())
  54     {'EvaluatedStr': [1, 2, 3]}
  55     """
  56     value = ast.literal_eval(str_to_eval)
  57     return {"str_after_eval": value}
  58
  ```
  
  Path: `dffml/operation/io.py`
  Content:
  ```
  1 import asyncio
  2 import concurrent.futures
  3 from typing import Dict, Any
  4 
  5 from dffml.df.types import Operation, Definition
  6 from dffml.df.base import (
  7     op,
  8     OperationImplementationContext,
  9     OperationImplementation,
  10 )
  11 
  12 
  13 # Definitions
  14 UserInput = Definition(name="UserInput", primitive="str")
  15 DataToPrint = Definition(name="DataToPrint", primitive="str")
  16 
  17 AcceptUserInput = Operation(
  18     name="AcceptUserInput",
  19     inputs={},
  20     outputs={"InputData": UserInput},
  21     conditions=[],
  22 )
  23 
  24 
  25 class AcceptUserInputContext(OperationImplementationContext):
  26     @staticmethod
  27     def receive_input():
  28         print("Enter the value: ", end="")
  29         return input()
  30 
  31     async def run(self, inputs: Dict[str, Any]) -> Dict[str, Any]:
  32         user_input = await self.parent.loop.run_in_executor(
  33             self.parent.pool, self.receive_input
  34         )
  35         return {"InputData": user_input}
  36 
  37 
  38 class AcceptUserInput(OperationImplementation):
  39     """
  40     Accept input from stdin using python input()
  41 
  42     Parameters
  43     ++++++++++
  44     inputs : dict
  45         A dictionary with a key and empty list as value.
  46 
  47     Returns
  48     +++++++
  49     dict
  50         A dictionary containing user input.
  51 
  52     Examples
  53     ++++++++
  54 
  55     The following example shows how to use AcceptUserInput.
  56     (Assumes that the input from stdio is "Data flow is awesome"!)
  57 
  58     >>> dataflow = DataFlow.auto(AcceptUserInput, GetSingle)
  59     >>> dataflow.seed.append(
  60     ...     Input(
  61     ...         value=[AcceptUserInput.op.outputs["InputData"].name],
  62     ...         definition=GetSingle.op.inputs["spec"]
  63     ...     )
  64     ... )
  65     >>>
  66     >>> async def main():
  67     ...     async for ctx, results in MemoryOrchestrator.run(dataflow, {"input":[]}):
  68     ...         print(results)
  69     >>>
  70     >>> asyncio.run(main())
  71     Enter the value: {'UserInput': 'Data flow is awesome'}
  72     """
  73 
  74     op = AcceptUserInput
  75     CONTEXT = AcceptUserInputContext
  76 
  77     def __init__(self, *args, **kwargs):
  78         super().__init__(*args, **kwargs)
  79         self.loop = None
  80         self.pool = None
  81         self.__pool = None
  82 
  83     async def __aenter__(self) -> "OperationImplementationContext":
  84         self.loop = asyncio.get_event_loop()
  85         self.pool = concurrent.futures.ThreadPoolExecutor()
  86         self.__pool = self.pool.__enter__()
  87         return self
  88 
  89     async def __aexit__(self, exc_type, exc_value, traceback):
  90         self.__pool.__exit__(exc_type, exc_value, traceback)
  91         self.__pool = None
  92         self.pool = None
  93         self.loop = None
  94 
  95 
  96 @op(inputs={"data": DataToPrint}, outputs={}, conditions=[])
  97 async def print_output(data: str):
  98     """
  99     Print the output on stdout using python print()
  100 
  101     Parameters
  102     ++++++++++
  103     inputs : list
  104         A list of Inputs whose value is to be printed.
  105 
  106     Examples
  107     ++++++++
  108 
  109     The following example shows how to use print_output.
  110 
  111     >>> dataflow = DataFlow.auto(print_output, GetSingle)
  112     >>> inputs = [
  113     ...     Input(
  114     ...         value="print_output example",
  115     ...         definition=dataflow.definitions["DataToPrint"],
  116     ...         parents=None,)]
  117     >>>
  118     >>> async def main():
  119     ...     async for ctx, results in MemoryOrchestrator.run(dataflow, inputs):
  120     ...         print("String to be printed is 'print_output example'")
  121     >>>
  122     >>> asyncio.run(main())
  123     print_output example
  124     String to be printed is 'print_output example'
  125     """
  126     print(data)
  127
  ```
  --- END FILES ---
  
  Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.
  
  Here is an example:
  
  ```diff
  diff --git a/examples/server_async.py b/examples/server_async.py
  --- a/examples/server_async.py
  +++ b/examples/server_async.py
  @@ -313,4 +313,4 @@
   
   
   if __name__ == "__main__":
  -    asyncio.run(run_async_server("."), debug=True)
  +    asyncio.run(run_async_server(), debug=True)
  diff --git a/examples/server_sync.py b/examples/server_sync.py
  --- a/examples/server_sync.py
  +++ b/examples/server_sync.py
  @@ -313,5 +313,5 @@
   
   
   if __name__ == "__main__":
  -    server = run_sync_server(".")
  +    server = run_sync_server()
       server.shutdown()
  
  ```
  
golden_diff: diff --git a/dffml/operation/io.py b/dffml/operation/io.py
  --- a/dffml/operation/io.py
  +++ b/dffml/operation/io.py
  @@ -12,7 +12,7 @@
   
   # Definitions
   UserInput = Definition(name="UserInput", primitive="str")
  -DataToPrint = Definition(name="DataToPrint", primitive="str")
  +DataToPrint = Definition(name="DataToPrint", primitive="generic")
   
   AcceptUserInput = Operation(
       name="AcceptUserInput",
  @@ -39,11 +39,6 @@
       """
       Accept input from stdin using python input()
   
  -    Parameters
  -    ++++++++++
  -    inputs : dict
  -        A dictionary with a key and empty list as value.
  -
       Returns
       +++++++
       dict
  @@ -59,12 +54,12 @@
       >>> dataflow.seed.append(
       ...     Input(
       ...         value=[AcceptUserInput.op.outputs["InputData"].name],
  -    ...         definition=GetSingle.op.inputs["spec"]
  +    ...         definition=GetSingle.op.inputs["spec"],
       ...     )
       ... )
       >>>
       >>> async def main():
  -    ...     async for ctx, results in MemoryOrchestrator.run(dataflow, {"input":[]}):
  +    ...     async for ctx, results in MemoryOrchestrator.run(dataflow, {"input": []}):
       ...         print(results)
       >>>
       >>> asyncio.run(main())
  @@ -94,33 +89,32 @@
   
   
   @op(inputs={"data": DataToPrint}, outputs={}, conditions=[])
  -async def print_output(data: str):
  +async def print_output(data: Any):
       """
       Print the output on stdout using python print()
   
       Parameters
       ++++++++++
  -    inputs : list
  -        A list of Inputs whose value is to be printed.
  +    data : Any
  +        A python literal to be printed.
   
       Examples
       ++++++++
   
       The following example shows how to use print_output.
   
  -    >>> dataflow = DataFlow.auto(print_output, GetSingle)
  +    >>> dataflow = DataFlow.auto(print_output)
       >>> inputs = [
       ...     Input(
  -    ...         value="print_output example",
  -    ...         definition=dataflow.definitions["DataToPrint"],
  -    ...         parents=None,)]
  +    ...         value="print_output example", definition=print_output.op.inputs["data"]
  +    ...     )
  +    ... ]
       >>>
       >>> async def main():
       ...     async for ctx, results in MemoryOrchestrator.run(dataflow, inputs):
  -    ...         print("String to be printed is 'print_output example'")
  +    ...         pass
       >>>
       >>> asyncio.run(main())
       print_output example
  -    String to be printed is 'print_output example'
       """
       print(data)
  diff --git a/dffml/operation/preprocess.py b/dffml/operation/preprocess.py
  --- a/dffml/operation/preprocess.py
  +++ b/dffml/operation/preprocess.py
  @@ -19,12 +19,13 @@
   
       Parameters
       ++++++++++
  -    inputs : str
  +    str_to_eval : str
           A string to be evaluated.
   
       Returns
       +++++++
  -    A python literal.
  +    dict
  +        A dict containing python literal.
   
       Examples
       ++++++++
  
verification_info: {"golden_diff": "diff --git a/dffml/operation/io.py b/dffml/operation/io.py\n--- a/dffml/operation/io.py\n+++ b/dffml/operation/io.py\n@@ -12,7 +12,7 @@\n \n # Definitions\n UserInput = Definition(name=\"UserInput\", primitive=\"str\")\n-DataToPrint = Definition(name=\"DataToPrint\", primitive=\"str\")\n+DataToPrint = Definition(name=\"DataToPrint\", primitive=\"generic\")\n \n AcceptUserInput = Operation(\n     name=\"AcceptUserInput\",\n@@ -39,11 +39,6 @@\n     \"\"\"\n     Accept input from stdin using python input()\n \n-    Parameters\n-    ++++++++++\n-    inputs : dict\n-        A dictionary with a key and empty list as value.\n-\n     Returns\n     +++++++\n     dict\n@@ -59,12 +54,12 @@\n     >>> dataflow.seed.append(\n     ...     Input(\n     ...         value=[AcceptUserInput.op.outputs[\"InputData\"].name],\n-    ...         definition=GetSingle.op.inputs[\"spec\"]\n+    ...         definition=GetSingle.op.inputs[\"spec\"],\n     ...     )\n     ... )\n     >>>\n     >>> async def main():\n-    ...     async for ctx, results in MemoryOrchestrator.run(dataflow, {\"input\":[]}):\n+    ...     async for ctx, results in MemoryOrchestrator.run(dataflow, {\"input\": []}):\n     ...         print(results)\n     >>>\n     >>> asyncio.run(main())\n@@ -94,33 +89,32 @@\n \n \n @op(inputs={\"data\": DataToPrint}, outputs={}, conditions=[])\n-async def print_output(data: str):\n+async def print_output(data: Any):\n     \"\"\"\n     Print the output on stdout using python print()\n \n     Parameters\n     ++++++++++\n-    inputs : list\n-        A list of Inputs whose value is to be printed.\n+    data : Any\n+        A python literal to be printed.\n \n     Examples\n     ++++++++\n \n     The following example shows how to use print_output.\n \n-    >>> dataflow = DataFlow.auto(print_output, GetSingle)\n+    >>> dataflow = DataFlow.auto(print_output)\n     >>> inputs = [\n     ...     Input(\n-    ...         value=\"print_output example\",\n-    ...         definition=dataflow.definitions[\"DataToPrint\"],\n-    ...         parents=None,)]\n+    ...         value=\"print_output example\", definition=print_output.op.inputs[\"data\"]\n+    ...     )\n+    ... ]\n     >>>\n     >>> async def main():\n     ...     async for ctx, results in MemoryOrchestrator.run(dataflow, inputs):\n-    ...         print(\"String to be printed is 'print_output example'\")\n+    ...         pass\n     >>>\n     >>> asyncio.run(main())\n     print_output example\n-    String to be printed is 'print_output example'\n     \"\"\"\n     print(data)\ndiff --git a/dffml/operation/preprocess.py b/dffml/operation/preprocess.py\n--- a/dffml/operation/preprocess.py\n+++ b/dffml/operation/preprocess.py\n@@ -19,12 +19,13 @@\n \n     Parameters\n     ++++++++++\n-    inputs : str\n+    str_to_eval : str\n         A string to be evaluated.\n \n     Returns\n     +++++++\n-    A python literal.\n+    dict\n+        A dict containing python literal.\n \n     Examples\n     ++++++++\n", "issue": "operations: io: Fixup example\nhttps://github.com/intel/dffml/blob/c0946b2d212239cfe4e470e63ab3da22c9cd97c4/dffml/operation/io.py#L116\r\n\r\ncopy the code here into a Python file and format it with black, then copy it back.\r\n\r\nWe also want to change\r\n\r\n```python\r\n    ...         definition=dataflow.definitions[\"DataToPrint\"],\r\n    ...         parents=None,)]\r\n```\r\n\r\nto\r\n\r\n```python\r\n    ...         definition=print_output.inputs[\"data\"],\r\n    ...     )\r\n    ... ]\r\n```\n", "before_files": [{"content": "import ast\nfrom dffml.df.types import Definition\nfrom dffml.df.base import op\n\n\n# Definitions\nInputStr = Definition(name=\"InputStr\", primitive=\"str\")\nEvaluatedStr = Definition(name=\"EvaluatedStr\", primitive=\"generic\")\n\n\n@op(\n    inputs={\"str_to_eval\": InputStr},\n    outputs={\"str_after_eval\": EvaluatedStr},\n    conditions=[],\n)\nasync def literal_eval(str_to_eval: str):\n    \"\"\"\n    Evaluate the input using ast.literal_eval()\n\n    Parameters\n    ++++++++++\n    inputs : str\n        A string to be evaluated.\n\n    Returns\n    +++++++\n    A python literal.\n\n    Examples\n    ++++++++\n\n    The following example shows how to use literal_eval.\n\n    >>> dataflow = DataFlow.auto(literal_eval, GetSingle)\n    >>> dataflow.seed.append(\n    ...    Input(\n    ...        value=[literal_eval.op.outputs[\"str_after_eval\"].name,],\n    ...        definition=GetSingle.op.inputs[\"spec\"],\n    ...    )\n    ... )\n    >>> inputs = [\n    ...    Input(\n    ...        value=\"[1,2,3]\",\n    ...        definition=literal_eval.op.inputs[\"str_to_eval\"],\n    ...        parents=None,\n    ...    )\n    ... ]\n    >>>\n    >>> async def main():\n    ...     async for ctx, results in MemoryOrchestrator.run(dataflow, inputs):\n    ...         print(results)\n    >>>\n    >>> asyncio.run(main())\n    {'EvaluatedStr': [1, 2, 3]}\n    \"\"\"\n    value = ast.literal_eval(str_to_eval)\n    return {\"str_after_eval\": value}\n", "path": "dffml/operation/preprocess.py"}, {"content": "import asyncio\nimport concurrent.futures\nfrom typing import Dict, Any\n\nfrom dffml.df.types import Operation, Definition\nfrom dffml.df.base import (\n    op,\n    OperationImplementationContext,\n    OperationImplementation,\n)\n\n\n# Definitions\nUserInput = Definition(name=\"UserInput\", primitive=\"str\")\nDataToPrint = Definition(name=\"DataToPrint\", primitive=\"str\")\n\nAcceptUserInput = Operation(\n    name=\"AcceptUserInput\",\n    inputs={},\n    outputs={\"InputData\": UserInput},\n    conditions=[],\n)\n\n\nclass AcceptUserInputContext(OperationImplementationContext):\n    @staticmethod\n    def receive_input():\n        print(\"Enter the value: \", end=\"\")\n        return input()\n\n    async def run(self, inputs: Dict[str, Any]) -> Dict[str, Any]:\n        user_input = await self.parent.loop.run_in_executor(\n            self.parent.pool, self.receive_input\n        )\n        return {\"InputData\": user_input}\n\n\nclass AcceptUserInput(OperationImplementation):\n    \"\"\"\n    Accept input from stdin using python input()\n\n    Parameters\n    ++++++++++\n    inputs : dict\n        A dictionary with a key and empty list as value.\n\n    Returns\n    +++++++\n    dict\n        A dictionary containing user input.\n\n    Examples\n    ++++++++\n\n    The following example shows how to use AcceptUserInput.\n    (Assumes that the input from stdio is \"Data flow is awesome\"!)\n\n    >>> dataflow = DataFlow.auto(AcceptUserInput, GetSingle)\n    >>> dataflow.seed.append(\n    ...     Input(\n    ...         value=[AcceptUserInput.op.outputs[\"InputData\"].name],\n    ...         definition=GetSingle.op.inputs[\"spec\"]\n    ...     )\n    ... )\n    >>>\n    >>> async def main():\n    ...     async for ctx, results in MemoryOrchestrator.run(dataflow, {\"input\":[]}):\n    ...         print(results)\n    >>>\n    >>> asyncio.run(main())\n    Enter the value: {'UserInput': 'Data flow is awesome'}\n    \"\"\"\n\n    op = AcceptUserInput\n    CONTEXT = AcceptUserInputContext\n\n    def __init__(self, *args, **kwargs):\n        super().__init__(*args, **kwargs)\n        self.loop = None\n        self.pool = None\n        self.__pool = None\n\n    async def __aenter__(self) -> \"OperationImplementationContext\":\n        self.loop = asyncio.get_event_loop()\n        self.pool = concurrent.futures.ThreadPoolExecutor()\n        self.__pool = self.pool.__enter__()\n        return self\n\n    async def __aexit__(self, exc_type, exc_value, traceback):\n        self.__pool.__exit__(exc_type, exc_value, traceback)\n        self.__pool = None\n        self.pool = None\n        self.loop = None\n\n\n@op(inputs={\"data\": DataToPrint}, outputs={}, conditions=[])\nasync def print_output(data: str):\n    \"\"\"\n    Print the output on stdout using python print()\n\n    Parameters\n    ++++++++++\n    inputs : list\n        A list of Inputs whose value is to be printed.\n\n    Examples\n    ++++++++\n\n    The following example shows how to use print_output.\n\n    >>> dataflow = DataFlow.auto(print_output, GetSingle)\n    >>> inputs = [\n    ...     Input(\n    ...         value=\"print_output example\",\n    ...         definition=dataflow.definitions[\"DataToPrint\"],\n    ...         parents=None,)]\n    >>>\n    >>> async def main():\n    ...     async for ctx, results in MemoryOrchestrator.run(dataflow, inputs):\n    ...         print(\"String to be printed is 'print_output example'\")\n    >>>\n    >>> asyncio.run(main())\n    print_output example\n    String to be printed is 'print_output example'\n    \"\"\"\n    print(data)\n", "path": "dffml/operation/io.py"}], "after_files": [{"content": "import ast\nfrom dffml.df.types import Definition\nfrom dffml.df.base import op\n\n\n# Definitions\nInputStr = Definition(name=\"InputStr\", primitive=\"str\")\nEvaluatedStr = Definition(name=\"EvaluatedStr\", primitive=\"generic\")\n\n\n@op(\n    inputs={\"str_to_eval\": InputStr},\n    outputs={\"str_after_eval\": EvaluatedStr},\n    conditions=[],\n)\nasync def literal_eval(str_to_eval: str):\n    \"\"\"\n    Evaluate the input using ast.literal_eval()\n\n    Parameters\n    ++++++++++\n    str_to_eval : str\n        A string to be evaluated.\n\n    Returns\n    +++++++\n    dict\n        A dict containing python literal.\n\n    Examples\n    ++++++++\n\n    The following example shows how to use literal_eval.\n\n    >>> dataflow = DataFlow.auto(literal_eval, GetSingle)\n    >>> dataflow.seed.append(\n    ...    Input(\n    ...        value=[literal_eval.op.outputs[\"str_after_eval\"].name,],\n    ...        definition=GetSingle.op.inputs[\"spec\"],\n    ...    )\n    ... )\n    >>> inputs = [\n    ...    Input(\n    ...        value=\"[1,2,3]\",\n    ...        definition=literal_eval.op.inputs[\"str_to_eval\"],\n    ...        parents=None,\n    ...    )\n    ... ]\n    >>>\n    >>> async def main():\n    ...     async for ctx, results in MemoryOrchestrator.run(dataflow, inputs):\n    ...         print(results)\n    >>>\n    >>> asyncio.run(main())\n    {'EvaluatedStr': [1, 2, 3]}\n    \"\"\"\n    value = ast.literal_eval(str_to_eval)\n    return {\"str_after_eval\": value}\n", "path": "dffml/operation/preprocess.py"}, {"content": "import asyncio\nimport concurrent.futures\nfrom typing import Dict, Any\n\nfrom dffml.df.types import Operation, Definition\nfrom dffml.df.base import (\n    op,\n    OperationImplementationContext,\n    OperationImplementation,\n)\n\n\n# Definitions\nUserInput = Definition(name=\"UserInput\", primitive=\"str\")\nDataToPrint = Definition(name=\"DataToPrint\", primitive=\"generic\")\n\nAcceptUserInput = Operation(\n    name=\"AcceptUserInput\",\n    inputs={},\n    outputs={\"InputData\": UserInput},\n    conditions=[],\n)\n\n\nclass AcceptUserInputContext(OperationImplementationContext):\n    @staticmethod\n    def receive_input():\n        print(\"Enter the value: \", end=\"\")\n        return input()\n\n    async def run(self, inputs: Dict[str, Any]) -> Dict[str, Any]:\n        user_input = await self.parent.loop.run_in_executor(\n            self.parent.pool, self.receive_input\n        )\n        return {\"InputData\": user_input}\n\n\nclass AcceptUserInput(OperationImplementation):\n    \"\"\"\n    Accept input from stdin using python input()\n\n    Returns\n    +++++++\n    dict\n        A dictionary containing user input.\n\n    Examples\n    ++++++++\n\n    The following example shows how to use AcceptUserInput.\n    (Assumes that the input from stdio is \"Data flow is awesome\"!)\n\n    >>> dataflow = DataFlow.auto(AcceptUserInput, GetSingle)\n    >>> dataflow.seed.append(\n    ...     Input(\n    ...         value=[AcceptUserInput.op.outputs[\"InputData\"].name],\n    ...         definition=GetSingle.op.inputs[\"spec\"],\n    ...     )\n    ... )\n    >>>\n    >>> async def main():\n    ...     async for ctx, results in MemoryOrchestrator.run(dataflow, {\"input\": []}):\n    ...         print(results)\n    >>>\n    >>> asyncio.run(main())\n    Enter the value: {'UserInput': 'Data flow is awesome'}\n    \"\"\"\n\n    op = AcceptUserInput\n    CONTEXT = AcceptUserInputContext\n\n    def __init__(self, *args, **kwargs):\n        super().__init__(*args, **kwargs)\n        self.loop = None\n        self.pool = None\n        self.__pool = None\n\n    async def __aenter__(self) -> \"OperationImplementationContext\":\n        self.loop = asyncio.get_event_loop()\n        self.pool = concurrent.futures.ThreadPoolExecutor()\n        self.__pool = self.pool.__enter__()\n        return self\n\n    async def __aexit__(self, exc_type, exc_value, traceback):\n        self.__pool.__exit__(exc_type, exc_value, traceback)\n        self.__pool = None\n        self.pool = None\n        self.loop = None\n\n\n@op(inputs={\"data\": DataToPrint}, outputs={}, conditions=[])\nasync def print_output(data: Any):\n    \"\"\"\n    Print the output on stdout using python print()\n\n    Parameters\n    ++++++++++\n    data : Any\n        A python literal to be printed.\n\n    Examples\n    ++++++++\n\n    The following example shows how to use print_output.\n\n    >>> dataflow = DataFlow.auto(print_output)\n    >>> inputs = [\n    ...     Input(\n    ...         value=\"print_output example\", definition=print_output.op.inputs[\"data\"]\n    ...     )\n    ... ]\n    >>>\n    >>> async def main():\n    ...     async for ctx, results in MemoryOrchestrator.run(dataflow, inputs):\n    ...         pass\n    >>>\n    >>> asyncio.run(main())\n    print_output example\n    \"\"\"\n    print(data)\n", "path": "dffml/operation/io.py"}]}