pytesprocess 0.1.1__py3-none-any.whl

pytesprocess/config/manager.py

@@ -0,0 +1,297 @@
+from __future__ import annotations
+
+import copy
+import warnings
+
+from .loader import load_processing_yaml
+from .warnings import ConfigDeprecationWarning
+from .resolvers import FeatureConfigResolver, TriggerConfigResolver, SaltingConfigResolver
+from .resolvers.common import rename_obsolete_keys
+from .validation import (
+    normalize_workflows, validate_resolved_workflow,
+    format_validation_summary,
+)
+
+
+_LEGACY_TRIGGER_OVERALL = {'coincident_window_msec', 'coincident_window_samples'}
+_LEGACY_SALTING_OVERALL = {
+    'dm_pdf_file', 'coincident_salts', 'energies', 'nsalt', 'do_salt_deadtime',
+    'random_seed'
+}
+_RESERVED_TOP_LEVEL = {
+    'config_version', 'resources', 'trigger', 'feature', 'salting', 'filter',
+    'ivsweep', 'didv', 'noise', 'template', 'global', 'filter_file', 'didv_file'
+}
+
+
+class ProcessingConfig:
+    """Load processing YAML once and resolve each workflow lazily.
+
+    The returned workflow dictionaries intentionally retain the runtime shape
+    expected by the existing TriggerProcessing/FeatureProcessing code. This
+    lets the public YAML evolve independently from processing internals.
+    """
+
+    def __init__(self, yaml_file, available_channels, sample_rate=None,
+                 verbose=True):
+        self._yaml_file = yaml_file
+        self._available_channels = ([available_channels]
+                                    if isinstance(available_channels, str)
+                                    else list(available_channels or []))
+        self._sample_rate = sample_rate
+        self._verbose = bool(verbose)
+        raw, version, path = load_processing_yaml(yaml_file)
+        self._version = int(version)
+        self._path = path
+        self._raw = rename_obsolete_keys(raw, self._version)
+        self._canonical = self._normalize(self._raw)
+        self._cache = {}
+
+    @property
+    def config_version(self):
+        return self._version
+
+    @property
+    def path(self):
+        return str(self._path)
+
+    def validate(self, workflows=None, check_resources=False, display=False):
+        """Resolve and validate requested workflow configurations up front.
+
+        Parameters
+        ----------
+        workflows : str or iterable of str, optional
+            Workflows to validate (for example ``['trigger', 'feature']``).
+            If omitted, validate every workflow that is configured in the YAML.
+        check_resources : bool, optional
+            If True, also check that configured input files such as
+            ``filter_file`` exist.  FilterData contents and raw-data-dependent
+            checks remain runtime validation.
+        display : bool, optional
+            Print a compact validation summary.
+
+        Returns
+        -------
+        dict
+            Validation summary suitable for a future CLI startup report.
+
+        Notes
+        -----
+        This method performs no processing and intentionally is not called by
+        ``scripts/process.py`` yet.  It lets a future multi-step CLI validate
+        all requested workflows before starting the first processing stage.
+        """
+        names = normalize_workflows(workflows)
+        if names is None:
+            names = self._configured_workflows()
+
+        summary = {
+            'valid': True,
+            'config_version': self._version,
+            'config_file': str(self._path),
+            'workflows': {},
+        }
+        for name in names:
+            resolved = self.get_config(name)
+            summary['workflows'][name] = validate_resolved_workflow(
+                name, resolved, check_resources=bool(check_resources))
+
+        if display:
+            print(format_validation_summary(summary))
+        return copy.deepcopy(summary)
+
+    def _configured_workflows(self):
+        names = []
+        for name in ('trigger', 'feature', 'salting', 'filter', 'ivsweep',
+                     'didv', 'noise', 'template'):
+            section = self._canonical.get(name, {})
+            if not isinstance(section, dict):
+                continue
+            if name in {'trigger', 'salting'}:
+                configured = bool(section.get('global') or section.get('channels'))
+            elif name == 'feature':
+                configured = bool(
+                    section.get('global') or section.get('presets') or
+                    section.get('channels'))
+            else:
+                configured = bool(section)
+            if configured:
+                names.append(name)
+        return names
+
+    def get_config(self, processing_type=None):
+        if processing_type is None:
+            out = {
+                'global': copy.deepcopy(self._canonical['resources'])
+            }
+            for name in ('trigger', 'feature', 'salting', 'filter', 'ivsweep',
+                         'didv', 'noise', 'template'):
+                out[name] = self.get_config(name)
+            return out
+
+        name = str(processing_type).lower()
+        if name in self._cache:
+            return copy.deepcopy(self._cache[name])
+
+        if name == 'feature':
+            resolved = FeatureConfigResolver(
+                self._canonical['feature'],
+                self._canonical['resources'],
+                self._available_channels,
+                sample_rate_hz=self._sample_rate,
+                version=self._version,
+            ).resolve()
+        elif name == 'trigger':
+            resolved = TriggerConfigResolver(
+                self._canonical['trigger'], self._canonical['resources'],
+                self._available_channels, version=self._version,
+            ).resolve()
+        elif name == 'salting':
+            resolved = SaltingConfigResolver(
+                self._canonical['salting'], self._canonical['resources'],
+                self._available_channels, version=self._version,
+            ).resolve()
+        elif name in {'filter', 'ivsweep'}:
+            resolved = copy.deepcopy(self._canonical.get(name, {}))
+        elif name in {'didv', 'noise', 'template'}:
+            resolved = self._resolve_generic_legacy_section(name)
+        else:
+            raise ValueError(f'ERROR: Configuration type "{processing_type}" not found!')
+
+        self._cache[name] = copy.deepcopy(resolved)
+        return copy.deepcopy(resolved)
+
+    def _normalize(self, raw):
+        if self._version >= 2:
+            return self._normalize_v2(raw)
+        return self._normalize_legacy(raw)
+
+    def _normalize_v2(self, raw):
+        allowed = {
+            'config_version', 'resources', 'trigger', 'feature', 'salting',
+            'filter', 'ivsweep', 'didv', 'noise', 'template'
+        }
+        unknown = set(raw) - allowed
+        if unknown:
+            raise ValueError(
+                f'ERROR: Unknown top-level config_version: 2 field(s): {sorted(unknown)}. '
+                f'Allowed fields are {sorted(allowed)}.'
+            )
+        resources = copy.deepcopy(raw.get('resources', {}))
+        if not isinstance(resources, dict):
+            raise ValueError('ERROR: "resources" must be a mapping.')
+        return {
+            'resources': resources,
+            'trigger': self._normalize_v2_workflow(raw.get('trigger', {}), 'trigger'),
+            'feature': copy.deepcopy(raw.get('feature', {})),
+            'salting': self._normalize_v2_workflow(raw.get('salting', {}), 'salting'),
+            'filter': copy.deepcopy(raw.get('filter', {})),
+            'ivsweep': copy.deepcopy(raw.get('ivsweep', {})),
+            'didv': copy.deepcopy(raw.get('didv', {})),
+            'noise': copy.deepcopy(raw.get('noise', {})),
+            'template': copy.deepcopy(raw.get('template', {})),
+        }
+
+    def _normalize_v2_workflow(self, section, name):
+        if section is None:
+            return {'global': {}, 'channels': {}}
+        if not isinstance(section, dict):
+            raise ValueError(f'ERROR: "{name}" must be a mapping.')
+        allowed = {'global', 'channels'}
+        unknown = set(section) - allowed
+        if unknown:
+            raise ValueError(
+                f'ERROR: config_version: 2 requires {name} settings under '
+                f'"{name}.global" or "{name}.channels". Unknown: {sorted(unknown)}'
+            )
+        return {
+            'global': copy.deepcopy(section.get('global', {})),
+            'channels': copy.deepcopy(section.get('channels', {})),
+        }
+
+    def _normalize_legacy(self, raw):
+        warnings.warn(
+            'Legacy processing YAML syntax is deprecated. Add "config_version: 2" '
+            'and move feature channel configuration under "feature.channels".',
+            ConfigDeprecationWarning,
+            stacklevel=3,
+        )
+        work = copy.deepcopy(raw)
+        resources = {}
+        for key in ('filter_file', 'didv_file'):
+            if key in work:
+                resources[key] = work.pop(key)
+
+        trigger_raw = work.pop('trigger', {}) or {}
+        salting_raw = work.pop('salting', {}) or {}
+        explicit_feature = work.pop('feature', {}) or {}
+        filter_cfg = work.pop('filter', {}) or {}
+        ivsweep_cfg = work.pop('ivsweep', {}) or {}
+        didv_cfg = work.pop('didv', {}) or {}
+        noise_cfg = work.pop('noise', {}) or {}
+        template_cfg = work.pop('template', {}) or {}
+        global_feature = work.pop('global', {}) or {}
+        work.pop('config_version', None)
+        work.pop('resources', None)
+
+        trigger = self._split_legacy_section(trigger_raw, _LEGACY_TRIGGER_OVERALL)
+        salting = self._split_legacy_section(salting_raw, _LEGACY_SALTING_OVERALL)
+
+        feature = {'global': {}, 'channels': {}}
+        if isinstance(explicit_feature, dict):
+            if 'global' in explicit_feature:
+                feature['global'].update(copy.deepcopy(explicit_feature['global']))
+            for key, value in explicit_feature.items():
+                if key != 'global':
+                    feature['channels'][key] = copy.deepcopy(value)
+        feature['global'].update(copy.deepcopy(global_feature))
+
+        # Any remaining legacy root key is a feature channel/expression.
+        for key, value in work.items():
+            if key in _RESERVED_TOP_LEVEL:
+                continue
+            feature['channels'][key] = copy.deepcopy(value)
+
+        return {
+            'resources': resources,
+            'trigger': trigger,
+            'feature': feature,
+            'salting': salting,
+            'filter': filter_cfg,
+            'ivsweep': ivsweep_cfg,
+            'didv': didv_cfg,
+            'noise': noise_cfg,
+            'template': template_cfg,
+        }
+
+    @staticmethod
+    def _split_legacy_section(section, overall_keys):
+        if section is None:
+            return {'global': {}, 'channels': {}}
+        if not isinstance(section, dict):
+            raise ValueError('ERROR: Legacy workflow section must be a mapping.')
+        global_cfg = {}
+        channels = {}
+        for key, value in section.items():
+            if key in overall_keys:
+                global_cfg[key] = copy.deepcopy(value)
+            elif key == 'global' and isinstance(value, dict):
+                global_cfg.update(copy.deepcopy(value))
+            elif key == 'channels' and isinstance(value, dict):
+                channels.update(copy.deepcopy(value))
+            else:
+                channels[key] = copy.deepcopy(value)
+        return {'global': global_cfg, 'channels': channels}
+
+    def _resolve_generic_legacy_section(self, name):
+        section = copy.deepcopy(self._canonical.get(name, {}))
+        if not section:
+            return {'overall': {}, 'channels': {}}
+        if isinstance(section, dict) and ('global' in section or 'channels' in section):
+            return {
+                'overall': copy.deepcopy(section.get('global', {})),
+                'channels': copy.deepcopy(section.get('channels', {})),
+            }
+        # Preserve the old generic behavior: arbitrary section keys were treated
+        # as channel configurations.
+        return {'overall': {}, 'channels': section if isinstance(section, dict) else {}}

pytesprocess/config/resolvers/__init__.py

@@ -0,0 +1,5 @@
+from .feature import FeatureConfigResolver
+from .trigger import TriggerConfigResolver
+from .salting import SaltingConfigResolver
+
+__all__ = ['FeatureConfigResolver', 'TriggerConfigResolver', 'SaltingConfigResolver']

pytesprocess/config/resolvers/common.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import copy
+import warnings
+
+from ..warnings import ConfigDeprecationWarning
+
+
+LEGACY_OBSOLETE_KEYS = {
+    'trigger_name': 'trigger_channel',
+    'nb_samples': 'trace_length_samples',
+    'nb_pretrigger_samples': 'pretrigger_length_samples',
+    'template_time_tags': 'template_group_ids',
+    'psd_tag': 'csd_tag',
+    'noise_tag': 'csd_tag',
+    'deadtime_salt': 'do_salt_deadtime',
+}
+
+V2_OBSOLETE_KEYS = {
+    'trigger_name': 'trigger_channel',
+    'template_time_tags': 'template_group_ids',
+    'noise_tag': 'csd_tag',
+    'deadtime_salt': 'do_salt_deadtime',
+}
+
+
+def deep_merge(base, override):
+    out = copy.deepcopy(base)
+    for key, value in (override or {}).items():
+        if key in out and isinstance(out[key], dict) and isinstance(value, dict):
+            out[key] = deep_merge(out[key], value)
+        else:
+            out[key] = copy.deepcopy(value)
+    return out
+
+
+def rename_obsolete_keys(data, version, _warned=None):
+    if _warned is None:
+        _warned = set()
+    if isinstance(data, dict):
+        mapping = LEGACY_OBSOLETE_KEYS if version < 2 else V2_OBSOLETE_KEYS
+        out = {}
+        for key, value in data.items():
+            new_key = mapping.get(key, key)
+            if new_key != key and key not in _warned:
+                warnings.warn(
+                    f'Configuration key "{key}" is deprecated; use "{new_key}".',
+                    ConfigDeprecationWarning,
+                    stacklevel=4,
+                )
+                _warned.add(key)
+            out[new_key] = rename_obsolete_keys(value, version, _warned)
+        return out
+    if isinstance(data, list):
+        return [rename_obsolete_keys(item, version, _warned) for item in data]
+    return copy.deepcopy(data)

pytesprocess/config/resolvers/feature.py

@@ -0,0 +1,293 @@
+from __future__ import annotations
+
+import copy
+import warnings
+
+from ..selectors import expand_channel_selector
+from ..warnings import ConfigDeprecationWarning
+from .common import deep_merge
+
+
+_TRACE_KEYS_MSEC = ('trace_length_msec', 'pretrigger_length_msec')
+_TRACE_KEYS_SAMPLES = ('trace_length_samples', 'pretrigger_length_samples')
+
+
+class FeatureConfigResolver:
+    """Resolve feature configuration into the legacy runtime dictionary shape."""
+
+    def __init__(self, config, resources, available_channels, sample_rate_hz=None,
+                 version=1):
+        self._config = copy.deepcopy(config or {})
+        self._resources = copy.deepcopy(resources or {})
+        self._available_channels = list(available_channels or [])
+        self._sample_rate_hz = sample_rate_hz
+        self._version = int(version)
+        self._legacy_sample_warning_emitted = False
+
+    def resolve(self):
+        if self._version >= 2:
+            return self._resolve_v2()
+        return self._resolve_legacy()
+
+    def _resolve_legacy(self):
+        cfg = copy.deepcopy(self._config)
+        overall = copy.deepcopy(cfg.get('global', {}))
+        channels = copy.deepcopy(cfg.get('channels', {}))
+        for key, value in self._resources.items():
+            overall.setdefault(key, value)
+
+        warnings.warn(
+            'Legacy feature configuration is deprecated. Move feature settings '
+            'under a top-level "feature:" section and use config_version: 2.',
+            ConfigDeprecationWarning,
+            stacklevel=3,
+        )
+        return self._resolve_channels(overall, channels, presets={}, legacy=True)
+
+    def _resolve_v2(self):
+        allowed = {'global', 'presets', 'channels'}
+        unknown = set(self._config) - allowed
+        if unknown:
+            raise ValueError(
+                f'ERROR: Unknown feature configuration field(s): {sorted(unknown)}. '
+                f'Allowed fields are {sorted(allowed)}.'
+            )
+        overall = copy.deepcopy(self._config.get('global', {}))
+        channels = copy.deepcopy(self._config.get('channels', {}))
+        presets = copy.deepcopy(self._config.get('presets', {}))
+        for key, value in self._resources.items():
+            overall.setdefault(key, value)
+
+        self._reject_v2_sample_lengths(overall, 'feature.global')
+        for name, preset in presets.items():
+            self._reject_v2_sample_lengths(preset, f'feature.presets.{name}')
+        for selector, block in channels.items():
+            self._reject_v2_sample_lengths(block, f'feature.channels.{selector}')
+        return self._resolve_channels(overall, channels, presets=presets, legacy=False)
+
+    def _reject_v2_sample_lengths(self, obj, path):
+        if not isinstance(obj, dict):
+            return
+        for key, value in obj.items():
+            if key in _TRACE_KEYS_SAMPLES:
+                raise ValueError(
+                    f'ERROR: "{path}.{key}" is not allowed in config_version: 2. '
+                    'Specify trace and pretrigger lengths in milliseconds.'
+                )
+            if isinstance(value, dict):
+                self._reject_v2_sample_lengths(value, f'{path}.{key}')
+
+    def _normalize_block(self, block, legacy=False):
+        if block is None:
+            block = {}
+        if not isinstance(block, dict):
+            raise ValueError('ERROR: Feature channel/preset configuration must be a mapping.')
+        block = copy.deepcopy(block)
+
+        if legacy:
+            algorithms = {}
+            meta = {}
+            for key, value in block.items():
+                if isinstance(value, dict):
+                    algorithms[key] = value
+                else:
+                    meta[key] = value
+            meta['algorithms'] = algorithms
+            return meta
+
+        algorithms = block.get('algorithms', {})
+        if algorithms is None:
+            algorithms = {}
+        if not isinstance(algorithms, dict):
+            raise ValueError('ERROR: feature channel "algorithms" must be a mapping.')
+        out = {key: copy.deepcopy(value) for key, value in block.items()
+               if key != 'algorithms'}
+        out['algorithms'] = copy.deepcopy(algorithms)
+        return out
+
+    def _apply_presets(self, block, presets):
+        use = block.pop('use', None)
+        if use is None:
+            return block
+        names = [use] if isinstance(use, str) else list(use)
+        merged = {}
+        for name in names:
+            if name not in presets:
+                raise ValueError(f'ERROR: Unknown feature preset "{name}".')
+            preset = self._normalize_block(presets[name], legacy=False)
+            merged = deep_merge(merged, preset)
+        return deep_merge(merged, block)
+
+    def _resolve_channels(self, overall, channel_blocks, presets, legacy):
+        if not isinstance(channel_blocks, dict):
+            raise ValueError('ERROR: feature.channels must be a mapping.')
+
+        # Expand selectors, then apply from least to most specific. Equal-
+        # specificity overlap is rejected to avoid order-dependent YAML.
+        assignments = {}
+        for selector, raw_block in channel_blocks.items():
+            block = self._normalize_block(raw_block, legacy=legacy)
+            if not legacy:
+                block = self._apply_presets(block, presets)
+            for match in expand_channel_selector(selector, self._available_channels):
+                assignments.setdefault(match.target, []).append((match.specificity, selector, block,
+                                                                  match.physical_channels))
+
+        resolved_channels = {}
+        physical_channel_list = []
+        for target, items in assignments.items():
+            items = sorted(items, key=lambda item: item[0])
+            seen_specificity = {}
+            merged = {}
+            physical = None
+            for specificity, selector, block, physical_channels in items:
+                if specificity in seen_specificity:
+                    raise ValueError(
+                        f'ERROR: Feature selectors "{seen_specificity[specificity]}" and '
+                        f'"{selector}" both match "{target}" with the same precedence. '
+                        'Use a more specific selector or combine the configuration.'
+                    )
+                seen_specificity[specificity] = selector
+                merged = deep_merge(merged, block)
+                physical = physical_channels
+
+            if merged.get('disable', False) or merged.get('run') is False:
+                continue
+            merged.pop('disable', None)
+            merged.pop('run', None)
+            physical_channel_list.extend(physical or [])
+
+            resolved = self._resolve_one_channel(target, overall, merged, legacy)
+            if resolved is not None:
+                resolved_channels[target] = resolved
+
+        # Build runtime trace map + optional channel weights.
+        traces_config = {}
+        weights = {}
+        for channel, channel_cfg in resolved_channels.items():
+            physical = expand_channel_selector(channel, self._available_channels)[0].physical_channels
+            for key, value in channel_cfg.items():
+                if key.startswith('weight_'):
+                    weights.setdefault(channel, {})[key] = value
+            for algo, algo_cfg in channel_cfg.items():
+                if not isinstance(algo_cfg, dict):
+                    continue
+                trace_tuple = (algo_cfg['nb_samples'], algo_cfg['nb_pretrigger_samples'])
+                traces_config.setdefault(trace_tuple, []).extend(physical)
+
+        for trace_tuple in list(traces_config):
+            traces_config[trace_tuple] = list(dict.fromkeys(traces_config[trace_tuple]))
+
+        return {
+            'overall': copy.deepcopy(overall),
+            'channels': resolved_channels,
+            'channel_list': list(dict.fromkeys(physical_channel_list)),
+            'traces_config': traces_config or None,
+            'weights': weights,
+        }
+
+    def _duration_pair(self, source, inherited=(None, None), legacy=False, path=''):
+        trace, pre = inherited
+        if not isinstance(source, dict):
+            return trace, pre
+
+        if legacy:
+            if 'trace_length_samples' in source:
+                if not self._legacy_sample_warning_emitted:
+                    warnings.warn(
+                        'Sample-count trace configuration is deprecated; use '
+                        'trace_length_msec and pretrigger_length_msec.',
+                        ConfigDeprecationWarning, stacklevel=5)
+                    self._legacy_sample_warning_emitted = True
+                trace = ('samples', int(source['trace_length_samples']))
+            elif 'trace_length_msec' in source:
+                trace = ('msec', float(source['trace_length_msec']))
+            if 'pretrigger_length_samples' in source:
+                if not self._legacy_sample_warning_emitted:
+                    warnings.warn(
+                        'Sample-count trace configuration is deprecated; use '
+                        'trace_length_msec and pretrigger_length_msec.',
+                        ConfigDeprecationWarning, stacklevel=5)
+                    self._legacy_sample_warning_emitted = True
+                pre = ('samples', int(source['pretrigger_length_samples']))
+            elif 'pretrigger_length_msec' in source:
+                pre = ('msec', float(source['pretrigger_length_msec']))
+        else:
+            if 'trace_length_msec' in source:
+                trace = ('msec', float(source['trace_length_msec']))
+            if 'pretrigger_length_msec' in source:
+                pre = ('msec', float(source['pretrigger_length_msec']))
+        return trace, pre
+
+    def _to_samples(self, value, label):
+        if value is None:
+            return None
+        units, number = value
+        if units == 'samples':
+            return int(number)
+        if self._sample_rate_hz is None:
+            raise ValueError(
+                f'ERROR: sample_rate_hz is required to resolve {label} specified in msec.'
+            )
+        try:
+            fs = float(self._sample_rate_hz)
+        except (TypeError, ValueError):
+            raise ValueError(
+                f'ERROR: Feature processing currently requires one sample rate, got '
+                f'{self._sample_rate_hz!r}. Millisecond configuration is retained; '
+                'per-stream sample-rate resolution will be handled in the later '
+                'ProcessingData refactor.'
+            )
+        return int(round(fs * float(number) / 1000.0))
+
+    def _resolve_one_channel(self, channel, overall, block, legacy):
+        global_pair = self._duration_pair(overall, legacy=legacy, path='feature.global')
+        channel_pair = self._duration_pair(
+            block, inherited=global_pair, legacy=legacy, path=f'feature.channels.{channel}')
+
+        algorithms = copy.deepcopy(block.get('algorithms', {}))
+        result = {key: copy.deepcopy(value) for key, value in block.items()
+                  if key not in {'algorithms', *_TRACE_KEYS_MSEC, *_TRACE_KEYS_SAMPLES}}
+
+        enabled = 0
+        for algo, algo_cfg in algorithms.items():
+            if algo_cfg is None:
+                algo_cfg = {}
+            if not isinstance(algo_cfg, dict):
+                raise ValueError(
+                    f'ERROR: Feature algorithm "{algo}" for channel "{channel}" '
+                    'must be a mapping.'
+                )
+            algo_cfg = copy.deepcopy(algo_cfg)
+            # Missing ``run`` means enabled for both legacy and v2 YAML.
+            # Users only need to specify ``run: false`` to disable an
+            # algorithm explicitly.
+            run = algo_cfg.get('run', True)
+            if not run:
+                continue
+            algo_cfg['run'] = True
+
+            pair = self._duration_pair(
+                algo_cfg, inherited=channel_pair, legacy=legacy,
+                path=f'feature.channels.{channel}.algorithms.{algo}')
+            nb_samples = self._to_samples(pair[0], f'{channel}/{algo} trace length')
+            nb_pre = self._to_samples(pair[1], f'{channel}/{algo} pretrigger length')
+            if (nb_samples is None) != (nb_pre is None):
+                raise ValueError(
+                    f'ERROR: Trace length and pretrigger length must both be defined '
+                    f'for channel {channel}, algorithm {algo}.'
+                )
+            if nb_samples is not None:
+                if nb_samples <= 0 or nb_pre < 0 or nb_pre > nb_samples:
+                    raise ValueError(
+                        f'ERROR: Invalid trace/pretrigger lengths for {channel}/{algo}: '
+                        f'{nb_samples}/{nb_pre} samples.'
+                    )
+            algo_cfg['nb_samples'] = nb_samples
+            algo_cfg['nb_pretrigger_samples'] = nb_pre
+            for key in (*_TRACE_KEYS_MSEC, *_TRACE_KEYS_SAMPLES):
+                algo_cfg.pop(key, None)
+            result[algo] = algo_cfg
+            enabled += 1
+
+        return result if enabled else None