featkit 0.1.0__py3-none-any.whl

featkit/layer2/distributional.py

@@ -0,0 +1,51 @@
+"""DistributionalColumn — one Layer 2B distributional metric column."""
+
+from __future__ import annotations
+
+from featkit.enums import DistributionalMetric, Layer2Aggregator, Layer2OutputType
+from featkit.fields.categorical_field import CategoricalField
+from featkit.fields.measurement_field import MeasurementField
+from featkit.layer2.base import AbstractLayer2Column
+
+
+class DistributionalColumn(AbstractLayer2Column):
+    """A single distributional metric column in the Layer 2B output table.
+
+    Args:
+        source_measurement: Measurement field providing the numerical context.
+        layer2_aggregator: SQL aggregation function applied to the measurement.
+        categorical: Categorical field whose value distribution is measured.
+        distributional_metric: The distributional statistic to compute.
+
+    Raises:
+        ValueError: If ``layer2_aggregator`` is not permitted by the
+            measurement's contract, or if ``categorical.name`` contains the
+            column name separator (``__``).
+    """
+
+    def __init__(
+        self,
+        source_measurement: MeasurementField,
+        layer2_aggregator: Layer2Aggregator,
+        categorical: CategoricalField,
+        distributional_metric: DistributionalMetric,
+    ) -> None:
+        super().__init__(source_measurement, layer2_aggregator)
+        self._check_name_part(categorical.name, "categorical field name")
+        self.categorical = categorical
+        self.distributional_metric = distributional_metric
+
+    @property
+    def output_type(self) -> Layer2OutputType:
+        if self.distributional_metric == DistributionalMetric.MODE:
+            return Layer2OutputType.CATEGORICAL
+        return Layer2OutputType.NUMERIC
+
+    @property
+    def column_name(self) -> str:
+        return (
+            f"{self.categorical.name}"
+            f"__{self.source_measurement.name}"
+            f"__{self.layer2_aggregator.value}"
+            f"__{self.distributional_metric.value}"
+        )

featkit/layer2/pivoted.py

@@ -0,0 +1,63 @@
+"""PivotedColumn — one cell in the Layer 2A pivot table."""
+
+from __future__ import annotations
+
+from featkit.enums import Layer2Aggregator, Layer2OutputType, MeasurementType
+from featkit.fields.categorical_field import CategoricalField
+from featkit.fields.measurement_field import MeasurementField
+from featkit.layer2.base import AbstractLayer2Column
+
+_MT_TO_OUTPUT: dict[MeasurementType, Layer2OutputType] = {
+    MeasurementType.MONTO: Layer2OutputType.NUMERIC,
+    MeasurementType.CANTIDAD: Layer2OutputType.NUMERIC,
+    MeasurementType.TICKET: Layer2OutputType.NUMERIC,
+    MeasurementType.FLAG: Layer2OutputType.FLAG,
+    MeasurementType.FECHA: Layer2OutputType.TEMPORAL,
+    MeasurementType.BALANCE: Layer2OutputType.NUMERIC,
+    MeasurementType.TIME_DIFF: Layer2OutputType.NUMERIC,
+    MeasurementType.ESTADISTICO: Layer2OutputType.NUMERIC,
+}
+
+
+class PivotedColumn(AbstractLayer2Column):
+    """A single cell in the Layer 2A (pivot) output table.
+
+    Args:
+        source_measurement: Measurement field being aggregated.
+        layer2_aggregator: SQL aggregation function applied to the measurement.
+        categorical_combination: Mapping of categorical field → value that
+            defines the filter for this cell. ``None`` as a value means the
+            ∅ marginal (no filter on that dimension). Defensively copied at
+            construction time.
+
+    Raises:
+        ValueError: If ``layer2_aggregator`` is not permitted by the
+            measurement's contract, or if any field name or categorical value
+            contains the column name separator (``__``).
+    """
+
+    def __init__(
+        self,
+        source_measurement: MeasurementField,
+        layer2_aggregator: Layer2Aggregator,
+        categorical_combination: dict[CategoricalField, str | None] | None = None,
+    ) -> None:
+        super().__init__(source_measurement, layer2_aggregator)
+        self.categorical_combination: dict[CategoricalField, str | None] = (
+            dict(categorical_combination) if categorical_combination is not None else {}
+        )
+        for field, value in self.categorical_combination.items():
+            self._check_name_part(field.name, "categorical field name")
+            if value is not None:
+                self._check_name_part(value, "categorical value")
+
+    @property
+    def output_type(self) -> Layer2OutputType:
+        return _MT_TO_OUTPUT[self.source_measurement.measurement_type]
+
+    @property
+    def column_name(self) -> str:
+        parts = [self.layer2_aggregator.value, self.source_measurement.name]
+        for field, value in sorted(self.categorical_combination.items(), key=lambda kv: kv[0].name):
+            parts.append(f"{field.name}_{value}" if value is not None else field.name)
+        return "__".join(parts)

featkit/layer3/temporal_feature.py

@@ -0,0 +1,87 @@
+"""TemporalFeature — a single Layer 3 output column."""
+
+from __future__ import annotations
+
+from featkit.enums import TemporalOperator, TimeWindowDirection
+from featkit.layer2.base import AbstractLayer2Column
+
+#: Operators that operate on a single point in time and do not require a window.
+_POINT_IN_TIME_OPERATORS: frozenset[TemporalOperator] = frozenset(
+    {TemporalOperator.ULT_MES, TemporalOperator.PREV_MES, TemporalOperator.REC}
+)
+
+
+class TemporalFeature:
+    """A single Layer 3 output column derived by applying a temporal operator to a Layer 2 column.
+
+    Args:
+        source: The Layer 2 column this feature is built from.
+        operator: Temporal operator to apply.
+        direction: Direction of the sliding window.
+        window_size: Number of periods in the window. Required for windowed
+            operators; must be ``None`` for point-in-time operators
+            (e.g. ``ULT_MES``, ``REC``).
+
+    Raises:
+        ValueError: If ``operator`` is not permitted by ``source.output_contract``.
+        ValueError: If a windowed operator is used with ``window_size=None``.
+        ValueError: If a point-in-time operator is used with a non-``None`` ``window_size``.
+        ValueError: If ``window_size`` is not a positive integer when provided.
+    """
+
+    def __init__(
+        self,
+        source: AbstractLayer2Column,
+        operator: TemporalOperator,
+        direction: TimeWindowDirection,
+        window_size: int | None = None,
+    ) -> None:
+        if not source.output_contract.is_valid(operator):
+            valid = ", ".join(
+                op.name
+                for op in sorted(
+                    source.output_contract.valid_temporal_operators, key=lambda o: o.value
+                )
+            )
+            raise ValueError(
+                f"TemporalOperator.{operator.name} is not valid for "
+                f"output type Layer2OutputType.{source.output_type.name}. "
+                f"Valid operators: {valid}"
+            )
+
+        is_pit = operator in _POINT_IN_TIME_OPERATORS
+        if is_pit and window_size is not None:
+            raise ValueError(
+                f"TemporalOperator.{operator.name} is a point-in-time operator; "
+                f"window_size must be None, got {window_size!r}"
+            )
+        if not is_pit and window_size is None:
+            raise ValueError(
+                f"TemporalOperator.{operator.name} is a windowed operator; window_size is required"
+            )
+        if window_size is not None and (
+            isinstance(window_size, bool) or not isinstance(window_size, int) or window_size < 1
+        ):
+            raise ValueError(f"window_size must be a positive integer, got {window_size!r}")
+
+        self.source = source
+        self.operator = operator
+        self.direction = direction
+        self.window_size = window_size
+
+    @property
+    def column_name(self) -> str:
+        """Deterministic name for this Layer 3 feature column."""
+        parts = [self.source.column_name, self.operator.value, self.direction.value]
+        if self.window_size is not None:
+            parts.append(str(self.window_size))
+        return "__".join(parts)
+
+    def __repr__(self) -> str:
+        return (
+            f"TemporalFeature("
+            f"source={self.source.column_name!r}, "
+            f"operator={self.operator.name!r}, "
+            f"direction={self.direction.name!r}, "
+            f"window_size={self.window_size!r})"
+        )

featkit/pipeline.py

@@ -0,0 +1,63 @@
+"""FeatureStorePipeline — orchestrates space builders and delegates to a code generator."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from featkit.builders.distributional_space import DistributionalSpaceBuilder
+from featkit.builders.pivot_space import PivotSpaceBuilder
+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.layer3.temporal_feature import TemporalFeature
+
+if TYPE_CHECKING:
+    from featkit.generators.base import AbstractCodeGenerator
+    from featkit.generators.output import FeatureStoreOutput
+
+
+class FeatureStorePipeline:
+    """Orchestrates the three space builders and delegates code generation.
+
+    The pipeline holds the results of the last ``build()`` call in three lists:
+    ``layer2a`` (pivot columns), ``layer2b`` (distributional columns), and
+    ``layer3`` (temporal features). All three are empty until ``build()`` is
+    called.
+
+    Args:
+        config: The pipeline configuration.
+    """
+
+    def __init__(self, config: FeatureStoreConfig) -> None:
+        self.config = config
+        self.layer2a: list[PivotedColumn] = []
+        self.layer2b: list[DistributionalColumn] = []
+        self.layer3: list[TemporalFeature] = []
+
+    def build(self) -> FeatureStorePipeline:
+        """Run all three space builders and return ``self``.
+
+        Idempotent: calling ``build()`` more than once replaces the previous
+        results with an identical fresh computation.
+        """
+        cfg = self.config
+        self.layer2a = PivotSpaceBuilder(
+            dataset=cfg.dataset,
+            include_marginals=cfg.include_marginals,
+            aggregators_override=cfg.aggregators_override,
+        ).build()
+        self.layer2b = DistributionalSpaceBuilder(
+            dataset=cfg.dataset,
+        ).build()
+        self.layer3 = TemporalSpaceBuilder(
+            layer2_columns=[*self.layer2a, *self.layer2b],
+            time_windows=cfg.time_windows,
+            composed_windows=cfg.composed_windows,
+            operators_override=cfg.operators_override,
+        ).build()
+        return self
+
+    def run(self, generator: AbstractCodeGenerator) -> FeatureStoreOutput:
+        """Delegate code generation entirely to the supplied generator."""
+        return generator.generate(self)

featkit-0.1.0.dist-info/METADATA

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: featkit
+Version: 0.1.0
+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
+Project-URL: Changelog, https://github.com/Mirkiux/featkit/blob/main/CHANGELOG.md
+Project-URL: Bug Tracker, https://github.com/Mirkiux/featkit/issues
+Author: Mirko
+License: MIT License
+        
+        Copyright (c) 2026 Mirko
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: analytics,data engineering,databricks,feature engineering,feature store,pivot,pyspark,snowflake
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: sqlglot>=23.0
+Provides-Extra: databricks
+Requires-Dist: databricks-sql-connector>=3.0; extra == 'databricks'
+Provides-Extra: dev
+Requires-Dist: build>=1.0; extra == 'dev'
+Requires-Dist: hatch>=1.9; extra == 'dev'
+Requires-Dist: mypy>=1.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Requires-Dist: twine>=5.0; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs-material>=9.5; extra == 'docs'
+Requires-Dist: mkdocs>=1.6; extra == 'docs'
+Requires-Dist: mkdocstrings[python]>=0.25; extra == 'docs'
+Provides-Extra: ibis
+Requires-Dist: ibis-framework>=9.0; extra == 'ibis'
+Provides-Extra: spark
+Requires-Dist: pyspark>=3.4; extra == 'spark'
+Description-Content-Type: text/markdown
+
+# featkit
+
+**featkit** is a Python framework for automated feature store generation from relational facts tables.
+
+It implements a three-layer architecture:
+
+- **Layer 1** — input facts table with typed columns (ID, time, categorical, measurement)
+- **Layer 2** — horizontal concept table built via pivot (2A) and distributional aggregations (2B)
+- **Layer 3** — temporal feature table produced by sliding operators over the Layer 2 columns
+
+The framework is engine-agnostic: the same pipeline definition produces either a standalone SQL script (Snowflake, Databricks SQL, Spark SQL) or a lazy PySpark execution plan, with the choice abstracted behind a code generator interface.
+
+## Key concepts
+
+| Layer | What it does |
+|---|---|
+| Layer 2A — Pivot | `GROUP BY (ID, time)` + `CASE WHEN` per categorical combination × measurement × aggregator |
+| Layer 2B — Distributional | Per-categorical CTEs computing entropy, HHI, dominant proportion, mode, count |
+| Layer 3 — Temporal | Sliding window operators (PROM_U, SUM_U, CREC, FREQ, REC, …) over all Layer 2 columns |
+
+## Installation
+
+```bash
+pip install featkit
+```
+
+## Quickstart
+
+```python
+from featkit import FeatureStorePipeline, FeatureStoreConfig
+from featkit.dataset import SimpleDataset
+from featkit.fields import IDField, TimeField, CategoricalField, MeasurementField
+from featkit.enums import MeasurementType, TimeGranularity, CategoricalTreatment
+from featkit.generators.sql import SnowflakeSQLCodeGenerator
+
+# Define schema
+fields = [
+    IDField(name="ID_CLIENTE"),
+    TimeField(name="PERIODO",
+              source_granularity=TimeGranularity.MONTHLY,
+              target_granularity=TimeGranularity.MONTHLY),
+    CategoricalField(name="SECTOR", treatment=CategoricalTreatment.PIVOT,
+                     allowed_values=["RETAIL", "CORP", "PYME"]),
+    CategoricalField(name="CANAL",  treatment=CategoricalTreatment.PIVOT,
+                     allowed_values=["DIGITAL", "PRESENCIAL", "TELEFONO"]),
+    MeasurementField(name="MTO", measurement_type=MeasurementType.MONTO),
+    MeasurementField(name="TRX", measurement_type=MeasurementType.CANTIDAD),
+]
+
+dataset = SimpleDataset(
+    source_reference="MY_DB.MY_SCHEMA.FACTS_TABLE",
+    fields=fields,
+)
+
+config = FeatureStoreConfig(
+    dataset=dataset,
+    output_schema="MY_DB.MY_SCHEMA",
+    output_table_prefix="FS",
+    time_windows=[3, 6, 9, 12],
+)
+
+pipeline = FeatureStorePipeline(config).build()
+output = pipeline.run(SnowflakeSQLCodeGenerator())
+
+output.save("./output")
+# Writes: output/script.sql, output/dag.json, output/diagram.md
+```
+
+## Architecture
+
+See [docs/general_plan.md](docs/general_plan.md) for the full implementation plan.
+
+## License
+
+MIT

featkit-0.1.0.dist-info/RECORD

@@ -0,0 +1,52 @@
+featkit/__init__.py,sha256=Gye3QbTN1Ipd8LAxOo81dnvXOEBHFz8n2cRvvyX5NUg,83
+featkit/config.py,sha256=jaa35QJsJ1RnxyTGBi3bgsu1TLzgKb9A4zC-bpY3a8I,1666
+featkit/enums.py,sha256=HhXffwPPLWtUmrjdQ31AyZVmhQf8TqkGLpX-YGI78TA,2463
+featkit/pipeline.py,sha256=JxndaErlD4PRyU8oS0h0Kumm8CmJba-4QhpO04AuQ7Y,2443
+featkit/builders/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+featkit/builders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+featkit/builders/distributional_space.py,sha256=KmhFT3eY-URyxvAvHLAZPW_rTGEy3S4AMo9_SXHXIWI,3274
+featkit/builders/pivot_space.py,sha256=a5EIS8FJrHaLLCPasU1mVu_nnN8CkuBSzQamuU1tZ7I,4578
+featkit/builders/temporal_space.py,sha256=p4xsy5H_MBRXSnv3bsisNEbEp7dsxEPYWND1PQOxWLo,3617
+featkit/contracts/__init__.py,sha256=fyhKqo6gfJRkh-Wpdm542xX_dTkSFjirxV8XYfvluQ0,50
+featkit/contracts/measurement/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+featkit/contracts/measurement/__init__.py,sha256=z6R5h_7B64zNNyQ3UAHsK0Bp5e5y4z7KBaXGbDrKPWM,645
+featkit/contracts/measurement/base.py,sha256=c15hjpiB-eseOvystZ-Ku5OCJuyi76JcBnYqZunQJG0,1735
+featkit/contracts/measurement/defaults.py,sha256=UeJ2CnFlBwUBGe3p9r9pbBGynkDze3JXACe5w7jl9zc,3688
+featkit/contracts/output/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+featkit/contracts/output/__init__.py,sha256=NuHpmLkm0Bi8CZiKBrEFOcV_DoPmud8lznSFjAFJNf8,518
+featkit/contracts/output/base.py,sha256=PNTvO87_JT4A9R3KtI7zdTK_BMzweAXotOM-FQR4sbw,1269
+featkit/contracts/output/defaults.py,sha256=p9pyObMgmkZpI6eu1sYG5W0ZGJ-A7ybgy1_MC9x490M,2593
+featkit/dataset/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+featkit/dataset/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+featkit/dataset/base.py,sha256=famnNBUamzekTAVjrznLP0CD5Ho-xteMvHrb2hvIOko,4436
+featkit/fields/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+featkit/fields/__init__.py,sha256=9-emUyqQLjPY_MBDrqEZGo0hRBIfoZpuw3_RChnmtBU,416
+featkit/fields/base.py,sha256=CbPb-M8NSzOYgkeVgeLT0C-ucyRRap3q4kT0Noj1xJ4,1430
+featkit/fields/categorical_field.py,sha256=ojoYXW8Zdcs-FK2S2u_S3JoMk5RgXNm5_oaXvZvvFac,2177
+featkit/fields/id_field.py,sha256=IHgOol2cxALly7cu1T8r27gbcr4Nc3BTJ5ODqMxkqyA,375
+featkit/fields/measurement_field.py,sha256=vP5vP-PBr4S03zQSSlreq3NF6c2RS8d6bgSpQc-smqY,1490
+featkit/fields/time_field.py,sha256=vYJ_Wdh3u039A2zpMcZxJQ8Hn-7poWLqj_kvKi49-hE,1337
+featkit/generators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+featkit/generators/base.py,sha256=v4SkI8hrMVCIVATQTI2oZPQAIpC9UG-sReUOd79-1Kc,6459
+featkit/generators/output.py,sha256=JxODvBXjyoa1OOtAmwneQK_z1o_qCA4HHCw7v9xjTIQ,3275
+featkit/generators/pyspark/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+featkit/generators/pyspark/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+featkit/generators/pyspark/databricks.py,sha256=5vP5Aq7C4EZkh4-dSl76EWLHN-HpMadJoE8rBdTNVeQ,18985
+featkit/generators/sql/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+featkit/generators/sql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+featkit/generators/sql/base.py,sha256=pEgNFBqEEJgk4XNy8MVAKBO7OYcWovurr6b9F-s4LeI,20417
+featkit/generators/sql/databricks.py,sha256=s2FDXkONXzs4iEm_IanbVLUNqqIoGFzCQvWinOZ_ybI,680
+featkit/generators/sql/snowflake.py,sha256=ljN9qrSi62JvwVsGU9JNeaRbp8VSjBRNgvHDk-e5mr0,677
+featkit/generators/sql/spark_sql.py,sha256=Ed-_OUXeBzohzUnzzFY5B7aeNVS-3xl_LtQ-VdodrHA,672
+featkit/layer2/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+featkit/layer2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+featkit/layer2/base.py,sha256=5Oqssix47dC__1_81vtY2o2XhTwXe2PeRW2f3JVOfMs,3266
+featkit/layer2/distributional.py,sha256=Y44Jhju-I6O3wOqeN3RqjOCWm6f8poGWAtgbLFmoJSk,1975
+featkit/layer2/pivoted.py,sha256=o5d5gnDfVKuzO4rLqSppTkPE4r4Vy4y-qbh3y2FET1A,2778
+featkit/layer3/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+featkit/layer3/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+featkit/layer3/temporal_feature.py,sha256=I_OIOIRxo5-l9Sm519ZzE2hWByfXB2yy8k6q_Pe0jhc,3462
+featkit-0.1.0.dist-info/METADATA,sha256=4SlWA7N812iB3O88_l262E8OS0LYWycGEjmTJIfLdqI,5866
+featkit-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+featkit-0.1.0.dist-info/licenses/LICENSE,sha256=CZwDNkl35IhZurGF12e5fdiH-dYFgHKdmm74PZDQWPI,1062
+featkit-0.1.0.dist-info/RECORD,,

featkit-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

featkit-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mirko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.