fram-core 0.0.0__py3-none-any.whl → 0.1.0__py3-none-any.whl

framcore/timeindexes/HourlyIndex.py

@@ -0,0 +1,33 @@
+from datetime import timedelta
+
+from framcore.timeindexes.ProfileTimeIndex import ProfileTimeIndex  # NB! full import path needed for inheritance to work
+
+
+class HourlyIndex(ProfileTimeIndex):
+    """
+    ProfileTimeIndex with one or more whole years with hourly resolution. Either years with 52 weeks or full iso calendar years.
+
+    No extrapolation inherited from ProfileTimeIndex.
+    """
+
+    def __init__(
+        self,
+        start_year: int,
+        num_years: int,
+        is_52_week_years: bool = True,
+    ) -> None:
+        """
+        Initialize HourlyIndex over a number of years. Either years with 52 weeks or full iso calendar years.
+
+        Args:
+            start_year (int): First year in the index.
+            num_years (int): Number of years in the index.
+            is_52_week_years (bool, optional): Whether to use 52-week years. If False, full iso calendar years are used. Defaults to True.
+
+        """
+        super().__init__(
+            start_year=start_year,
+            num_years=num_years,
+            period_duration=timedelta(hours=1),
+            is_52_week_years=is_52_week_years,
+        )

framcore/timeindexes/IsoCalendarDay.py

@@ -0,0 +1,33 @@
+from datetime import datetime, timedelta
+
+from framcore.timeindexes.SinglePeriodTimeIndex import SinglePeriodTimeIndex  # NB! full import path needed for inheritance to work
+
+
+class IsoCalendarDay(SinglePeriodTimeIndex):
+    """
+    Represents a single ISO calendar day using year, week, and day values.
+
+    Inherits from SinglePeriodTimeIndex and provides a time index for one day,
+    constructed from datetime.fromisocalendar(year, week, day).
+
+    """
+
+    def __init__(self, year: int, week: int, day: int) -> None:
+        """
+        IsoCalendarDay represent a day from datetime.fromisocalendar(year, week, day).
+
+        No extrapolation and is_52_week_years=False. Useful for testing.
+
+        Args:
+            year (int): The ISO year.
+            week (int): The ISO week number (1-53).
+            day (int): The ISO weekday (1=Monday, 7=Sunday).
+
+        """
+        super().__init__(
+            start_time=datetime.fromisocalendar(year, week, day),
+            period_duration=timedelta(days=1),
+            is_52_week_years=False,
+            extrapolate_first_point=False,
+            extrapolate_last_point=False,
+        )

framcore/timeindexes/ListTimeIndex.py

@@ -0,0 +1,277 @@
+import functools
+import math
+from datetime import datetime, timedelta, tzinfo
+
+import numpy as np
+from numpy.typing import NDArray
+
+from framcore.fingerprints import Fingerprint
+from framcore.timeindexes import FixedFrequencyTimeIndex, TimeIndex
+from framcore.timeindexes._time_vector_operations import period_duration
+
+
+class ListTimeIndex(TimeIndex):
+    """
+    ListTimeIndex class for TimeIndexes with a list of timestamps. Subclass of TimeIndex.
+
+    This TimeIndex is defined by a list of timestamps, with possible irregular intervals.The last timestamp is not
+    necessarily the end of the time vector, and the first timestamp is not necessarily the start of the time vector
+    if extrapolation is enabled.
+
+    ListTimeIndex is not recommended for large time vectors, as it is less efficient.
+    """
+
+    def __init__(
+        self,
+        datetime_list: list[datetime],
+        is_52_week_years: bool,
+        extrapolate_first_point: bool,
+        extrapolate_last_point: bool,
+    ) -> None:
+        """
+        Initialize the ListTimeIndex class.
+
+        Args:
+            datetime_list (list[datetime]): List of datetime objects defining the time index. Must be ordered and contain more than one element.
+            is_52_week_years (bool): Whether to use 52-week years. If False, full iso calendar years are used.
+            extrapolate_first_point (bool): Whether to extrapolate the first point.
+            extrapolate_last_point (bool): Whether to extrapolate the last point.
+
+        Raises:
+            ValueError: If datetime_list has less than two elements or is not ordered.
+
+        """
+        dts = datetime_list
+        if len(dts) <= 1:
+            msg = f"datetime_list must contain more than one element. Got {datetime_list}"
+            raise ValueError(msg)
+        if not all(dts[i] < dts[i + 1] for i in range(len(dts) - 1)):
+            msg = f"All elements of datetime_list must be smaller/lower than the succeeding element. Dates must be ordered. Got {datetime_list}."
+            raise ValueError(msg)
+        if len(set(dt.tzinfo for dt in dts if dt is not None)) > 1:
+            msg = f"Datetime objects in datetime_list have differing time zone information: {set(dt.tzinfo for dt in dts if dt is not None)}"
+            raise ValueError(msg)
+        if is_52_week_years and any(dts[i].isocalendar().week == 53 for i in range(len(dts))):  # noqa: PLR2004
+            msg = "When is_52_week_years is True, datetime_list should not contain week 53 datetimes."
+            raise ValueError(msg)
+
+        self._datetime_list = datetime_list
+        self._is_52_week_years = is_52_week_years
+        self._extrapolate_first_point = extrapolate_first_point
+        self._extrapolate_last_point = extrapolate_last_point
+
+    def __eq__(self, other) -> bool:  # noqa: ANN001
+        """Check if two ListTimeIndexes are equal."""
+        if not isinstance(other, type(self)):
+            return False
+        return (
+            self._datetime_list == other._datetime_list
+            and self._extrapolate_first_point == other._extrapolate_first_point
+            and self._extrapolate_last_point == other._extrapolate_last_point
+        )
+
+    def __hash__(self) -> int:
+        """Return the hash of the ListTimeIndex."""
+        return hash(
+            (
+                tuple(self._datetime_list),
+                self._extrapolate_first_point,
+                self._extrapolate_last_point,
+            ),
+        )
+
+    def __repr__(self) -> str:
+        """Return the string representation of the ListTimeIndex."""
+        return (
+            "ListTimeIndex("
+            f"datetimelist={self._datetime_list}, "
+            f"extrapolate_first_point={self._extrapolate_first_point}, "
+            f"extrapolate_last_point={self._extrapolate_last_point})"
+        )
+
+    def get_fingerprint(self) -> Fingerprint:
+        """Get the fingerprint of the ListTimeIndex."""
+        fingerprint = Fingerprint()
+        fingerprint.add("datetime_list", self._datetime_list)
+        fingerprint.add("is_52_week_years", self._is_52_week_years)
+        fingerprint.add("extrapolate_first_point", self._extrapolate_first_point)
+        fingerprint.add("extrapolate_last_point", self._extrapolate_last_point)
+        return fingerprint
+
+    def get_datetime_list(self) -> list[datetime]:
+        """Get a list of all periods (num_periods + 1 datetimes)."""
+        return self._datetime_list.copy()
+
+    def get_timezone(self) -> tzinfo | None:
+        """Get the timezone of the TimeIndex."""
+        return self._datetime_list[0].tzinfo
+
+    def get_num_periods(self) -> int:
+        """Get the number of periods in the TimeIndex."""
+        return len(self._datetime_list) - 1
+
+    def is_52_week_years(self) -> bool:
+        """Check if the TimeIndex is based on 52-week years."""
+        return self._is_52_week_years
+
+    def is_one_year(self) -> bool:
+        """Return True if exactly one whole year."""
+        if self._extrapolate_first_point or self._extrapolate_last_point:
+            return False
+        start_time = self._datetime_list[0]
+        stop_time = self._datetime_list[-1]
+        start_year, start_week, start_weekday = start_time.isocalendar()
+
+        if not start_weekday == start_week == 1:
+            return False
+
+        if self._is_52_week_years:
+            expected_stop_time = start_time + timedelta(weeks=52)
+            if expected_stop_time.isocalendar().week == 53:  # noqa: PLR2004
+                expected_stop_time += timedelta(weeks=1)
+            return stop_time == expected_stop_time
+
+        stop_year, stop_week, stop_weekday = stop_time.isocalendar()
+        return (start_year + 1 == stop_year) and (stop_weekday == stop_week == 1)
+
+    def is_whole_years(self) -> bool:
+        """Return True if index covers one or more full years."""
+        start_time = self._datetime_list[0]
+        _, start_week, start_weekday = start_time.isocalendar()
+
+        if not start_week == start_weekday == 1:
+            return False
+
+        stop_time = self._datetime_list[-1]
+
+        if not self.is_52_week_years():
+            _, stop_week, stop_weekday = stop_time.isocalendar()
+            return stop_week == stop_weekday == 1
+
+        total_period = self.total_duration()
+        total_seconds = int(total_period.total_seconds())
+        seconds_per_year = 52 * 7 * 24 * 3600
+
+        return total_seconds % seconds_per_year == 0
+
+    def extrapolate_first_point(self) -> bool:
+        """Check if the TimeIndex should extrapolate the first point."""
+        return self._extrapolate_first_point
+
+    def extrapolate_last_point(self) -> bool:
+        """Check if the TimeIndex should extrapolate the last point."""
+        return self._extrapolate_last_point
+
+    def get_period_average(self, vector: NDArray, start_time: datetime, duration: timedelta, is_52_week_years: bool) -> float:
+        """Get the average over the period from the vector."""
+        self._check_type(vector, np.ndarray)
+        self._check_type(start_time, datetime)
+        self._check_type(duration, timedelta)
+        self._check_type(is_52_week_years, bool)
+
+        if vector.shape != (self.get_num_periods(),):
+            msg = f"Vector shape {vector.shape} does not match number of periods {self.get_num_periods()} of timeindex ({self})."
+            raise ValueError(msg)
+
+        if not self.extrapolate_first_point():
+            if start_time < self._datetime_list[0]:
+                msg = f"start_time {start_time} is before start of timeindex {self._datetime_list[0]}, and extrapolate_first_point is False."
+                raise ValueError(msg)
+            if (start_time + duration) < self._datetime_list[0]:
+                msg = f"End time {start_time + duration} is before start of timeindex {self._datetime_list[0]}, and extrapolate_first_point is False."
+                raise ValueError(msg)
+
+        if not self.extrapolate_last_point():
+            if (start_time + duration) > self._datetime_list[-1]:
+                msg = f"End time {start_time + duration} is after end of timeindex {self._datetime_list[-1]}, and extrapolate_last_point is False."
+                raise ValueError(msg)
+            if start_time > self._datetime_list[-1]:
+                msg = f"start_time {start_time} is after end of timeindex {self._datetime_list[-1]}, and extrapolate_last_point is False."
+                raise ValueError(msg)
+
+        target_timeindex = FixedFrequencyTimeIndex(
+            start_time=start_time,
+            period_duration=duration,
+            num_periods=1,
+            is_52_week_years=is_52_week_years,
+            extrapolate_first_point=self.extrapolate_first_point(),
+            extrapolate_last_point=self.extrapolate_last_point(),
+        )
+
+        target_vector = np.zeros(1, dtype=vector.dtype)
+        self.write_into_fixed_frequency(
+            target_vector=target_vector,
+            target_timeindex=target_timeindex,
+            input_vector=vector,
+        )
+        return target_vector[0]
+
+    def write_into_fixed_frequency(
+        self,
+        target_vector: NDArray,
+        target_timeindex: FixedFrequencyTimeIndex,
+        input_vector: NDArray,
+    ) -> None:
+        """Write the input vector into the target vector using the target FixedFrequencyTimeIndex."""
+        self._check_type(target_vector, np.ndarray)
+        self._check_type(target_timeindex, FixedFrequencyTimeIndex)
+        self._check_type(input_vector, np.ndarray)
+
+        dts: list[datetime] = self._datetime_list
+
+        durations = set(self._microseconds(period_duration(dts[i], dts[i + 1], self._is_52_week_years)) for i in range(len(dts) - 1))
+        smallest_common_period_duration = functools.reduce(math.gcd, durations)
+
+        num_periods_ff = self._microseconds(self.total_duration()) // smallest_common_period_duration
+        input_vector_ff = np.zeros(num_periods_ff, dtype=target_vector.dtype)
+
+        i_start_ff = 0
+        for i in range(len(dts) - 1):
+            num_periods = self._microseconds(period_duration(dts[i], dts[i + 1], self._is_52_week_years)) // smallest_common_period_duration
+            i_stop_ff = i_start_ff + num_periods
+            input_vector_ff[i_start_ff:i_stop_ff] = input_vector[i]
+            i_start_ff = i_stop_ff
+
+        input_timeindex_ff = FixedFrequencyTimeIndex(
+            start_time=dts[0],
+            num_periods=num_periods_ff,
+            period_duration=timedelta(microseconds=smallest_common_period_duration),
+            is_52_week_years=self.is_52_week_years(),
+            extrapolate_first_point=self.extrapolate_first_point(),
+            extrapolate_last_point=self.extrapolate_last_point(),
+        )
+
+        input_timeindex_ff.write_into_fixed_frequency(
+            target_vector=target_vector,
+            target_timeindex=target_timeindex,
+            input_vector=input_vector_ff,
+        )
+
+    def total_duration(self) -> timedelta:
+        """
+        Return the total duration covered by the time index.
+
+        Returns
+        -------
+        timedelta
+            The duration from the first to the last datetime in the index, skipping all weeks 53 periods if 52-week time format.
+
+        """
+        start_time = self._datetime_list[0]
+        end_time = self._datetime_list[-1]
+        return period_duration(start_time, end_time, self.is_52_week_years())
+
+    def _microseconds(self, duration: timedelta) -> int:
+        return int(duration.total_seconds() * 1e6)
+
+    def is_constant(self) -> bool:
+        """
+        Return True if the time index is constant (single period and both extrapolation flags are True).
+
+        Returns
+        -------
+        bool
+            True if the time index is constant, False otherwise.
+
+        """
+        return self.get_num_periods() == 1 and self.extrapolate_first_point() == self.extrapolate_last_point() is True

framcore/timeindexes/ModelYear.py

@@ -0,0 +1,23 @@
+from datetime import datetime, timedelta
+
+from framcore.timeindexes.SinglePeriodTimeIndex import SinglePeriodTimeIndex  # NB! full import path needed for inheritance to work
+
+
+class ModelYear(SinglePeriodTimeIndex):
+    """ModelYear represent a period of 52 weeks starting from the iso calendar week 1 of a specified year. No extrapolation."""
+
+    def __init__(self, year: int) -> None:
+        """
+        Initialize ModelYear to a period of 52 weeks starting from the iso calendar week 1 of the specified year. No extrapolation.
+
+        Args:
+            year (int): Year to represent.
+
+        """
+        super().__init__(
+            start_time=datetime.fromisocalendar(year, 1, 1),
+            period_duration=timedelta(weeks=52),
+            is_52_week_years=True,
+            extrapolate_first_point=False,
+            extrapolate_last_point=False,
+        )

framcore/timeindexes/ModelYears.py

@@ -0,0 +1,27 @@
+from datetime import datetime
+
+from framcore.timeindexes.ListTimeIndex import ListTimeIndex  # NB! full import path needed for inheritance to work
+
+
+class ModelYears(ListTimeIndex):
+    """ModelYears represents a collection of years as a ListTimeIndex. Extrapolation is enabled and full iso calendar is used."""
+
+    def __init__(self, years: list[int]) -> None:
+        """
+        Initialize ModelYears with a list of years.
+
+        Args:
+            years (list[int]): List of years to represent.
+
+        """
+        if not years:
+            raise ValueError("At least one year must be provided.")
+
+        datetime_list = [datetime.fromisocalendar(year, 1, 1) for year in years]
+        datetime_list.append(datetime.fromisocalendar(years[-1] + 1, 1, 1))
+        super().__init__(
+            datetime_list=datetime_list,
+            is_52_week_years=False,
+            extrapolate_first_point=True,
+            extrapolate_last_point=True,
+        )

framcore/timeindexes/OneYearProfileTimeIndex.py

@@ -0,0 +1,29 @@
+from datetime import timedelta
+
+from framcore.timeindexes.ProfileTimeIndex import ProfileTimeIndex  # NB! full import path needed for inheritance to work
+
+
+class OneYearProfileTimeIndex(ProfileTimeIndex):
+    """
+    ProfileTimeIndex with fixed frequency over one year of either 52 or 53 weeks. No extrapolation inherited from ProfileTimeIndex.
+
+    Attributes:
+        period_duration (timedelta): Duration of each period.
+        is_52_week_years (bool): Whether to use 52-week years.
+
+    """
+
+    def __init__(self, period_duration: timedelta, is_52_week_years: bool) -> None:
+        """
+        Initialize a ProfileTimeIndex with a fixed frequency over one year.
+
+        If is_52_week_years is True, the period_duration must divide evenly into 52 weeks. If False, it must divide evenly into 53 weeks.
+        We use 1982 for 52-week years and 1981 for 53-week years.
+
+        Args:
+            period_duration (timedelta): Duration of each period.
+            is_52_week_years (bool): Whether to use 52-week years.
+
+        """
+        year = 1982 if is_52_week_years else 1981
+        super().__init__(year, 1, period_duration, is_52_week_years)

framcore/timeindexes/ProfileTimeIndex.py

@@ -0,0 +1,43 @@
+from datetime import datetime, timedelta
+
+from framcore.timeindexes.FixedFrequencyTimeIndex import FixedFrequencyTimeIndex  # NB! full import path needed for inheritance to work
+
+
+class ProfileTimeIndex(FixedFrequencyTimeIndex):
+    """ProfileTimeIndex represent one or more whole years with fixed time resolution standard. No extrapolation."""
+
+    def __init__(
+        self,
+        start_year: int,
+        num_years: int,
+        period_duration: timedelta,
+        is_52_week_years: bool,
+    ) -> None:
+        """
+        Initialize the ProfileTimeIndex. No extrapolation.
+
+        Args:
+            start_year (int): First year in the index.
+            num_years (int): Number of years in the index.
+            period_duration (timedelta): Duration of each period in the index.
+            is_52_week_years (bool): Whether to use 52-week years. If False, full iso calendar years are used.
+
+        """
+        start_time = datetime.fromisocalendar(start_year, 1, 1)
+        if not is_52_week_years:
+            stop_time = datetime.fromisocalendar(start_year + num_years, 1, 1)
+            num_periods = (stop_time - start_time).total_seconds() / period_duration.total_seconds()
+        else:
+            num_periods = timedelta(weeks=52 * num_years).total_seconds() / period_duration.total_seconds()
+        if not num_periods.is_integer():
+            msg = f"Number of periods derived from input arguments must be an integer/whole number. Got {num_periods}."
+            raise ValueError(msg)
+        num_periods = int(num_periods)
+        super().__init__(
+            start_time=start_time,
+            period_duration=period_duration,
+            num_periods=num_periods,
+            is_52_week_years=is_52_week_years,
+            extrapolate_first_point=False,
+            extrapolate_last_point=False,
+        )

framcore/timeindexes/SinglePeriodTimeIndex.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from datetime import datetime, timedelta
+
+from framcore.timeindexes.FixedFrequencyTimeIndex import FixedFrequencyTimeIndex  # NB! full import path needed for inheritance to work
+
+
+class SinglePeriodTimeIndex(FixedFrequencyTimeIndex):
+    """FixedFrequencyTimeIndex with just one single step."""
+
+    def __init__(
+        self,
+        start_time: datetime,
+        period_duration: timedelta,
+        is_52_week_years: bool = False,
+        extrapolate_first_point: bool = False,
+        extrapolate_last_point: bool = False,
+    ) -> None:
+        """
+        Initialize a SinglePeriodTimeIndex with a single time period.
+
+        Args:
+            start_time (datetime): The start time of the period.
+            period_duration (timedelta): The duration of the period.
+            is_52_week_years (bool, optional): Whether to use 52-week years. Defaults to False.
+            extrapolate_first_point (bool, optional): Whether to extrapolate the first point. Defaults to False.
+            extrapolate_last_point (bool, optional): Whether to extrapolate the last point. Defaults to False.
+
+        """
+        super().__init__(
+            start_time=start_time,
+            period_duration=period_duration,
+            num_periods=1,
+            is_52_week_years=is_52_week_years,
+            extrapolate_first_point=extrapolate_first_point,
+            extrapolate_last_point=extrapolate_last_point,
+        )

framcore/timeindexes/TimeIndex.py

@@ -0,0 +1,103 @@
+# from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from datetime import datetime, timedelta, tzinfo
+
+from numpy.typing import NDArray
+
+from framcore import Base
+from framcore.fingerprints.fingerprint import Fingerprint
+from framcore.timeindexes import FixedFrequencyTimeIndex
+
+
+class TimeIndex(Base, ABC):
+    """TimeIndex interface for TimeVectors."""
+
+    @abstractmethod
+    def __eq__(self, other) -> bool:  # noqa: ANN001
+        """Check if two TimeIndexes are equal."""
+        pass
+
+    @abstractmethod
+    def __hash__(self) -> int:
+        """Compute hash value.."""
+        pass
+
+    @abstractmethod
+    def get_fingerprint(self) -> Fingerprint:
+        """Get the fingerprint of the TimeIndex."""
+        pass
+
+    @abstractmethod
+    def get_timezone(self) -> tzinfo | None:
+        """Get the timezone of the TimeIndex."""
+        pass
+
+    @abstractmethod
+    def get_num_periods(self) -> bool:
+        """Get the number of periods in the TimeIndex."""
+        pass
+
+    @abstractmethod
+    def is_52_week_years(self) -> bool:
+        """Check if the TimeIndex is based on 52-week years."""
+        pass
+
+    @abstractmethod
+    def is_one_year(self) -> bool:
+        """
+        Check if the TimeIndex represents a single year.
+
+        Must be False if extrapolate_first_point and or extrapolate_last_point is True.
+
+        When True, can be repeted in profiles.
+        """
+        pass
+
+    @abstractmethod
+    def is_whole_years(self) -> bool:
+        """Check if the TimeIndex represents whole years."""
+        pass
+
+    @abstractmethod
+    def extrapolate_first_point(self) -> bool:
+        """Check if the TimeIndex should extrapolate the first point. Must be False if is_one_year is True."""
+        pass
+
+    @abstractmethod
+    def extrapolate_last_point(self) -> bool:
+        """Check if the TimeIndex should extrapolate the last point. Must be False if is_one_year is True."""
+        pass
+
+    @abstractmethod
+    def get_period_average(self, vector: NDArray, start_time: datetime, duration: timedelta, is_52_week_years: bool) -> float:
+        """Get the average over the period from the vector."""
+        pass
+
+    @abstractmethod
+    def write_into_fixed_frequency(
+        self,
+        target_vector: NDArray,
+        target_timeindex: FixedFrequencyTimeIndex,
+        input_vector: NDArray,
+    ) -> None:
+        """
+        Write the input vector into the target vector based on the target FixedFrequencyTimeIndex.
+
+        Main functionality in FRAM to extracts data to the correct time period and resolution.
+        A conversion of the data into a specific time period and resolution follows these steps:
+        - If the TimeIndex is not a FixedFrequencyTimeIndex, convert the TimeIndex and the vector to this format.
+        - Then convert the data according to the target TimeIndex.
+        - It is easier to efficiently do time series operations between FixedFrequencyTimeIndex
+            and we only need to implement all the other conversion functionality once here.
+            For example, converting between 52-week and ISO-time TimeVectors, selecting a period, extrapolation or changing the resolution.
+        - And when we implement a new TimeIndex, we only need to implement the conversion to FixedFrequencyTimeIndex
+            and the rest of the conversion functionality can be reused.
+
+        """
+        pass
+
+    @abstractmethod
+    def is_constant(self) -> bool:
+        """Check if the TimeIndex is constant."""
+        pass

framcore/timeindexes/WeeklyIndex.py

@@ -0,0 +1,33 @@
+from datetime import timedelta
+
+from framcore.timeindexes.ProfileTimeIndex import ProfileTimeIndex  # NB! full import path needed for inheritance to work
+
+
+class WeeklyIndex(ProfileTimeIndex):
+    """
+    ProfileTimeIndex with one or more whole years with weekly resolution. Either years with 52 weeks or full iso calendar years.
+
+    No extrapolation inherited from ProfileTimeIndex.
+    """
+
+    def __init__(
+        self,
+        start_year: int,
+        num_years: int,
+        is_52_week_years: bool = True,
+    ) -> None:
+        """
+        Initialize WeeklyIndex with one or more whole years with weekly resolution. Either years with 52 weeks or full iso calendar years.
+
+        Args:
+            start_year (int): First year in the index.
+            num_years (int): Number of years in the index.
+            is_52_week_years (bool, optional): Whether to use 52-week years. If False, full iso calendar years are used. Defaults to True.
+
+        """
+        super().__init__(
+            start_year=start_year,
+            num_years=num_years,
+            period_duration=timedelta(weeks=1),
+            is_52_week_years=is_52_week_years,
+        )

framcore/timeindexes/__init__.py

@@ -0,0 +1,36 @@
+# framcore/timeindexes/__init__.py
+
+"""FRAM time indexes package provides functionality for handling time-related data."""
+
+from framcore.timeindexes.FixedFrequencyTimeIndex import FixedFrequencyTimeIndex
+from framcore.timeindexes.TimeIndex import TimeIndex
+from framcore.timeindexes.SinglePeriodTimeIndex import SinglePeriodTimeIndex
+from framcore.timeindexes.ListTimeIndex import ListTimeIndex
+from framcore.timeindexes.ProfileTimeIndex import ProfileTimeIndex
+from framcore.timeindexes.AverageYearRange import AverageYearRange
+from framcore.timeindexes.ConstantTimeIndex import ConstantTimeIndex
+from framcore.timeindexes.DailyIndex import DailyIndex
+from framcore.timeindexes.HourlyIndex import HourlyIndex
+from framcore.timeindexes.ModelYear import ModelYear
+from framcore.timeindexes.ModelYears import ModelYears
+from framcore.timeindexes.OneYearProfileTimeIndex import OneYearProfileTimeIndex
+from framcore.timeindexes.WeeklyIndex import WeeklyIndex
+from framcore.timeindexes.IsoCalendarDay import IsoCalendarDay
+
+
+__all__ = [
+    "AverageYearRange",
+    "ConstantTimeIndex",
+    "DailyIndex",
+    "FixedFrequencyTimeIndex",
+    "HourlyIndex",
+    "IsoCalendarDay",
+    "ListTimeIndex",
+    "ModelYear",
+    "ModelYears",
+    "OneYearProfileTimeIndex",
+    "ProfileTimeIndex",
+    "SinglePeriodTimeIndex",
+    "TimeIndex",
+    "WeeklyIndex",
+]