mloda-community-offset 0.3.1__py3-none-any.whl

mloda/community/feature_groups/data_operations/row_preserving/offset/base.py

@@ -0,0 +1,216 @@
+"""Base class for offset feature groups."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from mloda.core.abstract_plugins.components.feature import Feature
+from mloda.core.abstract_plugins.components.feature_chainer.feature_chain_parser import FeatureChainParser
+from mloda.core.abstract_plugins.components.feature_chainer.feature_chain_parser_mixin import FeatureChainParserMixin
+from mloda.core.abstract_plugins.components.feature_set import FeatureSet
+from mloda.provider import DefaultOptionKeys, FeatureGroup
+
+
+class OffsetFeatureGroup(FeatureChainParserMixin, FeatureGroup):
+    """Base class for offset operations that preserve row count.
+
+    Offset operations access values at a fixed offset from the current row
+    within an ordered partition. The output always has the same number of
+    rows as the input.
+
+    ## Supported Offset Types
+
+    - ``lag_N``: Value N rows before the current row
+    - ``lead_N``: Value N rows after the current row
+    - ``diff_N``: Difference between current value and value N rows before
+    - ``pct_change_N``: Percentage change from value N rows before
+    - ``first_value``: First value in the partition
+    - ``last_value``: Last value in the partition
+
+    ## Feature Creation Methods
+
+    ### 1. String-Based Creation
+
+    Features follow the naming pattern: ``{source_column}__{offset_type}_offset``
+
+    Examples::
+
+        features = [
+            Feature("sales__lag_1_offset", options=Options(context={
+                "partition_by": ["region"], "order_by": "timestamp",
+            })),
+            Feature("price__diff_1_offset", options=Options(context={
+                "partition_by": ["category"], "order_by": "date",
+            })),
+        ]
+
+    ### 2. Configuration-Based Creation
+
+    Uses Options with proper context parameter separation::
+
+        feature = Feature(
+            name="my_lag",
+            options=Options(
+                context={
+                    "offset_type": "lag_1",
+                    "in_features": "sales",
+                    "partition_by": ["region"],
+                    "order_by": "timestamp",
+                }
+            ),
+        )
+
+    ## Null Behavior
+
+    Offset positions that fall outside the partition boundary produce null.
+    For example, ``lag_1`` on the first row of a partition returns null.
+    ``first_value`` and ``last_value`` ignore null source values; if all
+    values in a partition are null, the result is null.
+
+    ## Parameter Classification
+
+    ### Context Parameters
+    - ``offset_type``: The type of offset to perform
+    - ``in_features``: The source feature
+    - ``partition_by``: List of columns to partition by
+    - ``order_by``: Column to order by within each partition
+    """
+
+    PREFIX_PATTERN = r".*__([\w]+)_offset$"
+
+    MIN_IN_FEATURES = 1
+    MAX_IN_FEATURES = 1
+
+    OFFSET_TYPE = "offset_type"
+    PARTITION_BY = "partition_by"
+    ORDER_BY = "order_by"
+
+    OFFSET_TYPES = {
+        "first_value": "First value in partition",
+        "last_value": "Last value in partition",
+    }
+
+    PROPERTY_MAPPING = {
+        OFFSET_TYPE: {
+            **OFFSET_TYPES,
+            DefaultOptionKeys.context: True,
+            DefaultOptionKeys.strict_validation: False,
+            DefaultOptionKeys.type_validator: lambda v: isinstance(v, str),
+        },
+        DefaultOptionKeys.in_features: {
+            "explanation": "Source feature for offset operation",
+            DefaultOptionKeys.context: True,
+            DefaultOptionKeys.strict_validation: False,
+        },
+        PARTITION_BY: {
+            "explanation": "List of columns to partition by",
+            DefaultOptionKeys.context: True,
+            DefaultOptionKeys.strict_validation: False,
+        },
+        ORDER_BY: {
+            "explanation": "Column to order by within each partition",
+            DefaultOptionKeys.context: True,
+            DefaultOptionKeys.strict_validation: False,
+        },
+    }
+
+    @classmethod
+    def _supports_offset_type(cls, offset_type: str) -> bool:
+        """Check if the given offset type is supported."""
+        if offset_type in cls.OFFSET_TYPES:
+            return True
+        for prefix in ("lag_", "lead_", "diff_", "pct_change_"):
+            if offset_type.startswith(prefix):
+                suffix = offset_type[len(prefix) :]
+                if suffix.isdigit() and int(suffix) >= 1:
+                    return True
+        return False
+
+    @classmethod
+    def _validate_string_match(cls, feature_name: str, operation_config: str, source_feature: str) -> bool:
+        """Validate that the offset type is supported."""
+        return cls._supports_offset_type(operation_config)
+
+    @classmethod
+    def match_feature_group_criteria(
+        cls,
+        feature_name: Any,
+        options: Any,
+        _data_access_collection: Any = None,
+    ) -> bool:
+        """Extend mixin matching with partition_by, order_by, and in_features validation."""
+        if not super().match_feature_group_criteria(feature_name, options, _data_access_collection):
+            return False
+
+        partition_by = options.get(cls.PARTITION_BY)
+        if not isinstance(partition_by, (list, tuple)):
+            return False
+        if not all(isinstance(item, str) for item in partition_by):
+            return False
+
+        order_by = options.get(cls.ORDER_BY)
+        if order_by is None:
+            return False
+        if not isinstance(order_by, str):
+            return False
+
+        in_features_raw = options.get(DefaultOptionKeys.in_features)
+        if in_features_raw is not None:
+            in_features = options.get_in_features()
+            if len(in_features) > cls.MAX_IN_FEATURES:
+                return False
+
+        return True
+
+    @classmethod
+    def get_offset_type(cls, feature_name: str) -> str:
+        """Extract the offset type from a feature name string."""
+        prefix_patterns = cls._get_prefix_patterns()
+        operation_config, _ = FeatureChainParser.parse_feature_name(feature_name, prefix_patterns)
+        if operation_config is not None:
+            return operation_config
+        raise ValueError(f"Could not extract offset type from feature name: {feature_name}")
+
+    @classmethod
+    def _extract_offset_type(cls, feature: Feature) -> str:
+        """Extract offset type from feature (string-based or config-based)."""
+        feature_name = feature.name
+        prefix_patterns = cls._get_prefix_patterns()
+        operation_config, _ = FeatureChainParser.parse_feature_name(feature_name, prefix_patterns)
+        if operation_config is not None:
+            return operation_config
+        offset_type = feature.options.get(cls.OFFSET_TYPE)
+        if offset_type is None:
+            raise ValueError(f"Could not extract offset type for {feature_name}")
+        return str(offset_type)
+
+    @classmethod
+    def calculate_feature(cls, data: Any, features: FeatureSet) -> Any:
+        """Shared loop: extract params from each feature, delegate to _compute_offset."""
+        table = data
+
+        for feature in features.features:
+            feature_name = feature.name
+
+            source_features = cls._extract_source_features(feature)
+            source_col = source_features[0]
+            offset_type = cls._extract_offset_type(feature)
+            partition_by = feature.options.get(cls.PARTITION_BY)
+            order_by = feature.options.get(cls.ORDER_BY)
+
+            table = cls._compute_offset(table, feature_name, source_col, partition_by, order_by, offset_type)
+
+        return table
+
+    @classmethod
+    def _compute_offset(
+        cls,
+        data: Any,
+        feature_name: str,
+        source_col: str,
+        partition_by: list[str],
+        order_by: str,
+        offset_type: str,
+    ) -> Any:
+        """Subclasses must implement the actual offset computation."""
+        raise NotImplementedError

mloda/community/feature_groups/data_operations/row_preserving/offset/duckdb_offset.py

@@ -0,0 +1,99 @@
+"""DuckDB implementation for offset feature groups."""
+
+from __future__ import annotations
+
+from mloda.provider import ComputeFramework
+from mloda_plugins.compute_framework.base_implementations.duckdb.duckdb_framework import DuckDBFramework
+from mloda_plugins.compute_framework.base_implementations.duckdb.duckdb_relation import DuckdbRelation
+from mloda_plugins.compute_framework.base_implementations.sql.sql_utils import quote_ident
+
+from mloda.community.feature_groups.data_operations.reserved_columns import assert_no_reserved_columns
+from mloda.community.feature_groups.data_operations.row_preserving.offset.base import (
+    OffsetFeatureGroup,
+)
+
+_RN_COL = "__mloda_orig_rn__"
+
+
+class DuckdbOffset(OffsetFeatureGroup):
+    @classmethod
+    def compute_framework_rule(cls) -> set[type[ComputeFramework]] | None:
+        return {DuckDBFramework}
+
+    @classmethod
+    def _compute_offset(
+        cls,
+        data: DuckdbRelation,
+        feature_name: str,
+        source_col: str,
+        partition_by: list[str],
+        order_by: str,
+        offset_type: str,
+    ) -> DuckdbRelation:
+        assert_no_reserved_columns(data.columns, framework="DuckDB", operation="offset")
+
+        quoted_source = quote_ident(source_col)
+        quoted_order = quote_ident(order_by)
+        quoted_feature = quote_ident(feature_name)
+        partition_clause = ", ".join(quote_ident(col) for col in partition_by)
+
+        window_clause = f"PARTITION BY {partition_clause} ORDER BY {quoted_order} ASC NULLS LAST"
+
+        if offset_type.startswith("lag_"):
+            offset_n = int(offset_type[len("lag_") :])
+            offset_expr = f"LAG({quoted_source}, {offset_n})"
+        elif offset_type.startswith("lead_"):
+            offset_n = int(offset_type[len("lead_") :])
+            offset_expr = f"LEAD({quoted_source}, {offset_n})"
+        elif offset_type.startswith("diff_"):
+            offset_n = int(offset_type[len("diff_") :])
+            offset_expr = f"{quoted_source} - LAG({quoted_source}, {offset_n})"
+        elif offset_type.startswith("pct_change_"):
+            offset_n = int(offset_type[len("pct_change_") :])
+            prev = f"LAG({quoted_source}, {offset_n}) OVER ({window_clause})"
+            offset_expr = (
+                f"CASE WHEN {prev} IS NOT NULL AND {prev} != 0 "
+                f"THEN ({quoted_source} - {prev}) / CAST({prev} AS DOUBLE) END"
+            )
+
+            qrn = quote_ident(_RN_COL)
+            sql = (
+                f"SELECT *, "  # nosec
+                f"{offset_expr} AS {quoted_feature}, "
+                f"ROW_NUMBER() OVER () AS {qrn} "
+                f"FROM __t ORDER BY {qrn}"
+            )
+            new_rel = data._relation.query("__t", sql)
+            result_rel = new_rel.project(
+                ", ".join(quote_ident(c) for c in [col for col in new_rel.columns if col != _RN_COL])
+            )
+            return DuckdbRelation(data.connection, result_rel)
+        elif offset_type == "first_value":
+            offset_expr = f"FIRST_VALUE({quoted_source} IGNORE NULLS)"
+            # PyArrow parity: the reference scans the entire partition for
+            # first/last non-null. DuckDB default ordered-window frame
+            # (UNBOUNDED PRECEDING to CURRENT ROW) would make LAST_VALUE
+            # return the current row. Explicit UNBOUNDED FOLLOWING gives
+            # partition-wide visibility.
+            window_clause += " ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING"
+        elif offset_type == "last_value":
+            offset_expr = f"LAST_VALUE({quoted_source} IGNORE NULLS)"
+            window_clause += " ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING"
+        else:
+            raise ValueError(f"Unsupported offset type for DuckDB: {offset_type}")
+
+        # PyArrow parity: the reference returns results in original row
+        # order. DuckDB window functions with ORDER BY reorder rows; tag
+        # positions with ROW_NUMBER() and ORDER BY qrn to restore.
+        qrn = quote_ident(_RN_COL)
+        sql = (
+            f"SELECT *, "  # nosec
+            f"{offset_expr} OVER ({window_clause}) AS {quoted_feature}, "
+            f"ROW_NUMBER() OVER () AS {qrn} "
+            f"FROM __t ORDER BY {qrn}"
+        )
+        new_rel = data._relation.query("__t", sql)
+        result_rel = new_rel.project(
+            ", ".join(quote_ident(c) for c in [col for col in new_rel.columns if col != _RN_COL])
+        )
+        return DuckdbRelation(data.connection, result_rel)

mloda/community/feature_groups/data_operations/row_preserving/offset/pandas_offset.py

@@ -0,0 +1,66 @@
+"""Pandas implementation for offset feature groups."""
+
+from __future__ import annotations
+
+import pandas as pd
+
+from mloda.provider import ComputeFramework
+from mloda_plugins.compute_framework.base_implementations.pandas.dataframe import PandasDataFrame
+
+from mloda.community.feature_groups.data_operations.reserved_columns import assert_no_reserved_columns
+from mloda.community.feature_groups.data_operations.row_preserving.offset.base import (
+    OffsetFeatureGroup,
+)
+from mloda.community.feature_groups.data_operations.pandas_helpers import null_safe_groupby
+
+
+class PandasOffset(OffsetFeatureGroup):
+    @classmethod
+    def compute_framework_rule(cls) -> set[type[ComputeFramework]] | None:
+        return {PandasDataFrame}
+
+    @classmethod
+    def _compute_offset(
+        cls,
+        data: pd.DataFrame,
+        feature_name: str,
+        source_col: str,
+        partition_by: list[str],
+        order_by: str,
+        offset_type: str,
+    ) -> pd.DataFrame:
+        assert_no_reserved_columns(data.columns, framework="Pandas", operation="offset")
+
+        data = data.copy()
+
+        # Sort by partition + order_by (nulls last) to ensure correct offset
+        null_sort = data[order_by].isna().astype(int)
+        data["__mloda_null_sort"] = null_sort
+        data = data.sort_values(partition_by + ["__mloda_null_sort", order_by])
+
+        grouped = null_safe_groupby(data, partition_by, source_col)
+
+        if offset_type.startswith("lag_"):
+            offset_n = int(offset_type[len("lag_") :])
+            data[feature_name] = grouped.shift(offset_n)
+        elif offset_type.startswith("lead_"):
+            offset_n = int(offset_type[len("lead_") :])
+            data[feature_name] = grouped.shift(-offset_n)
+        elif offset_type.startswith("diff_"):
+            offset_n = int(offset_type[len("diff_") :])
+            data[feature_name] = data[source_col] - grouped.shift(offset_n)
+        elif offset_type.startswith("pct_change_"):
+            offset_n = int(offset_type[len("pct_change_") :])
+            prev = grouped.shift(offset_n)
+            data[feature_name] = (data[source_col] - prev) / prev.replace(0, float("nan"))
+        elif offset_type == "first_value":
+            data[feature_name] = grouped.transform(lambda x: x.dropna().iloc[0] if x.dropna().any() else None)
+        elif offset_type == "last_value":
+            data[feature_name] = grouped.transform(lambda x: x.dropna().iloc[-1] if x.dropna().any() else None)
+        else:
+            raise ValueError(f"Unsupported offset type: {offset_type}")
+
+        data = data.drop(columns=["__mloda_null_sort"])
+        # Restore original row order
+        data = data.sort_index()
+        return data

mloda/community/feature_groups/data_operations/row_preserving/offset/polars_lazy_offset.py

@@ -0,0 +1,70 @@
+"""Polars Lazy implementation for offset feature groups."""
+
+from __future__ import annotations
+
+
+import polars as pl
+
+from mloda.provider import ComputeFramework
+from mloda_plugins.compute_framework.base_implementations.polars.lazy_dataframe import PolarsLazyDataFrame
+
+from mloda.community.feature_groups.data_operations.reserved_columns import assert_no_reserved_columns
+from mloda.community.feature_groups.data_operations.row_preserving.offset.base import (
+    OffsetFeatureGroup,
+)
+
+
+class PolarsLazyOffset(OffsetFeatureGroup):
+    @classmethod
+    def compute_framework_rule(cls) -> set[type[ComputeFramework]] | None:
+        return {PolarsLazyDataFrame}
+
+    @classmethod
+    def _compute_offset(
+        cls,
+        data: pl.LazyFrame,
+        feature_name: str,
+        source_col: str,
+        partition_by: list[str],
+        order_by: str,
+        offset_type: str,
+    ) -> pl.LazyFrame:
+        """PyArrow parity: offset requires sorting by order_by, which reorders rows.
+        Tag rows with an index before sorting and restore input order afterward."""
+        assert_no_reserved_columns(data.collect_schema().names(), framework="Polars", operation="offset")
+
+        # Track original row order
+        data = data.with_row_index("__mloda_orig_idx")
+
+        # Sort by partition_by + order_by (nulls last) for correct offset
+        data = data.sort(partition_by + [order_by], nulls_last=True)
+
+        if offset_type.startswith("lag_"):
+            offset_n = int(offset_type[len("lag_") :])
+            expr = pl.col(source_col).shift(offset_n).over(partition_by).alias(feature_name)
+        elif offset_type.startswith("lead_"):
+            offset_n = int(offset_type[len("lead_") :])
+            expr = pl.col(source_col).shift(-offset_n).over(partition_by).alias(feature_name)
+        elif offset_type.startswith("diff_"):
+            offset_n = int(offset_type[len("diff_") :])
+            expr = (pl.col(source_col) - pl.col(source_col).shift(offset_n)).over(partition_by).alias(feature_name)
+        elif offset_type.startswith("pct_change_"):
+            offset_n = int(offset_type[len("pct_change_") :])
+            prev = pl.col(source_col).shift(offset_n)
+            expr = (
+                pl.when(prev.is_not_null() & (prev != 0))
+                .then((pl.col(source_col) - prev) / prev)
+                .otherwise(pl.lit(None))
+                .over(partition_by)
+                .alias(feature_name)
+            )
+        elif offset_type == "first_value":
+            expr = pl.col(source_col).drop_nulls().first().over(partition_by).alias(feature_name)
+        elif offset_type == "last_value":
+            expr = pl.col(source_col).drop_nulls().last().over(partition_by).alias(feature_name)
+        else:
+            raise ValueError(f"Unsupported offset type: {offset_type}")
+
+        result = data.with_columns(expr)
+        # Restore original row order and drop helper column
+        return result.sort("__mloda_orig_idx").drop("__mloda_orig_idx")

mloda/community/feature_groups/data_operations/row_preserving/offset/sqlite_offset.py

@@ -0,0 +1,104 @@
+"""SQLite implementation for offset feature groups."""
+
+from __future__ import annotations
+
+from mloda.provider import ComputeFramework
+from mloda_plugins.compute_framework.base_implementations.sql.sql_utils import quote_ident
+from mloda_plugins.compute_framework.base_implementations.sqlite.sqlite_framework import SqliteFramework
+from mloda_plugins.compute_framework.base_implementations.sqlite.sqlite_relation import SqliteRelation
+
+from mloda.community.feature_groups.data_operations.reserved_columns import assert_no_reserved_columns
+from mloda.community.feature_groups.data_operations.row_preserving.offset.base import (
+    OffsetFeatureGroup,
+)
+
+
+class SqliteOffset(OffsetFeatureGroup):
+    @classmethod
+    def compute_framework_rule(cls) -> set[type[ComputeFramework]] | None:
+        return {SqliteFramework}
+
+    @classmethod
+    def _compute_offset(
+        cls,
+        data: SqliteRelation,
+        feature_name: str,
+        source_col: str,
+        partition_by: list[str],
+        order_by: str,
+        offset_type: str,
+    ) -> SqliteRelation:
+        assert_no_reserved_columns(data.columns, framework="SQLite", operation="offset")
+
+        quoted_source = quote_ident(source_col)
+        quoted_order = quote_ident(order_by)
+        quoted_feature = quote_ident(feature_name)
+        partition_clause = ", ".join(quote_ident(col) for col in partition_by)
+        qrn = quote_ident("__mloda_rn__")
+
+        null_sort = f"CASE WHEN {quoted_order} IS NULL THEN 1 ELSE 0 END"
+        order_clause = f"{null_sort}, {quoted_order}"
+        window_clause = f"PARTITION BY {partition_clause} ORDER BY {order_clause}"  # nosec
+
+        if offset_type.startswith("lag_"):
+            offset_n = int(offset_type[len("lag_") :])
+            offset_expr = f"LAG({quoted_source}, {offset_n})"
+        elif offset_type.startswith("lead_"):
+            offset_n = int(offset_type[len("lead_") :])
+            offset_expr = f"LEAD({quoted_source}, {offset_n})"
+        elif offset_type in ("first_value", "last_value"):
+            return cls._compute_first_last(data, feature_name, source_col, partition_by, order_by, offset_type)
+        else:
+            supported = "lag, lead, first_value, last_value"
+            raise ValueError(f"Unsupported offset type for SQLite: {offset_type}. Supported types: {supported}")
+
+        sql = (
+            f"SELECT {offset_expr} OVER ({window_clause}) AS {quoted_feature}, "  # nosec
+            f"ROW_NUMBER() OVER (ORDER BY rowid) AS {qrn} "
+            f"FROM {quote_ident(data.table_name)} ORDER BY {qrn}"
+        )
+        cursor = data.connection.execute(sql)
+        rows = cursor.fetchall()
+
+        result_values = [row[0] for row in rows]
+        return data.append_column(feature_name, result_values)
+
+    @classmethod
+    def _compute_first_last(
+        cls,
+        data: SqliteRelation,
+        feature_name: str,
+        source_col: str,
+        partition_by: list[str],
+        order_by: str,
+        offset_type: str,
+    ) -> SqliteRelation:
+        """SQLite lacks IGNORE NULLS in window functions, so select the first
+        (or last) non-null value per partition via a correlated subquery."""
+        quoted_source = quote_ident(source_col)
+        quoted_order = quote_ident(order_by)
+        quoted_feature = quote_ident(feature_name)
+        qrn = quote_ident("__mloda_rn__")
+
+        partition_match = " AND ".join(f"t2.{quote_ident(col)} IS t1.{quote_ident(col)}" for col in partition_by)
+        null_sort = f"CASE WHEN t2.{quoted_order} IS NULL THEN 1 ELSE 0 END"
+
+        if offset_type == "first_value":
+            sort_clause = f"{null_sort}, t2.{quoted_order}"
+        else:
+            sort_clause = f"{null_sort} DESC, t2.{quoted_order} DESC"
+
+        subquery = (
+            f"(SELECT t2.{quoted_source} FROM {quote_ident(data.table_name)} t2 "  # nosec
+            f"WHERE {partition_match} AND t2.{quoted_source} IS NOT NULL "
+            f"ORDER BY {sort_clause} LIMIT 1)"
+        )
+        sql = (
+            f"SELECT {subquery} AS {quoted_feature}, "  # nosec
+            f"ROW_NUMBER() OVER (ORDER BY rowid) AS {qrn} "
+            f"FROM {quote_ident(data.table_name)} t1 ORDER BY {qrn}"
+        )
+        cursor = data.connection.execute(sql)
+        rows = cursor.fetchall()
+        result_values = [row[0] for row in rows]
+        return data.append_column(feature_name, result_values)

mloda_community_offset-0.3.1.dist-info/METADATA

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: mloda-community-offset
+Version: 0.3.1
+Summary: Offset feature group (lag, lead, diff, pct_change, first_value, last_value, row-preserving)
+Author-email: Tom Kaltofen <info@mloda.ai>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://mloda.ai
+Project-URL: Repository, https://github.com/mloda-ai/mloda-registry
+Requires-Python: >=3.10
+Requires-Dist: mloda-community-data-operations>=0.2.12
+Provides-Extra: dev
+Requires-Dist: mloda-testing; extra == "dev"
+Requires-Dist: pytest>=9.0.3; extra == "dev"
+Provides-Extra: sqlite
+Provides-Extra: duckdb
+Requires-Dist: duckdb; extra == "duckdb"
+Provides-Extra: polars
+Requires-Dist: polars; extra == "polars"
+Provides-Extra: pandas
+Requires-Dist: pandas; extra == "pandas"
+Provides-Extra: all
+Requires-Dist: polars; extra == "all"
+Requires-Dist: pandas; extra == "all"
+Requires-Dist: duckdb; extra == "all"

mloda_community_offset-0.3.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+mloda/community/feature_groups/data_operations/row_preserving/offset/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mloda/community/feature_groups/data_operations/row_preserving/offset/base.py,sha256=tnbvAQkLegYkfgdLRX5c8XuExgP92U7o7aAZ6a-vsX8,7860
+mloda/community/feature_groups/data_operations/row_preserving/offset/duckdb_offset.py,sha256=6IkCwUWE5JU07so7YqQ1nnGcKbbg_cfDLhJWhpNsDbI,4490
+mloda/community/feature_groups/data_operations/row_preserving/offset/pandas_offset.py,sha256=jOFf_-hLXu5TYjXfrVnR97kTLtiDMOjHmthDz2_k0OQ,2700
+mloda/community/feature_groups/data_operations/row_preserving/offset/polars_lazy_offset.py,sha256=AkzAnI6MyYnrqe2CXkhY4RUDX45_xPr35BzTg-YTc5s,2993
+mloda/community/feature_groups/data_operations/row_preserving/offset/sqlite_offset.py,sha256=n3hDmGBtr-6Fjehb_ELzJmu3jYMStn4DOFrX7yt2rEA,4384
+mloda_community_offset-0.3.1.dist-info/METADATA,sha256=iCgKmErAiH6HS9M5T65dh8xynHU82_lAYIPxxaNRCwg,887
+mloda_community_offset-0.3.1.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+mloda_community_offset-0.3.1.dist-info/top_level.txt,sha256=srwNjqzXpP1WfLRhbrVc9JLt8TdfsaQe-Th7cGcAvYY,6
+mloda_community_offset-0.3.1.dist-info/RECORD,,

mloda_community_offset-0.3.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (79.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mloda_community_offset-0.3.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+mloda