anemoi-datasets 0.5.28__py3-none-any.whl → 0.5.29__py3-none-any.whl

anemoi/datasets/create/sources/accumulate_utils/covering_intervals.py

@@ -0,0 +1,221 @@
+# (C) Copyright 2025 Anemoi contributors.
+#
+# This software is licensed under the terms of the Apache Licence Version 2.0
+# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# In applying this licence, ECMWF does not waive the privileges and immunities
+# granted to it by virtue of its status as an intergovernmental organisation
+# nor does it submit to any jurisdiction.
+
+import itertools
+import logging
+from dataclasses import dataclass
+from dataclasses import field
+from datetime import datetime
+from datetime import timedelta
+from heapq import heappop
+from heapq import heappush
+from typing import Callable
+from typing import List
+from typing import Optional
+
+LOG = logging.getLogger(__name__)
+
+# This module implements an algorithm to cover a target time interval with a sequence of signed intervals
+# (which can be positive or negative in length)
+# It is general purpose but is mainly designed to support accumulation over variable periods,
+# e.g. to cover a 6h accumulation with available intervals of +/-3h,
+
+
+class SignedInterval:
+    def __init__(self, start: datetime, end: datetime, base: Optional[datetime] = None):
+        self.start = start
+        self.end = end
+        self.base = base
+
+    @property
+    def length(self) -> float:
+        """Length in seconds (can be negative)."""
+        return (self.end - self.start).total_seconds()
+
+    @property
+    def sign(self) -> int:
+        return 1 if self.length >= 0 else -1
+
+    @property
+    def min(self):
+        return min(self.start, self.end)
+
+    @property
+    def max(self):
+        return max(self.start, self.end)
+
+    def __neg__(self):
+        return SignedInterval(start=self.end, end=self.start, base=self.base)
+
+    def __eq__(self, other):
+        if not isinstance(other, SignedInterval):
+            return NotImplemented
+        if self.start != other.start or self.end != other.end:
+            return False
+        if self.base != other.base:
+            return False
+        return True
+
+    def __hash__(self):
+        return hash((self.start, self.end, self.base))
+
+    def __rich__(self):
+        return self.__repr__(colored=True)
+
+    def __repr__(self, colored: bool = False):
+        try:
+            # use frequency_to_string only if available
+            # as this class should not depends on anemoi.utils
+            from anemoi.utils.dates import frequency_to_string
+        except ImportError:
+
+            def frequency_to_string(delta):
+                return str(delta)
+
+        start = self.start.strftime("%Y%m%d.%H%M")
+        end = self.end.strftime("%Y%m%d.%H%M")
+        if start[:9] == end[:9]:
+            end = " " * 9 + end[9:]
+
+        if self.base is not None:
+            base = self.base.strftime("%Y%m%d.%H%M")
+            if self.sign > 0:
+                steps = [
+                    int((self.start - self.base).total_seconds() / 3600),
+                    int((self.end - self.base).total_seconds() / 3600),
+                ]
+            else:
+                steps = [
+                    -int((self.end - self.base).total_seconds() / 3600),
+                    int((self.start - self.base).total_seconds() / 3600),
+                ]
+            base_str = f", base={base}, [{steps[0]}-{steps[1]}]"
+        else:
+            base_str = ""
+
+        if self.start < self.end:
+            period = f"+{frequency_to_string(self.end - self.start)}"
+        elif self.start == self.end:
+            period = "0s"
+        else:
+            period = f"-{frequency_to_string(self.start - self.end)}"
+        period = period.ljust(4)
+
+        if colored:
+            # using rich colors
+            start = f"[blue]{start}[/blue]"
+            end = f"[blue]{end}[/blue]"
+            if self.start < self.end:
+                period = f"[green]{period}[/green]"
+            elif self.start == self.end:
+                period = f"[yellow]{period}[/yellow]"
+            else:
+                period = f"[red]{period}[/red]"
+
+        return f"SignedInterval({start}{period}->{end}{base_str} )"
+
+
+@dataclass(order=True)
+class HeapState:
+    total_cost: float
+    covered: float
+    counter: int
+    current_time: datetime
+    current_base: Optional[datetime]
+    path: List[SignedInterval] = field(compare=False)
+
+
+def covering_intervals(
+    start: datetime,
+    end: datetime,
+    candidates: Callable,
+    /,
+    switch_penalty: int = 24 * 3600 * 7,
+    max_delta: timedelta = timedelta(hours=24 * 2),
+    error_on_fail: bool = True,
+) -> List[SignedInterval] | None:
+    """Find a path of intervals covering [start, end] with minimal base switches, then minimal total absolute length.
+    Uses a Dijkstra-like algorithm to find the optimal path.
+
+    Args:
+        start: Start datetime of the target interval.
+
+        end: End datetime of the target interval.
+
+        candidates: A function(current: datetime, current_base: Optional[datetime], start: datetime, end: datetime) -> Iterable[SignedInterval]
+            that provides candidate intervals covering the current time.
+
+        switch_penalty: Penalty (in seconds) for switching bases between intervals.
+
+        max_delta: Maximum allowed deviation from start/end for search.
+
+        error_on_fail: Whether to raise an error if coverage cannot be found.
+
+    Returns:
+        A list of SignedInterval objects covering [start, end], or None if no coverage found and error_on_fail is False.
+
+    """
+    target_length = (end - start).total_seconds()
+
+    pq: List[HeapState] = []  # pq: priority queue
+    counter = itertools.count()
+    heappush(
+        pq,
+        HeapState(total_cost=0.0, covered=0.0, counter=next(counter), current_time=start, current_base=None, path=[]),
+    )
+
+    visited: dict[tuple[datetime, Optional[datetime], float], float] = {}
+
+    while pq:
+        state = heappop(pq)
+        key = (state.current_time, state.current_base, state.covered)
+
+        if key in visited and state.total_cost >= visited[key]:
+            continue
+        visited[key] = state.total_cost
+
+        # Goal: cumulative coverage matches target
+        if state.covered == target_length:
+            return state.path
+
+        if (len(visited) > 1000) and (state.current_time > end + max_delta or state.current_time < start - max_delta):
+            msg = f"Exceeded search limits: visited={len(visited)}, current_time={state.current_time}, target=({start} → {end}), max_delta={max_delta}"
+            if error_on_fail:
+                raise ValueError(msg)
+            LOG.warning(msg)
+            return None
+
+        for interval in candidates(state.current_time):
+            if interval.start != state.current_time:
+                raise ValueError(
+                    f"Candidate interval {interval} does not start or end at current_time {state.current_time}"
+                )
+
+            # Edge cost = abs(length) + switch penalty if base changes
+            edge_cost = abs(interval.length)
+            if state.current_base is not None and state.current_base != interval.base:
+                edge_cost += switch_penalty
+
+            heappush(
+                pq,
+                HeapState(
+                    total_cost=state.total_cost + edge_cost,
+                    covered=state.covered + interval.length,
+                    counter=next(counter),  # counter only used to break ties in heapq
+                    current_time=interval.end,
+                    current_base=interval.base,
+                    path=state.path + [interval],
+                ),
+            )
+
+    msg = f"Cannot find coverage of {start} → {end}"
+    if error_on_fail:
+        raise ValueError(msg)
+    LOG.warning(msg)
+    return None

anemoi/datasets/create/sources/accumulate_utils/field_to_interval.py

@@ -0,0 +1,149 @@
+# (C) Copyright 2025 Anemoi contributors.
+#
+# This software is licensed under the terms of the Apache Licence Version 2.0
+# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# In applying this licence, ECMWF does not waive the privileges and immunities
+# granted to it by virtue of its status as an intergovernmental organisation
+# nor does it submit to any jurisdiction.
+
+
+import datetime
+import logging
+
+from anemoi.utils.dates import frequency_to_timedelta
+
+from .covering_intervals import SignedInterval
+
+LOG = logging.getLogger(__name__)
+
+
+class FieldToInterval:
+    """Convert a field to its accumulation interval, applying patches if needed."""
+
+    def __init__(self, patches: dict | None = None):
+        if patches is None:
+            patches = {}
+        assert isinstance(patches, dict), ("patches must be a dict", patches)
+
+        self.patches = patches
+        for key in patches:
+            if key not in (
+                "start_step_is_zero",
+                "start_step_is_end_step",
+                "start_step_greater_than_end_step",
+            ):
+                raise ValueError(f"Unknown patch key: {key}")
+
+    def __call__(self, field) -> SignedInterval:
+        date_str = str(field.metadata("date")).zfill(8)
+        time_str = str(field.metadata("time")).zfill(4)
+        base_datetime = datetime.datetime.strptime(date_str + time_str, "%Y%m%d%H%M")
+
+        endStep = field.metadata("endStep")
+        startStep = field.metadata("startStep")
+
+        LOG.debug(f"    field before patching: {startStep=}, {endStep=}")
+
+        if startStep > endStep:
+            startStep, endStep = self.start_step_greater_than_end_step(startStep, endStep, field=field)
+        elif startStep == endStep:
+            startStep, endStep = self.start_step_is_end_step(startStep, endStep, field=field)
+        elif frequency_to_timedelta(startStep).total_seconds() == 0:
+            startStep, endStep = self.start_step_is_zero(startStep, endStep, field=field)
+
+        LOG.debug(f"    field after patching : {startStep=}, {endStep=}")
+
+        start_step = datetime.timedelta(hours=startStep)
+        end_step = datetime.timedelta(hours=endStep)
+
+        assert startStep >= 0, ("After patching, startStep must be >= 0", field, startStep, endStep)
+        assert startStep < endStep, ("After patching, startStep must be < endStep", field, startStep, endStep)
+
+        interval = SignedInterval(start=base_datetime + start_step, end=base_datetime + end_step, base=base_datetime)
+
+        date_str = str(field.metadata("validityDate")).zfill(8)
+        time_str = str(field.metadata("validityTime")).zfill(4)
+        valid_date = datetime.datetime.strptime(date_str + time_str, "%Y%m%d%H%M")
+        assert valid_date == interval.max, (valid_date, interval)
+
+        return interval
+
+    def start_step_is_zero(self, startStep, endStep, field=None):
+        # Patch to handle cases where start_step is zero
+        # No patch yet implemented
+        match self.patches.get("start_step_is_zero", None):
+            case False | None:
+                pass  # do nothing
+            case _ as options:
+                raise ValueError(f"Unknown option for patch.start_step_is_zero: {options}")
+
+        return startStep, endStep
+
+    def start_step_is_end_step(self, startStep, endStep, field=None):
+        # Patch to handle cases where start_step equals end_step
+        # this should not happen in normal cases but some datasets have this issue
+        # The default is to set start_step to zero
+        # This can be disabled by setting the patch to False
+
+        match self.patches.get("start_step_is_end_step", "set_start_step_to_zero"):
+            case False | None:
+                pass  # do nothing
+
+            case "set_from_end_step_ceiled_to_24_hours":
+                startStep, endStep = _set_start_step_from_end_step_ceiled_to_24_hours(startStep, endStep, field=field)
+
+            case "set_start_step_to_zero":
+                startStep, endStep = 0, endStep
+
+            case _ as options:
+                raise ValueError(f"Unknown option for patch.start_step_is_end_step: {options}")
+
+        return startStep, endStep
+
+    def start_step_greater_than_end_step(self, startStep, endStep, field=None):
+
+        # Patch to handle cases where start_step is greater than end_step
+        # this should not happen in normal cases but some datasets have this issue
+        # The default is to do swap the values of start_step and end_step
+        # This can be disabled by setting the patch to False
+
+        match self.patches.get("start_step_greater_than_end_step", None):
+
+            case False | None:
+                pass  # do nothing
+
+            case "swap":
+                startStep, endStep = endStep, startStep
+
+            case _ as options:
+                raise ValueError(f"Unknown option for patch.start_step_greater_than_end_step: {options}")
+
+        return startStep, endStep
+
+
+def _set_start_step_from_end_step_ceiled_to_24_hours(startStep, endStep, field=None):
+    # Because the data wrongly encode start_step, but end_step is correct
+    # and we know that accumulations are always reseted every multiple of 24 hours
+    #
+    # 1-1 -> 0-1
+    # 2-2 -> 0-2
+    # ...
+    # 23-23 -> 0-23
+    # 24-24 -> 0-24
+    # 25-25 -> 24-25
+    # 26-26 -> 24-26
+    # ...
+    # 47-47 -> 24-47
+    # 48-48 -> 24-48
+    # 49-49 -> 48-49
+    # 50-50 -> 48-50
+    # etc.
+    if endStep % 24 == 0:
+        # Special case: endStep is exactly 24, 48, 72, etc.
+        # Map to previous 24-hour boundary (24 -> 0, 48 -> 24, etc.)
+        return endStep - 24, endStep
+
+    # General case: floor to the nearest 24-hour boundary
+    # (1-23 -> 0, 25-47 -> 24, etc.)
+    return endStep - (endStep % 24), endStep

anemoi/datasets/create/sources/accumulate_utils/interval_generators.py

@@ -0,0 +1,321 @@
+# (C) Copyright 2025 Anemoi contributors.
+#
+# This software is licensed under the terms of the Apache Licence Version 2.0
+# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# In applying this licence, ECMWF does not waive the privileges and immunities
+# granted to it by virtue of its status as an intergovernmental organisation
+# nor does it submit to any jurisdiction.
+
+
+import datetime
+import logging
+from abc import abstractmethod
+from typing import Iterable
+
+from anemoi.utils.dates import frequency_to_timedelta
+
+from anemoi.datasets.create.sources.accumulate_utils.covering_intervals import SignedInterval
+from anemoi.datasets.create.sources.accumulate_utils.covering_intervals import covering_intervals
+
+LOG = logging.getLogger(__name__)
+
+
+def build_interval(
+    current_time: datetime.datetime, start_step: int, end_step: int, base_time: str | int | None
+) -> SignedInterval:
+    """Build a SignedInterval object corresponding to current_time's day
+    This SignedInterval may not have a base datetime
+
+    """
+    try:
+        usable_base_time = int(base_time) if base_time is not None else 0
+    except ValueError:
+        raise ValueError(f"Invalid base_time: {base_time} ({type(base_time)})")
+    base = datetime.datetime(current_time.year, current_time.month, current_time.day, usable_base_time)
+    start = base + datetime.timedelta(hours=start_step)
+    end = base + datetime.timedelta(hours=end_step)
+
+    interval_base = base if base_time is not None else None
+
+    return SignedInterval(start=start, end=end, base=interval_base)
+
+
+class IntervalGenerator:
+    """Abstract base class to generate intervals.
+    Call to IntervalGenerator will provide candidate intervals to be selected by the covering_intervals method
+    """
+
+    @abstractmethod
+    def covering_intervals(self, start: datetime, end: datetime) -> Iterable[SignedInterval]:
+        pass
+
+    @abstractmethod
+    def __call__():
+        pass
+
+
+class Pattern:
+    """Common format of config arguments to build SearchableIntervalGenerator
+    Used to supply candidate intervals for IntervalGenerator
+    """
+
+    def __init__(
+        self,
+        base_time: str | datetime.datetime,
+        steps: str | list[str],
+        search_range: list[int] | None = None,
+        base_date: dict | None = None,
+    ):
+        steps = normalise_steps(steps)
+        self.steps = steps
+
+        if base_time == "*":
+            base_time = None
+        self.base_time = base_time
+
+        if search_range is None:
+            search_range = [datetime.timedelta(days=d) for d in [-1, 0, 1]]
+        else:
+            search_range = [datetime.timedelta(days=d) for d in search_range]
+        self.search_range = search_range
+
+        if base_date:
+            assert isinstance(base_date, dict), base_date
+            assert "day_of_month" in base_date, base_date
+            assert len(base_date) == 1, base_date
+        self.base_date = base_date
+
+    def filter(self, interval: SignedInterval) -> bool:
+        if self.base_date:
+            if interval.base.day != self.base_date["day_of_month"]:
+                return False
+        return True
+
+
+class SearchableIntervalGenerator(IntervalGenerator):
+    def __init__(self, config: tuple | list | dict):
+        if isinstance(config, (tuple, list)):
+            patterns = []
+            for base_time, steps in config:
+                patterns.append(Pattern(base_time=base_time, steps=steps))
+
+        if isinstance(config, dict):
+            patterns = [Pattern(**config)]
+
+        self.patterns: list[Pattern] = patterns
+
+    def covering_intervals(self, start: datetime.datetime, end: datetime.datetime) -> Iterable[SignedInterval]:
+        """Perform interval search among candidates with minimal base switches and length.
+        Candidates are given by self call
+        Return available SignedIntervals covering the period start->end (where start>end is possible)
+        """
+        return covering_intervals(start, end, self)
+
+    def __call__(
+        self,
+        current_time: datetime.datetime,
+    ) -> Iterable[SignedInterval]:
+        """This generates candidate intervals starting or ending at the given current_time
+        Candidates correspond to the pairs of base_time, steps stored in patterns
+        """
+        intervals = []
+        for p in self.patterns:
+            search_range = p.search_range
+            for delta in search_range:
+                base_time = p.base_time
+                steps = p.steps
+                for start_step, end_step in steps:
+                    interval = build_interval(current_time + delta, start_step, end_step, base_time)
+                    if not p.filter(interval):
+                        continue
+
+                    if interval not in intervals:
+                        intervals.append(interval)
+
+        # filter only the interval starting at current_time (or ending at current_time)
+        filtered = []
+        for i in intervals:
+            if i.start == current_time:
+                filtered.append(i)
+            elif (-i).start == current_time:
+                filtered.append(-i)
+        intervals = filtered
+
+        # quite important to sort by reversed base to prioritise most recent base in case of ties
+        # in some cases, we may want to sort by other criteria
+        intervals = sorted(intervals, key=lambda x: -(x.base or x.start).timestamp())
+
+        return intervals
+
+
+def normalise_steps(steps_list: str | list[str]) -> list[list[int]]:
+    """Convert the input step_list to a list of [start,end] pairs"""
+    res = []
+    if isinstance(steps_list, str):
+        steps_list = steps_list.split("/")
+    assert isinstance(steps_list, list), steps_list
+
+    for start_end_step in steps_list:
+        if isinstance(start_end_step, str):
+            assert "-" in start_end_step, start_end_step
+            start_end_step = start_end_step.split("-")
+        assert isinstance(start_end_step, (list, tuple)) and len(start_end_step) == 2, start_end_step
+        start_step, end_step = int(start_end_step[0]), int(start_end_step[1])
+        res.append([start_step, end_step])
+    return res
+
+
+class AccumulatedFromStartIntervalGenerator(SearchableIntervalGenerator):
+    def __init__(self, basetime: str | datetime.datetime, frequency: int, last_step: int):
+        config = []
+        for base in basetime:
+            for i in range(0, last_step, frequency):
+                config.append([base, [f"0-{i+frequency}"]])
+        super().__init__(config)
+
+
+class AccumulatedFromPreviousStepIntervalGenerator(SearchableIntervalGenerator):
+    def __init__(self, basetime: str | datetime.datetime, frequency: int, last_step: int):
+        config = []
+        for base in basetime:
+            for i in range(0, last_step, frequency):
+                config.append([base, [f"{i}-{i+frequency}"]])
+        super().__init__(config)
+
+
+def _match_mars_config(_class: str, _stream: str | None = None, _origin: str | None = None) -> list | tuple:
+    """Match MARS configuration (class, stream, origin) to interval generator config.
+
+    Parameters
+    ----------
+    _class
+        MARS class (e.g., 'ea', 'od', 'rr', 'l5').
+    _stream
+        MARS stream (e.g., 'oper', 'enda', 'elda', 'enfo'). Defaults to 'oper'.
+    _origin
+        MARS origin (e.g., 'se-al-ec', 'fr-ms-ec'). Defaults to None.
+
+    Returns
+    -------
+    list | tuple
+        Interval generator configuration.
+
+    Raises
+    ------
+    NotImplementedError
+        If the combination is not yet implemented.
+    ValueError
+        If the combination is unknown.
+    """
+    _stream = _stream or "oper"
+
+    match (_class, _stream, _origin):
+        case ("ea", "oper", _):
+            return [
+                (6, "0-1/1-2/2-3/3-4/4-5/5-6/6-7/7-8/8-9/9-10/10-11/11-12/12-13/13-14/14-15/15-16/16-17/17-18"),
+                (18, "0-1/1-2/2-3/3-4/4-5/5-6/6-7/7-8/8-9/9-10/10-11/11-12/12-13/13-14/14-15/15-16/16-17/17-18"),
+            ]
+        case ("ea", "enda", _):
+            return [
+                (6, "0-3/3-6/6-9/9-12/12-15/15-18"),
+                (18, "0-3/3-6/6-9/9-12/12-15/15-18"),
+            ]
+
+        case ("od", "oper", _):
+            # https://apps.ecmwf.int/mars-catalogue/?stream=oper&levtype=sfc&time=00%3A00%3A00&expver=1&month=aug&year=2020&date=2020-08-25&type=fc&class=od
+            steps = [f"{0}-{i}" for i in range(1, 91)]
+            return ((0, steps), (12, steps))
+        case ("od", "elda", _):
+            # https://apps.ecmwf.int/mars-catalogue/?stream=elda&levtype=sfc&time=06%3A00%3A00&expver=1&month=aug&year=2020&date=2020-08-31&type=fc&class=od
+            # (6,  "0-1/0-2/0-3/0-4/0-5/0-6/0-7/0-8/0-9/0-10/0-11/0-12"),
+            # (18, "0-1/0-2/0-3/0-4/0-5/0-6/0-7/0-8/0-9/0-10/0-11/0-12")
+            steps = [f"{0}-{i}" for i in range(1, 13)]
+            return ((6, steps), (18, steps))
+        case ("od", "enfo", _):
+            # https://apps.ecmwf.int/mars-catalogue/?class=od&stream=enfo&expver=1&type=fc&year=2020&month=aug&levtype=sfc&date=2020-08-31&time=06:00:00
+            raise NotImplementedError("od-enfo interval generator not implemented yet")
+
+        case ("rr", _, "se-al-ec"):
+            # https://apps.ecmwf.int/mars-catalogue/?class=rr&expver=prod&origin=se-al-ec&stream=oper&type=fc&year=2020&month=aug&levtype=sfc
+            return [[0, [(0, i) for i in [1, 2, 3, 4, 5, 6, 9, 12, 15, 18, 21, 24, 27, 30]]]]
+        case ("rr", _, "fr-ms-ec"):
+            # https://apps.ecmwf.int/mars-catalogue/?origin=fr-ms-ec&stream=oper&levtype=sfc&time=06%3A00%3A00&expver=prod&month=aug&year=2020&date=2020-08-31&type=fc&class=rr
+            return [[0, [(0, i) for i in range(1, 22, 3)]]]
+
+        case ("l5", "oper", _):
+            # https://apps.ecmwf.int/mars-catalogue/?class=l5&stream=oper&expver=1&type=fc&year=2020&month=aug&levtype=sfc&date=2020-08-25&time=00:00:00
+            return [[0, [(int(i), int(i) + 1) for i in range(0, 24)]]]
+
+        case _:
+            raise ValueError(f"Unknown MARS configuration: class={_class}, stream={_stream}, origin={_origin}")
+
+
+def _interval_generator_factory(
+    config, source_name: str | None = None, source: dict | None = None
+) -> IntervalGenerator | list | dict:
+    match config:
+        case IntervalGenerator():
+            return config
+
+        case {"type": "accumulated-from-start", **params}:
+            return AccumulatedFromStartIntervalGenerator(**params)
+        case {"accumulated-from-start": params}:
+            return AccumulatedFromStartIntervalGenerator(**params)
+
+        case {"accumulated-from-previous-step": params}:
+            return AccumulatedFromPreviousStepIntervalGenerator(**params)
+        case {"type": "accumulated-from-previous-step", **params}:
+            return AccumulatedFromPreviousStepIntervalGenerator(**params)
+
+        case {"type": _, **params}:
+            raise NotImplementedError(f"Unknown availability config {config}")
+
+        case {"mars": mars_config}:
+            _class = mars_config.get("class")
+            _stream = mars_config.get("stream")
+            _origin = mars_config.get("origin")
+            assert _class is not None, "mars config must have a 'class' key"
+            return _match_mars_config(_class, _stream, _origin)
+
+        case dict() | list() | tuple():
+            return SearchableIntervalGenerator(config)
+
+        case "auto":
+            assert None not in (source_name, source), "Source must be specified when using 'auto' discovery"
+            assert source_name == "mars", "Only 'mars' source is currently supported for 'auto' availability discovery"
+
+            _class, _stream, _origin = source.get("class", None), source.get("stream", None), source.get("origin", None)
+
+            assert (
+                _class is not None
+            ), "Availability should be automatically determined from mars source, but the mars source has no 'class'"
+
+            if (_stream is None) or (_origin is None):
+                LOG.warning(
+                    f"Stream and/or origin unspecified for class {_class}, "
+                    f"stream and/or origin will be set as defaults.",
+                )
+
+            return {"mars": {"class": _class, "stream": _stream, "origin": _origin}}
+
+        case str():
+            try:
+                data_accumulation_period = frequency_to_timedelta(config)
+            except Exception as e:
+                raise ValueError(f"Unknown interval generator config: {config}") from e
+
+            hours = data_accumulation_period.total_seconds() / 3600
+            if not (hours.is_integer() and hours > 0):
+                raise ValueError("Only accumulation periods multiple of 1 hour are supported for now")
+
+            return [["*", [f"{i}-{i+1}" for i in range(0, 24)]]]
+
+        case _:
+            raise ValueError(f"Unknown interval generator config: {config}")
+
+
+def interval_generator_factory(config, source_name: str | None = None, source: dict | None = None) -> IntervalGenerator:
+    while not isinstance(config, IntervalGenerator):
+        config = _interval_generator_factory(config, source_name, source)
+    return config