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

mloda/community/feature_groups/data_operations/string/__init__.py

@@ -0,0 +1 @@
+

mloda/community/feature_groups/data_operations/string/base.py

@@ -0,0 +1,136 @@
+"""Base class for string operation 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
+
+STRING_OPS = {
+    "upper": "Convert string to uppercase",
+    "lower": "Convert string to lowercase",
+    "trim": "Strip leading and trailing whitespace",
+    "length": "Return the length of the string (integer)",
+    "reverse": "Reverse the string",
+}
+
+
+class StringFeatureGroup(FeatureChainParserMixin, FeatureGroup):
+    """Base class for element-wise string operations that preserve row count.
+
+    String operations transform a single string column element by element.
+    The output always has the same number of rows as the input.
+
+    Supported operations: upper, lower, trim, length, reverse.
+
+    Not every compute framework supports every operation. For example,
+    SQLite has no native ``REVERSE`` function, so ``SqliteStringOps``
+    restricts its supported set via ``_validate_string_match``.
+    SQLite's ``UPPER``/``LOWER`` only handle ASCII characters;
+    non-ASCII accented characters are not transformed.
+
+    Feature Creation Methods
+    ------------------------
+
+    1. String-based (pattern):
+        Features follow the naming pattern ``<source_column>__<operation>``.
+
+        Examples::
+
+            Feature("name__upper")
+            Feature("title__trim")
+            Feature("description__length")
+
+    2. Configuration-based:
+        Uses Options with context parameters::
+
+            Feature(
+                "uppercased_name",
+                options=Options(context={
+                    "string_op": "upper",
+                    "in_features": "name",
+                }),
+            )
+    """
+
+    PREFIX_PATTERN = r".+__(upper|lower|trim|length|reverse)$"
+
+    MIN_IN_FEATURES = 1
+    MAX_IN_FEATURES = 1
+
+    STRING_OP = "string_op"
+
+    PROPERTY_MAPPING = {
+        STRING_OP: {
+            **STRING_OPS,
+            DefaultOptionKeys.context: True,
+            DefaultOptionKeys.strict_validation: True,
+        },
+        DefaultOptionKeys.in_features: {
+            "explanation": "Source string column",
+            DefaultOptionKeys.context: True,
+            DefaultOptionKeys.strict_validation: False,
+        },
+    }
+
+    @classmethod
+    def _validate_string_match(cls, feature_name: str, operation_config: str, source_feature: str) -> bool:
+        """Validate that the parsed operation is a known string operation.
+
+        Subclasses (e.g. SqliteStringOps) can override to further restrict
+        the set of supported operations.
+        """
+        return operation_config in STRING_OPS
+
+    @classmethod
+    def get_string_op(cls, feature_name: str) -> str:
+        """Extract the string operation from a pattern-based 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
+        raise ValueError(f"Could not extract string operation from feature name: {feature_name}")
+
+    @classmethod
+    def _extract_string_op(cls, feature: Feature) -> str:
+        """Extract string operation 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
+        op = feature.options.get(cls.STRING_OP)
+        if op is None:
+            raise ValueError(f"Could not extract string operation for {feature_name}")
+        return str(op)
+
+    @classmethod
+    def calculate_feature(cls, data: Any, features: FeatureSet) -> Any:
+        """Shared loop: extract params from each feature, delegate to _compute_string."""
+        table = data
+
+        for feature in features.features:
+            feature_name = feature.name
+
+            source_features = cls._extract_source_features(feature)
+            source_col = source_features[0]
+            op = cls._extract_string_op(feature)
+
+            table = cls._compute_string(table, feature_name, source_col, op)
+
+        return table
+
+    @classmethod
+    def _compute_string(
+        cls,
+        data: Any,
+        feature_name: str,
+        source_col: str,
+        op: str,
+    ) -> Any:
+        """Subclasses must implement the actual string computation."""
+        raise NotImplementedError

mloda/community/feature_groups/data_operations/string/duckdb_string.py

@@ -0,0 +1,49 @@
+"""DuckDB implementation for string operation feature groups."""
+
+from __future__ import annotations
+
+from typing import Any
+
+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.string.base import (
+    StringFeatureGroup,
+)
+
+# DuckDB native string function expressions.
+_DUCKDB_STRING_EXPRS: dict[str, str] = {
+    "upper": "UPPER({col})",
+    "lower": "LOWER({col})",
+    "trim": "TRIM({col})",
+    "length": "LENGTH({col})",
+    "reverse": "REVERSE({col})",
+}
+
+
+class DuckdbStringOps(StringFeatureGroup):
+    @classmethod
+    def compute_framework_rule(cls) -> set[type[ComputeFramework]] | None:
+        return {DuckDBFramework}
+
+    @classmethod
+    def _compute_string(
+        cls,
+        data: Any,
+        feature_name: str,
+        source_col: str,
+        op: str,
+    ) -> DuckdbRelation:
+        expr_template = _DUCKDB_STRING_EXPRS.get(op)
+        if expr_template is None:
+            raise ValueError(f"Unsupported string operation for DuckDB: {op}")
+
+        quoted_source = quote_ident(source_col)
+        expr = expr_template.format(col=quoted_source)
+        quoted_feature = quote_ident(feature_name)
+
+        raw_sql = f"*, {expr} AS {quoted_feature}"
+        result: DuckdbRelation = data.select(_raw_sql=raw_sql)
+        return result

mloda/community/feature_groups/data_operations/string/pandas_string.py

@@ -0,0 +1,44 @@
+"""Pandas implementation for string operation 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.string.base import (
+    StringFeatureGroup,
+)
+
+
+class PandasStringOps(StringFeatureGroup):
+    @classmethod
+    def compute_framework_rule(cls) -> set[type[ComputeFramework]] | None:
+        return {PandasDataFrame}
+
+    @classmethod
+    def _compute_string(
+        cls,
+        data: pd.DataFrame,
+        feature_name: str,
+        source_col: str,
+        op: str,
+    ) -> pd.DataFrame:
+        data = data.copy()
+        col = data[source_col]
+
+        if op == "upper":
+            data[feature_name] = col.str.upper()
+        elif op == "lower":
+            data[feature_name] = col.str.lower()
+        elif op == "trim":
+            data[feature_name] = col.str.strip()
+        elif op == "length":
+            data[feature_name] = col.str.len()
+        elif op == "reverse":
+            data[feature_name] = col.str[::-1]
+        else:
+            raise ValueError(f"Unsupported string operation: {op}")
+
+        return data

mloda/community/feature_groups/data_operations/string/polars_lazy_string.py

@@ -0,0 +1,43 @@
+"""Polars Lazy implementation for string operation 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.string.base import (
+    StringFeatureGroup,
+)
+
+
+class PolarsLazyStringOps(StringFeatureGroup):
+    @classmethod
+    def compute_framework_rule(cls) -> set[type[ComputeFramework]] | None:
+        return {PolarsLazyDataFrame}
+
+    @classmethod
+    def _compute_string(
+        cls,
+        data: pl.LazyFrame,
+        feature_name: str,
+        source_col: str,
+        op: str,
+    ) -> pl.LazyFrame:
+        col = pl.col(source_col)
+
+        if op == "upper":
+            expr = col.str.to_uppercase()
+        elif op == "lower":
+            expr = col.str.to_lowercase()
+        elif op == "trim":
+            expr = col.str.strip_chars()
+        elif op == "length":
+            expr = col.str.len_chars()
+        elif op == "reverse":
+            expr = col.str.reverse()
+        else:
+            raise ValueError(f"Unsupported string operation: {op}")
+
+        return data.with_columns(expr.alias(feature_name))

mloda/community/feature_groups/data_operations/string/pyarrow_string.py

@@ -0,0 +1,43 @@
+"""PyArrow implementation for string operation feature groups."""
+
+from __future__ import annotations
+
+import pyarrow as pa
+import pyarrow.compute as pc
+
+from mloda.provider import ComputeFramework
+from mloda_plugins.compute_framework.base_implementations.pyarrow.table import PyArrowTable
+
+from mloda.community.feature_groups.data_operations.string.base import (
+    StringFeatureGroup,
+)
+
+_PYARROW_STRING_FUNCS: dict[str, str] = {
+    "upper": "utf8_upper",
+    "lower": "utf8_lower",
+    "trim": "utf8_trim_whitespace",
+    "length": "utf8_length",
+    "reverse": "utf8_reverse",
+}
+
+
+class PyArrowStringOps(StringFeatureGroup):
+    @classmethod
+    def compute_framework_rule(cls) -> set[type[ComputeFramework]] | None:
+        return {PyArrowTable}
+
+    @classmethod
+    def _compute_string(
+        cls,
+        table: pa.Table,
+        feature_name: str,
+        source_col: str,
+        op: str,
+    ) -> pa.Table:
+        func_name = _PYARROW_STRING_FUNCS.get(op)
+        if func_name is None:
+            raise ValueError(f"Unsupported string operation: {op}")
+
+        col = table.column(source_col)
+        new_col = getattr(pc, func_name)(col)
+        return table.append_column(feature_name, new_col)

mloda/community/feature_groups/data_operations/string/sqlite_string.py

@@ -0,0 +1,72 @@
+"""SQLite implementation for string operation 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.string.base import (
+    StringFeatureGroup,
+)
+
+# SQLite's native UPPER/LOWER are ASCII-only: UPPER('héllo') returns 'HéLLO'
+# instead of 'HÉLLO'. Rather than emulate unicode-aware semantics in Python
+# and risk silent divergence from the PyArrow reference, SQLite refuses to
+# match upper/lower and lets the resolver fall back to another framework.
+# The same pattern is used for 'reverse', which SQLite has no native function for.
+_SQLITE_STRING_EXPRS: dict[str, str] = {
+    "trim": "TRIM({col})",
+    "length": "LENGTH({col})",
+}
+
+
+class SqliteStringOps(StringFeatureGroup):
+    @classmethod
+    def compute_framework_rule(cls) -> set[type[ComputeFramework]] | None:
+        return {SqliteFramework}
+
+    @classmethod
+    def _validate_string_match(cls, feature_name: str, operation_config: str, source_feature: str) -> bool:
+        """SQLite only supports trim and length. upper/lower are ASCII-only
+        in SQLite so they diverge from the PyArrow reference; reverse has
+        no native SQLite function. All three are refused at match time."""
+        return operation_config in _SQLITE_STRING_EXPRS
+
+    @classmethod
+    def _compute_string(
+        cls,
+        data: SqliteRelation,
+        feature_name: str,
+        source_col: str,
+        op: str,
+    ) -> SqliteRelation:
+        assert_no_reserved_columns(data.columns, framework="SQLite", operation="string")
+
+        expr_template = _SQLITE_STRING_EXPRS.get(op)
+        if expr_template is None:
+            raise ValueError(f"Unsupported string operation for SQLite: {op}")
+
+        quoted_source = quote_ident(source_col)
+        expr = expr_template.format(col=quoted_source)
+        quoted_feature = quote_ident(feature_name)
+        qrn = quote_ident("__mloda_rn__")
+
+        sql = " ".join(
+            [
+                "SELECT",
+                f"{expr} AS {quoted_feature},",
+                f"ROW_NUMBER() OVER (ORDER BY rowid) AS {qrn}",
+                "FROM",
+                f"{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)

mloda_community_string-0.3.1.dist-info/METADATA

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: mloda-community-string
+Version: 0.3.1
+Summary: String operation feature group (element-wise, 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"

mloda_community_string-0.3.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+mloda/community/feature_groups/data_operations/string/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+mloda/community/feature_groups/data_operations/string/base.py,sha256=oUMEzaROR852lTzZoxqMiQQypMfd99qZMhKko4H_c7E,4876
+mloda/community/feature_groups/data_operations/string/duckdb_string.py,sha256=tWTgD9xojOek60VXWMiFiJVFQB7oRly5oHRlrd2D1nU,1604
+mloda/community/feature_groups/data_operations/string/pandas_string.py,sha256=QH1RU9ejmInh1q9FP0hfpuqY3hND2F0Ox6SVARcLVwc,1254
+mloda/community/feature_groups/data_operations/string/polars_lazy_string.py,sha256=GOU47bvdWh2Z0yOD0-w0IOt66hTjSbKcga8PT9nTvSM,1250
+mloda/community/feature_groups/data_operations/string/pyarrow_string.py,sha256=L5I9Aupf1upkRLwGwXzUU8vYgUqoUO0PMpMeAjV1Wwg,1214
+mloda/community/feature_groups/data_operations/string/sqlite_string.py,sha256=LPGy_T6iWTC3imbsSCf4noRSSUEa2q7ZPhAaBC7j8go,2865
+mloda_community_string-0.3.1.dist-info/METADATA,sha256=V2AYfE0OsZO0mZyeDtVTwwuvb-I3eqIhGVdpKFybvtc,508
+mloda_community_string-0.3.1.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+mloda_community_string-0.3.1.dist-info/top_level.txt,sha256=srwNjqzXpP1WfLRhbrVc9JLt8TdfsaQe-Th7cGcAvYY,6
+mloda_community_string-0.3.1.dist-info/RECORD,,

mloda_community_string-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_string-0.3.1.dist-info/top_level.txt

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