Cycles-utils 3.1.0__tar.gz → 4.0.0__tar.gz

{cycles_utils-3.1.0 → cycles_utils-4.0.0}/Cycles_utils.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Cycles-utils
-Version: 3.1.0
+Version: 4.0.0
 Summary: Python scripts to build Cycles input files and post-process Cycles output files
 Home-page: https://github.com/PSUmodeling/Cycles-utils
 Author: Yuning Shi
@@ -53,4 +53,4 @@ pip install Cycles-utils
 
 # API reference
 
-Coming soon
+[psumodeling.github.io/Cycles-utils](https://psumodeling.github.io/Cycles-utils)

{cycles_utils-3.1.0 → cycles_utils-4.0.0}/Cycles_utils.egg-info/SOURCES.txt

@@ -10,7 +10,17 @@ Cycles_utils.egg-info/top_level.txt
 cycles/__init__.py
 cycles/cycles.py
 cycles/cycles_runner.py
-cycles/cycles_tools.py
+cycles/rotation_builder.py
+cycles/cycles_tools/__init__.py
+cycles/cycles_tools/_base_file.py
+cycles/cycles_tools/control_file.py
+cycles/cycles_tools/nudge_file.py
+cycles/cycles_tools/operation_file.py
+cycles/cycles_tools/output_file.py
+cycles/cycles_tools/plot_tools.py
+cycles/cycles_tools/reinit_file.py
+cycles/cycles_tools/soil_file.py
+cycles/cycles_tools/weather_file.py
 cycles/data/GLDASp5_elevation_025d.nc4
 cycles/data/GLDASp5_landmask_025d.nc4
 cycles/data/NLDAS_elevation.nc4
@@ -21,9 +31,9 @@ cycles/data/metdata_elevationdata.nc
 cycles/data/us_states.csv
 cycles/gadm/__init__.py
 cycles/gadm/gadm.py
-cycles/gssurgo/__init__.py
-cycles/gssurgo/gssurgo.py
 cycles/soilgrids/__init__.py
 cycles/soilgrids/soilgrids.py
+cycles/ssurgo/__init__.py
+cycles/ssurgo/ssurgo.py
 cycles/weather/__init__.py
 cycles/weather/weather.py

{cycles_utils-3.1.0 → cycles_utils-4.0.0}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Penn State Earth System Modeling Team
+Copyright (c) 2026 Penn State Earth System Modeling Team
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{cycles_utils-3.1.0 → cycles_utils-4.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Cycles-utils
-Version: 3.1.0
+Version: 4.0.0
 Summary: Python scripts to build Cycles input files and post-process Cycles output files
 Home-page: https://github.com/PSUmodeling/Cycles-utils
 Author: Yuning Shi
@@ -53,4 +53,4 @@ pip install Cycles-utils
 
 # API reference
 
-Coming soon
+[psumodeling.github.io/Cycles-utils](https://psumodeling.github.io/Cycles-utils)

{cycles_utils-3.1.0 → cycles_utils-4.0.0}/README.md

@@ -15,4 +15,4 @@ pip install Cycles-utils
 
 # API reference
 
-Coming soon
+[psumodeling.github.io/Cycles-utils](https://psumodeling.github.io/Cycles-utils)

cycles_utils-4.0.0/cycles/__init__.py

@@ -0,0 +1,17 @@
+from .cycles import Cycles
+from .cycles_tools import generate_control_file
+from .cycles_tools import generate_nudge_file
+from .cycles_tools import generate_soil_file
+from .cycles_tools import generate_reinit_file
+from .cycles_tools import read_control_file
+from .cycles_tools import read_soil_file
+from .cycles_tools import read_weather_file
+from .cycles_tools import read_output
+from .cycles_tools import read_operation_file
+from .cycles_tools import SoilLayer
+from .cycles_tools import plot_yield
+from .cycles_tools import plot_operations
+from .cycles_tools import plot_map
+from .cycles_tools import Operation, Planting, Tillage, Harvest, Kill, FixedFertilization, FixedIrrigation, AutoIrrigation
+from .cycles_runner import CyclesRunner
+from .rotation_builder import CyclesRotationBuilder, Crop, CropGroup

cycles_utils-4.0.0/cycles/cycles.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+import numpy as np
+import os
+import pandas as pd
+import subprocess
+from collections.abc import Collection
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from matplotlib.axes import Axes
+from .cycles_tools import SoilLayer, ControlConfig
+from .cycles_tools import read_control_file as _read_control_file
+from .cycles_tools import read_soil_file as _read_soil_file
+from .cycles_tools import read_weather_file as _read_weather_file
+from .cycles_tools import read_output as _read_output
+from .cycles_tools import read_operation_file as _read_operation_file
+from .cycles_tools import generate_reinit_file as _generate_reinit_file
+from .cycles_tools import plot_yield as _plot_yield
+from .cycles_tools import plot_operations as _plot_operations
+
+@dataclass
+class Output:
+    data: pd.DataFrame
+    units: dict[str, str]
+
+@dataclass
+class Cycles:
+    """Interface for executing one Cycles simulation and reading its files.
+
+    Provides methods to run simulations, read outputs, and inspect soil/weather/operation
+    configurations. Automatically loads the control file upon initialization.
+
+    Attributes:
+        path: Path to the simulation directory (containing input/ and output/ subdirs).
+        simulation: Name of the simulation (base name of control file without extension).
+        output: Dictionary mapping output table names to Output objects with data and units.
+        control: Parsed control file configuration from the input directory.
+        operations: List of parsed operation records from the operation file.
+        soil_profile: List of SoilLayer objects describing the soil profile.
+        curve_number: Runoff curve number for hydrologic calculations.
+        slope: Land slope used in erosion and runoff models.
+        weather: DataFrame of weather forcing data (temperature, precipitation, etc.).
+        executable: Absolute path to the Cycles executable binary.
+    """
+
+    path: Path | str
+    simulation: str
+    output: dict[str, Output] = field(default_factory=dict[str, Output])
+    control: ControlConfig | None = None
+    operations: list | None = None
+    soil_profile: list[SoilLayer] | None = None
+    curve_number: int | None = None
+    slope: float | None = None
+    weather: pd.DataFrame | None = None
+    executable: Path | str | None = None
+
+
+    def __post_init__(self):
+        self.path = Path(self.path)
+        assert isinstance(self.path, Path)
+        self.control = _read_control_file(self.path / 'input' / f'{self.simulation}.ctrl')
+        if self.executable is not None:
+            self.executable = str(Path(self.executable).resolve())
+
+
+    def run(self, options: str, silence: bool=False) -> tuple[int, str]:
+        """Run the Cycles executable for this simulation.
+
+        Args:
+            options: Command-line options passed to Cycles.
+            silence: If True, suppress stdout and stderr printing.
+
+        Returns:
+            A tuple with process return code and stdout text.
+        """
+        cmd = [self.executable, *(options.split() if options else []), self.simulation]
+        result = subprocess.run(
+            cmd,
+            shell=os.name == 'nt',
+            capture_output=True,
+            text=True,
+        )
+        if not silence:
+            print(result.stdout)
+        if result.stderr:
+            print(result.stderr)
+        return result.returncode, result.stdout
+
+
+    def read_output(self, output_types: Collection) -> None:
+        """Read one or more output tables into memory.
+
+        Args:
+            output_types: Output table name or collection of names.
+        """
+        assert isinstance(self.path, Path)
+        if isinstance(output_types, str):
+            output_types = output_types,
+
+        for output_type in output_types:
+            df, units = _read_output(self.path / 'output' / self.simulation, output_type)
+            self.output[output_type] = Output(data=df, units=units)
+
+
+    def read_operation_file(self) -> None:
+        """Load operation records defined in the control file."""
+        assert isinstance(self.path, Path)
+        assert self.control is not None
+        self.operations = _read_operation_file(self.path / 'input' / self.control.input_files.operation_file)
+
+
+    def read_soil_file(self) -> None:
+        """Load soil profile layers and metadata from the configured soil file."""
+        assert isinstance(self.path, Path)
+        assert self.control is not None
+        self.soil_profile, meta = _read_soil_file(self.path / 'input' / self.control.input_files.soil_file)
+        self.curve_number = meta['curve_number']
+        self.slope = meta['slope']
+
+
+    def read_weather_file(self, *, start_year: int=-9999, end_year: int=9999, subdaily: bool=False) -> None:
+        """Read weather forcing data for the configured weather file.
+
+        Args:
+            start_year: Inclusive first year to keep.
+            end_year: Inclusive last year to keep.
+            subdaily: If True, parse hourly format instead of daily.
+        """
+        assert isinstance(self.path, Path)
+        assert self.control is not None
+        self.weather = _read_weather_file(self.path / 'input' / self.control.input_files.weather_file, start_year=start_year, end_year=end_year, subdaily=subdaily)
+
+
+    def generate_reinit_file(self, doy: int, *, reinit: str | None=None) -> None:
+        """Generate a reinitialization file from model output.
+
+        Args:
+            doy: Day-of-year to extract from reinit output.
+            reinit: Optional output stem for the reinit file.
+        """
+        assert isinstance(self.path, Path)
+        _generate_reinit_file(self.path / 'input' / f'{self.simulation if reinit is None else reinit}.reinit', self.path / 'output' / self.simulation, doy)
+
+
+    def plot_yield(self, *, ax: Axes | None=None, fontsize: int | None=None) -> Axes:
+        """Plot grain and forage yields from harvest output."""
+        if 'harvest' not in self.output:
+            self.read_output('harvest')
+
+        return _plot_yield(self.output['harvest'].data, ax=ax, fontsize=fontsize)
+
+
+    def plot_operations(self, rotation_size: int | None=None, *, axs: Axes | np.ndarray | None=None, fontsize: int | None=None):
+        """Plot operation timelines grouped by rotation year.
+
+        Args:
+            rotation_size: Number of years in the plotted rotation.
+            axs: Optional axes object(s) to draw on.
+            fontsize: Global matplotlib font size override.
+
+        Returns:
+            The axes used for plotting.
+        """
+        if self.operations is None:
+            self.read_operation_file()
+
+        assert self.control is not None
+        assert self.operations is not None
+
+        if rotation_size is None:
+            rotation_size = self.control.simulation_years.rotation_size
+
+        return _plot_operations(self.operations, rotation_size, axs=axs, fontsize=fontsize)

cycles_utils-4.0.0/cycles/cycles_runner.py

@@ -0,0 +1,170 @@
+from __future__ import annotations
+import os
+import pandas as pd
+import shutil
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+from string import Template
+from typing import Any
+from .cycles import Cycles
+from .cycles_tools import generate_control_file, generate_nudge_file, resolve_dict_values
+
+SimulationConfig = list[dict] | pd.DataFrame
+
+INPUT_DIR: Path = Path('input')
+OUTPUT_DIR: Path = Path('output')
+SUMMARY_DIR: Path = Path('summary')
+
+@dataclass
+class SimulationContext:
+    name: str
+    control_dict: dict
+    operation_dict: dict | None
+    calibration_dict: dict | None
+    operation_fn: Path
+
+
+@dataclass
+class CyclesRunner:
+    """Run one or many Cycles simulations with templated inputs.
+
+    Manages batch execution of Cycles simulations by generating control files,
+    operation files, and nudge files from templates and parameter dictionaries.
+    Consolidates results into a summary CSV file.
+
+    Attributes:
+        executable: Absolute path to the Cycles executable binary.
+        rotation_builder: If True, disables spin-up option and enables rotation features.
+    """
+
+    executable: str
+    rotation_builder: bool = False
+
+    def __post_init__(self):
+        self.executable = str(Path(self.executable).resolve())
+
+
+    def run(self, simulations: SimulationConfig, control_dict: dict[str, Any], *,
+        summary: str='summary.csv', operation_template: Path | str | None=None, operation_dict: dict[str, Any] | None=None, calibration_dict: dict[str, Any] | None=None,
+        options: str='', rm_input: bool=False, rm_output: bool=False, rm_steady_state_soil: bool=True, silence: bool=True, user_comment: str='') -> None:
+        """Execute a batch of simulations and write a consolidated summary.
+
+        Args:
+            simulations: Simulation rows as list of dicts or a DataFrame.
+            control_dict: Control-file values or callables evaluated per row.
+            summary: Summary CSV name written under summary directory.
+            operation_template: Template file for generated operation files.
+            operation_dict: Substitutions used with operation template.
+            calibration_dict: Nudge-file values or callables per row.
+            options: Cycles command options.
+            rm_input: Remove generated input files after each run.
+            rm_output: Remove run output directory after each run.
+            rm_steady_state_soil: Remove generated steady-state soil file.
+            silence: If True, suppress simulation screen output.
+            user_comment: Optional text prefixed to summary header comments.
+        """
+        if isinstance(simulations, pd.DataFrame):
+            simulations = simulations.to_dict(orient='records')
+        assert isinstance(simulations, list)
+
+        if (operation_template is None) != (operation_dict is None):
+            raise ValueError(
+                "operation_template and operation_dict must be provided together or not at all. "
+                f"Got operation_template={'None' if operation_template is None else repr(operation_template)}, "
+                f"operation_dict={'None' if operation_dict is None else '...'}"
+            )
+
+        if 's' in options and self.rotation_builder:
+            raise ValueError('Spin-up cannot be used with rotation builder.')
+
+        operation_template = Path(operation_template) if operation_template is not None else None
+        comment = user_comment + _generate_comment(self.executable, options)
+        first_run = True
+
+        SUMMARY_DIR.mkdir(exist_ok=True)
+
+        for s in simulations:
+            cxt: SimulationContext = self._resolve(s, control_dict, operation_dict, calibration_dict)
+            print(f'{cxt.name} - ', end='')
+
+            self._write_inputs(cxt, operation_template)
+
+            cycles = Cycles(path='.', simulation=cxt.name, executable=self.executable)
+
+            code, _ = cycles.run(options=options, silence=silence)
+
+            if code == 0:
+                self._write_summary(cycles, summary, header=first_run, comment=comment)
+                first_run = False
+                print('Success')
+            elif code == 1:
+                print('Fail')
+
+            if rm_input:
+                self._remove_inputs(cxt)
+            if rm_output:
+                shutil.rmtree(OUTPUT_DIR / cxt.name, ignore_errors=True)
+            if rm_steady_state_soil:
+                (INPUT_DIR / f'{cxt.name}_ss.soil').unlink(missing_ok=True)
+
+
+    def _resolve(self, simulation: dict[str, Any], control_dict: dict[str, Any], operation_dict: dict[str, Any] | None, calibration_dict: dict[str, Any] | None) -> SimulationContext:
+        """Call control_dict once per row and resolve all derived values."""
+        control = resolve_dict_values(control_dict, simulation)
+        return SimulationContext(
+            name=control['simulation_name'],
+            control_dict=control,
+            operation_dict=resolve_dict_values(operation_dict, simulation) if operation_dict is not None else None,
+            calibration_dict=resolve_dict_values(calibration_dict, simulation) if calibration_dict is not None else None,
+            operation_fn=INPUT_DIR / control['operation_file'],
+        )
+
+
+    def _write_inputs(self, cxt: SimulationContext, operation_template: Path | None) -> None:
+        if operation_template is not None:
+            assert cxt.operation_dict is not None
+            _render_template(operation_template, cxt.operation_fn, cxt.operation_dict)
+        if cxt.calibration_dict is not None:
+            generate_nudge_file(INPUT_DIR / f'{cxt.name}.nudge', cxt.calibration_dict)
+        generate_control_file(INPUT_DIR / f'{cxt.name}.ctrl', cxt.control_dict)
+
+
+    def _remove_inputs(self, cxt: SimulationContext) -> None:
+        (INPUT_DIR / f'{cxt.name}.ctrl').unlink(missing_ok=True)
+        (INPUT_DIR / f'{cxt.name}.nudge').unlink(missing_ok=True)
+        if cxt.operation_dict is not None:
+            cxt.operation_fn.unlink(missing_ok=True)
+
+
+    def _write_summary(self, cycles: Cycles, summary: str, *, header: bool, comment: str) -> None:
+        cycles.read_output('harvest')
+        cycles.output['harvest'].data.insert(0, 'simulation', cycles.simulation)
+
+        mode = 'w' if header else 'a'
+        with open(SUMMARY_DIR / summary, mode) as f:
+            if header:
+                f.write(comment)
+            cycles.output['harvest'].data.to_csv(f, header=header, index=False)
+
+
+def _render_template(template_fn: Path, dest_fn: Path, substitutions: dict) -> None:
+    dest_fn.write_text(Template(template_fn.read_text()).substitute(substitutions) + '\n')
+
+
+def _generate_comment(executable: str, options: str) -> str:
+    result = subprocess.run(
+        [executable, '-V'],
+        shell=os.name == 'nt',
+        capture_output=True,
+        text=True,
+    )
+    version = ''.join(result.stdout.splitlines())
+    parts = [
+        f'# {version}',
+        'with spin-up' if 's' in options else 'without spin-up',
+        'with calibration' if 'n' in options else None,
+        'grain model turned on' if 'g' in options else None,
+        'dynamically reduced fertilization rates' if 'x' in options else None,
+    ]
+    return ', '.join(p for p in parts if p) + '\n'

cycles_utils-4.0.0/cycles/cycles_tools/__init__.py

@@ -0,0 +1,34 @@
+from .control_file import generate_control_file
+from .control_file import read_control_file
+from .control_file import ControlConfig
+from .nudge_file import generate_nudge_file
+from .operation_file import read_operation_file
+from .operation_file import Operation, Planting, Tillage, Harvest, Kill, FixedFertilization, FixedIrrigation, AutoIrrigation
+from .output_file import read_output
+from .soil_file import MAPPABLE_PARAMETERS
+from .soil_file import SoilLayer
+from .soil_file import generate_soil_file
+from .soil_file import read_soil_file
+from .soil_file import map_to_dataframe
+from .soil_file import from_dataframe
+from .weather_file import read_weather_file
+from .reinit_file import generate_reinit_file
+from .plot_tools import plot_yield
+from .plot_tools import plot_operations
+from .plot_tools import plot_map
+from ._base_file import resolve_dict_values
+
+__all__ = [
+    "generate_control_file",
+    "read_control_file",
+    "generate_nudge_file",
+    "read_operation_file",
+    "read_output",
+    "generate_soil_file",
+    "read_soil_file",
+    "read_weather_file",
+    "generate_reinit_file",
+    "plot_yield",
+    "plot_operations",
+    "plot_map",
+]

cycles_utils-4.0.0/cycles/cycles_tools/_base_file.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+import types
+from dataclasses import fields
+from pathlib import Path
+from typing import Union, Any
+
+def _format_block(label: str, block) -> str:
+    lines = [f'## {label.replace("_", " ").upper()} ##']
+    for f in fields(block):
+        lines.append('%-27s\t%s' % (f.name.upper(), getattr(block, f.name)))
+    lines.append('')
+
+    return '\n'.join(lines)
+
+
+def write_file(fn: Path, config) -> None:
+    content = '\n'.join(
+        _format_block(f.name, getattr(config, f.name))
+        for f in fields(config)
+        if getattr(config, f.name) is not None
+    )
+    fn.write_text(content)
+
+
+def resolve_dict_values(user_dict: dict, simulation: dict[str, Any] | None) -> dict:
+    return {key: func(simulation) if callable(func) else func for key, func in user_dict.items()}
+
+
+def extract(dc_class, resolved: dict) -> dict:
+    return {f.name: resolved[f.name] for f in fields(dc_class) if f.name in resolved}
+
+
+def parse_value(raw: str, name: str, hint: type) -> int | float | str:
+    hint = unwrap_optional(hint)
+    if raw.split()[0].lower() == name.lower():
+        if hint is int: return int(raw.split()[1])
+        if hint is float: return float(raw.split()[1])
+        return raw.split()[1]
+    else:
+        raise ValueError(f"Expected field name '{name}' not found in line: {raw}")
+
+
+def unwrap_optional(t) -> type:
+    origin = getattr(t, '__origin__', None)
+    if origin is Union or origin is types.UnionType:
+        return next(arg for arg in t.__args__ if arg is not type(None))
+    return t

cycles_utils-4.0.0/cycles/cycles_tools/control_file.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+import warnings
+from dataclasses import dataclass, fields
+from pathlib import Path
+from typing import Any, get_type_hints
+from ._base_file import write_file, resolve_dict_values, extract, parse_value, unwrap_optional
+
+@dataclass(kw_only=True)
+class SimulationYears:
+    simulation_start_year: int
+    simulation_end_year: int
+    rotation_size: int
+
+@dataclass(kw_only=True)
+class InputFiles:
+    crop_file: str = 'GenericCrops.crop'
+    operation_file: str
+    soil_file: str
+    weather_file: str
+    reinit_file: str = 'N/A'
+
+@dataclass(kw_only=True)
+class SimulationOptions:
+    soil_layers: int
+    co2_level: float = -999
+    use_reinitialization: int = 0
+    adjusted_yields: int = 0
+    hydrology_option: int = 1
+    automatic_nitrogen: int = 0
+    automatic_phosphorus: int = 0
+    automatic_sulfur: int = 0
+
+@dataclass(kw_only=True)
+class OutputControl:
+    daily_weather_out: int = 0
+    daily_crop_out: int = 0
+    daily_residue_out: int = 0
+    daily_water_out: int = 0
+    daily_nitrogen_out: int = 0
+    daily_soil_carbon_out: int = 0
+    daily_soil_lyr_cn_out: int = 0
+    annual_soil_out: int = 0
+    annual_profile_out: int = 0
+    annual_nflux_out: int = 0
+
+@dataclass
+class ControlConfig:
+    simulation_years: SimulationYears
+    input_files: InputFiles
+    simulation_options: SimulationOptions
+    output_control: OutputControl
+
+
+def _build_control_config(control_dict: dict, simulation_dict: dict[str, Any] | None, input_dir: Path) -> ControlConfig:
+    resolved = resolve_dict_values(control_dict, simulation_dict)
+
+    if 'soil_layers' not in resolved:
+        resolved['soil_layers'] = _get_soil_layers(input_dir / resolved['soil_file'])
+
+    return ControlConfig(
+        simulation_years=SimulationYears(**extract(SimulationYears, resolved)),
+        input_files=InputFiles(**extract(InputFiles, resolved)),
+        simulation_options=SimulationOptions(**extract(SimulationOptions, resolved)),
+        output_control=OutputControl(**extract(OutputControl, resolved)),
+    )
+
+
+def _get_soil_layers(fn: Path) -> int:
+    NUM_HEADER_LINES = 2
+    try:
+        lines = [line for line in fn.read_text().splitlines() if line.strip() and not line.strip().startswith('#')]
+        return len(lines) - NUM_HEADER_LINES - 1
+    except FileNotFoundError:
+        warnings.warn(f"Soil file not found: {fn}")
+        return -999
+
+
+def generate_control_file(fn: str | Path, user_dict: dict, *, simulation_dict: dict[str, Any] | None=None) -> ControlConfig:
+    """Generate and write a Cycles control file.
+
+    Args:
+        fn: Destination control file path.
+        user_dict: Values or callables for control fields.
+        simulation_dict: Optional simulation row for callable resolution.
+
+    Returns:
+        The generated control configuration.
+    """
+    fn = Path(fn)
+    config = _build_control_config(user_dict, simulation_dict, fn.parent)
+    write_file(fn, config)
+
+    return config
+
+
+def read_control_file(control: str | Path) -> ControlConfig:
+    """Parse a Cycles control file into a ControlConfig instance.
+
+    Args:
+        control: Path to a Cycles control file path.
+
+    Returns:
+        Control configuration.
+    """
+    with open(Path(control)) as f:
+        lines = f.read().splitlines()
+    lines = iter([line for line in lines if (not line.strip().startswith('#')) and line.strip()])
+
+    hints = get_type_hints(ControlConfig)   # resolves all string annotations → actual types
+
+    control_dict = {}
+    for f in fields(ControlConfig):
+        target_class = unwrap_optional(hints[f.name])
+        sub_hints = get_type_hints(target_class)
+        control_dict[f.name] = target_class(**{sub_field.name: parse_value(next(lines), sub_field.name, sub_hints[sub_field.name]) for sub_field in fields(target_class)})
+
+    return ControlConfig(**control_dict)