fameio 1.8.1__py3-none-any.whl → 2.0.0__py3-none-any.whl

fameio/source/cli/parser.py

@@ -0,0 +1,238 @@
+# SPDX-FileCopyrightText: 2024 German Aerospace Center <fame@dlr.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+import copy
+from argparse import ArgumentParser, ArgumentTypeError, BooleanOptionalAction, Namespace
+from enum import Enum
+from pathlib import Path
+from typing import Optional, Dict, Any, List, Union
+
+from fameio.source.cli.options import MergingOptions, TimeOptions, ResolveOptions, Options
+from fameio.source.logs import LOG_LEVELS
+
+_ERR_NEGATIVE_INT = "Given value `{}` is not a non-negative int."
+
+_OPTION_ARGUMENT_NAME: Dict[str, Union[Options, Dict]] = {
+    "file": Options.FILE,
+    "log": Options.LOG_LEVEL,
+    "logfile": Options.LOG_FILE,
+    "output": Options.OUTPUT,
+    "agents": Options.AGENT_LIST,
+    "single_export": Options.SINGLE_AGENT_EXPORT,
+    "memory_saving": Options.MEMORY_SAVING,
+    "time": Options.TIME,
+    "input_recovery": Options.INPUT_RECOVERY,
+    "complex_column": Options.RESOLVE_COMPLEX_FIELD,
+    "time_merging": {
+        "name": Options.TIME_MERGING,
+        "inner_elements": {
+            "focal_point": MergingOptions.FOCAL_POINT,
+            "steps_before": MergingOptions.STEPS_BEFORE,
+            "steps_after": MergingOptions.STEPS_AFTER,
+        },
+    },
+}
+
+
+def add_file_argument(parser: ArgumentParser, default: Optional[Path], help_text: str) -> None:
+    """
+    Adds 'file' argument to the provided `parser` with the provided `help_text`.
+    If a default is not specified, the argument is required (optional otherwise)
+
+    Args:
+        parser: to add the argument to
+        default: optional, if it is a valid Path, it is added as default and the argument becomes optional
+        help_text: to be displayed
+    """
+    if default is not None and isinstance(default, (Path, str)):
+        parser.add_argument("-f", "--file", type=Path, required=False, default=default, help=help_text)
+    else:
+        parser.add_argument("-f", "--file", type=Path, required=True, help=help_text)
+
+
+def add_select_agents_argument(parser: ArgumentParser, default: List[str]) -> None:
+    """Adds optional repeatable string argument 'agent' to given `parser`"""
+    help_text = "Provide list of agents to extract (default=None)"
+    parser.add_argument("-a", "--agents", nargs="*", type=str, default=default, help=help_text)
+
+
+def add_logfile_argument(parser: ArgumentParser, default: Path) -> None:
+    """Adds optional argument 'logfile' to given `parser`"""
+    help_text = "provide logging file (default=None)"
+    parser.add_argument("-lf", "--logfile", type=Path, default=default, help=help_text)
+
+
+def add_output_argument(parser: ArgumentParser, default_value, help_text: str) -> None:
+    """Adds optional argument 'output' to given `parser` using the given `help_text` and `default_value`"""
+    parser.add_argument("-o", "--output", type=Path, default=default_value, help=help_text)
+
+
+def add_log_level_argument(parser: ArgumentParser, default_value: str) -> None:
+    """Adds optional argument 'log' to given `parser`"""
+    help_text = "choose logging level (default: {})".format(default_value)
+    parser.add_argument(
+        "-l",
+        "--log",
+        default=default_value,
+        choices=list(LOG_LEVELS.keys()),
+        type=str.lower,
+        help=help_text,
+    )
+
+
+def add_single_export_argument(parser: ArgumentParser, default_value: bool) -> None:
+    """Adds optional repeatable string argument 'agent' to given `parser`"""
+    help_text = "Enable export of single agents (default=False)"
+    parser.add_argument(
+        "-se",
+        "--single-export",
+        default=default_value,
+        action="store_true",
+        help=help_text,
+    )
+
+
+def add_memory_saving_argument(parser: ArgumentParser, default_value: bool) -> None:
+    """Adds optional bool argument to given `parser` to enable memory saving mode"""
+    help_text = "Reduces memory usage profile at the cost of runtime (default=False)"
+    parser.add_argument(
+        "-m",
+        "--memory-saving",
+        default=default_value,
+        action="store_true",
+        help=help_text,
+    )
+
+
+def add_resolve_complex_argument(parser: ArgumentParser, default_value: Union[ResolveOptions, str]):
+    """Instructs given `parser` how to deal with complex field outputs"""
+    default_value = default_value if isinstance(default_value, ResolveOptions) else ResolveOptions[default_value]
+    help_text = f"How to deal with complex index columns? (default={default_value})"
+    parser.add_argument(
+        "-cc",
+        "--complex-column",
+        type=ResolveOptions.instantiate,
+        default=default_value,
+        choices=ResolveOptions,
+        help=help_text,
+    )
+
+
+def add_time_argument(parser: ArgumentParser, default_value: Union[TimeOptions, str]) -> None:
+    """Adds optional argument to given `parser` to define conversion of TimeSteps"""
+    default_value = default_value if isinstance(default_value, TimeOptions) else TimeOptions[default_value]
+    help_text = "Apply conversion of time steps to given format (default=UTC)"
+    parser.add_argument(
+        "-t",
+        "--time",
+        type=TimeOptions.instantiate,
+        default=default_value,
+        choices=TimeOptions,
+        help=help_text,
+    )
+
+
+def add_merge_time_parser(parser: ArgumentParser) -> None:
+    """Adds subparser for merging of TimeSteps to given `parser`"""
+    subparser = parser.add_subparsers(dest="time_merging", required=False, help="Optional merging of TimeSteps")
+    group_parser = subparser.add_parser("merge-times")
+    add_focal_point_argument(group_parser)
+    add_steps_before_argument(group_parser)
+    add_steps_after_argument(group_parser)
+
+
+def add_focal_point_argument(parser: ArgumentParser) -> None:
+    """Adds `focal-point` argument to given `parser`"""
+    help_text = "TimeStep on which `steps_before` earlier and `steps_after` later TimeSteps are merged on"
+    parser.add_argument("-fp", "--focal-point", required=True, type=int, help=help_text)
+
+
+def add_steps_before_argument(parser: ArgumentParser) -> None:
+    """Adds `steps-before` argument to given `parser`"""
+    help_text = "Range of TimeSteps before the `focal-point` they get merged to"
+    parser.add_argument("-sb", "--steps-before", required=True, type=_non_negative_int, help=help_text)
+
+
+def _non_negative_int(value: Any) -> int:
+    """
+    Casts a given ´value` to int and checks it for non-negativity
+
+    Args:
+        value: to check and parse
+
+    Returns:
+        `value` parsed to int if it is a non-negative integer
+
+    Raises:
+        TypeError: if `value` is None
+        ValueError: if `value` cannot be parsed to int
+        argparse.ArgumentTypeError: if `value` is a negative int
+
+    """
+    value = int(value)
+    if value < 0:
+        raise ArgumentTypeError(_ERR_NEGATIVE_INT.format(value))
+    return value
+
+
+def add_steps_after_argument(parser: ArgumentParser) -> None:
+    """Adds `steps-after` argument to given `parser`"""
+    help_text = "Range of TimeSteps after the `focal-point` they get merged to"
+    parser.add_argument("-sa", "--steps-after", required=True, type=_non_negative_int, help=help_text)
+
+
+def add_inputs_recovery_argument(parser: ArgumentParser, default: bool) -> None:
+    """Adds optional bool argument to given `parser` to recover inputs"""
+    help_text = "If --(no-)input-recovery is specified, (no) inputs will be recovered"
+    parser.add_argument(
+        "--input-recovery",
+        action=BooleanOptionalAction,
+        default=default,
+        help=help_text,
+    )
+
+
+def update_default_config(config: Optional[dict], default: dict) -> dict:
+    """Returns `default` config with updated fields received from `config`"""
+    result = copy.deepcopy(default)
+    if config:
+        for name, option in config.items():
+            result[name] = option
+    return result
+
+
+def map_namespace_to_options_dict(parsed: Namespace) -> Dict[Options, Any]:
+    """
+    Maps given parsing results to their corresponding configuration option
+
+    Args:
+        parsed: result of a parsing
+
+    Returns:
+        Map of each parsed argument to their configuration option
+    """
+    return _map_namespace_to_options(parsed, _OPTION_ARGUMENT_NAME)
+
+
+def _map_namespace_to_options(parsed: Namespace, names_to_options: Dict[str, Enum]) -> Dict[Options, Any]:
+    """
+    Maps given parsing results to their corresponding configuration option; elements that cannot be mapped are ignored.
+    If a configuration option has inner elements, these well be also read and added as inner dictionary.
+
+    Args:
+        parsed: result of a parsing
+        names_to_options: dict to search for configuration option specifications
+
+    Returns:
+         Map parsed arguments to their configuration option if they exist in the given `names_to_options` dict
+    """
+    config = {}
+    for name, value in vars(parsed).items():
+        option = names_to_options.get(name, None)
+        if option:
+            if isinstance(option, dict):
+                inner_element_map = option["inner_elements"]
+                option = option["name"]
+                value = _map_namespace_to_options(parsed, inner_element_map)
+            config[option] = value
+    return config

fameio/source/loader.py

@@ -2,14 +2,13 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-import logging as log
 import os
 from pathlib import Path
 from fnmatch import fnmatch
 from typing import IO, Any, Callable
 
 import yaml
-from fameio.source.logs import log_and_raise_critical
+from fameio.source.logs import log_and_raise_critical, logger
 from fameio.source.path_resolver import PathResolver
 
 DISABLING_YAML_FILE_PREFIX = "IGNORE_"
@@ -29,7 +28,7 @@ def read_args(loader, args):
     file_string = None
     if isinstance(args, yaml.nodes.ScalarNode):
         file_string = loader.construct_scalar(args)
-        log.debug("Found instance `ScalarNode` in {}".format(file_string))
+        logger().debug("Found instance `ScalarNode` in {}".format(file_string))
     elif isinstance(args, yaml.nodes.SequenceNode):
         argument_list = loader.construct_sequence(args)
         if len(argument_list) not in [1, 2]:
@@ -37,7 +36,7 @@ def read_args(loader, args):
         elif len(argument_list) == 2:
             node_string = argument_list[1]
         file_string = argument_list[0]
-        log.debug("Found instance `SequenceNode` in {}".format(file_string))
+        logger().debug("Found instance `SequenceNode` in {}".format(file_string))
     elif isinstance(args, yaml.nodes.MappingNode):
         argument_map = loader.construct_mapping(args)
         for key, value in argument_map.items():
@@ -56,7 +55,7 @@ def read_args(loader, args):
 
 def split_nodes(node_string):
     """Returns a list of nodes created from the given `node_string`"""
-    log.debug("Splitting given node_string `{}`".format(node_string))
+    logger().debug("Splitting given node_string `{}`".format(node_string))
     return node_string.split(":")
 
 
@@ -64,7 +63,7 @@ class FameYamlLoader(yaml.SafeLoader):
     """Custom YAML Loader for `!include` constructor"""
 
     def __init__(self, stream: IO, path_resolver=PathResolver()) -> None:
-        log.debug("Initialize custom YAML loader")
+        logger().debug("Initialize custom YAML loader")
         self._path_resolver = path_resolver
         try:
             self._root_path = os.path.split(stream.name)[0]
@@ -100,12 +99,12 @@ def resolve_imported_path(loader: FameYamlLoader, included_path: str):
     cleaned_file_list = []
     for file in file_list:
         if fnmatch(file, ignore_filter):
-            log.debug("Ignoring file {} due to prefix {}".format(file, DISABLING_YAML_FILE_PREFIX))
+            logger().debug("Ignoring file {} due to prefix {}".format(file, DISABLING_YAML_FILE_PREFIX))
         else:
             cleaned_file_list.append(file)
     if not cleaned_file_list:
         log_and_raise_critical("Failed to find any file matching the `!include` directive `{}`".format(included_path))
-    log.debug("Collected file(s) `{}` from given included path `{}`".format(cleaned_file_list, included_path))
+    logger().debug("Collected file(s) `{}` from given included path `{}`".format(cleaned_file_list, included_path))
     return cleaned_file_list
 
 
@@ -118,7 +117,7 @@ def read_data_from_file(file, node_address, path_resolver: PathResolver):
                 data = data[node]
             except KeyError:
                 log_and_raise_critical("'!include_node [{}, {}]': Cannot find '{}'.".format(file, node_address, node))
-    log.debug("Searched file `{}` for node `{}`".format(file, node_address))
+    logger().debug("Searched file `{}` for node `{}`".format(file, node_address))
     return data
 
 
@@ -157,7 +156,7 @@ def construct_include(loader: FameYamlLoader, args: yaml.Node) -> Any:
         with open(file_name, "r") as open_file:
             data = read_data_from_file(open_file, nodes, loader.path_resolver)
             joined_data = join_data(data, joined_data)
-    log.debug("Joined all files `{}` to joined data `{}`".format(files, joined_data))
+    logger().debug("Joined all files `{}` to joined data `{}`".format(files, joined_data))
     return joined_data
 
 
@@ -166,7 +165,7 @@ FameYamlLoader.add_constructor("!include", construct_include)
 
 def load_yaml(yaml_file_path: Path, path_resolver=PathResolver()):
     """Loads the yaml file from given `yaml_file_path` and returns its content"""
-    log.info("Loading yaml from {}".format(yaml_file_path))
+    logger().info("Loading yaml from {}".format(yaml_file_path))
     with open(yaml_file_path, "r") as configfile:
         data = yaml.load(configfile, make_yaml_loader_builder(path_resolver))
     return data

fameio/source/logs.py

@@ -4,7 +4,7 @@
 
 import logging as log
 from pathlib import Path
-from typing import NoReturn
+from typing import NoReturn, Optional, List
 
 LOG_LEVELS = {
     "critical": log.CRITICAL,
@@ -15,45 +15,69 @@ LOG_LEVELS = {
     "debug": log.DEBUG,
 }
 
+_loggers: List[log.Logger] = []
+
+_FORMAT_NORMAL = "%(asctime)s — %(levelname)s — %(message)s"  # noqa
+_FORMAT_DETAILLED = "%(asctime)s.%(msecs)03d — %(levelname)s — %(module)s:%(funcName)s:%(lineno)d — %(message)s"  # noqa
+_TIME_FORMAT = "%H:%M:%S"
+
+_WARN_ALREADY_INITIALIZED = "Cannot set up new FAMEIO logger: using existing logger with previous settings."
+_WARN_NOT_INITIALIZED = "Logger not initialised for FAMEIO - using default root logger"
+
+LOGGER_NAME = "fameio"
+
+
+def logger() -> log.Logger:
+    """Returns already set up FAME-Io's logger or - if not set up - a new logger with level `INFO`"""
+    if not _loggers:
+        set_up_logger("info")
+        log.warning(_WARN_NOT_INITIALIZED)
+    return _loggers[0]
+
 
 def log_and_raise_critical(message: str) -> NoReturn:
     """Raises a critical error and logs with given `error_message`"""
-    log.critical(message)
+    logger().critical(message)
     raise Exception(message)
 
 
 def log_error_and_raise(exception: Exception) -> NoReturn:
     """Raises the specified `exception` and logs an error with the same `message`"""
-    log.error(str(exception))
+    logger().error(str(exception))
     raise exception
 
 
-def set_up_logger(level_name: str, file_name: Path) -> None:
+def set_up_logger(level_name: str, file_name: Optional[Path] = None) -> None:
     """Uses existing logger or sets up logger"""
-    if not log.getLogger().hasHandlers():
-        _set_up_new_logger(level_name, file_name)
+    if not _loggers:
+        _loggers.append(log.getLogger(LOGGER_NAME))
+        level = LOG_LEVELS.get(level_name.lower())
+        _set_log_level(level)
+        formatter = _get_formatter(level)
+        _add_handler(log.StreamHandler(), formatter)
+        if file_name:
+            _add_handler(log.FileHandler(file_name, mode="w"), formatter)
+    else:
+        log.warning(_WARN_ALREADY_INITIALIZED)
 
 
-def _set_up_new_logger(level_name: str, file_name: Path) -> None:
-    """Sets up new logger which always writes to the console and if provided also to `file_name`"""
-    level = LOG_LEVELS.get(level_name.lower())
-    if level is log.DEBUG:
-        formatter_string = (
-            "%(asctime)s.%(msecs)03d — %(levelname)s — %(module)s:%(funcName)s:%(lineno)d — %(message)s"  # noqa
-        )
-    else:
-        formatter_string = "%(asctime)s — %(levelname)s — %(message)s"  # noqa
+def _set_log_level(level: int) -> None:
+    """Set the global log level to given `level`"""
+    logger().setLevel(level)
 
-    log_formatter = log.Formatter(formatter_string, "%H:%M:%S")
 
-    root_logger = log.getLogger()
-    root_logger.setLevel(level)
+def _get_formatter(level: int) -> log.Formatter:
+    """
+    Returns a log formatter depending on the given log `level`
+    Args:
+        level: this log level determines how detailed the logger's output is
+    Returns:
+        new log formatter
+    """
+    return log.Formatter(_FORMAT_DETAILLED if level is log.DEBUG else _FORMAT_NORMAL, _TIME_FORMAT)
 
-    if file_name:
-        file_handler = log.FileHandler(file_name, mode="w")
-        file_handler.setFormatter(log_formatter)
-        root_logger.addHandler(file_handler)
 
-    console_handler = log.StreamHandler()
-    console_handler.setFormatter(log_formatter)
-    root_logger.addHandler(console_handler)
+def _add_handler(handler: log.Handler, formatter: log.Formatter) -> None:
+    """Adds given `handler` to root logger using the specified `formatter`"""
+    handler.setFormatter(formatter)
+    logger().addHandler(handler)

fameio/source/results/conversion.py

@@ -4,13 +4,12 @@
 
 import math
 from typing import Dict, Optional
-import logging as log
 
 import pandas as pd
 
 from fameio.source import FameTime
-from fameio.source.cli import TimeOptions, MergingOptions
-from fameio.source.logs import log_error_and_raise
+from fameio.source.cli.options import TimeOptions, MergingOptions
+from fameio.source.logs import log_error_and_raise, logger
 from fameio.source.time import ConversionException
 
 _ERR_UNIMPLEMENTED = "Time conversion mode '{}' not implemented."
@@ -28,7 +27,7 @@ def apply_time_merging(data: Dict[Optional[str], pd.DataFrame], config: Optional
         Nothing - data is modified inplace
     """
     if config:
-        log.debug(f"Grouping TimeSteps...")
+        logger().debug(f"Grouping TimeSteps...")
         offset = config[MergingOptions.STEPS_BEFORE]
         period = config[MergingOptions.STEPS_AFTER] + config[MergingOptions.STEPS_BEFORE] + 1
         first_positive_focal_point = config[MergingOptions.FOCAL_POINT] % period
@@ -37,7 +36,7 @@ def apply_time_merging(data: Dict[Optional[str], pd.DataFrame], config: Optional
             index_columns = df.index.names
             df.reset_index(inplace=True)
             df["TimeStep"] = df["TimeStep"].apply(lambda t: merge_time(t, first_positive_focal_point, offset, period))
-            data[key] = df.groupby(by=index_columns, axis=0).sum()
+            data[key] = df.groupby(by=index_columns).sum()
 
 
 def merge_time(time_step: int, focal_time: int, offset: int, period: int) -> int:
@@ -56,26 +55,25 @@ def merge_time(time_step: int, focal_time: int, offset: int, period: int) -> int
     return math.floor((time_step + offset - focal_time) / period) * period + focal_time
 
 
-def apply_time_option(data: Dict[Optional[str], pd.DataFrame], mode_name: str) -> None:
+def apply_time_option(data: Dict[Optional[str], pd.DataFrame], mode: TimeOptions) -> None:
     """
     Applies time option based on given `mode` inplace of given `data`
 
     Args:
         data: one or multiple DataFrames of time series; column `TimeStep` might be modified (depending on mode)
-        mode_name: name of time conversion mode (derived from Enum)
+        mode: name of time conversion mode (derived from Enum)
 
     Returns:
         Nothing - data is modified inplace
     """
-    mode_name = mode_name.upper()
-    if mode_name == TimeOptions.INT.name:
-        log.debug("No time conversion...")
-    elif mode_name == TimeOptions.UTC.name:
+    if mode == TimeOptions.INT:
+        logger().debug("No time conversion...")
+    elif mode == TimeOptions.UTC:
         _convert_time_index(data, "%Y-%m-%d %H:%M:%S")
-    elif mode_name == TimeOptions.FAME.name:
+    elif mode == TimeOptions.FAME:
         _convert_time_index(data, "%Y-%m-%d_%H:%M:%S")
     else:
-        log_error_and_raise(ConversionException(_ERR_UNIMPLEMENTED.format(mode_name)))
+        log_error_and_raise(ConversionException(_ERR_UNIMPLEMENTED.format(mode)))
 
 
 def _convert_time_index(data: Dict[Optional[str], pd.DataFrame], datetime_format: str) -> None:
@@ -90,7 +88,7 @@ def _convert_time_index(data: Dict[Optional[str], pd.DataFrame], datetime_format
     Returns:
         Nothing - data is modified inplace
     """
-    log.debug(f"Converting TimeStep to format '{datetime_format}'...")
+    logger().debug(f"Converting TimeStep to format '{datetime_format}'...")
     for _, df in data.items():
         index_columns = df.index.names
         df.reset_index(inplace=True)

fameio/source/results/csv_writer.py

@@ -1,14 +1,16 @@
-# SPDX-FileCopyrightText: 2023 German Aerospace Center <fame@dlr.de>
+# SPDX-FileCopyrightText: 2024 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: Apache-2.0
 
-import logging as log
 from pathlib import Path
 from typing import Dict, Union
 
 import pandas as pd
 
+from fameio.source.logs import logger
 from fameio.source.results.data_transformer import INDEX
+from fameio.source.series import TimeSeriesManager
+from fameio.source.tools import ensure_path_exists
 
 
 class CsvWriter:
@@ -28,15 +30,15 @@ class CsvWriter:
         """Returns name of the output folder derived either from the specified `config_output` or `input_file_path`"""
         if config_output:
             output_folder_name = config_output
-            log.info(CsvWriter._INFO_USING_PATH.format(config_output))
+            logger().info(CsvWriter._INFO_USING_PATH.format(config_output))
         else:
             output_folder_name = input_file_path.stem
-            log.info(CsvWriter._INFO_USING_DERIVED_PATH.format(output_folder_name))
+            logger().info(CsvWriter._INFO_USING_DERIVED_PATH.format(output_folder_name))
         return Path(output_folder_name)
 
     def _create_output_folder(self) -> None:
         """Creates output folder if not yet present"""
-        log.debug("Creating output folder if required...")
+        logger().debug("Creating output folder if required...")
         if not self._output_folder.is_dir():
             self._output_folder.mkdir(parents=True)
 
@@ -52,6 +54,15 @@ class CsvWriter:
                 identifier = self._get_identifier(agent_name, column_name)
                 self._write_data_frame(column_data, identifier)
 
+    def write_time_series_to_disk(self, timeseries_manager: TimeSeriesManager) -> None:
+        """Writes time_series of given `timeseries_manager` to disk"""
+        for _, name, data in timeseries_manager.get_all_series():
+            if data is not None:
+                target_path = Path(self._output_folder, name)
+                ensure_path_exists(target_path.parent)
+                # noinspection PyTypeChecker
+                data.to_csv(path_or_buf=target_path, sep=";", header=None, index=None)
+
     @staticmethod
     def _get_identifier(agent_name: str, column_name: str, agent_id: str = None) -> str:
         """Returns unique identifier for given `agent_name` and (optional) `agent_id` and `column_name`"""

fameio/source/results/data_transformer.py

@@ -1,6 +1,7 @@
 # SPDX-FileCopyrightText: 2023 German Aerospace Center <fame@dlr.de>
 #
 # SPDX-License-Identifier: Apache-2.0
+from __future__ import annotations
 
 from abc import ABC
 from builtins import staticmethod
@@ -10,7 +11,7 @@ import pandas as pd
 from fameprotobuf.Services_pb2 import Output
 from pandas import DataFrame
 
-from fameio.source.cli import ResolveOptions
+from fameio.source.cli.options import ResolveOptions
 from fameio.source.results.agent_type import AgentType
 
 INDEX = ("AgentId", "TimeStep")
@@ -27,7 +28,7 @@ class DataTransformer(ABC):
     SIMPLE_COLUMN_INDEX = -1
 
     @staticmethod
-    def build(complex_column_mode: ResolveOptions) -> "DataTransformer":
+    def build(complex_column_mode: ResolveOptions) -> DataTransformer:
         return DataTransformer.MODES[complex_column_mode]()
 
     def extract_agent_data(