featkit 0.3.0__tar.gz → 0.4.1__tar.gz

featkit-0.4.1/.github/workflows/auto-tag.yml

@@ -0,0 +1,54 @@
+name: Auto-tag on version bump
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - "pyproject.toml"
+
+jobs:
+  tag:
+    name: Create version tag
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Ensure RELEASE_TOKEN is configured
+        env:
+          RELEASE_TOKEN: ${{ secrets.RELEASE_TOKEN }}
+        run: |
+          if [ -z "$RELEASE_TOKEN" ]; then
+            echo "RELEASE_TOKEN secret is not set. Add it (PAT with contents:read/write) so tag pushes can trigger publish.yml." >&2
+            exit 1
+          fi
+
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          # A PAT is required so the tag push triggers downstream workflows
+          # (pushes made with GITHUB_TOKEN are intentionally excluded from
+          # workflow triggers by GitHub to prevent infinite loops).
+          token: ${{ secrets.RELEASE_TOKEN }}
+
+      - name: Read version from pyproject.toml
+        id: version
+        run: |
+          VERSION=$(grep '^version = ' pyproject.toml | head -1 | sed 's/version = "\(.*\)"/\1/')
+          echo "version=$VERSION" >> $GITHUB_OUTPUT
+
+      - name: Check if tag exists
+        id: tag_check
+        run: |
+          if git rev-parse "v${{ steps.version.outputs.version }}" >/dev/null 2>&1; then
+            echo "exists=true" >> $GITHUB_OUTPUT
+          else
+            echo "exists=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Create and push tag
+        if: steps.tag_check.outputs.exists == 'false'
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git tag "v${{ steps.version.outputs.version }}"
+          git push origin "v${{ steps.version.outputs.version }}"

{featkit-0.3.0 → featkit-0.4.1}/CHANGELOG.md

@@ -7,6 +7,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.4.1] - 2026-06-09
+
+### Fixed
+- CI: auto-tag workflow now uses a PAT (`RELEASE_TOKEN`) to push tags so that `publish.yml` is triggered correctly (`fix(ci)`)
+
+## [0.4.0] - 2026-06-09
+
+### Added
+- Ratio/percentage features (`RatioPivotedColumn`, `RatioSpaceBuilder`): for every pivot combination with at least one non-`None` categorical value, a `numerator / NULLIF(denominator, 0)` column is generated for each proper marginal projection of that combination. Controlled by `FeatureStoreConfig.include_ratios` (default `True`, requires `include_marginals=True`). (`feat(ratio)`)
+- `verbose` parameter on `AdapterDomainResolver` and `AdapterCombinationResolver`: when `True`, the generated `SELECT DISTINCT` SQL is emitted at `DEBUG` level before execution. `FeatureStorePipeline` forwards `cfg.verbose` to the combination resolver automatically. (`feat(domain-resolver)`)
+
 ## [0.3.0] - 2026-06-08
 
 ### Added

{featkit-0.3.0 → featkit-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: featkit
-Version: 0.3.0
+Version: 0.4.1
 Summary: featkit — automated feature store generation from relational facts tables
 Project-URL: Repository, https://github.com/Mirkiux/featkit
 Project-URL: Documentation, https://mirkiux.github.io/featkit

{featkit-0.3.0 → featkit-0.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "featkit"
-version = "0.3.0"
+version = "0.4.1"
 description = "featkit — automated feature store generation from relational facts tables"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -78,6 +78,7 @@ module = ["tests.*"]
 disallow_untyped_defs = false
 disallow_untyped_calls = false
 disallow_any_generics = false
+disallow_incomplete_defs = false
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

featkit-0.4.1/src/featkit/builders/ratio_space.py

@@ -0,0 +1,102 @@
+"""RatioSpaceBuilder — generates RatioPivotedColumn objects from pivot columns."""
+
+from __future__ import annotations
+
+import logging
+
+from featkit.layer2.pivoted import PivotedColumn
+from featkit.layer2.ratio import RatioPivotedColumn
+
+_log = logging.getLogger(__name__)
+
+
+class RatioSpaceBuilder:
+    """Generates all valid ratio columns from a list of pivot columns.
+
+    For each pivot column that has at least one non-``None`` categorical value
+    (potential numerator), the builder finds every other column in the list
+    that is a proper marginal projection of it and creates a
+    :class:`~featkit.layer2.ratio.RatioPivotedColumn` for each valid
+    (numerator, denominator) pair.
+
+    A proper marginal projection (denominator) satisfies:
+
+    * same aggregator and source measurement instance,
+    * same set of categorical fields,
+    * every non-``None`` denominator value equals the numerator's value for
+      that field, and
+    * at least one field that is ``None`` in the denominator but non-``None``
+      in the numerator (the denominator sums over that dimension).
+
+    Args:
+        pivot_columns: The full set of Layer 2A pivot columns, typically
+            ``FeatureStorePipeline.layer2a``.
+        verbose: When ``True``, emits ``DEBUG``-level log messages listing
+            each generated ratio column name.
+    """
+
+    def __init__(
+        self,
+        pivot_columns: list[PivotedColumn],
+        verbose: bool = False,
+    ) -> None:
+        self.pivot_columns = pivot_columns
+        self.verbose = verbose
+
+    def build(self) -> list[RatioPivotedColumn]:
+        """Build and return all RatioPivotedColumn objects."""
+        if self.verbose:
+            _log.debug("RatioSpaceBuilder.build() started")
+
+        # Potential numerators: must have at least one categorical field (non-empty combination)
+        # and at least one non-None value (explicitly excludes all-None/global-marginal columns).
+        numerators = [
+            c
+            for c in self.pivot_columns
+            if c.categorical_combination
+            and any(v is not None for v in c.categorical_combination.values())
+        ]
+        # Potential denominators: any column with at least one None categorical value
+        denominators = [
+            c
+            for c in self.pivot_columns
+            if any(v is None for v in c.categorical_combination.values())
+        ]
+
+        results: list[RatioPivotedColumn] = []
+        seen: set[str] = set()
+
+        for num in numerators:
+            num_fields = set(num.categorical_combination.keys())
+            for denom in denominators:
+                if (
+                    denom.layer2_aggregator != num.layer2_aggregator
+                    or denom.source_measurement is not num.source_measurement
+                    or set(denom.categorical_combination.keys()) != num_fields
+                ):
+                    continue
+                # Denom must not contradict num, and must marginalize at least one
+                # field that num has a non-None value for.
+                valid = True
+                is_proper = False
+                for f, dv in denom.categorical_combination.items():
+                    nv = num.categorical_combination[f]
+                    if dv is not None and dv != nv:
+                        valid = False
+                        break
+                    if dv is None and nv is not None:
+                        is_proper = True
+                if not valid or not is_proper:
+                    continue
+                col = RatioPivotedColumn(num, denom)
+                if col.column_name not in seen:
+                    seen.add(col.column_name)
+                    if self.verbose:
+                        _log.debug("column_name: %r", col.column_name)
+                    results.append(col)
+
+        if self.verbose:
+            _log.debug(
+                "RatioSpaceBuilder.build() done — %d ratio column(s) generated", len(results)
+            )
+        return results

{featkit-0.3.0 → featkit-0.4.1}/src/featkit/builders/temporal_space.py

@@ -6,7 +6,7 @@ import logging
 from collections.abc import Sequence
 
 from featkit.enums import Layer2OutputType, TemporalOperator, TimeWindowDirection
-from featkit.layer2.base import AbstractLayer2Column
+from featkit.layer2.base import AbstractL2Column
 from featkit.layer3.temporal_feature import _POINT_IN_TIME_OPERATORS, TemporalFeature
 
 _log = logging.getLogger(__name__)
@@ -44,14 +44,14 @@ class TemporalSpaceBuilder:
 
     def __init__(
         self,
-        layer2_columns: list[AbstractLayer2Column],
+        layer2_columns: list[AbstractL2Column],
         time_windows: list[int],
         composed_windows: list[int] | None = None,
         direction: TimeWindowDirection = TimeWindowDirection.BACKWARD,
         operators_override: dict[Layer2OutputType, list[TemporalOperator]] | None = None,
         verbose: bool = False,
     ) -> None:
-        self.layer2_columns = layer2_columns
+        self.layer2_columns: list[AbstractL2Column] = layer2_columns
         self.time_windows = time_windows
         self.composed_windows = composed_windows
         self.direction = direction

{featkit-0.3.0 → featkit-0.4.1}/src/featkit/config.py

@@ -26,6 +26,12 @@ class FeatureStoreConfig:
             When ``None`` those operators are omitted entirely.
         include_marginals: When ``True``, ``PivotSpaceBuilder`` includes the ∅
             marginal combination for each categorical.
+        include_ratios: When ``True`` (and ``include_marginals`` is also
+            ``True``), ``RatioSpaceBuilder`` derives a ratio column
+            (``numerator / NULLIF(denominator, 0)``) for every pivot
+            combination over each of its proper marginal projections.  Has no
+            effect when ``include_marginals`` is ``False`` (no marginal
+            denominators exist).
         aggregators_override: Per-measurement-type override for Layer 2
             aggregators. Only contract-valid aggregators are used.
         operators_override: Per-output-type override for temporal operators.
@@ -46,6 +52,7 @@ class FeatureStoreConfig:
     time_windows: list[int]
     composed_windows: list[int] | None = None
     include_marginals: bool = True
+    include_ratios: bool = True
     aggregators_override: dict[MeasurementType, list[Layer2Aggregator]] | None = None
     operators_override: dict[Layer2OutputType, list[TemporalOperator]] | None = field(default=None)
     adapter: DataSourceAdapter | None = None

{featkit-0.3.0 → featkit-0.4.1}/src/featkit/execution/domain_resolver.py

@@ -2,11 +2,14 @@
 
 from __future__ import annotations
 
+import logging
 import re
 
 from featkit.execution.adapters.base import DataSourceAdapter
 from featkit.fields.categorical_field import CategoricalField
 
+_log = logging.getLogger(__name__)
+
 # Matches a simple SQL identifier: letters, digits, underscores; must start
 # with a letter or underscore.  Dollar signs are excluded deliberately —
 # they are technically valid in some dialects but uncommon and easy to abuse.
@@ -69,6 +72,8 @@ class AdapterDomainResolver:
         source_reference: Fully-qualified table name (e.g.
             ``"mydb.myschema.silver_transactions"``).  Validated against a
             safe identifier pattern at construction time.
+        verbose: When ``True``, emits a ``DEBUG``-level log message with the
+            generated SQL before each query is executed.
 
     Raises:
         ValueError: At construction time if *source_reference* contains
@@ -76,10 +81,13 @@ class AdapterDomainResolver:
             if the resolved field name does the same.
     """
 
-    def __init__(self, adapter: DataSourceAdapter, source_reference: str) -> None:
+    def __init__(
+        self, adapter: DataSourceAdapter, source_reference: str, verbose: bool = False
+    ) -> None:
         _require_safe_reference(source_reference, "source_reference")
         self._adapter = adapter
         self._source_reference = source_reference
+        self._verbose = verbose
 
     def __call__(self, field: CategoricalField) -> list[str]:
         """Return distinct non-null values for *field* from the facts table.
@@ -94,6 +102,8 @@ class AdapterDomainResolver:
             f"WHERE {field.name} IS NOT NULL "
             f"ORDER BY 1"
         )
+        if self._verbose:
+            _log.debug("AdapterDomainResolver SQL: %s", sql)
         df = self._adapter.execute(sql)
         return list(df.iloc[:, 0].astype(str))
 
@@ -121,16 +131,21 @@ class AdapterCombinationResolver:
             instance used to execute the query.
         source_reference: Fully-qualified table name.  Validated at
             construction time.
+        verbose: When ``True``, emits a ``DEBUG``-level log message with the
+            generated SQL before each query is executed.
 
     Raises:
         ValueError: At construction time if *source_reference* is unsafe,
             or at call time if any field name is unsafe.
     """
 
-    def __init__(self, adapter: DataSourceAdapter, source_reference: str) -> None:
+    def __init__(
+        self, adapter: DataSourceAdapter, source_reference: str, verbose: bool = False
+    ) -> None:
         _require_safe_reference(source_reference, "source_reference")
         self._adapter = adapter
         self._source_reference = source_reference
+        self._verbose = verbose
 
     def __call__(self, fields: list[CategoricalField]) -> list[dict[CategoricalField, str]]:
         """Return observed non-null combinations for *fields* from the facts table.
@@ -169,6 +184,8 @@ class AdapterCombinationResolver:
             f"WHERE {' AND '.join(where_parts)} "
             f"ORDER BY {order_list}"
         )
+        if self._verbose:
+            _log.debug("AdapterCombinationResolver SQL: %s", sql)
         df = self._adapter.execute(sql)
         if df.empty:
             return []

{featkit-0.3.0 → featkit-0.4.1}/src/featkit/generators/sql/base.py

@@ -17,6 +17,7 @@ from featkit.generators.output import SQLOutput
 
 if TYPE_CHECKING:
     from featkit.layer2.distributional import DistributionalColumn
+    from featkit.layer2.pivoted import PivotedColumn
     from featkit.layer3.temporal_feature import TemporalFeature
     from featkit.pipeline import FeatureStorePipeline
 
@@ -160,6 +161,26 @@ class AbstractSQLCodeGenerator(AbstractCodeGenerator):
     # build_layer2a
     # ------------------------------------------------------------------
 
+    def _pivoted_agg_expr(self, col: PivotedColumn) -> str:
+        """Return the bare aggregate SQL expression for *col* (without alias).
+
+        Used both for regular pivot columns and as numerator/denominator
+        sub-expressions when building ratio columns.
+        """
+        meas = col.source_measurement.name
+        agg = col.layer2_aggregator.value
+        conditions = [
+            f"{self._quoted_id(cat_field.name)} = {self._str_literal(cat_val)}"
+            for cat_field, cat_val in sorted(
+                col.categorical_combination.items(), key=lambda kv: kv[0].name
+            )
+            if cat_val is not None
+        ]
+        if conditions:
+            predicate = " AND ".join(conditions)
+            return f"{agg}(CASE WHEN {predicate} THEN {meas} END)"
+        return f"{agg}({meas})"
+
     def build_layer2a(self, pipeline: FeatureStorePipeline) -> SQLOutput:
         """Generate the Layer 2A pivot aggregation table.
 
@@ -167,6 +188,9 @@ class AbstractSQLCodeGenerator(AbstractCodeGenerator):
         :meth:`_str_literal` to escape special characters and prevent
         SQL injection in the generated script.  Column identifiers are
         double-quoted via :meth:`_quoted_id`.
+
+        Ratio columns (``layer2c``) are computed in the same SELECT as the
+        base pivot columns: ``numerator_expr / NULLIF(denominator_expr, 0)``.
         """
         verbose = pipeline.config.verbose
         if verbose:
@@ -181,25 +205,12 @@ class AbstractSQLCodeGenerator(AbstractCodeGenerator):
         select_parts: list[str] = list(id_cols) + [time_col]
 
         for col in pipeline.layer2a:
-            meas = col.source_measurement.name
-            agg = col.layer2_aggregator.value
-            alias = col.column_name
-
-            conditions = [
-                f"{self._quoted_id(cat_field.name)} = {self._str_literal(cat_val)}"
-                for cat_field, cat_val in sorted(
-                    col.categorical_combination.items(), key=lambda kv: kv[0].name
-                )
-                if cat_val is not None
-            ]
-
-            if conditions:
-                predicate = " AND ".join(conditions)
-                agg_expr = f"{agg}(CASE WHEN {predicate} THEN {meas} END)"
-            else:
-                agg_expr = f"{agg}({meas})"
+            select_parts.append(f"{self._pivoted_agg_expr(col)} AS {col.column_name}")
 
-            select_parts.append(f"{agg_expr} AS {alias}")
+        for ratio_col in pipeline.layer2c:
+            num_expr = self._pivoted_agg_expr(ratio_col.numerator)
+            denom_expr = self._pivoted_agg_expr(ratio_col.denominator)
+            select_parts.append(f"{num_expr} / NULLIF({denom_expr}, 0) AS {ratio_col.column_name}")
 
         group_cols = ", ".join(id_cols + [time_col])
         select_list = ",\n  ".join(select_parts)
@@ -516,6 +527,7 @@ class AbstractSQLCodeGenerator(AbstractCodeGenerator):
             [f"l2a.{c}" for c in id_cols]
             + [f"l2a.{time_col}"]
             + [f"l2a.{col.column_name}" for col in pipeline.layer2a]
+            + [f"l2a.{col.column_name}" for col in pipeline.layer2c]
         )
         if pipeline.layer2b:
             select_parts += [f"l2b.{col.column_name}" for col in pipeline.layer2b]

{featkit-0.3.0 → featkit-0.4.1}/src/featkit/layer2/base.py

@@ -18,16 +18,12 @@ if TYPE_CHECKING:
 COLUMN_NAME_SEP = "__"
 
 
-class AbstractLayer2Column(ABC):
-    """Common base for every column in the Layer 2 horizontal concept table.
+class AbstractL2Column(ABC):
+    """Minimal interface for any Layer 2 column.
 
-    Subclasses supply the concrete ``output_type`` and ``column_name``; this
-    class derives ``output_contract`` from ``output_type`` automatically.
-
-    Raises:
-        ValueError: If ``layer2_aggregator`` is not permitted by the
-            measurement's contract, or if ``source_measurement.name``
-            contains the column name separator.
+    All Layer 2 columns — whether pivot aggregations, distributional metrics,
+    or derived ratio columns — satisfy this interface.  :class:`TemporalFeature`
+    and :class:`TemporalSpaceBuilder` accept any subclass of this base.
     """
 
     @staticmethod
@@ -39,6 +35,37 @@ class AbstractLayer2Column(ABC):
                 f"{COLUMN_NAME_SEP!r}"
             )
 
+    @property
+    @abstractmethod
+    def output_type(self) -> Layer2OutputType:
+        """Layer 2 output type that governs valid Layer 3 temporal operators."""
+        ...
+
+    @property
+    def output_contract(self) -> AbstractLayer2OutputContract:
+        """Contract for the Layer 2 → Layer 3 boundary, derived from ``output_type``."""
+        return get_default_output_contract(self.output_type)
+
+    @property
+    @abstractmethod
+    def column_name(self) -> str:
+        """Deterministic name for this column in the Layer 2 output table."""
+        ...
+
+
+class AbstractLayer2Column(AbstractL2Column):
+    """Base for Layer 2 columns derived from a single measurement + aggregator.
+
+    Subclasses supply the concrete ``output_type`` and ``column_name``; this
+    class derives ``output_contract`` from ``output_type`` automatically and
+    validates that the aggregator is permitted by the measurement's contract.
+
+    Raises:
+        ValueError: If ``layer2_aggregator`` is not permitted by the
+            measurement's contract, or if ``source_measurement.name``
+            contains the column name separator.
+    """
+
     def __init__(
         self,
         source_measurement: MeasurementField,
@@ -60,23 +87,6 @@ class AbstractLayer2Column(ABC):
         self.source_measurement = source_measurement
         self.layer2_aggregator = layer2_aggregator
 
-    @property
-    @abstractmethod
-    def output_type(self) -> Layer2OutputType:
-        """Layer 2 output type that governs valid Layer 3 temporal operators."""
-        ...
-
-    @property
-    def output_contract(self) -> AbstractLayer2OutputContract:
-        """Contract for the Layer 2 → Layer 3 boundary, derived from ``output_type``."""
-        return get_default_output_contract(self.output_type)
-
-    @property
-    @abstractmethod
-    def column_name(self) -> str:
-        """Deterministic name for this column in the Layer 2 output table."""
-        ...
-
     def __repr__(self) -> str:
         return (
             f"{type(self).__name__}("

featkit-0.4.1/src/featkit/layer2/ratio.py

@@ -0,0 +1,101 @@
+"""RatioPivotedColumn — a Layer 2 column that is the ratio of two PivotedColumns."""
+
+from __future__ import annotations
+
+from featkit.enums import Layer2OutputType
+from featkit.layer2.base import AbstractL2Column
+from featkit.layer2.pivoted import PivotedColumn
+
+
+class RatioPivotedColumn(AbstractL2Column):
+    """A Layer 2 column representing the ratio of a pivot cell over one of its
+    marginal projections.
+
+    The ratio is computed per entity-period in the Layer 2A table as::
+
+        numerator_agg_expr / NULLIF(denominator_agg_expr, 0)
+
+    Temporal operators are then applied to the pre-computed per-period ratio
+    exactly as they are for any other numeric Layer 2 column.
+
+    The denominator must be a *proper* marginal projection of the numerator:
+    every non-``None`` denominator value must match the corresponding numerator
+    value, and at least one field that is non-``None`` in the numerator must be
+    ``None`` in the denominator (i.e. the denominator sums over that dimension).
+    The numerator itself may contain ``None`` fields — those dimensions are
+    already marginalised in both columns and are left unchanged.
+
+    Args:
+        numerator: A :class:`~featkit.layer2.pivoted.PivotedColumn` with at
+            least one non-``None`` categorical value.
+        denominator: A :class:`~featkit.layer2.pivoted.PivotedColumn` that is a
+            proper marginal projection of *numerator* — same aggregator, same
+            measurement instance, same categorical fields, every non-``None``
+            denominator value equal to the corresponding numerator value, and
+            at least one field that is ``None`` in the denominator but
+            non-``None`` in the numerator.
+
+    Raises:
+        ValueError: If the numerator/denominator pair violates any of the
+            constraints above.
+    """
+
+    def __init__(self, numerator: PivotedColumn, denominator: PivotedColumn) -> None:
+        if numerator.layer2_aggregator != denominator.layer2_aggregator:
+            raise ValueError(
+                f"numerator and denominator must share the same aggregator; "
+                f"got {numerator.layer2_aggregator.name!r} vs "
+                f"{denominator.layer2_aggregator.name!r}"
+            )
+        if numerator.source_measurement is not denominator.source_measurement:
+            raise ValueError(
+                f"numerator and denominator must share the same source_measurement; "
+                f"got {numerator.source_measurement.name!r} vs "
+                f"{denominator.source_measurement.name!r}"
+            )
+        if numerator.categorical_combination.keys() != denominator.categorical_combination.keys():
+            raise ValueError("numerator and denominator must have the same categorical fields")
+        # Denominator must be a proper projection: it cannot contradict the numerator,
+        # and must marginalize at least one field that numerator has a non-None value for.
+        has_proper_marginal = False
+        for field, dval in denominator.categorical_combination.items():
+            nval = numerator.categorical_combination[field]
+            if dval is not None and dval != nval:
+                raise ValueError(
+                    f"denominator value for field {field.name!r} is {dval!r} but "
+                    f"numerator has {nval!r}; "
+                    "denominator must be a proper marginal projection of the numerator"
+                )
+            if dval is None and nval is not None:
+                has_proper_marginal = True
+        if not has_proper_marginal:
+            raise ValueError(
+                "denominator must marginalize at least one field that has a non-None value "
+                "in the numerator (denominator must be a proper marginal projection)"
+            )
+
+        self._numerator = numerator
+        self._denominator = denominator
+
+    @property
+    def numerator(self) -> PivotedColumn:
+        return self._numerator
+
+    @property
+    def denominator(self) -> PivotedColumn:
+        return self._denominator
+
+    @property
+    def output_type(self) -> Layer2OutputType:
+        return Layer2OutputType.NUMERIC
+
+    @property
+    def column_name(self) -> str:
+        return f"{self._numerator.column_name}__over__{self._denominator.column_name}"
+
+    def __repr__(self) -> str:
+        return (
+            f"RatioPivotedColumn("
+            f"numerator={self._numerator.column_name!r}, "
+            f"denominator={self._denominator.column_name!r})"
+        )

{featkit-0.3.0 → featkit-0.4.1}/src/featkit/layer3/temporal_feature.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from featkit.enums import TemporalOperator, TimeWindowDirection
-from featkit.layer2.base import AbstractLayer2Column
+from featkit.layer2.base import AbstractL2Column
 
 #: Operators that operate on a single point in time and do not require a window.
 _POINT_IN_TIME_OPERATORS: frozenset[TemporalOperator] = frozenset(
@@ -31,7 +31,7 @@ class TemporalFeature:
 
     def __init__(
         self,
-        source: AbstractLayer2Column,
+        source: AbstractL2Column,
         operator: TemporalOperator,
         direction: TimeWindowDirection,
         window_size: int | None = None,
@@ -64,7 +64,7 @@ class TemporalFeature:
         ):
             raise ValueError(f"window_size must be a positive integer, got {window_size!r}")
 
-        self.source = source
+        self.source: AbstractL2Column = source
         self.operator = operator
         self.direction = direction
         self.window_size = window_size

{featkit-0.3.0 → featkit-0.4.1}/src/featkit/pipeline.py

@@ -6,10 +6,12 @@ from typing import TYPE_CHECKING
 
 from featkit.builders.distributional_space import DistributionalSpaceBuilder
 from featkit.builders.pivot_space import PivotSpaceBuilder
+from featkit.builders.ratio_space import RatioSpaceBuilder
 from featkit.builders.temporal_space import TemporalSpaceBuilder
 from featkit.config import FeatureStoreConfig
 from featkit.layer2.distributional import DistributionalColumn
 from featkit.layer2.pivoted import PivotedColumn
+from featkit.layer2.ratio import RatioPivotedColumn
 from featkit.layer3.temporal_feature import TemporalFeature
 
 if TYPE_CHECKING:
@@ -33,6 +35,7 @@ class FeatureStorePipeline:
         self.config = config
         self.layer2a: list[PivotedColumn] = []
         self.layer2b: list[DistributionalColumn] = []
+        self.layer2c: list[RatioPivotedColumn] = []
         self.layer3: list[TemporalFeature] = []
 
     def build(self) -> FeatureStorePipeline:
@@ -48,7 +51,7 @@ class FeatureStorePipeline:
             from featkit.execution.domain_resolver import AdapterCombinationResolver
 
             combination_resolver = AdapterCombinationResolver(
-                cfg.adapter, cfg.dataset.source_reference
+                cfg.adapter, cfg.dataset.source_reference, verbose=cfg.verbose
             )
 
         self.layer2a = PivotSpaceBuilder(
@@ -62,8 +65,13 @@ class FeatureStorePipeline:
             dataset=cfg.dataset,
             verbose=cfg.verbose,
         ).build()
+        self.layer2c = (
+            RatioSpaceBuilder(self.layer2a, verbose=cfg.verbose).build()
+            if cfg.include_ratios and cfg.include_marginals
+            else []
+        )
         self.layer3 = TemporalSpaceBuilder(
-            layer2_columns=[*self.layer2a, *self.layer2b],
+            layer2_columns=[*self.layer2a, *self.layer2b, *self.layer2c],
             time_windows=cfg.time_windows,
             composed_windows=cfg.composed_windows,
             operators_override=cfg.operators_override,