mloda 0.3.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

mloda_plugins/feature_group/experimental/dynamic_feature_group_factory/dynamic_feature_group_factory.py

@@ -1,18 +1,18 @@
 from typing import Any, Dict, Optional, Type, Set, List, Union
-from mloda_core.abstract_plugins.abstract_feature_group import AbstractFeatureGroup
-from mloda_core.abstract_plugins.components.options import Options
-from mloda_core.abstract_plugins.components.feature_name import FeatureName
-from mloda_core.abstract_plugins.components.data_access_collection import DataAccessCollection
-from mloda_core.abstract_plugins.components.feature_set import FeatureSet
-from mloda_core.abstract_plugins.components.data_types import DataType
-from mloda_core.abstract_plugins.compute_frame_work import ComputeFrameWork
-from mloda_core.abstract_plugins.components.index.index import Index
-from mloda_core.abstract_plugins.components.input_data.base_input_data import BaseInputData
+from mloda import FeatureGroup
+from mloda import Options
+from mloda.user import FeatureName
+from mloda.user import DataAccessCollection
+from mloda.provider import FeatureSet
+from mloda.user import DataType
+from mloda import ComputeFramework
+from mloda.user import Index
+from mloda.provider import BaseInputData
 
 
 class DynamicFeatureGroupCreator:
     """
-    Base class for dynamically creating AbstractFeatureGroup subclasses at runtime.
+    Base class for dynamically creating FeatureGroup subclasses at runtime.
 
     This factory enables programmatic creation of feature groups by specifying their
     behavior through a properties dictionary. It's useful for generating feature groups
@@ -23,7 +23,7 @@ class DynamicFeatureGroupCreator:
 
     - Create feature group classes at runtime without explicit class definitions
     - Override specific methods (calculate_feature, match_feature_group_criteria, etc.)
-    - Inherit from any AbstractFeatureGroup subclass (e.g., ReadFileFeature, SourceInputFeature)
+    - Inherit from any FeatureGroup subclass (e.g., ReadFileFeature, SourceInputFeature)
     - Cache created classes to avoid duplicate definitions
     - Support full feature group lifecycle customization
 
@@ -36,7 +36,7 @@ class DynamicFeatureGroupCreator:
 
     ## Available Method Overrides
 
-    All methods from AbstractFeatureGroup can be overridden via the properties dictionary:
+    All methods from FeatureGroup can be overridden via the properties dictionary:
 
     - `set_feature_name`: Customize feature name resolution
     - `match_feature_group_criteria`: Define custom matching logic
@@ -59,7 +59,7 @@ class DynamicFeatureGroupCreator:
     from mloda_plugins.feature_group.experimental.dynamic_feature_group_factory import (
         DynamicFeatureGroupCreator
     )
-    from mloda_core.abstract_plugins.components.feature_name import FeatureName
+    from mloda.user import FeatureName
 
     # Define custom behavior
     properties = {
@@ -126,7 +126,7 @@ class DynamicFeatureGroupCreator:
     ### Complex Custom Logic
 
     ```python
-    from mloda_core.abstract_plugins.components.feature import Feature
+    from mloda import Feature
 
     def custom_input_features(self, options, feature_name):
         # Return dynamically determined input features
@@ -156,22 +156,22 @@ class DynamicFeatureGroupCreator:
 
     - `properties`: Dictionary mapping method names to callable implementations
     - `class_name`: Name for the dynamically created class (used for caching)
-    - `feature_group_cls`: Base class to inherit from (default: AbstractFeatureGroup)
+    - `feature_group_cls`: Base class to inherit from (default: FeatureGroup)
 
     ## Implementation Details
 
     - Created classes are cached in `_created_classes` dictionary
     - Requesting the same `class_name` twice returns the cached class
     - Properties use lambda functions or regular functions as method implementations
-    - Method signatures must match the original AbstractFeatureGroup signatures
+    - Method signatures must match the original FeatureGroup signatures
     - Unspecified methods fall back to parent class implementations
 
     ## Requirements
 
-    - Properties dictionary with valid method names from AbstractFeatureGroup
+    - Properties dictionary with valid method names from FeatureGroup
     - Callable implementations matching expected method signatures
     - Unique class_name for each distinct feature group type
-    - Base class must be AbstractFeatureGroup or its subclass
+    - Base class must be FeatureGroup or its subclass
 
     ## Real-World Example
 
@@ -180,23 +180,23 @@ class DynamicFeatureGroupCreator:
     groups on-the-fly for joining multiple files.
     """
 
-    _created_classes: Dict[str, Type[AbstractFeatureGroup]] = {}  # Store created classes
+    _created_classes: Dict[str, Type[FeatureGroup]] = {}  # Store created classes
 
     @staticmethod
     def create(
         properties: Dict[str, Any],
         class_name: str = "DynamicFeatureGroup",
-        feature_group_cls: Type[AbstractFeatureGroup] = AbstractFeatureGroup,
-    ) -> Type[AbstractFeatureGroup]:
+        feature_group_cls: Type[FeatureGroup] = FeatureGroup,
+    ) -> Type[FeatureGroup]:
         """
-        Creates a new AbstractFeatureGroup subclass with the given properties.
+        Creates a new FeatureGroup subclass with the given properties.
 
         Args:
             properties: A dictionary containing the properties for the new class.
             class_name: The name of the new class.
 
         Returns:
-            A new AbstractFeatureGroup subclass.
+            A new FeatureGroup subclass.
         """
 
         if class_name in DynamicFeatureGroupCreator._created_classes:
@@ -242,7 +242,7 @@ class DynamicFeatureGroupCreator:
                 return properties["artifact"]()  # type: ignore[no-any-return]
             return super(new_class, cls).artifact()  # type: ignore[misc, arg-type, no-any-return]
 
-        def compute_framework_rule(cls) -> Union[bool, Set[Type[ComputeFrameWork]]]:  # type: ignore[no-untyped-def]
+        def compute_framework_rule(cls) -> Union[bool, Set[Type[ComputeFramework]]]:  # type: ignore[no-untyped-def]
             if "compute_framework_rule" in properties:
                 return properties["compute_framework_rule"]()  # type: ignore[no-any-return]
             return super(new_class, cls).compute_framework_rule()  # type: ignore[misc, arg-type, no-any-return]

mloda_plugins/feature_group/experimental/forecasting/base.py

@@ -7,21 +7,17 @@ from __future__ import annotations
 from abc import abstractmethod
 from typing import Any, List, Optional, Set, Type, Union
 
-from mloda_core.abstract_plugins.abstract_feature_group import AbstractFeatureGroup
-from mloda_core.abstract_plugins.components.base_artifact import BaseArtifact
-from mloda_core.abstract_plugins.components.feature import Feature
-from mloda_core.abstract_plugins.components.feature_chainer.feature_chain_parser import (
-    CHAIN_SEPARATOR,
-    FeatureChainParser,
-)
-from mloda_core.abstract_plugins.components.feature_name import FeatureName
-from mloda_core.abstract_plugins.components.feature_set import FeatureSet
-from mloda_core.abstract_plugins.components.options import Options
+from mloda import FeatureGroup
+from mloda.provider import BaseArtifact
+from mloda import Feature
+from mloda.provider import CHAIN_SEPARATOR, FeatureChainParser, FeatureChainParserMixin, FeatureSet
+from mloda.user import FeatureName
+from mloda import Options
 from mloda_plugins.feature_group.experimental.default_options_key import DefaultOptionKeys
 from mloda_plugins.feature_group.experimental.forecasting.forecasting_artifact import ForecastingArtifact
 
 
-class ForecastingFeatureGroup(AbstractFeatureGroup):
+class ForecastingFeatureGroup(FeatureChainParserMixin, FeatureGroup):
     """
     Base class for all forecasting feature groups.
 
@@ -98,7 +94,7 @@ class ForecastingFeatureGroup(AbstractFeatureGroup):
 
     ## Requirements
     - The input data must have a datetime column that can be used for time-based operations
-    - By default, the feature group will use DefaultOptionKeys.reference_time (default: "time_filter")
+    - By default, the feature group will use DefaultOptionKeys.reference_time (default: "reference_time")
     - You can specify a custom time column by setting the reference_time option in the feature group options
     """
 
@@ -133,38 +129,42 @@ class ForecastingFeatureGroup(AbstractFeatureGroup):
     # Define the prefix pattern for this feature group
     PREFIX_PATTERN = r".*__([\w]+)_forecast_(\d+)([\w]+)$"
 
+    # In-feature configuration for FeatureChainParserMixin
+    MIN_IN_FEATURES = 1
+    MAX_IN_FEATURES = 1
+
     # Property mapping for configuration-based features with group/context separation
     PROPERTY_MAPPING = {
         ALGORITHM: {
             **FORECASTING_ALGORITHMS,
-            DefaultOptionKeys.mloda_context: True,
-            DefaultOptionKeys.mloda_strict_validation: True,
+            DefaultOptionKeys.context: True,
+            DefaultOptionKeys.strict_validation: True,
         },
         HORIZON: {
             "explanation": "Forecast horizon (number of time units to predict)",
-            DefaultOptionKeys.mloda_context: True,
-            DefaultOptionKeys.mloda_strict_validation: True,
-            DefaultOptionKeys.mloda_validation_function: lambda x: (
+            DefaultOptionKeys.context: True,
+            DefaultOptionKeys.strict_validation: True,
+            DefaultOptionKeys.validation_function: lambda x: (
                 isinstance(x, int) or (isinstance(x, str) and x.isdigit())
             )
             and int(x) > 0,
         },
         TIME_UNIT: {
             **TIME_UNITS,
-            DefaultOptionKeys.mloda_context: True,
-            DefaultOptionKeys.mloda_strict_validation: True,
+            DefaultOptionKeys.context: True,
+            DefaultOptionKeys.strict_validation: True,
         },
         DefaultOptionKeys.in_features: {
             "explanation": "Source feature to generate forecasts for",
-            DefaultOptionKeys.mloda_context: True,
-            DefaultOptionKeys.mloda_strict_validation: False,
+            DefaultOptionKeys.context: True,
+            DefaultOptionKeys.strict_validation: False,
         },
         OUTPUT_CONFIDENCE_INTERVALS: {
             "explanation": "Whether to output confidence intervals as separate columns using ~lower and ~upper suffix pattern",
-            DefaultOptionKeys.mloda_context: True,
-            DefaultOptionKeys.mloda_strict_validation: False,
-            DefaultOptionKeys.mloda_default: False,  # Default is False (don't output confidence intervals)
-            DefaultOptionKeys.mloda_validation_function: lambda value: isinstance(value, bool),
+            DefaultOptionKeys.context: True,
+            DefaultOptionKeys.strict_validation: False,
+            DefaultOptionKeys.default: False,  # Default is False (don't output confidence intervals)
+            DefaultOptionKeys.validation_function: lambda value: isinstance(value, bool),
         },
     }
 
@@ -179,15 +179,15 @@ class ForecastingFeatureGroup(AbstractFeatureGroup):
         return ForecastingArtifact
 
     @classmethod
-    def get_time_filter_feature(cls, options: Optional[Options] = None) -> str:
+    def get_reference_time_column(cls, options: Optional[Options] = None) -> str:
         """
-        Get the time filter feature name from options or use the default.
+        Get the reference time column name from options or use the default.
 
         Args:
-            options: Optional Options object that may contain a custom time filter feature name
+            options: Optional Options object that may contain a custom reference time column name
 
         Returns:
-            The time filter feature name to use
+            The reference time column name to use
         """
         reference_time_key = DefaultOptionKeys.reference_time.value
         if options and options.get(reference_time_key):
@@ -197,7 +197,7 @@ class ForecastingFeatureGroup(AbstractFeatureGroup):
                     f"Invalid reference_time option: {reference_time}. Must be string. Is: {type(reference_time)}."
                 )
             return reference_time
-        return reference_time_key
+        return DefaultOptionKeys.reference_time.value
 
     def input_features(self, options: Options, feature_name: FeatureName) -> Optional[Set[Feature]]:
         """Extract source feature and time filter feature from either configuration-based options or string parsing."""
@@ -207,7 +207,7 @@ class ForecastingFeatureGroup(AbstractFeatureGroup):
         # Try string-based parsing first
         _, source_feature = FeatureChainParser.parse_feature_name(feature_name, [self.PREFIX_PATTERN])
         if source_feature is not None:
-            time_filter_feature = Feature(self.get_time_filter_feature(options))
+            time_filter_feature = Feature(self.get_reference_time_column(options))
             return {Feature(source_feature), time_filter_feature}
 
         # Fall back to configuration-based approach
@@ -218,7 +218,7 @@ class ForecastingFeatureGroup(AbstractFeatureGroup):
             )
 
         source_feature_obj = next(iter(source_features))
-        time_filter_feature = Feature(self.get_time_filter_feature(options))
+        time_filter_feature = Feature(self.get_reference_time_column(options))
         return {source_feature_obj, time_filter_feature}
 
     @classmethod
@@ -287,35 +287,28 @@ class ForecastingFeatureGroup(AbstractFeatureGroup):
         return algorithm, horizon, time_unit
 
     @classmethod
-    def match_feature_group_criteria(
-        cls,
-        feature_name: Union[FeatureName, str],
-        options: Options,
-        data_access_collection: Optional[Any] = None,
-    ) -> bool:
-        """Check if feature name matches the expected pattern for forecasting features."""
-
-        # Use the unified parser with property mapping for full configuration support
-        result = FeatureChainParser.match_configuration_feature_chain_parser(
-            feature_name,
-            options,
-            property_mapping=cls.PROPERTY_MAPPING,
-            prefix_patterns=[cls.PREFIX_PATTERN],
-        )
+    def _validate_string_match(cls, feature_name: str, _operation_config: str, _source_feature: str) -> bool:
+        """
+        Validate that a string-based feature name has valid forecasting components.
+
+        Validates algorithm, horizon, and time_unit using parse_forecast_suffix().
 
-        # If it matches and it's a string-based feature, validate with our custom logic
-        if result:
-            feature_name_str = feature_name.name if isinstance(feature_name, FeatureName) else feature_name
+        Args:
+            feature_name: The full feature name to validate
+            _operation_config: The operation config extracted by the regex (unused)
+            _source_feature: The source feature extracted by the regex (unused)
 
-            # Check if this is a string-based feature (contains the pattern)
-            if FeatureChainParser.is_chained_feature(feature_name_str):
-                try:
-                    # Use existing validation logic that validates algorithm, horizon, and time_unit
-                    cls.parse_forecast_suffix(feature_name_str)
-                except ValueError:
-                    # If validation fails, this feature doesn't match
-                    return False
-        return result
+        Returns:
+            True if valid, False otherwise
+        """
+        if FeatureChainParser.is_chained_feature(feature_name):
+            try:
+                # Use existing validation logic that validates algorithm, horizon, and time_unit
+                cls.parse_forecast_suffix(feature_name)
+            except ValueError:
+                # If validation fails, this feature doesn't match
+                return False
+        return True
 
     @classmethod
     def calculate_feature(cls, data: Any, features: FeatureSet) -> Any:
@@ -339,10 +332,10 @@ class ForecastingFeatureGroup(AbstractFeatureGroup):
                     raise ValueError("All features must have the same options.")
             _options = feature.options
 
-        time_filter_feature = cls.get_time_filter_feature(_options)
+        reference_time_column = cls.get_reference_time_column(_options)
 
-        cls._check_time_filter_feature_exists(data, time_filter_feature)
-        cls._check_time_filter_feature_is_datetime(data, time_filter_feature)
+        cls._check_reference_time_column_exists(data, reference_time_column)
+        cls._check_reference_time_column_is_datetime(data, reference_time_column)
 
         # Store the original clean data
         original_data = data
@@ -381,7 +374,13 @@ class ForecastingFeatureGroup(AbstractFeatureGroup):
             if output_confidence_intervals:
                 # Get forecast, lower bound, and upper bound
                 result, lower_bound, upper_bound, updated_artifact = cls._perform_forecasting_with_confidence(
-                    original_data, algorithm, horizon, time_unit, resolved_columns, time_filter_feature, model_artifact
+                    original_data,
+                    algorithm,
+                    horizon,
+                    time_unit,
+                    resolved_columns,
+                    reference_time_column,
+                    model_artifact,
                 )
 
                 # Save the updated artifact if needed
@@ -395,7 +394,13 @@ class ForecastingFeatureGroup(AbstractFeatureGroup):
             else:
                 # Original behavior: only output point forecast
                 result, updated_artifact = cls._perform_forecasting(
-                    original_data, algorithm, horizon, time_unit, resolved_columns, time_filter_feature, model_artifact
+                    original_data,
+                    algorithm,
+                    horizon,
+                    time_unit,
+                    resolved_columns,
+                    reference_time_column,
+                    model_artifact,
                 )
 
                 # Save the updated artifact if needed
@@ -427,74 +432,71 @@ class ForecastingFeatureGroup(AbstractFeatureGroup):
         Raises:
             ValueError: If parameters cannot be extracted
         """
-        # Try string-based parsing first
-        feature_name_str = feature.name.name if hasattr(feature.name, "name") else str(feature.name)
+        source_features = cls._extract_source_features(feature)
+        algorithm, horizon, time_unit = cls._extract_forecast_params(feature)
+        if algorithm is None or horizon is None or time_unit is None:
+            raise ValueError(f"Could not extract forecasting parameters from: {feature.name}")
+        return algorithm, horizon, time_unit, source_features[0]
 
-        if FeatureChainParser.is_chained_feature(feature_name_str):
-            algorithm, horizon, time_unit = cls.parse_forecast_suffix(feature_name_str)
+    @classmethod
+    def _extract_forecast_params(cls, feature: Feature) -> tuple[Optional[str], Optional[int], Optional[str]]:
+        """
+        Extract forecast-specific parameters (algorithm, horizon, time_unit) from a feature.
 
-            # Extract source feature name (everything before the last double underscore)
-            source_feature_name = feature_name_str.rsplit(CHAIN_SEPARATOR, 1)[0]
-            return algorithm, horizon, time_unit, source_feature_name
+        Tries string-based parsing first using parse_forecast_suffix, falls back to configuration-based approach.
 
-        # Fall back to configuration-based approach
-        source_features = feature.options.get_in_features()
-        source_feature = next(iter(source_features))
-        source_feature_name = source_feature.get_name()
+        Args:
+            feature: The feature to extract parameters from
 
+        Returns:
+            Tuple of (algorithm, horizon, time_unit), where any value may be None if not found
+
+        Raises:
+            ValueError: If string-based parsing fails validation
+        """
+        # Try string-based first using parse_forecast_suffix
+        feature_name_str = feature.name.name if hasattr(feature.name, "name") else str(feature.name)
+        if FeatureChainParser.is_chained_feature(feature_name_str):
+            try:
+                algorithm, horizon, time_unit = cls.parse_forecast_suffix(feature_name_str)
+                return algorithm, horizon, time_unit
+            except ValueError:
+                pass
+        # Fall back to config
         algorithm = feature.options.get(cls.ALGORITHM)
         horizon = feature.options.get(cls.HORIZON)
         time_unit = feature.options.get(cls.TIME_UNIT)
-
-        if algorithm is None or horizon is None or time_unit is None or source_feature_name is None:
-            raise ValueError(f"Could not extract forecasting parameters from: {feature.name}")
-
-        # Validate parameters
-        if algorithm not in cls.FORECASTING_ALGORITHMS:
-            raise ValueError(
-                f"Unsupported forecasting algorithm: {algorithm}. "
-                f"Supported algorithms: {', '.join(cls.FORECASTING_ALGORITHMS.keys())}"
-            )
-
-        if time_unit not in cls.TIME_UNITS:
-            raise ValueError(f"Unsupported time unit: {time_unit}. Supported units: {', '.join(cls.TIME_UNITS.keys())}")
-
-        # Convert horizon to integer if it's a string
-        if isinstance(horizon, str):
+        if horizon is not None and isinstance(horizon, str):
             horizon = int(horizon)
-
-        if not isinstance(horizon, int) or horizon <= 0:
-            raise ValueError(f"Invalid horizon: {horizon}. Must be a positive integer.")
-
-        return algorithm, horizon, time_unit, source_feature_name
+        return algorithm, horizon, time_unit
 
     @classmethod
     @abstractmethod
-    def _check_time_filter_feature_exists(cls, data: Any, time_filter_feature: str) -> None:
+    def _check_reference_time_column_exists(cls, data: Any, reference_time_column: str) -> None:
         """
-        Check if the time filter feature exists in the data.
+        Check if the reference time column exists in the data.
 
         Args:
             data: The input data
-            time_filter_feature: The name of the time filter feature
+            reference_time_column: The name of the reference time column
 
         Raises:
-            ValueError: If the time filter feature does not exist in the data
+            ValueError: If the reference time column does not exist in the data
         """
         ...
 
     @classmethod
     @abstractmethod
-    def _check_time_filter_feature_is_datetime(cls, data: Any, time_filter_feature: str) -> None:
+    def _check_reference_time_column_is_datetime(cls, data: Any, reference_time_column: str) -> None:
         """
-        Check if the time filter feature is a datetime column.
+        Check if the reference time column is a datetime column.
 
         Args:
             data: The input data
-            time_filter_feature: The name of the time filter feature
+            reference_time_column: The name of the reference time column
 
         Raises:
-            ValueError: If the time filter feature is not a datetime column
+            ValueError: If the reference time column is not a datetime column
         """
         ...
 

mloda_plugins/feature_group/experimental/forecasting/forecasting_artifact.py

@@ -7,8 +7,8 @@ import pickle  # nosec
 import base64
 from typing import Any, Dict, Optional
 
-from mloda_core.abstract_plugins.components.base_artifact import BaseArtifact
-from mloda_core.abstract_plugins.components.feature_set import FeatureSet
+from mloda.provider import BaseArtifact
+from mloda.provider import FeatureSet
 
 
 class ForecastingArtifact(BaseArtifact):

mloda_plugins/feature_group/experimental/forecasting/pandas.py

@@ -27,14 +27,14 @@ except ImportError:
     np = None  # type: ignore
 
 
-from mloda_core.abstract_plugins.compute_frame_work import ComputeFrameWork
+from mloda import ComputeFramework
 from mloda_plugins.compute_framework.base_implementations.pandas.dataframe import PandasDataFrame
 from mloda_plugins.feature_group.experimental.forecasting.base import ForecastingFeatureGroup
 
 
 class PandasForecastingFeatureGroup(ForecastingFeatureGroup):
     @classmethod
-    def compute_framework_rule(cls) -> set[type[ComputeFrameWork]]:
+    def compute_framework_rule(cls) -> set[type[ComputeFramework]]:
         """Define the compute framework for this feature group."""
         return {PandasDataFrame}
 
@@ -44,39 +44,39 @@ class PandasForecastingFeatureGroup(ForecastingFeatureGroup):
         return set(data.columns)
 
     @classmethod
-    def _check_time_filter_feature_exists(cls, data: pd.DataFrame, time_filter_feature: str) -> None:
+    def _check_reference_time_column_exists(cls, data: pd.DataFrame, reference_time_column: str) -> None:
         """
-        Check if the time filter feature exists in the DataFrame.
+        Check if the reference time column exists in the DataFrame.
 
         Args:
             data: The pandas DataFrame
-            time_filter_feature: The name of the time filter feature
+            reference_time_column: The name of the reference time column
 
         Raises:
-            ValueError: If the time filter feature does not exist in the DataFrame
+            ValueError: If the reference time column does not exist in the DataFrame
         """
-        if time_filter_feature not in data.columns:
+        if reference_time_column not in data.columns:
             raise ValueError(
-                f"Time filter feature '{time_filter_feature}' not found in data. "
+                f"Reference time column '{reference_time_column}' not found in data. "
                 f"Please ensure the DataFrame contains this column."
             )
 
     @classmethod
-    def _check_time_filter_feature_is_datetime(cls, data: pd.DataFrame, time_filter_feature: str) -> None:
+    def _check_reference_time_column_is_datetime(cls, data: pd.DataFrame, reference_time_column: str) -> None:
         """
-        Check if the time filter feature is a datetime column.
+        Check if the reference time column is a datetime column.
 
         Args:
             data: The pandas DataFrame
-            time_filter_feature: The name of the time filter feature
+            reference_time_column: The name of the reference time column
 
         Raises:
-            ValueError: If the time filter feature is not a datetime column
+            ValueError: If the reference time column is not a datetime column
         """
-        if not pd.api.types.is_datetime64_any_dtype(data[time_filter_feature]):
+        if not pd.api.types.is_datetime64_any_dtype(data[reference_time_column]):
             raise ValueError(
-                f"Time filter feature '{time_filter_feature}' must be a datetime column. "
-                f"Current dtype: {data[time_filter_feature].dtype}"
+                f"Reference time column '{reference_time_column}' must be a datetime column. "
+                f"Current dtype: {data[reference_time_column].dtype}"
             )
 
     @classmethod