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()

```

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
     ++++++++

{"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"}]}