def send_telemetry(event_name, properties=None):
    try:
        if properties == None:
            properties = {}
        properties["oi_version"] = pkg_resources.get_distribution(
            "open-interpreter"
        ).version
        with open(os.devnull, "w") as f, contextlib.redirect_stdout(
            f
        ), contextlib.redirect_stderr(f):
            posthog.capture(user_id, event_name, properties)
    except:
        pass
send_telemetry(event_name='started_chat', properties={'in_terminal_interface': False, 'message_type': 'str', 'os_mode': False})

{'in_terminal_interface': False, 'message_type': 'str', 'os_mode': False, 'oi_version': '0.2.0'}

{'in_terminal_interface': False, 'message_type': 'str', 'os_mode': False, 'oi_version': '0.2.0', '$lib': 'posthog-python', '$lib_version': '3.1.0', '$geoip_disable': True}

<_io.TextIOWrapper name='/dev/null' mode='w' encoding='UTF-8'>


{'in_terminal_interface': False, 'message_type': 'str', 'os_mode': False, 'oi_version': '0.2.0', '$lib': 'posthog-python', '$lib_version': '3.1.0', '$geoip_disable': True}


def preprocess_python(code):
    code = code.strip()
    if not any(line.strip().startswith(("!", "%")) for line in code.split("\n")):
        code = add_active_line_prints(code)
    code_lines = code.split("\n")
    code_lines = [c for c in code_lines if c.strip() != ""]
    code = "\n".join(code_lines)
    return code
preprocess_python(code="\n        import matplotlib\n        matplotlib.use('Agg')\n        ")

"import matplotlib\n        matplotlib.use('Agg')"


def add_active_line_prints(code):
    code_lines = code.split("\n")
    in_multiline_string = False
    for i in range(len(code_lines)):
        line = code_lines[i]
        if '"""' in line or "'''" in line:
            in_multiline_string = not in_multiline_string
        if not in_multiline_string and (line.strip().startswith("
            whitespace = len(line) - len(line.lstrip(" "))
            code_lines[i] = " " * whitespace + "pass"
    processed_code = "\n".join(code_lines)
    try:
        tree = ast.parse(processed_code)
    except:
        tree = ast.parse(code)
    transformer = AddLinePrints()
    new_tree = transformer.visit(tree)
    return ast.unparse(new_tree)
add_active_line_prints(code="import matplotlib\n        matplotlib.use('Agg')")

['import matplotlib', "        matplotlib.use('Agg')"]


def fixed_litellm_completions(**params):
    first_error = None
    try:
        yield from litellm.completion(**params)
    except Exception as e:
        first_error = e
        if "api key" in str(first_error).lower() and "api_key" not in params:
            print(
                "LiteLLM requires an API key. Please set a dummy API key to prevent this message. (e.g `interpreter --api_key x` or `interpreter.llm.api_key = 'x'`)"
            )
        params["api_key"] = "x"
        try:
            yield from litellm.completion(**params)
        except:
            raise first_error
fixed_litellm_completions(params={'model': 'gpt-3.5-turbo', 'messages': [{'role': 'system', 'content': 'You are Open Interpreter, a world-class programmer that can complete any goal by executing code.\nFirst, write a plan. **Always recap the plan between each code block** (you have extreme short-term memory loss, so you need to recap the plan between each message block to retain it).\nWhen you execute code, it will be executed **on the user\'s machine**. The user has given you **full and complete permission** to execute any code necessary to complete the task. Execute the code.\nIf you want to send data between programming languages, save the data to a txt or json.\nYou can access the internet. Run **any code** to achieve the goal, and if at first you don\'t succeed, try again and again.\nYou can install new packages.\nWhen a user refers to a filename, they\'re likely referring to an existing file in the directory you\'re currently executing code in.\nWrite messages to the user in Markdown.\nIn general, try to **make plans** with as few steps as possible. As for actually executing code to carry out that plan, for *stateful* languages (like python, javascript, shell, but NOT for html which starts from 0 every time) **it\'s critical not to try to do everything in one code block.** You should try something, print information about it, then continue from there in tiny, informed steps. You will never get it on the first try, and attempting it in one go will often lead to errors you cant see.\nYou are capable of **any** task.\n\n[User Info]\n\nName: \'XXX\'\nCWD: \'/local/rcs/XXX/code/pytrace-collector/logs/self_collected/tried/KillianLucas+open-interpreter/KillianLucas+open-interpreter\'\nSHELL: \'/bin/bash\'\nOS: \'Linux\'"\n\nWhen you execute code with `react`, your react code will be run in a script tag after being inserted into the HTML template, following the installation of React, ReactDOM, and Babel for JSX parsing. **We will handle this! Don\'t make an HTML file to run React, just execute `react`.**\nUse ONLY the function you have been provided with — \'execute(language, code)\'.'}, {'role': 'user', 'content': "What's 38023*40334? Use Python\nNo talk or plan, just immediatly code, then tell me the answer."}], 'stream': True, 'functions': [{'name': 'execute', 'description': "Executes code on the user's machine **in the users local environment** and returns the output", 'parameters': {'type': 'object', 'properties': {'language': {'type': 'string', 'description': 'The programming language (required parameter to the `execute` function)', 'enum': ['python', 'shell', 'javascript', 'html', 'applescript', 'r', 'powershell', 'react']}, 'code': {'type': 'string', 'description': 'The code to execute (required)'}}, 'required': ['language', 'code']}}]})

{'model': 'gpt-3.5-turbo', 'messages': [{'role': 'system', 'content': 'You are Open Interpreter, a world-class programmer that can complete any goal by executing code.\nFirst, write a plan. **Always recap the plan between each code block** (you have extreme short-term memory loss, so you need to recap the plan between each message block to retain it).\nWhen you execute code, it will be executed **on the user\'s machine**. The user has given you **full and complete permission** to execute any code necessary to complete the task. Execute the code.\nIf you want to send data between programming languages, save the data to a txt or json.\nYou can access the internet. Run **any code** to achieve the goal, and if at first you don\'t succeed, try again and again.\nYou can install new packages.\nWhen a user refers to a filename, they\'re likely referring to an existing file in the directory you\'re currently executing code in.\nWrite messages to the user in Markdown.\nIn general, try to **make plans** with as few steps as possible. As for actually executing code to carry out that plan, for *stateful* languages (like python, javascript, shell, but NOT for html which starts from 0 every time) **it\'s critical not to try to do everything in one code block.** You should try something, print information about it, then continue from there in tiny, informed steps. You will never get it on the first try, and attempting it in one go will often lead to errors you cant see.\nYou are capable of **any** task.\n\n[User Info]\n\nName: \'XXX\'\nCWD: \'/local/rcs/XXX/code/pytrace-collector/logs/self_collected/tried/KillianLucas+open-interpreter/KillianLucas+open-interpreter\'\nSHELL: \'/bin/bash\'\nOS: \'Linux\'"\n\nWhen you execute code with `react`, your react code will be run in a script tag after being inserted into the HTML template, following the installation of React, ReactDOM, and Babel for JSX parsing. **We will handle this! Don\'t make an HTML file to run React, just execute `react`.**\nUse ONLY the function you have been provided with — \'execute(language, code)\'.'}, {'role': 'user', 'content': "What's 38023*40334? Use Python\nNo talk or plan, just immediatly code, then tell me the answer."}], 'stream': True, 'functions': [{'name': 'execute', 'description': "Executes code on the user's machine **in the users local environment** and returns the output", 'parameters': {'type': 'object', 'properties': {'language': {'type': 'string', 'description': 'The programming language (required parameter to the `execute` function)', 'enum': ['python', 'shell', 'javascript', 'html', 'applescript', 'r', 'powershell', 'react']}, 'code': {'type': 'string', 'description': 'The code to execute (required)'}}, 'required': ['language', 'code']}}], 'api_key': 'x'}

APIError('OpenAIException - The api_key client option must be set either by passing api_key to the client or by setting the OPENAI_API_KEY environment variable')


APIError('OpenAIException - The api_key client option must be set either by passing api_key to the client or by setting the OPENAI_API_KEY environment variable')


def interpreter_info(interpreter):
    try:
        if interpreter.offline and interpreter.llm.api_base:
            try:
                curl = subprocess.check_output(f"curl {interpreter.llm.api_base}")
            except Exception as e:
                curl = str(e)
        else:
            curl = "Not local"
        messages_to_display = []
        for message in interpreter.messages:
            message = message.copy()
            try:
                if len(message["content"]) > 600:
                    message["content"] = (
                        message["content"][:300] + "..." + message["content"][-300:]
                    )
            except Exception as e:
                print(str(e), "for message:", message)
            messages_to_display.append(message)
        return f"""
        Vision: {interpreter.llm.supports_vision}
        Model: {interpreter.llm.model}
        Function calling: {interpreter.llm.supports_functions}
        Context window: {interpreter.llm.context_window}
        Max tokens: {interpreter.llm.max_tokens}
        Auto run: {interpreter.auto_run}
        API base: {interpreter.llm.api_base}
        Offline: {interpreter.offline}
        Curl output: {curl}
        System Message: {interpreter.system_message}

{messages=[{'role': 'user', 'type': 'message', 'content': "What's 38023*40334? Use Python\nNo talk or plan, just immediatly code, then tell me the answer."}], responding=True, last_messages_count=1, offline=False, auto_run=True, verbose=False, max_output=2800, safe_mode='off', shrink_images=False, force_task_completion=False, anonymous_telemetry=True, in_terminal_interface=False, conversation_history=True, conversation_filename=None, conversation_history_path='/home/XXX/.config/Open Interpreter/conversations', os=False, speak_messages=False, llm=<interpreter.core.llm.llm.Llm object at 0x7f3a3bd21b50>, system_message='You are Open Interpreter, a world-class programmer that can complete any goal by executing code.\nFirst, write a plan. **Always recap the plan between each code block** (you have extreme short-term memory loss, so you need to recap the plan between each message block to retain it).\nWhen you execute code, it will be executed **on the user\'s machine**. The user has given you **full and complete permission** to execute any code necessary to complete the task. Execute the code.\nIf you want to send data between programming languages, save the data to a txt or json.\nYou can access the internet. Run **any code** to achieve the goal, and if at first you don\'t succeed, try again and again.\nYou can install new packages.\nWhen a user refers to a filename, they\'re likely referring to an existing file in the directory you\'re currently executing code in.\nWrite messages to the user in Markdown.\nIn general, try to **make plans** with as few steps as possible. As for actually executing code to carry out that plan, for *stateful* languages (like python, javascript, shell, but NOT for html which starts from 0 every time) **it\'s critical not to try to do everything in one code block.** You should try something, print information about it, then continue from there in tiny, informed steps. You will never get it on the first try, and attempting it in one go will often lead to errors you cant see.\nYou are capable of **any** task.\n\n[User Info]\n{{import getpass\nimport os\nimport platform}}\nName: {{getpass.getuser()}}\nCWD: {{os.getcwd()}}\nSHELL: {{os.environ.get(\'SHELL\')}}\nOS: {{platform.system()}}"', custom_instructions='', computer=<interpreter.core.computer.computer.Computer object at 0x7f3ae471f9a0>}


def run_function_calling_llm(llm, request_params):
    function_schema["parameters"]["properties"]["language"]["enum"] = [
        i.name.lower() for i in llm.interpreter.computer.terminal.languages
    ]
    request_params["functions"] = [function_schema]
    request_params["messages"][0][
        "content"
    ] += "\nUse ONLY the function you have been provided with — 'execute(language, code)'."
    accumulated_deltas = {}
    language = None
    code = ""
    for chunk in llm.completions(**request_params):
        if "choices" not in chunk or len(chunk["choices"]) == 0:
            continue
        delta = chunk["choices"][0]["delta"]
        accumulated_deltas = merge_deltas(accumulated_deltas, delta)
        if "content" in delta and delta["content"]:
            yield {"type": "message", "content": delta["content"]}
        if (
            accumulated_deltas.get("function_call")
            and "arguments" in accumulated_deltas["function_call"]
            and accumulated_deltas["function_call"]["arguments"]
        ):
            if (
                "name" in accumulated_deltas["function_call"]
                and accumulated_deltas["function_call"]["name"] == "execute"
            ):
                arguments = accumulated_deltas["function_call"]["arguments"]
                arguments = parse_partial_json(arguments)
                if arguments:
                    if (
                        language is None
                        and "language" in arguments
                        and "code"
                        in arguments
                        and arguments["language"]
                    ):
                        language = arguments["language"]
                    if language is not None and "code" in arguments:
                        code_delta = arguments["code"][len(code) :]
                        code = arguments["code"]
                        if code_delta:
                            yield {
                                "type": "code",
                                "format": language,
                                "content": code_delta,
                            }
                else:
                    if llm.interpreter.verbose:
                        print("Arguments not a dict.")
            elif "name" in accumulated_deltas["function_call"] and (
                accumulated_deltas["function_call"]["name"] == "python"
                or accumulated_deltas["function_call"]["name"] == "functions"
            ):
                if llm.interpreter.verbose:
                    print("Got direct python call")
                if language is None:
                    language = "python"
                if language is not None:
                    code_delta = accumulated_deltas["function_call"]["arguments"][
                        len(code) :
                    ]
                    code = accumulated_deltas["function_call"]["arguments"]
                    if code_delta:
                        yield {
                            "type": "code",
                            "format": language,
                            "content": code_delta,
                        }
            else:
                if "name" in accumulated_deltas["function_call"]:
                    print(
                        "Encountered an unexpected function call: ",
                        accumulated_deltas["function_call"],
                        "\nPlease open an issue and provide the above info at: https://github.com/KillianLucas/open-interpreter",
                    )
run_function_calling_llm(llm={interpreter=<interpreter.core.core.OpenInterpreter object at 0x7f3ae468a0d0>, model='gpt-3.5-turbo', temperature=0, supports_vision=False, supports_functions=None, context_window=300, max_tokens=None, api_base=None, api_key=None, api_version=None, max_budget=None}, request_params={'model': 'gpt-3.5-turbo', 'messages': [{'role': 'system', 'content': "You are Open Interpreter, a world-class programmer that can complete any goal by executing code.\nFirst, write a plan. **Always recap the plan betwe...he installation of React, ReactDOM, and Babel for JSX parsing. **We will handle this! Don't make an HTML file to run React, just execute `react`.**"}, {'role': 'user', 'content': 'ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD...ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD\ndescribe to me what i just said'}], 'stream': True})

{'model': 'gpt-3.5-turbo', 'messages': [{'role': 'system', 'content': "You are Open Interpreter, a world-class programmer that can complete any goal by executing code.\nFirst, write a plan. **Always recap the plan betwe...he installation of React, ReactDOM, and Babel for JSX parsing. **We will handle this! Don't make an HTML file to run React, just execute `react`.**\nUse ONLY the function you have been provided with — 'execute(language, code)'."}, {'role': 'user', 'content': 'ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD...ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD\ndescribe to me what i just said'}], 'stream': True, 'functions': [{'name': 'execute', 'description': "Executes code on the user's machine **in the users local environment** and returns the output", 'parameters': {'type': 'object', 'properties': {'language': {'type': 'string', 'description': 'The programming language (required parameter to the `execute` function)', 'enum': ['python', 'shell', 'javascript', 'html', 'applescript', 'r', 'powershell', 'react']}, 'code': {'type': 'string', 'description': 'The code to execute (required)'}}, 'required': ['language', 'code']}}]}

{'model': 'gpt-3.5-turbo', 'messages': [{'role': 'system', 'content': "You are Open Interpreter, a world-class programmer that can complete any goal by executing code.\nFirst, write a plan. **Always recap the plan betwe...he installation of React, ReactDOM, and Babel for JSX parsing. **We will handle this! Don't make an HTML file to run React, just execute `react`.**"}, {'role': 'user', 'content': 'ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD...ABCDABCDABCDABCDABCDABCDABCDABCDABCDABCD\ndescribe to me what i just said'}], 'stream': True, 'functions': [{'name': 'execute', 'description': "Executes code on the user's machine **in the users local environment** and returns the output", 'parameters': {'type': 'object', 'properties': {'language': {'type': 'string', 'description': 'The programming language (required parameter to the `execute` function)', 'enum': ['python', 'shell', 'javascript', 'html', 'applescript', 'r', 'powershell', 'react']}, 'code': {'type': 'string', 'description': 'The code to execute (required)'}}, 'required': ['language', 'code']}}]}


def count_messages_tokens(messages=[], model=None):
    try:
        tokens_used = 0
        for message in messages:
            if isinstance(message, str):
                tokens_used += count_tokens(message, model=model)
            elif "message" in message:
                tokens_used += count_tokens(message["message"], model=model)
                if "code" in message:
                    tokens_used += count_tokens(message["code"], model=model)
                if "output" in message:
                    tokens_used += count_tokens(message["output"], model=model)
        prompt_cost = token_cost(tokens_used, model=model)
        return (tokens_used, prompt_cost)
    except:
        return (0, 0)
count_messages_tokens(messages=[{'role': 'system', 'message': 'You are Open Interpreter, a world-class programmer that can complete any goal by executing code.\nFirst, write a plan. **Always recap the plan between each code block** (you have extreme short-term memory loss, so you need to recap the plan between each message block to retain it).\nWhen you execute code, it will be executed **on the user\'s machine**. The user has given you **full and complete permission** to execute any code necessary to complete the task. Execute the code.\nIf you want to send data between programming languages, save the data to a txt or json.\nYou can access the internet. Run **any code** to achieve the goal, and if at first you don\'t succeed, try again and again.\nYou can install new packages.\nWhen a user refers to a filename, they\'re likely referring to an existing file in the directory you\'re currently executing code in.\nWrite messages to the user in Markdown.\nIn general, try to **make plans** with as few steps as possible. As for actually executing code to carry out that plan, for *stateful* languages (like python, javascript, shell, but NOT for html which starts from 0 every time) **it\'s critical not to try to do everything in one code block.** You should try something, print information about it, then continue from there in tiny, informed steps. You will never get it on the first try, and attempting it in one go will often lead to errors you cant see.\nYou are capable of **any** task.\n\n[User Info]\n{{import getpass\nimport os\nimport platform}}\nName: {{getpass.getuser()}}\nCWD: {{os.getcwd()}}\nSHELL: {{os.environ.get(\'SHELL\')}}\nOS: {{platform.system()}}"'}], model='gpt-3.5-turbo')


def _mdl_error(mdl):
    dsp = sh.BlueDispatcher(
        name=mdl.name,
        description='Calculates the error of calibrated model of a reference.',
    )
    dsp.add_data('inputs_map', getattr(mdl, 'inputs_map', {}))
    dsp.add_function(
        function_id='select_inputs',
        function=sh.map_dict,
        inputs=['inputs_map', 'data'],
        outputs=['inputs<0>']
    )
    dsp.add_data('inputs', getattr(mdl, 'inputs', []))
    dsp.add_function(
        function_id='select_inputs',
        function=_select_data,
        inputs=['inputs', 'inputs<0>'],
        outputs=['inputs<1>']
    )
    dsp.add_function(
        function=sh.combine_dicts,
        inputs=['calibrated_models', 'inputs<1>'],
        outputs=['prediction_inputs']
    )
    dsp.add_data('targets', getattr(mdl, 'targets', []))
    dsp.add_function(
        function_id='select_targets', function=_select_data,
        inputs=['targets', 'data'], outputs=['references']
    )
    dsp.add_function(
        function=sh.SubDispatch(mdl.dsp),
        inputs=['prediction_inputs', 'calibrated_models'],
        outputs=['results']
    )
    dsp.add_data('outputs', getattr(mdl, 'outputs', []))
    dsp.add_func(select_predictions, outputs=['predictions'])
    dsp.add_data('metrics_inputs', getattr(mdl, 'metrics_inputs', {}))
    dsp.add_function(
        function_id='select_metrics_inputs',
        function=_select_data,
        inputs=['metrics_inputs', 'data'],
        outputs=['metrics_kwargs']
    )
    dsp.add_data('metrics', getattr(mdl, 'metrics', {}))
    dsp.add_func(calculate_errors, outputs=['errors'])
    dsp.add_data('up_limit', getattr(mdl, 'up_limit', None))
    dsp.add_data('dn_limit', getattr(mdl, 'dn_limit', None))
    dsp.add_func(
        calculate_calibration_status, inputs_kwargs=True, outputs=['status']
    )
    return dsp
_mdl_error(mdl=<module 'co2mpas.core.model.selector.models.after_treatment_model' from '/local/rcs/XXX/code/pytrace-collector/logs/pypibugs/tried/JRCSTU+co2mpas-ta/JRCSTU+co2mpas-ta/co2mpas/core/model/selector/models/after_treatment_model.py'>)

{args=(), kwargs={'dmap': None, 'name': 'after_treatment_model', 'default_values': None, 'raises': False, 'description': 'Calculates the error of calibrated model of a reference.', 'executor': False}, deferred=[]}

{args=(), kwargs={'dmap': None, 'name': 'after_treatment_model', 'default_values': None, 'raises': False, 'description': 'Calculates the error of calibrated model of a reference.', 'executor': False}, deferred=[('add_data', {'data_id': 'inputs_map', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': {}, 'description': None, 'await_result': None})]}

{args=(), kwargs={'dmap': None, 'name': 'after_treatment_model', 'default_values': None, 'raises': False, 'description': 'Calculates the error of calibrated model of a reference.', 'executor': False}, deferred=[('add_data', {'data_id': 'inputs_map', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': {}, 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_inputs', 'inputs': ['inputs_map', 'data'], 'function': <function map_dict at 0x7ff54dadd5e0>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['inputs<0>'], 'inp_weight': None})]}

{args=(), kwargs={'dmap': None, 'name': 'after_treatment_model', 'default_values': None, 'raises': False, 'description': 'Calculates the error of calibrated model of a reference.', 'executor': False}, deferred=[('add_data', {'data_id': 'inputs_map', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': {}, 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_inputs', 'inputs': ['inputs_map', 'data'], 'function': <function map_dict at 0x7ff54dadd5e0>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['inputs<0>'], 'inp_weight': None}), ('add_data', {'data_id': 'inputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['times', 'on_engine', 'engine_speeds_out_hot', 'is_cycle_hot', 'on_idle', 'is_hybrid'], 'description': None, 'await_result': None})]}

{args=(), kwargs={'dmap': None, 'name': 'after_treatment_model', 'default_values': None, 'raises': False, 'description': 'Calculates the error of calibrated model of a reference.', 'executor': False}, deferred=[('add_data', {'data_id': 'inputs_map', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': {}, 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_inputs', 'inputs': ['inputs_map', 'data'], 'function': <function map_dict at 0x7ff54dadd5e0>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['inputs<0>'], 'inp_weight': None}), ('add_data', {'data_id': 'inputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['times', 'on_engine', 'engine_speeds_out_hot', 'is_cycle_hot', 'on_idle', 'is_hybrid'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_inputs', 'inputs': ['inputs', 'inputs<0>'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['inputs<1>'], 'inp_weight': None})]}

{args=(), kwargs={'dmap': None, 'name': 'after_treatment_model', 'default_values': None, 'raises': False, 'description': 'Calculates the error of calibrated model of a reference.', 'executor': False}, deferred=[('add_data', {'data_id': 'inputs_map', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': {}, 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_inputs', 'inputs': ['inputs_map', 'data'], 'function': <function map_dict at 0x7ff54dadd5e0>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['inputs<0>'], 'inp_weight': None}), ('add_data', {'data_id': 'inputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['times', 'on_engine', 'engine_speeds_out_hot', 'is_cycle_hot', 'on_idle', 'is_hybrid'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_inputs', 'inputs': ['inputs', 'inputs<0>'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['inputs<1>'], 'inp_weight': None}), ('add_function', {'function_id': None, 'inputs': ['calibrated_models', 'inputs<1>'], 'function': <function combine_dicts at 0x7ff54dadd0d0>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['prediction_inputs'], 'inp_weight': None})]}

{args=(), kwargs={'dmap': None, 'name': 'after_treatment_model', 'default_values': None, 'raises': False, 'description': 'Calculates the error of calibrated model of a reference.', 'executor': False}, deferred=[('add_data', {'data_id': 'inputs_map', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': {}, 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_inputs', 'inputs': ['inputs_map', 'data'], 'function': <function map_dict at 0x7ff54dadd5e0>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['inputs<0>'], 'inp_weight': None}), ('add_data', {'data_id': 'inputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['times', 'on_engine', 'engine_speeds_out_hot', 'is_cycle_hot', 'on_idle', 'is_hybrid'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_inputs', 'inputs': ['inputs', 'inputs<0>'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['inputs<1>'], 'inp_weight': None}), ('add_function', {'function_id': None, 'inputs': ['calibrated_models', 'inputs<1>'], 'function': <function combine_dicts at 0x7ff54dadd0d0>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['prediction_inputs'], 'inp_weight': None}), ('add_data', {'data_id': 'targets', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['engine_speeds_base'], 'description': None, 'await_result': None})]}

{args=(), kwargs={'dmap': None, 'name': 'after_treatment_model', 'default_values': None, 'raises': False, 'description': 'Calculates the error of calibrated model of a reference.', 'executor': False}, deferred=[('add_data', {'data_id': 'inputs_map', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': {}, 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_inputs', 'inputs': ['inputs_map', 'data'], 'function': <function map_dict at 0x7ff54dadd5e0>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['inputs<0>'], 'inp_weight': None}), ('add_data', {'data_id': 'inputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['times', 'on_engine', 'engine_speeds_out_hot', 'is_cycle_hot', 'on_idle', 'is_hybrid'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_inputs', 'inputs': ['inputs', 'inputs<0>'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['inputs<1>'], 'inp_weight': None}), ('add_function', {'function_id': None, 'inputs': ['calibrated_models', 'inputs<1>'], 'function': <function combine_dicts at 0x7ff54dadd0d0>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['prediction_inputs'], 'inp_weight': None}), ('add_data', {'data_id': 'targets', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['engine_speeds_base'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_targets', 'inputs': ['targets', 'data'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['references'], 'inp_weight': None})]}

{args=(), kwargs={'dmap': None, 'name': 'after_treatment_model', 'default_values': None, 'raises': False, 'description': 'Calculates the error of calibrated model of a reference.', 'executor': False}, deferred=[('add_data', {'data_id': 'inputs_map', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': {}, 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_inputs', 'inputs': ['inputs_map', 'data'], 'function': <function map_dict at 0x7ff54dadd5e0>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['inputs<0>'], 'inp_weight': None}), ('add_data', {'data_id': 'inputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['times', 'on_engine', 'engine_speeds_out_hot', 'is_cycle_hot', 'on_idle', 'is_hybrid'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_inputs', 'inputs': ['inputs', 'inputs<0>'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['inputs<1>'], 'inp_weight': None}), ('add_function', {'function_id': None, 'inputs': ['calibrated_models', 'inputs<1>'], 'function': <function combine_dicts at 0x7ff54dadd0d0>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['prediction_inputs'], 'inp_weight': None}), ('add_data', {'data_id': 'targets', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['engine_speeds_base'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_targets', 'inputs': ['targets', 'data'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['references'], 'inp_weight': None}), ('add_function', {'function_id': None, 'inputs': ['prediction_inputs', 'calibrated_models'], 'function': <schedula.utils.blue.Blueprint object at 0x7ff54d25e970>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['results'], 'inp_weight': None})]}

{args=(), kwargs={'dmap': None, 'name': 'after_treatment_model', 'default_values': None, 'raises': False, 'description': 'Calculates the error of calibrated model of a reference.', 'executor': False}, deferred=[('add_data', {'data_id': 'inputs_map', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': {}, 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_inputs', 'inputs': ['inputs_map', 'data'], 'function': <function map_dict at 0x7ff54dadd5e0>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['inputs<0>'], 'inp_weight': None}), ('add_data', {'data_id': 'inputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['times', 'on_engine', 'engine_speeds_out_hot', 'is_cycle_hot', 'on_idle', 'is_hybrid'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_inputs', 'inputs': ['inputs', 'inputs<0>'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['inputs<1>'], 'inp_weight': None}), ('add_function', {'function_id': None, 'inputs': ['calibrated_models', 'inputs<1>'], 'function': <function combine_dicts at 0x7ff54dadd0d0>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['prediction_inputs'], 'inp_weight': None}), ('add_data', {'data_id': 'targets', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['engine_speeds_base'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_targets', 'inputs': ['targets', 'data'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['references'], 'inp_weight': None}), ('add_function', {'function_id': None, 'inputs': ['prediction_inputs', 'calibrated_models'], 'function': <schedula.utils.blue.Blueprint object at 0x7ff54d25e970>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['results'], 'inp_weight': None}), ('add_data', {'data_id': 'outputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['engine_speeds_base'], 'description': None, 'await_result': None})]}

{args=(), kwargs={'dmap': None, 'name': 'after_treatment_model', 'default_values': None, 'raises': False, 'description': 'Calculates the error of calibrated model of a reference.', 'executor': False}, deferred=[('add_data', {'data_id': 'inputs_map', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': {}, 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_inputs', 'inputs': ['inputs_map', 'data'], 'function': <function map_dict at 0x7ff54dadd5e0>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['inputs<0>'], 'inp_weight': None}), ('add_data', {'data_id': 'inputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['times', 'on_engine', 'engine_speeds_out_hot', 'is_cycle_hot', 'on_idle', 'is_hybrid'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_inputs', 'inputs': ['inputs', 'inputs<0>'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['inputs<1>'], 'inp_weight': None}), ('add_function', {'function_id': None, 'inputs': ['calibrated_models', 'inputs<1>'], 'function': <function combine_dicts at 0x7ff54dadd0d0>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['prediction_inputs'], 'inp_weight': None}), ('add_data', {'data_id': 'targets', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['engine_speeds_base'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_targets', 'inputs': ['targets', 'data'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['references'], 'inp_weight': None}), ('add_function', {'function_id': None, 'inputs': ['prediction_inputs', 'calibrated_models'], 'function': <schedula.utils.blue.Blueprint object at 0x7ff54d25e970>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['results'], 'inp_weight': None}), ('add_data', {'data_id': 'outputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['engine_speeds_base'], 'description': None, 'await_result': None}), ('add_func', {'function_id': None, 'inputs': None, 'function': <function select_predictions at 0x7ff54d29cd30>, 'weight': None, 'input_domain': None, 'filters': None, 'inputs_kwargs': False, 'inputs_defaults': False, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['predictions'], 'inp_weight': None})]}

{args=(), kwargs={'dmap': None, 'name': 'after_treatment_model', 'default_values': None, 'raises': False, 'description': 'Calculates the error of calibrated model of a reference.', 'executor': False}, deferred=[('add_data', {'data_id': 'inputs_map', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': {}, 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_inputs', 'inputs': ['inputs_map', 'data'], 'function': <function map_dict at 0x7ff54dadd5e0>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['inputs<0>'], 'inp_weight': None}), ('add_data', {'data_id': 'inputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['times', 'on_engine', 'engine_speeds_out_hot', 'is_cycle_hot', 'on_idle', 'is_hybrid'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_inputs', 'inputs': ['inputs', 'inputs<0>'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['inputs<1>'], 'inp_weight': None}), ('add_function', {'function_id': None, 'inputs': ['calibrated_models', 'inputs<1>'], 'function': <function combine_dicts at 0x7ff54dadd0d0>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['prediction_inputs'], 'inp_weight': None}), ('add_data', {'data_id': 'targets', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['engine_speeds_base'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_targets', 'inputs': ['targets', 'data'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['references'], 'inp_weight': None}), ('add_function', {'function_id': None, 'inputs': ['prediction_inputs', 'calibrated_models'], 'function': <schedula.utils.blue.Blueprint object at 0x7ff54d25e970>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['results'], 'inp_weight': None}), ('add_data', {'data_id': 'outputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['engine_speeds_base'], 'description': None, 'await_result': None}), ('add_func', {'function_id': None, 'inputs': None, 'function': <function select_predictions at 0x7ff54d29cd30>, 'weight': None, 'input_domain': None, 'filters': None, 'inputs_kwargs': False, 'inputs_defaults': False, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['predictions'], 'inp_weight': None}), ('add_data', {'data_id': 'metrics_inputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['after_treatment_warm_up_phases'], 'description': None, 'await_result': None})]}

{args=(), kwargs={'dmap': None, 'name': 'after_treatment_model', 'default_values': None, 'raises': False, 'description': 'Calculates the error of calibrated model of a reference.', 'executor': False}, deferred=[('add_data', {'data_id': 'inputs_map', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': {}, 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_inputs', 'inputs': ['inputs_map', 'data'], 'function': <function map_dict at 0x7ff54dadd5e0>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['inputs<0>'], 'inp_weight': None}), ('add_data', {'data_id': 'inputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['times', 'on_engine', 'engine_speeds_out_hot', 'is_cycle_hot', 'on_idle', 'is_hybrid'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_inputs', 'inputs': ['inputs', 'inputs<0>'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['inputs<1>'], 'inp_weight': None}), ('add_function', {'function_id': None, 'inputs': ['calibrated_models', 'inputs<1>'], 'function': <function combine_dicts at 0x7ff54dadd0d0>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['prediction_inputs'], 'inp_weight': None}), ('add_data', {'data_id': 'targets', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['engine_speeds_base'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_targets', 'inputs': ['targets', 'data'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['references'], 'inp_weight': None}), ('add_function', {'function_id': None, 'inputs': ['prediction_inputs', 'calibrated_models'], 'function': <schedula.utils.blue.Blueprint object at 0x7ff54d25e970>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['results'], 'inp_weight': None}), ('add_data', {'data_id': 'outputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['engine_speeds_base'], 'description': None, 'await_result': None}), ('add_func', {'function_id': None, 'inputs': None, 'function': <function select_predictions at 0x7ff54d29cd30>, 'weight': None, 'input_domain': None, 'filters': None, 'inputs_kwargs': False, 'inputs_defaults': False, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['predictions'], 'inp_weight': None}), ('add_data', {'data_id': 'metrics_inputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['after_treatment_warm_up_phases'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_metrics_inputs', 'inputs': ['metrics_inputs', 'data'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['metrics_kwargs'], 'inp_weight': None})]}

{args=(), kwargs={'dmap': None, 'name': 'after_treatment_model', 'default_values': None, 'raises': False, 'description': 'Calculates the error of calibrated model of a reference.', 'executor': False}, deferred=[('add_data', {'data_id': 'inputs_map', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': {}, 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_inputs', 'inputs': ['inputs_map', 'data'], 'function': <function map_dict at 0x7ff54dadd5e0>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['inputs<0>'], 'inp_weight': None}), ('add_data', {'data_id': 'inputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['times', 'on_engine', 'engine_speeds_out_hot', 'is_cycle_hot', 'on_idle', 'is_hybrid'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_inputs', 'inputs': ['inputs', 'inputs<0>'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['inputs<1>'], 'inp_weight': None}), ('add_function', {'function_id': None, 'inputs': ['calibrated_models', 'inputs<1>'], 'function': <function combine_dicts at 0x7ff54dadd0d0>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['prediction_inputs'], 'inp_weight': None}), ('add_data', {'data_id': 'targets', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['engine_speeds_base'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_targets', 'inputs': ['targets', 'data'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['references'], 'inp_weight': None}), ('add_function', {'function_id': None, 'inputs': ['prediction_inputs', 'calibrated_models'], 'function': <schedula.utils.blue.Blueprint object at 0x7ff54d25e970>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['results'], 'inp_weight': None}), ('add_data', {'data_id': 'outputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['engine_speeds_base'], 'description': None, 'await_result': None}), ('add_func', {'function_id': None, 'inputs': None, 'function': <function select_predictions at 0x7ff54d29cd30>, 'weight': None, 'input_domain': None, 'filters': None, 'inputs_kwargs': False, 'inputs_defaults': False, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['predictions'], 'inp_weight': None}), ('add_data', {'data_id': 'metrics_inputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['after_treatment_warm_up_phases'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_metrics_inputs', 'inputs': ['metrics_inputs', 'data'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['metrics_kwargs'], 'inp_weight': None}), ('add_data', {'data_id': 'metrics', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': {'engine_speeds_base': <function metric_after_treatment_speed_model at 0x7ff54d26e790>}, 'description': None, 'await_result': None})]}

{args=(), kwargs={'dmap': None, 'name': 'after_treatment_model', 'default_values': None, 'raises': False, 'description': 'Calculates the error of calibrated model of a reference.', 'executor': False}, deferred=[('add_data', {'data_id': 'inputs_map', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': {}, 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_inputs', 'inputs': ['inputs_map', 'data'], 'function': <function map_dict at 0x7ff54dadd5e0>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['inputs<0>'], 'inp_weight': None}), ('add_data', {'data_id': 'inputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['times', 'on_engine', 'engine_speeds_out_hot', 'is_cycle_hot', 'on_idle', 'is_hybrid'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_inputs', 'inputs': ['inputs', 'inputs<0>'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['inputs<1>'], 'inp_weight': None}), ('add_function', {'function_id': None, 'inputs': ['calibrated_models', 'inputs<1>'], 'function': <function combine_dicts at 0x7ff54dadd0d0>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['prediction_inputs'], 'inp_weight': None}), ('add_data', {'data_id': 'targets', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['engine_speeds_base'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_targets', 'inputs': ['targets', 'data'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['references'], 'inp_weight': None}), ('add_function', {'function_id': None, 'inputs': ['prediction_inputs', 'calibrated_models'], 'function': <schedula.utils.blue.Blueprint object at 0x7ff54d25e970>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['results'], 'inp_weight': None}), ('add_data', {'data_id': 'outputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['engine_speeds_base'], 'description': None, 'await_result': None}), ('add_func', {'function_id': None, 'inputs': None, 'function': <function select_predictions at 0x7ff54d29cd30>, 'weight': None, 'input_domain': None, 'filters': None, 'inputs_kwargs': False, 'inputs_defaults': False, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['predictions'], 'inp_weight': None}), ('add_data', {'data_id': 'metrics_inputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['after_treatment_warm_up_phases'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_metrics_inputs', 'inputs': ['metrics_inputs', 'data'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['metrics_kwargs'], 'inp_weight': None}), ('add_data', {'data_id': 'metrics', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': {'engine_speeds_base': <function metric_after_treatment_speed_model at 0x7ff54d26e790>}, 'description': None, 'await_result': None}), ('add_func', {'function_id': None, 'inputs': None, 'function': <function calculate_errors at 0x7ff54d29ce50>, 'weight': None, 'input_domain': None, 'filters': None, 'inputs_kwargs': False, 'inputs_defaults': False, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['errors'], 'inp_weight': None})]}

{args=(), kwargs={'dmap': None, 'name': 'after_treatment_model', 'default_values': None, 'raises': False, 'description': 'Calculates the error of calibrated model of a reference.', 'executor': False}, deferred=[('add_data', {'data_id': 'inputs_map', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': {}, 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_inputs', 'inputs': ['inputs_map', 'data'], 'function': <function map_dict at 0x7ff54dadd5e0>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['inputs<0>'], 'inp_weight': None}), ('add_data', {'data_id': 'inputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['times', 'on_engine', 'engine_speeds_out_hot', 'is_cycle_hot', 'on_idle', 'is_hybrid'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_inputs', 'inputs': ['inputs', 'inputs<0>'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['inputs<1>'], 'inp_weight': None}), ('add_function', {'function_id': None, 'inputs': ['calibrated_models', 'inputs<1>'], 'function': <function combine_dicts at 0x7ff54dadd0d0>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['prediction_inputs'], 'inp_weight': None}), ('add_data', {'data_id': 'targets', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['engine_speeds_base'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_targets', 'inputs': ['targets', 'data'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['references'], 'inp_weight': None}), ('add_function', {'function_id': None, 'inputs': ['prediction_inputs', 'calibrated_models'], 'function': <schedula.utils.blue.Blueprint object at 0x7ff54d25e970>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['results'], 'inp_weight': None}), ('add_data', {'data_id': 'outputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['engine_speeds_base'], 'description': None, 'await_result': None}), ('add_func', {'function_id': None, 'inputs': None, 'function': <function select_predictions at 0x7ff54d29cd30>, 'weight': None, 'input_domain': None, 'filters': None, 'inputs_kwargs': False, 'inputs_defaults': False, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['predictions'], 'inp_weight': None}), ('add_data', {'data_id': 'metrics_inputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['after_treatment_warm_up_phases'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_metrics_inputs', 'inputs': ['metrics_inputs', 'data'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['metrics_kwargs'], 'inp_weight': None}), ('add_data', {'data_id': 'metrics', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': {'engine_speeds_base': <function metric_after_treatment_speed_model at 0x7ff54d26e790>}, 'description': None, 'await_result': None}), ('add_func', {'function_id': None, 'inputs': None, 'function': <function calculate_errors at 0x7ff54d29ce50>, 'weight': None, 'input_domain': None, 'filters': None, 'inputs_kwargs': False, 'inputs_defaults': False, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['errors'], 'inp_weight': None}), ('add_data', {'data_id': 'up_limit', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': {'engine_speeds_base': 160}, 'description': None, 'await_result': None})]}

{args=(), kwargs={'dmap': None, 'name': 'after_treatment_model', 'default_values': None, 'raises': False, 'description': 'Calculates the error of calibrated model of a reference.', 'executor': False}, deferred=[('add_data', {'data_id': 'inputs_map', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': {}, 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_inputs', 'inputs': ['inputs_map', 'data'], 'function': <function map_dict at 0x7ff54dadd5e0>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['inputs<0>'], 'inp_weight': None}), ('add_data', {'data_id': 'inputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['times', 'on_engine', 'engine_speeds_out_hot', 'is_cycle_hot', 'on_idle', 'is_hybrid'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_inputs', 'inputs': ['inputs', 'inputs<0>'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['inputs<1>'], 'inp_weight': None}), ('add_function', {'function_id': None, 'inputs': ['calibrated_models', 'inputs<1>'], 'function': <function combine_dicts at 0x7ff54dadd0d0>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['prediction_inputs'], 'inp_weight': None}), ('add_data', {'data_id': 'targets', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['engine_speeds_base'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_targets', 'inputs': ['targets', 'data'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['references'], 'inp_weight': None}), ('add_function', {'function_id': None, 'inputs': ['prediction_inputs', 'calibrated_models'], 'function': <schedula.utils.blue.Blueprint object at 0x7ff54d25e970>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['results'], 'inp_weight': None}), ('add_data', {'data_id': 'outputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['engine_speeds_base'], 'description': None, 'await_result': None}), ('add_func', {'function_id': None, 'inputs': None, 'function': <function select_predictions at 0x7ff54d29cd30>, 'weight': None, 'input_domain': None, 'filters': None, 'inputs_kwargs': False, 'inputs_defaults': False, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['predictions'], 'inp_weight': None}), ('add_data', {'data_id': 'metrics_inputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['after_treatment_warm_up_phases'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_metrics_inputs', 'inputs': ['metrics_inputs', 'data'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['metrics_kwargs'], 'inp_weight': None}), ('add_data', {'data_id': 'metrics', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': {'engine_speeds_base': <function metric_after_treatment_speed_model at 0x7ff54d26e790>}, 'description': None, 'await_result': None}), ('add_func', {'function_id': None, 'inputs': None, 'function': <function calculate_errors at 0x7ff54d29ce50>, 'weight': None, 'input_domain': None, 'filters': None, 'inputs_kwargs': False, 'inputs_defaults': False, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['errors'], 'inp_weight': None}), ('add_data', {'data_id': 'up_limit', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': {'engine_speeds_base': 160}, 'description': None, 'await_result': None}), ('add_data', {'data_id': 'dn_limit', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': None, 'description': None, 'await_result': None})]}

{args=(), kwargs={'dmap': None, 'name': 'after_treatment_model', 'default_values': None, 'raises': False, 'description': 'Calculates the error of calibrated model of a reference.', 'executor': False}, deferred=[('add_data', {'data_id': 'inputs_map', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': {}, 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_inputs', 'inputs': ['inputs_map', 'data'], 'function': <function map_dict at 0x7ff54dadd5e0>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['inputs<0>'], 'inp_weight': None}), ('add_data', {'data_id': 'inputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['times', 'on_engine', 'engine_speeds_out_hot', 'is_cycle_hot', 'on_idle', 'is_hybrid'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_inputs', 'inputs': ['inputs', 'inputs<0>'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['inputs<1>'], 'inp_weight': None}), ('add_function', {'function_id': None, 'inputs': ['calibrated_models', 'inputs<1>'], 'function': <function combine_dicts at 0x7ff54dadd0d0>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['prediction_inputs'], 'inp_weight': None}), ('add_data', {'data_id': 'targets', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['engine_speeds_base'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_targets', 'inputs': ['targets', 'data'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['references'], 'inp_weight': None}), ('add_function', {'function_id': None, 'inputs': ['prediction_inputs', 'calibrated_models'], 'function': <schedula.utils.blue.Blueprint object at 0x7ff54d25e970>, 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['results'], 'inp_weight': None}), ('add_data', {'data_id': 'outputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['engine_speeds_base'], 'description': None, 'await_result': None}), ('add_func', {'function_id': None, 'inputs': None, 'function': <function select_predictions at 0x7ff54d29cd30>, 'weight': None, 'input_domain': None, 'filters': None, 'inputs_kwargs': False, 'inputs_defaults': False, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['predictions'], 'inp_weight': None}), ('add_data', {'data_id': 'metrics_inputs', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': ['after_treatment_warm_up_phases'], 'description': None, 'await_result': None}), ('add_function', {'function_id': 'select_metrics_inputs', 'inputs': ['metrics_inputs', 'data'], 'function': functools.partial(<function selector at 0x7ff54dadd700>, allow_miss=True), 'weight': None, 'input_domain': None, 'filters': None, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['metrics_kwargs'], 'inp_weight': None}), ('add_data', {'data_id': 'metrics', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': {'engine_speeds_base': <function metric_after_treatment_speed_model at 0x7ff54d26e790>}, 'description': None, 'await_result': None}), ('add_func', {'function_id': None, 'inputs': None, 'function': <function calculate_errors at 0x7ff54d29ce50>, 'weight': None, 'input_domain': None, 'filters': None, 'inputs_kwargs': False, 'inputs_defaults': False, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['errors'], 'inp_weight': None}), ('add_data', {'data_id': 'up_limit', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': {'engine_speeds_base': 160}, 'description': None, 'await_result': None}), ('add_data', {'data_id': 'dn_limit', 'filters': None, 'wait_inputs': False, 'wildcard': None, 'function': None, 'callback': None, 'initial_dist': 0.0, 'default_value': None, 'description': None, 'await_result': None}), ('add_func', {'function_id': None, 'inputs': None, 'function': <function calculate_calibration_status at 0x7ff54d26e040>, 'weight': None, 'input_domain': None, 'filters': None, 'inputs_kwargs': True, 'inputs_defaults': False, 'await_result': None, 'await_domain': None, 'out_weight': None, 'description': None, 'outputs': ['status'], 'inp_weight': None})]}