featkit 0.1.0__py3-none-any.whl

featkit/__init__.py

@@ -0,0 +1 @@
+"""featkit — automated feature store generation from relational facts tables."""

featkit/builders/distributional_space.py

@@ -0,0 +1,77 @@
+"""DistributionalSpaceBuilder — generates all DistributionalColumn objects from a dataset."""
+
+from __future__ import annotations
+
+from typing import cast
+
+from featkit.contracts.measurement.defaults import get_default_contract
+from featkit.dataset.base import AbstractDataset
+from featkit.enums import CategoricalTreatment
+from featkit.fields.categorical_field import CategoricalField
+from featkit.fields.measurement_field import MeasurementField
+from featkit.layer2.distributional import DistributionalColumn
+
+
+class DistributionalSpaceBuilder:
+    """Generates the full set of DistributionalColumn objects for a dataset.
+
+    For each DISTRIBUTIONAL- or BOTH-treatment categorical, each measurement
+    field, each contract-valid aggregator, and each distributional metric
+    declared on the categorical, one ``DistributionalColumn`` is produced.
+
+    Args:
+        dataset: The source facts-table schema.
+        value_measurements: Restrict which measurement fields are used as the
+            value source. ``None`` means use all measurement fields in the dataset.
+            An empty list produces no columns. Every entry must be present in the
+            dataset (compared by name, type, and contract); a ``ValueError`` is
+            raised for unknown fields.
+    """
+
+    def __init__(
+        self,
+        dataset: AbstractDataset,
+        value_measurements: list[MeasurementField] | None = None,
+    ) -> None:
+        self.dataset = dataset
+        self.value_measurements = value_measurements
+
+    def build(self) -> list[DistributionalColumn]:
+        """Build and return all DistributionalColumn objects."""
+        all_cats = [cast(CategoricalField, f) for f in self.dataset.categorical_fields]
+        dist_cats = [
+            c
+            for c in all_cats
+            if c.treatment in {CategoricalTreatment.DISTRIBUTIONAL, CategoricalTreatment.BOTH}
+        ]
+
+        dataset_measurements = [cast(MeasurementField, f) for f in self.dataset.measurement_fields]
+
+        if self.value_measurements is not None:
+            measurements: list[MeasurementField] = []
+            for requested in self.value_measurements:
+                matched = next((m for m in dataset_measurements if m == requested), None)
+                if matched is None:
+                    raise ValueError(
+                        f"MeasurementField {requested.name!r} "
+                        f"(type {requested.measurement_type.name}) is not present in the dataset"
+                    )
+                measurements.append(matched)
+        else:
+            measurements = dataset_measurements
+
+        results: list[DistributionalColumn] = []
+        seen: set[str] = set()
+
+        for cat in dist_cats:
+            for mf in measurements:
+                contract = mf.contract or get_default_contract(mf.measurement_type)
+                aggs = sorted(contract.valid_layer2_aggregators, key=lambda a: a.value)
+                for agg in aggs:
+                    for metric in cat.distributional_metrics:
+                        col = DistributionalColumn(mf, agg, cat, metric)
+                        if col.column_name not in seen:
+                            seen.add(col.column_name)
+                            results.append(col)
+
+        return results

featkit/builders/pivot_space.py

@@ -0,0 +1,102 @@
+"""PivotSpaceBuilder — generates all PivotedColumn objects from a dataset."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from itertools import product
+from typing import cast
+
+from featkit.contracts.measurement.defaults import get_default_contract
+from featkit.dataset.base import AbstractDataset
+from featkit.enums import CategoricalTreatment, Layer2Aggregator, MeasurementType
+from featkit.fields.categorical_field import CategoricalField
+from featkit.fields.measurement_field import MeasurementField
+from featkit.layer2.pivoted import PivotedColumn
+
+
+class PivotSpaceBuilder:
+    """Generates the full set of PivotedColumn objects for a dataset.
+
+    Args:
+        dataset: The source facts-table schema.
+        include_marginals: When True, each categorical domain is augmented with
+            None (the ∅ marginal), producing one column per ∅-substituted
+            combination in addition to the fully-specified ones.
+        aggregators_override: Per-measurement-type override list. Only aggregators
+            that are also contract-valid for the measurement type are used.
+        domain_resolver: Callable invoked to resolve the domain of a categorical
+            whose ``allowed_values`` is None. Must return a list of string values.
+            Raises ``ValueError`` at build time if not provided for such a field.
+    """
+
+    def __init__(
+        self,
+        dataset: AbstractDataset,
+        include_marginals: bool = True,
+        aggregators_override: dict[MeasurementType, list[Layer2Aggregator]] | None = None,
+        domain_resolver: Callable[[CategoricalField], list[str]] | None = None,
+    ) -> None:
+        self.dataset = dataset
+        self.include_marginals = include_marginals
+        self.aggregators_override = aggregators_override
+        self.domain_resolver = domain_resolver
+
+    def build(self) -> list[PivotedColumn]:
+        """Build and return all PivotedColumn objects."""
+        all_cats = [cast(CategoricalField, f) for f in self.dataset.categorical_fields]
+        pivot_cats = [
+            c
+            for c in all_cats
+            if c.treatment in {CategoricalTreatment.PIVOT, CategoricalTreatment.BOTH}
+        ]
+
+        cat_domains: dict[CategoricalField, list[str | None]] = {}
+        for cat in pivot_cats:
+            if cat.allowed_values is not None:
+                raw: list[str] = list(cat.allowed_values)
+            elif self.domain_resolver is not None:
+                raw = list(self.domain_resolver(cat))
+            else:
+                raise ValueError(
+                    f"CategoricalField {cat.name!r} has no allowed_values and no "
+                    f"domain_resolver was provided"
+                )
+            if any(v is None for v in raw):
+                raise ValueError(
+                    f"CategoricalField {cat.name!r}: resolved domain contains None; "
+                    f"None is reserved as the \u2205 marginal sentinel"
+                )
+            domain: list[str | None] = list(raw)
+            if self.include_marginals:
+                domain = domain + [None]
+            cat_domains[cat] = domain
+
+        measurements = [cast(MeasurementField, f) for f in self.dataset.measurement_fields]
+
+        cats = list(cat_domains.keys())
+        combos = product(*(cat_domains[c] for c in cats)) if cats else ((),)
+
+        results: list[PivotedColumn] = []
+        seen: dict[str, PivotedColumn] = {}
+
+        for combo in combos:
+            cat_combination = {cats[i]: combo[i] for i in range(len(cats))} if cats else {}
+            for mf in measurements:
+                for agg in self._valid_aggregators(mf):
+                    col = PivotedColumn(mf, agg, cat_combination)
+                    if col.column_name in seen:
+                        raise ValueError(
+                            f"Duplicate pivot column name generated: {col.column_name!r}. "
+                            f"Conflicting columns: {seen[col.column_name]!r} and {col!r}"
+                        )
+                    seen[col.column_name] = col
+                    results.append(col)
+
+        return results
+
+    def _valid_aggregators(self, mf: MeasurementField) -> list[Layer2Aggregator]:
+        contract = mf.contract or get_default_contract(mf.measurement_type)
+        valid = contract.valid_layer2_aggregators
+        if self.aggregators_override and mf.measurement_type in self.aggregators_override:
+            return [a for a in self.aggregators_override[mf.measurement_type] if a in valid]
+        return sorted(valid, key=lambda a: a.value)

featkit/builders/temporal_space.py

@@ -0,0 +1,86 @@
+"""TemporalSpaceBuilder — generates all TemporalFeature objects from Layer 2 columns."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+from featkit.enums import Layer2OutputType, TemporalOperator, TimeWindowDirection
+from featkit.layer2.base import AbstractLayer2Column
+from featkit.layer3.temporal_feature import _POINT_IN_TIME_OPERATORS, TemporalFeature
+
+#: Operators that require composed (MEDIA_ABS / RATIO) window sizes.
+_COMPOSED_OPERATORS: frozenset[TemporalOperator] = frozenset(
+    {TemporalOperator.MEDIA_ABS, TemporalOperator.RATIO}
+)
+
+
+class TemporalSpaceBuilder:
+    """Generates the full set of TemporalFeature objects from a list of Layer 2 columns.
+
+    For each Layer 2 column, the operator set is taken from the column's output
+    contract (or the per-output-type override). Each operator is then paired with
+    the appropriate window sizes:
+
+    - Point-in-time operators (``ULT_MES``, ``PREV_MES``, ``REC``): ``window_size=None``
+    - ``MEDIA_ABS`` / ``RATIO``: ``composed_windows`` (skipped when ``None``)
+    - All other windowed operators: ``time_windows``
+
+    Args:
+        layer2_columns: All Layer 2 columns to build features from.
+        time_windows: Window sizes for standard windowed operators.
+        composed_windows: Window sizes for ``MEDIA_ABS`` and ``RATIO``. When
+            ``None``, those operators are omitted entirely.
+        direction: Sliding-window direction applied to every feature.
+        operators_override: Per-output-type override. Only operators that are
+            also contract-valid for the column's output type are used.
+    """
+
+    def __init__(
+        self,
+        layer2_columns: list[AbstractLayer2Column],
+        time_windows: list[int],
+        composed_windows: list[int] | None = None,
+        direction: TimeWindowDirection = TimeWindowDirection.BACKWARD,
+        operators_override: dict[Layer2OutputType, list[TemporalOperator]] | None = None,
+    ) -> None:
+        self.layer2_columns = layer2_columns
+        self.time_windows = time_windows
+        self.composed_windows = composed_windows
+        self.direction = direction
+        self.operators_override = operators_override
+
+    def build(self) -> list[TemporalFeature]:
+        """Build and return all TemporalFeature objects."""
+        results: list[TemporalFeature] = []
+        seen: set[str] = set()
+
+        for col in self.layer2_columns:
+            if self.operators_override and col.output_type in self.operators_override:
+                operators = [
+                    op
+                    for op in self.operators_override[col.output_type]
+                    if col.output_contract.is_valid(op)
+                ]
+            else:
+                operators = sorted(
+                    col.output_contract.valid_temporal_operators, key=lambda o: o.value
+                )
+
+            for op in operators:
+                window_sizes: Sequence[int | None]
+                if op in _COMPOSED_OPERATORS:
+                    if self.composed_windows is None:
+                        continue
+                    window_sizes = list(self.composed_windows)
+                elif op in _POINT_IN_TIME_OPERATORS:
+                    window_sizes = [None]
+                else:
+                    window_sizes = list(self.time_windows)
+
+                for ws in window_sizes:
+                    feat = TemporalFeature(col, op, self.direction, window_size=ws)
+                    if feat.column_name not in seen:
+                        seen.add(feat.column_name)
+                        results.append(feat)
+
+        return results

featkit/config.py

@@ -0,0 +1,38 @@
+"""FeatureStoreConfig — top-level configuration object for a feature store pipeline."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from featkit.dataset.base import AbstractDataset
+from featkit.enums import Layer2Aggregator, Layer2OutputType, MeasurementType, TemporalOperator
+
+
+@dataclass
+class FeatureStoreConfig:
+    """Configuration for a FeatureStorePipeline run.
+
+    Args:
+        dataset: The source facts-table schema.
+        output_schema: Destination schema (database/schema) for generated tables.
+        output_table_prefix: Prefix applied to every output table name.
+        time_windows: Window sizes (in granularity units) for standard windowed
+            temporal operators.
+        composed_windows: Window sizes for ``MEDIA_ABS`` and ``RATIO`` operators.
+            When ``None`` those operators are omitted entirely.
+        include_marginals: When ``True``, ``PivotSpaceBuilder`` includes the ∅
+            marginal combination for each categorical.
+        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.
+            Only contract-valid operators are used.
+    """
+
+    dataset: AbstractDataset
+    output_schema: str
+    output_table_prefix: str
+    time_windows: list[int]
+    composed_windows: list[int] | None = None
+    include_marginals: bool = True
+    aggregators_override: dict[MeasurementType, list[Layer2Aggregator]] | None = None
+    operators_override: dict[Layer2OutputType, list[TemporalOperator]] | None = field(default=None)

featkit/contracts/__init__.py

@@ -0,0 +1 @@
+"""Type boundary contracts for featkit layers."""

featkit/contracts/measurement/__init__.py

@@ -0,0 +1,27 @@
+"""Layer 1 → Layer 2 measurement type contracts."""
+
+from featkit.contracts.measurement.base import AbstractMeasurementTypeContract
+from featkit.contracts.measurement.defaults import (
+    BalanceContract,
+    CantidadContract,
+    EstadisticoContract,
+    FechaContract,
+    FlagContract,
+    MontoContract,
+    TicketContract,
+    TimeDiffContract,
+    get_default_contract,
+)
+
+__all__ = [
+    "AbstractMeasurementTypeContract",
+    "BalanceContract",
+    "CantidadContract",
+    "EstadisticoContract",
+    "FechaContract",
+    "FlagContract",
+    "MontoContract",
+    "TicketContract",
+    "TimeDiffContract",
+    "get_default_contract",
+]

featkit/contracts/measurement/base.py

@@ -0,0 +1,47 @@
+"""Abstract base for Layer 1 → Layer 2 type boundary contracts."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+from featkit.enums import Layer2Aggregator, MeasurementType
+
+
+class AbstractMeasurementTypeContract(ABC):
+    """Governs which Layer2Aggregators are semantically valid for a MeasurementType.
+
+    This is the Layer 1 → Layer 2 type boundary: the contract ensures that only
+    aggregators that make semantic sense for the measurement are applied.
+    """
+
+    def __init__(self, measurement_type: MeasurementType) -> None:
+        self._measurement_type = measurement_type
+
+    @property
+    def measurement_type(self) -> MeasurementType:
+        """The MeasurementType this contract governs (read-only)."""
+        return self._measurement_type
+
+    @property
+    @abstractmethod
+    def valid_layer2_aggregators(self) -> frozenset[Layer2Aggregator]:
+        """Frozen set of aggregators that are semantically valid for this measurement type."""
+        ...
+
+    def is_valid(self, aggregator: Layer2Aggregator) -> bool:
+        """Return ``True`` if the aggregator is permitted by this contract."""
+        return aggregator in self.valid_layer2_aggregators
+
+    def _key(self) -> tuple[object, ...]:
+        return (self.measurement_type, self.valid_layer2_aggregators)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, AbstractMeasurementTypeContract):
+            return NotImplemented
+        return type(self) is type(other) and self._key() == other._key()
+
+    def __hash__(self) -> int:
+        return hash((type(self), self._key()))
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}(measurement_type={self.measurement_type.name})"

featkit/contracts/measurement/defaults.py

@@ -0,0 +1,117 @@
+"""Default concrete contracts — one per MeasurementType."""
+
+from __future__ import annotations
+
+from featkit.contracts.measurement.base import AbstractMeasurementTypeContract
+from featkit.enums import Layer2Aggregator, MeasurementType
+
+_S = Layer2Aggregator.SUM
+_C = Layer2Aggregator.COUNT
+_MX = Layer2Aggregator.MAX
+_MN = Layer2Aggregator.MIN
+_AV = Layer2Aggregator.AVG
+
+
+class MontoContract(AbstractMeasurementTypeContract):
+    _AGGREGATORS: frozenset[Layer2Aggregator] = frozenset({_S, _MX, _MN, _AV})
+
+    def __init__(self) -> None:
+        super().__init__(MeasurementType.MONTO)
+
+    @property
+    def valid_layer2_aggregators(self) -> frozenset[Layer2Aggregator]:
+        return self._AGGREGATORS
+
+
+class CantidadContract(AbstractMeasurementTypeContract):
+    _AGGREGATORS: frozenset[Layer2Aggregator] = frozenset({_S})
+
+    def __init__(self) -> None:
+        super().__init__(MeasurementType.CANTIDAD)
+
+    @property
+    def valid_layer2_aggregators(self) -> frozenset[Layer2Aggregator]:
+        return self._AGGREGATORS
+
+
+class TicketContract(AbstractMeasurementTypeContract):
+    _AGGREGATORS: frozenset[Layer2Aggregator] = frozenset({_AV})
+
+    def __init__(self) -> None:
+        super().__init__(MeasurementType.TICKET)
+
+    @property
+    def valid_layer2_aggregators(self) -> frozenset[Layer2Aggregator]:
+        return self._AGGREGATORS
+
+
+class FlagContract(AbstractMeasurementTypeContract):
+    _AGGREGATORS: frozenset[Layer2Aggregator] = frozenset({_MX})
+
+    def __init__(self) -> None:
+        super().__init__(MeasurementType.FLAG)
+
+    @property
+    def valid_layer2_aggregators(self) -> frozenset[Layer2Aggregator]:
+        return self._AGGREGATORS
+
+
+class FechaContract(AbstractMeasurementTypeContract):
+    _AGGREGATORS: frozenset[Layer2Aggregator] = frozenset({_MX, _MN})
+
+    def __init__(self) -> None:
+        super().__init__(MeasurementType.FECHA)
+
+    @property
+    def valid_layer2_aggregators(self) -> frozenset[Layer2Aggregator]:
+        return self._AGGREGATORS
+
+
+class BalanceContract(AbstractMeasurementTypeContract):
+    _AGGREGATORS: frozenset[Layer2Aggregator] = frozenset({_MX, _MN, _AV})
+
+    def __init__(self) -> None:
+        super().__init__(MeasurementType.BALANCE)
+
+    @property
+    def valid_layer2_aggregators(self) -> frozenset[Layer2Aggregator]:
+        return self._AGGREGATORS
+
+
+class TimeDiffContract(AbstractMeasurementTypeContract):
+    _AGGREGATORS: frozenset[Layer2Aggregator] = frozenset({_S, _AV, _MX, _MN})
+
+    def __init__(self) -> None:
+        super().__init__(MeasurementType.TIME_DIFF)
+
+    @property
+    def valid_layer2_aggregators(self) -> frozenset[Layer2Aggregator]:
+        return self._AGGREGATORS
+
+
+class EstadisticoContract(AbstractMeasurementTypeContract):
+    _AGGREGATORS: frozenset[Layer2Aggregator] = frozenset({_S, _AV, _MX, _MN, _C})
+
+    def __init__(self) -> None:
+        super().__init__(MeasurementType.ESTADISTICO)
+
+    @property
+    def valid_layer2_aggregators(self) -> frozenset[Layer2Aggregator]:
+        return self._AGGREGATORS
+
+
+_DEFAULTS: dict[MeasurementType, AbstractMeasurementTypeContract] = {
+    MeasurementType.MONTO: MontoContract(),
+    MeasurementType.CANTIDAD: CantidadContract(),
+    MeasurementType.TICKET: TicketContract(),
+    MeasurementType.FLAG: FlagContract(),
+    MeasurementType.FECHA: FechaContract(),
+    MeasurementType.BALANCE: BalanceContract(),
+    MeasurementType.TIME_DIFF: TimeDiffContract(),
+    MeasurementType.ESTADISTICO: EstadisticoContract(),
+}
+
+
+def get_default_contract(mt: MeasurementType) -> AbstractMeasurementTypeContract:
+    """Return the default contract for the given :class:`~featkit.enums.MeasurementType`."""
+    return _DEFAULTS[mt]

featkit/contracts/output/__init__.py

@@ -0,0 +1,19 @@
+"""Layer 2 → Layer 3 output type contracts."""
+
+from featkit.contracts.output.base import AbstractLayer2OutputContract
+from featkit.contracts.output.defaults import (
+    CategoricalOutputContract,
+    FlagOutputContract,
+    NumericOutputContract,
+    TemporalOutputContract,
+    get_default_output_contract,
+)
+
+__all__ = [
+    "AbstractLayer2OutputContract",
+    "CategoricalOutputContract",
+    "FlagOutputContract",
+    "NumericOutputContract",
+    "TemporalOutputContract",
+    "get_default_output_contract",
+]

featkit/contracts/output/base.py

@@ -0,0 +1,36 @@
+"""Abstract base for Layer 2 → Layer 3 type boundary contracts."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+
+from featkit.enums import Layer2OutputType, TemporalOperator
+
+
+class AbstractLayer2OutputContract(ABC):
+    """Governs which TemporalOperators are semantically valid for a Layer2OutputType.
+
+    This is the Layer 2 → Layer 3 type boundary: the contract ensures that only
+    operators that make semantic sense for the output column type are applied.
+    """
+
+    def __init__(self, output_type: Layer2OutputType) -> None:
+        self._output_type = output_type
+
+    @property
+    def output_type(self) -> Layer2OutputType:
+        """The Layer2OutputType this contract governs (read-only)."""
+        return self._output_type
+
+    @property
+    @abstractmethod
+    def valid_temporal_operators(self) -> frozenset[TemporalOperator]:
+        """Frozen set of temporal operators valid for this output type."""
+        ...
+
+    def is_valid(self, operator: TemporalOperator) -> bool:
+        """Return ``True`` if the operator is permitted by this contract."""
+        return operator in self.valid_temporal_operators
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}(output_type={self.output_type.name})"

featkit/contracts/output/defaults.py

@@ -0,0 +1,80 @@
+"""Default concrete output contracts — one per Layer2OutputType."""
+
+from __future__ import annotations
+
+from featkit.contracts.output.base import AbstractLayer2OutputContract
+from featkit.enums import Layer2OutputType, TemporalOperator
+
+_PU = TemporalOperator.PROM_U
+_PP = TemporalOperator.PROM_P
+_SU = TemporalOperator.SUM_U
+_SP = TemporalOperator.SUM_P
+_UM = TemporalOperator.ULT_MES
+_PM = TemporalOperator.PREV_MES
+_CR = TemporalOperator.CREC
+_FR = TemporalOperator.FREQ
+_MNU = TemporalOperator.MIN_U
+_MXU = TemporalOperator.MAX_U
+_RC = TemporalOperator.REC
+_XM = TemporalOperator.XM
+_MA = TemporalOperator.MEDIA_ABS
+_RA = TemporalOperator.RATIO
+
+
+class NumericOutputContract(AbstractLayer2OutputContract):
+    _OPERATORS: frozenset[TemporalOperator] = frozenset(
+        {_PU, _PP, _SU, _SP, _CR, _MNU, _MXU, _UM, _PM, _FR, _XM, _MA, _RA}
+    )
+
+    def __init__(self) -> None:
+        super().__init__(Layer2OutputType.NUMERIC)
+
+    @property
+    def valid_temporal_operators(self) -> frozenset[TemporalOperator]:
+        return self._OPERATORS
+
+
+class FlagOutputContract(AbstractLayer2OutputContract):
+    _OPERATORS: frozenset[TemporalOperator] = frozenset({_UM, _PM, _FR, _XM, _RC})
+
+    def __init__(self) -> None:
+        super().__init__(Layer2OutputType.FLAG)
+
+    @property
+    def valid_temporal_operators(self) -> frozenset[TemporalOperator]:
+        return self._OPERATORS
+
+
+class CategoricalOutputContract(AbstractLayer2OutputContract):
+    _OPERATORS: frozenset[TemporalOperator] = frozenset({_UM, _PM, _RC})
+
+    def __init__(self) -> None:
+        super().__init__(Layer2OutputType.CATEGORICAL)
+
+    @property
+    def valid_temporal_operators(self) -> frozenset[TemporalOperator]:
+        return self._OPERATORS
+
+
+class TemporalOutputContract(AbstractLayer2OutputContract):
+    _OPERATORS: frozenset[TemporalOperator] = frozenset({_UM, _PM, _RC, _MNU, _MXU, _CR})
+
+    def __init__(self) -> None:
+        super().__init__(Layer2OutputType.TEMPORAL)
+
+    @property
+    def valid_temporal_operators(self) -> frozenset[TemporalOperator]:
+        return self._OPERATORS
+
+
+_DEFAULTS: dict[Layer2OutputType, AbstractLayer2OutputContract] = {
+    Layer2OutputType.NUMERIC: NumericOutputContract(),
+    Layer2OutputType.FLAG: FlagOutputContract(),
+    Layer2OutputType.CATEGORICAL: CategoricalOutputContract(),
+    Layer2OutputType.TEMPORAL: TemporalOutputContract(),
+}
+
+
+def get_default_output_contract(ot: Layer2OutputType) -> AbstractLayer2OutputContract:
+    """Return the default contract for the given :class:`~featkit.enums.Layer2OutputType`."""
+    return _DEFAULTS[ot]