additory 0.1.0a3__py3-none-any.whl → 0.1.0a4__py3-none-any.whl

additory/__init__.py

@@ -3,7 +3,7 @@
 from .dynamic_api import add as _api_instance
 
 # Version information
-__version__ = "0.1.0a3"
+__version__ = "0.1.0a4"
 
 # Expose the API instance normally
 add = _api_instance

additory/core/config.py

@@ -329,14 +329,14 @@ def set_custom_formula_path(path):
 
 # backend preference setting
 
-_backend_preference: str | None = None  # "cpu", "gpu", or None
+_backend_preference: Optional[str] = None  # "cpu", "gpu", or None
 
-def set_backend_preference(mode: str | None):
+def set_backend_preference(mode: Optional[str]):
     global _backend_preference
     if mode not in (None, "cpu", "gpu"):
         raise ValueError("backend must be 'cpu', 'gpu', or None")
     _backend_preference = mode
 
-def get_backend_preference() -> str | None:
+def get_backend_preference() -> Optional[str]:
     return _backend_preference
 

additory/core/registry.py

@@ -2,6 +2,7 @@
 # Versioned registry for additory
 
 from dataclasses import dataclass
+from typing import Optional
 import os
 import json
 
@@ -26,9 +27,9 @@ class ResolvedFormula:
     source: str
     version: str
     mode: str = "local"
-    ast: dict | None = None
-    sample_clean: dict | None = None
-    sample_unclean: dict | None = None
+    ast: Optional[dict] = None
+    sample_clean: Optional[dict] = None
+    sample_unclean: Optional[dict] = None
 
 
 # ------------------------------------------------------------

additory/dynamic_api.py

@@ -30,8 +30,15 @@ class AdditoryAPI(SimpleNamespace):
         self.my = ExpressionProxy(namespace="user")
         self._builtin_proxy = ExpressionProxy(namespace="builtin")
         
-        # Explicitly set the synthetic method to prevent namespace conflicts
+        # Explicitly set methods to prevent namespace conflicts
         self.synthetic = self._synthetic_method
+        self.deduce = self._deduce_method
+        self.to = self._to_method
+        self.onehotencoding = self._onehotencoding_method
+        self.harmonize_units = self._harmonize_units_method
+        self.scan = self._scan_method
+        self.games = self._games_method
+        self.play = self._play_method
     
     def __getattr__(self, name):
         """
@@ -118,7 +125,7 @@ class AdditoryAPI(SimpleNamespace):
                 additory.synthetic = self._synthetic_method
             raise
     
-    def to(self, target_df, from_df=None, bring=None, against=None, **kwargs):
+    def _to_method(self, target_df, from_df=None, bring=None, against=None, **kwargs):
         """
         Add columns from reference dataframe to target dataframe.
         
@@ -139,7 +146,7 @@ class AdditoryAPI(SimpleNamespace):
         from additory.utilities.lookup import to
         return to(target_df, from_df, bring=bring, against=against, **kwargs)
     
-    def onehotencoding(self, df, columns=None, **kwargs):
+    def _onehotencoding_method(self, df, columns=None, **kwargs):
         """
         One-hot encode categorical columns.
         
@@ -154,7 +161,7 @@ class AdditoryAPI(SimpleNamespace):
         from additory.utilities.encoding import onehotencoding
         return onehotencoding(df, column=columns, **kwargs)
     
-    def harmonize_units(self, df, value_column, unit_column, target_unit=None, position="end", **kwargs):
+    def _harmonize_units_method(self, df, value_column, unit_column, target_unit=None, position="end", **kwargs):
         """
         Harmonize units in a dataframe.
         
@@ -176,7 +183,7 @@ class AdditoryAPI(SimpleNamespace):
         from additory.utilities.units import harmonize_units
         return harmonize_units(df, value_column, unit_column, target_unit, position, **kwargs)
     
-    def scan(
+    def _scan_method(
         self,
         df: Union[pl.DataFrame, pd.DataFrame, Any],
         preset: Optional[str] = None,
@@ -259,7 +266,48 @@ class AdditoryAPI(SimpleNamespace):
             verbose=verbose
         )
     
-    def games(self):
+    def _deduce_method(
+        self,
+        df: Union[pd.DataFrame, pl.DataFrame, Any],
+        from_column: Union[str, List[str]],
+        to_column: str
+    ) -> Union[pd.DataFrame, pl.DataFrame, Any]:
+        """
+        Deduce missing labels based on text similarity to labeled examples.
+        
+        Uses cosine similarity on TF-IDF vectors. Pure Python, no LLMs, offline-first.
+        Requires at least 3 labeled examples to work.
+        
+        When multiple source columns are provided, they are concatenated with
+        spaces before computing similarity.
+        
+        Args:
+            df: DataFrame with some labeled and some unlabeled rows
+            from_column: Text column(s) to analyze
+                        - str: Single column (e.g., "comment")
+                        - List[str]: Multiple columns (e.g., ["comment", "notes"])
+            to_column: Label column to fill (e.g., "status")
+            
+        Returns:
+            DataFrame with deduced labels filled in
+            
+        Examples:
+            # Single column
+            >>> result = add.deduce(df, from_column="comment", to_column="status")
+            
+            # Multiple columns (better accuracy)
+            >>> result = add.deduce(
+            ...     df, 
+            ...     from_column=["comment", "notes", "description"],
+            ...     to_column="status"
+            ... )
+        
+        Privacy: Your data never leaves your machine. No external connections.
+        """
+        from additory.synthetic.deduce import deduce as deduce_impl
+        return deduce_impl(df, from_column, to_column)
+    
+    def _games_method(self):
         """
         List available games! 🎮
         
@@ -275,7 +323,7 @@ class AdditoryAPI(SimpleNamespace):
         """
         return ['tictactoe', 'sudoku']
     
-    def play(self, game: str = "tictactoe"):
+    def _play_method(self, game: str = "tictactoe"):
         """
         Play a game! 🎮
         

additory/expressions/registry.py

@@ -28,9 +28,9 @@ class ResolvedFormula:
     version: str
     mode: str = "local"
     namespace: str = "builtin"  # NEW: "builtin" or "user"
-    ast: dict | None = None
-    sample_clean: dict | None = None
-    sample_unclean: dict | None = None
+    ast: Optional[dict] = None
+    sample_clean: Optional[dict] = None
+    sample_unclean: Optional[dict] = None
 
 
 # ------------------------------------------------------------

additory/synthetic/deduce.py

@@ -0,0 +1,259 @@
+#!/usr/bin/env python3
+"""
+Text-based label deduction for additory.
+
+Uses TF-IDF + cosine similarity to deduce labels from text.
+Pure Python, no LLMs, offline-first.
+"""
+
+import math
+import re
+from collections import Counter
+from typing import Union, List, Optional
+import pandas as pd
+import polars as pl
+
+
+def tokenize(text: str) -> List[str]:
+    """
+    Tokenize text into words.
+    
+    Args:
+        text: Input text
+        
+    Returns:
+        List of lowercase tokens
+    """
+    if text is None or not isinstance(text, str):
+        return []
+    
+    text = text.lower()
+    text = re.sub(r"[^a-z0-9\s]", " ", text)
+    return [w for w in text.split() if w]
+
+
+def vectorize(tokens: List[str]) -> Counter:
+    """
+    Convert tokens to TF vector (term frequency).
+    
+    Args:
+        tokens: List of tokens
+        
+    Returns:
+        Counter with term frequencies
+    """
+    return Counter(tokens)
+
+
+def cosine_similarity(v1: Counter, v2: Counter) -> float:
+    """
+    Compute cosine similarity between two vectors.
+    
+    Args:
+        v1: First vector (Counter)
+        v2: Second vector (Counter)
+        
+    Returns:
+        Similarity score (0-1)
+    """
+    # Dot product
+    dot = sum(v1[t] * v2[t] for t in v1 if t in v2)
+    
+    # Magnitudes
+    mag1 = math.sqrt(sum(v * v for v in v1.values()))
+    mag2 = math.sqrt(sum(v * v for v in v2.values()))
+    
+    if mag1 == 0 or mag2 == 0:
+        return 0.0
+    
+    return dot / (mag1 * mag2)
+
+
+def _deduce_polars(
+    df: pl.DataFrame,
+    from_column: Union[str, List[str]],
+    to_column: str,
+    min_examples: int = 3
+) -> pl.DataFrame:
+    """
+    Deduce missing labels using text similarity (Polars-native).
+    
+    Args:
+        df: Polars DataFrame
+        from_column: Text column(s) to analyze
+        to_column: Label column to fill
+        min_examples: Minimum labeled examples required
+        
+    Returns:
+        DataFrame with deduced labels
+        
+    Raises:
+        ValueError: If insufficient labeled examples
+    """
+    # Normalize from_column to list
+    if isinstance(from_column, str):
+        source_cols = [from_column]
+    else:
+        source_cols = from_column
+    
+    # Validate columns exist
+    for col in source_cols:
+        if col not in df.columns:
+            raise ValueError(f"Column '{col}' not found in DataFrame")
+    
+    if to_column not in df.columns:
+        raise ValueError(f"Column '{to_column}' not found in DataFrame")
+    
+    # Create combined text column if multiple sources
+    if len(source_cols) == 1:
+        text_col = source_cols[0]
+        df_work = df.clone()
+    else:
+        # Concatenate multiple columns with spaces
+        df_work = df.with_columns([
+            pl.concat_str(
+                [pl.col(c).fill_null("") for c in source_cols],
+                separator=" "
+            ).alias("__deduce_text__")
+        ])
+        text_col = "__deduce_text__"
+    
+    # Split into labeled and unlabeled
+    labeled_df = df_work.filter(pl.col(to_column).is_not_null())
+    unlabeled_df = df_work.filter(pl.col(to_column).is_null())
+    
+    # Check if we have enough labeled examples
+    n_labeled = len(labeled_df)
+    if n_labeled == 0:
+        raise ValueError(
+            f"⚠️ Cannot deduce labels: No labeled examples found in '{to_column}' column.\n"
+            f"Please manually label at least {min_examples} examples per category, then run again.\n\n"
+            f"Note: additory uses pure Python text similarity (no LLMs, no external calls).\n"
+            f"Your data never leaves your machine."
+        )
+    
+    if n_labeled < min_examples:
+        print(
+            f"⚠️ Only {n_labeled} labeled examples found. "
+            f"For better accuracy, label at least {min_examples} examples.\n"
+            f"Proceeding with available data..."
+        )
+    
+    # If no unlabeled rows, return original
+    if len(unlabeled_df) == 0:
+        if len(source_cols) > 1:
+            # Remove temporary column
+            return df_work.drop("__deduce_text__")
+        return df_work
+    
+    # Precompute vectors for labeled rows
+    labeled_vectors = []
+    for row in labeled_df.iter_rows(named=True):
+        text = row[text_col]
+        label = row[to_column]
+        tokens = tokenize(text)
+        vec = vectorize(tokens)
+        labeled_vectors.append((vec, label))
+    
+    # Deduce labels for unlabeled rows
+    deduced_labels = []
+    for row in unlabeled_df.iter_rows(named=True):
+        text = row[text_col]
+        tokens = tokenize(text)
+        vec = vectorize(tokens)
+        
+        # Find most similar labeled example
+        best_label = None
+        best_score = -1.0
+        
+        for labeled_vec, label in labeled_vectors:
+            score = cosine_similarity(vec, labeled_vec)
+            if score > best_score:
+                best_score = score
+                best_label = label
+        
+        deduced_labels.append(best_label)
+    
+    # Create deduced labels series
+    deduced_series = pl.Series(to_column, deduced_labels)
+    
+    # Update unlabeled rows with deduced labels
+    unlabeled_df = unlabeled_df.with_columns([deduced_series])
+    
+    # Combine labeled and unlabeled back together
+    result_df = pl.concat([labeled_df, unlabeled_df])
+    
+    # Remove temporary column if created
+    if len(source_cols) > 1:
+        result_df = result_df.drop("__deduce_text__")
+    
+    # Print success message
+    n_deduced = len(deduced_labels)
+    print(f"✓ Deduced {n_deduced} label{'s' if n_deduced != 1 else ''} from {n_labeled} examples (offline, no LLMs)")
+    
+    return result_df
+
+
+def deduce(
+    df: Union[pd.DataFrame, pl.DataFrame],
+    from_column: Union[str, List[str]],
+    to_column: str
+) -> Union[pd.DataFrame, pl.DataFrame]:
+    """
+    Deduce missing labels based on text similarity to labeled examples.
+    
+    Uses cosine similarity on TF-IDF vectors. Pure Python, no LLMs, offline-first.
+    Requires at least 3 labeled examples to work.
+    
+    When multiple source columns are provided, they are concatenated with
+    spaces before computing similarity.
+    
+    Args:
+        df: DataFrame with some labeled and some unlabeled rows
+        from_column: Text column(s) to analyze
+                    - str: Single column (e.g., "comment")
+                    - List[str]: Multiple columns (e.g., ["comment", "notes"])
+        to_column: Label column to fill (e.g., "status")
+        
+    Returns:
+        DataFrame with deduced labels filled in
+        
+    Examples:
+        # Single column
+        >>> result = add.deduce(df, from_column="comment", to_column="status")
+        
+        # Multiple columns (better accuracy)
+        >>> result = add.deduce(
+        ...     df, 
+        ...     from_column=["comment", "notes", "description"],
+        ...     to_column="status"
+        ... )
+    
+    Privacy: Your data never leaves your machine. No external connections.
+    """
+    # Detect input backend
+    if isinstance(df, pd.DataFrame):
+        backend = "pandas"
+        # Convert to Polars
+        df_polars = pl.from_pandas(df)
+    elif isinstance(df, pl.DataFrame):
+        backend = "polars"
+        df_polars = df
+    else:
+        # Try arrow bridge (for cudf, etc.)
+        try:
+            df_polars = pl.from_arrow(df)
+            backend = "arrow"
+        except Exception:
+            raise TypeError(f"Unsupported DataFrame type: {type(df)}")
+    
+    # Process in Polars
+    result_polars = _deduce_polars(df_polars, from_column, to_column)
+    
+    # Convert back to original format
+    if backend == "pandas":
+        return result_polars.to_pandas()
+    elif backend == "polars":
+        return result_polars
+    else:  # arrow
+        return result_polars.to_arrow()

additory/synthetic/strategies.py

@@ -848,3 +848,79 @@ def apply_smote_strategy(
         )
     except Exception as e:
         raise ValidationError(f"SMOTE strategy failed: {e}")
+
+
+def parse_deduce_strategy(strategy_spec: str) -> Tuple[str, List[str]]:
+    """
+    Parse deduce strategy specification.
+    
+    Args:
+        strategy_spec: Strategy string like:
+            - "deduce:comment"
+            - "deduce:[comment, notes]"
+    
+    Returns:
+        Tuple of (strategy_type, source_columns)
+        - strategy_type: "deduce"
+        - source_columns: List of source column names
+    
+    Raises:
+        ValidationError: If strategy format is invalid
+    
+    Examples:
+        >>> parse_deduce_strategy("deduce:comment")
+        ("deduce", ["comment"])
+        
+        >>> parse_deduce_strategy("deduce:[comment, notes]")
+        ("deduce", ["comment", "notes"])
+    """
+    if not strategy_spec.startswith("deduce:"):
+        raise ValidationError(
+            f"Invalid deduce strategy: {strategy_spec}. "
+            "Must start with 'deduce:'"
+        )
+    
+    # Extract source specification after "deduce:"
+    source_spec = strategy_spec[7:].strip()  # Remove "deduce:" prefix
+    
+    if not source_spec:
+        raise ValidationError(
+            f"Deduce strategy requires source column(s): {strategy_spec}. "
+            "Format: 'deduce:column' or 'deduce:[col1, col2]'"
+        )
+    
+    # Check if it's multiple columns: deduce:[col1, col2]
+    if source_spec.startswith("[") and source_spec.endswith("]"):
+        # Multiple columns
+        columns_str = source_spec[1:-1]  # Remove brackets
+        
+        if not columns_str.strip():
+            raise ValidationError(
+                f"Deduce column list cannot be empty: {strategy_spec}"
+            )
+        
+        # Split by comma and strip whitespace
+        columns = [c.strip() for c in columns_str.split(",")]
+        
+        if len(columns) == 0:
+            raise ValidationError(
+                f"Deduce strategy must specify at least one column: {strategy_spec}"
+            )
+        
+        return "deduce", columns
+    else:
+        # Single column
+        return "deduce", [source_spec]
+
+
+def is_deduce_strategy(strategy_spec: str) -> bool:
+    """
+    Check if a strategy specification is a deduce strategy.
+    
+    Args:
+        strategy_spec: Strategy string
+    
+    Returns:
+        True if it's a deduce strategy, False otherwise
+    """
+    return isinstance(strategy_spec, str) and strategy_spec.startswith("deduce:")

{additory-0.1.0a3.dist-info → additory-0.1.0a4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: additory
-Version: 0.1.0a3
+Version: 0.1.0a4
 Summary: A semantic, extensible dataframe transformation engine with expressions, lookup, and synthetic data generation support.
 Author: Krishnamoorthy Sankaran
 License: MIT
@@ -39,7 +39,7 @@ Dynamic: license-file
 
 [![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Version](https://img.shields.io/badge/version-0.1.0a2-orange.svg)](https://github.com/sekarkrishna/additory/tree/main/V0.1.0a1/)
+[![Version](https://img.shields.io/badge/version-0.1.0a4-orange.svg)](https://github.com/sekarkrishna/additory)
 
 **Author:** Krishnamoorthy Sankaran
 
@@ -52,17 +52,17 @@ Dynamic: license-file
 ## 📦 Installation
 
 ```bash
-pip install additory==0.1.0a2
+pip install additory==0.1.0a4
 ```
 
 **Optional GPU support:**
 ```bash
-pip install additory[gpu]==0.1.0a2  # Includes cuDF for GPU acceleration
+pip install additory[gpu]==0.1.0a4  # Includes cuDF for GPU acceleration
 ```
 
 **Development installation:**
 ```bash
-pip install additory[dev]==0.1.0a2  # Includes testing and development tools
+pip install additory[dev]==0.1.0a4  # Includes testing and development tools
 ```
 
 ## 🎯 Core Functions
@@ -70,7 +70,8 @@ pip install additory[dev]==0.1.0a2  # Includes testing and development tools
 | Function | Purpose | Example |
 |----------|---------|---------|
 | `add.to()` | Lookup/join operations | `add.to(df1, from_df=df2, bring='col', against='key')` |
-| `add.augment()` | Generate additional data | `add.augment(df, n_rows=1000)` |
+| `add.synthetic()` | Generate additional data | `add.synthetic(df, n_rows=1000)` |
+| `add.deduce()` | Text-based label deduction | `add.deduce(df, from_column='text', to_column='label')` |
 | `add.scan()` | Data profiling & analysis | `add.scan(df, preset="full")` |
 
 ## 🧬 Available Expressions
@@ -119,7 +120,7 @@ import additory as add
 
 # Works with polars
 df_polars = pl.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
-result = add.augment(df_polars, n_rows=100)
+result = add.synthetic(df_polars, n_rows=100)
 
 # Automatic type detection and conversion
 ```
@@ -193,22 +194,44 @@ patients_with_bsa = add.bsa(patients)
 result = add.fitness_score(add.bmr(add.bmi(patients)))
 ```
 
-### 🔄 Augment Data Generation
+### 🔄 Synthetic Data Generation
 
-**Augment** generates additional data similar to your existing dataset using inline strategies.
+**Synthetic** generates additional data similar to your existing dataset using inline strategies.
 
 ```python
-# Augment existing data (learns from patterns)
-more_customers = add.augment(customers, n_rows=1000)
+# Extend existing data (learns from patterns)
+more_customers = add.synthetic(customers, n_rows=1000)
 
 # Create data from scratch with strategies
-new_data = add.augment("@new", n_rows=500, strategy={
+new_data = add.synthetic("@new", n_rows=500, strategy={
     'id': 'increment:start=1',
     'name': 'choice:[John,Jane,Bob]',
     'age': 'range:18-65'
 })
 ```
 
+### 🤖 Text-Based Label Deduction
+
+**Deduce** automatically fills in missing labels by learning from your existing labeled examples. Pure Python, no LLMs, offline-first.
+
+```python
+# Deduce missing labels from text
+tickets = pd.DataFrame({
+    "ticket_text": ["Cannot log in", "Billing question", "App crashes", "Need invoice"],
+    "category": ["Technical", "Billing", None, None]
+})
+
+# Automatically fill in missing categories
+result = add.deduce(tickets, from_column="ticket_text", to_column="category")
+
+# Use multiple columns for better accuracy
+result = add.deduce(
+    df,
+    from_column=["title", "description"],
+    to_column="category"
+)
+```
+
 ## 🧪 Examples
 
 ### E-commerce Data Pipeline
@@ -224,7 +247,7 @@ customers = pd.DataFrame({
 })
 
 # Generate more customers
-customers = add.augment(customers, n_rows=10000)
+customers = add.synthetic(customers, n_rows=10000)
 
 # Add customer tiers
 tiers = pd.DataFrame({
@@ -250,7 +273,7 @@ strategy = {
     'height_cm': 'range:150-200'  # Height in cm
 }
 
-patients = add.augment("@new", n_rows=1000, strategy=strategy)
+patients = add.synthetic("@new", n_rows=1000, strategy=strategy)
 
 # Convert height to meters for expressions
 patients['height_m'] = patients['height_cm'] / 100
@@ -265,19 +288,19 @@ print(result.correlations)
 
 ## 📚 Documentation
 
-- **[Function Documentation](https://github.com/sekarkrishna/additory/tree/main/V0.1.0a1/documentation/V0.1.0/)** - Detailed guides for each function
-- **[Expressions Guide](https://github.com/sekarkrishna/additory/tree/main/V0.1.0a1/documentation/V0.1.0/expressions.html)** - Complete expressions reference
+- **[Function Documentation](https://github.com/sekarkrishna/additory/tree/main/documentation/)** - Detailed guides for each function
+- **[Expressions Guide](https://github.com/sekarkrishna/additory/tree/main/documentation/)** - Complete expressions reference
 
 ## 📄 License
 
-MIT License - see [LICENSE](https://github.com/sekarkrishna/additory/tree/main/V0.1.0a1/LICENSE) file for details.
+MIT License - see [LICENSE](LICENSE) file for details.
 
 ## 📞 Support
 
 - **Issues**: [GitHub Issues](https://github.com/sekarkrishna/additory/issues)
-- **Documentation**: [Full Documentation](https://github.com/sekarkrishna/additory/tree/main/V0.1.0a1/documentation/V0.1.0)
+- **Documentation**: [Full Documentation](https://github.com/sekarkrishna/additory/tree/main/documentation/)
 
-## 🗺️ v0.1.1 (February 2025)
+## 🗺️ v0.1.1 (January 2026)
 - Enhanced documentation and tutorials
 - Performance optimizations
 - Additional expressions

{additory-0.1.0a3.dist-info → additory-0.1.0a4.dist-info}/RECORD

@@ -1,5 +1,5 @@
-additory/__init__.py,sha256=Q0vhhQxwcI-Wl-8TERWqYaq4_8gJXqUBUGSywlhdD3E,397
-additory/dynamic_api.py,sha256=q38rax223ZX5lRNRPs0I7WXd1YZwBJEF2nm1IG-mzFI,11843
+additory/__init__.py,sha256=6LWidwOfdQInwiTCaS9OlJG97WDnXCEMncZF9f9Uheo,397
+additory/dynamic_api.py,sha256=XcmXMS-k2u5RoH5uM6BoQfTLGgF4UcZvXs9f9-BlOM4,13814
 additory/analysis/__init__.py,sha256=F_yhD_hcIWbwO1wrRe8Js1RI-vkozaKyWNIIEb-jSMk,986
 additory/analysis/cardinality.py,sha256=y4ttjk3VFNm3mEfNZaTegVQxH7btnmXgnDUSkctNuTo,2976
 additory/analysis/correlations.py,sha256=n0vIPW9lTTSPsPlr40YOIohTX3mUgGmSLdlBrkJZa1c,3909
@@ -20,7 +20,7 @@ additory/core/__init__.py,sha256=dhEBneupBndNBlsQI8niFZgQjUJDLORzRcFtvXGXg-E,630
 additory/core/ast_builder.py,sha256=cW65w-utVGjUJos1ffmfEPgPbxVwN6WU-vcDKrBPy8o,5303
 additory/core/column_positioning.py,sha256=1frwieAvdHXvlZzlUhL1BXP1P_iOZ7yzCNDlvw4L9kI,13241
 additory/core/compiler_polars.py,sha256=wN_785yk7N3tYGPCP2IsOpCeWxqJNOMq35TX-xoSCS8,5161
-additory/core/config.py,sha256=DIGsBfs9sVPGKMZNDtulPrXCUO8dcywc9Zp_R2pIIew,9578
+additory/core/config.py,sha256=3qqM_JIahzf4ZscjU0OzlAAYQ7kEdfjG7ztKk8993nQ,9587
 additory/core/enhanced_cache_manager.py,sha256=7hpoMucAWkP_-sUzst_JigPKK04S6TsYLpI_m-s9FrY,47230
 additory/core/enhanced_matchers.py,sha256=lZO-PPfiAiriX4SjTenaulWqijogq9NnhUATHfwMqak,20353
 additory/core/enhanced_version_manager.py,sha256=wIk5pg0Pn5KahgsGMYtmHxxxX3sltnwHqJ_QT7mosNw,12957
@@ -32,7 +32,7 @@ additory/core/memory_manager.py,sha256=b1H1juAg2CXioSI4N65XldPdKxHTXRI3MSTSAtKV3
 additory/core/namespace_manager.py,sha256=RWbMZBcoXvpdcz5km2CJlXcrDwWE4DES-lGET4r98Pk,23325
 additory/core/parser.py,sha256=yVh87CiE4fmrg4jFisNMKTHlz4OpAMNVFF4thq6I0JE,4748
 additory/core/polars_expression_engine.py,sha256=O4s-ZtHgP2SQd_LsdGgCPVOACJgJsL7W48wj6CbutFw,23158
-additory/core/registry.py,sha256=_K9DY4lprBUbMJl5D18D9lmOjwhDawxXpV4_hdSBy7o,5621
+additory/core/registry.py,sha256=bhm__bPuLvGvjbEUm8xbb0lUXQ1ZMd1Pcn2oUsIg4Rc,5658
 additory/core/sample_data_manager.py,sha256=urBT2T5NZZM0KXriuW5xfCwC1SA3WHwraVMtz5qyw7Y,19800
 additory/core/user_namespace.py,sha256=qgPhuHuhiePa9Qr2CtBCuflpUfxD8wTakWFcp5Ve2xU,22522
 additory/core/validator.py,sha256=em71_1TAdk44B2yyNwzmxkh4pMpqAq1JN_oHoDH7fCk,588
@@ -43,16 +43,17 @@ additory/expressions/__init__.py,sha256=FYZjHA7zJie1HRAQjMo6MdQxwYW2owrHulKXjfBF
 additory/expressions/engine.py,sha256=yOzZDNKjltP-HLVKBL4BXke63ALqgRFXgHK4YeeXLQ8,21138
 additory/expressions/parser.py,sha256=yVh87CiE4fmrg4jFisNMKTHlz4OpAMNVFF4thq6I0JE,4748
 additory/expressions/proxy.py,sha256=kohaZTtU5f_r3O_WidnNKXzN3IAmAnt6M0L5F3mpb7I,22044
-additory/expressions/registry.py,sha256=R0nj3-qRx5Q9OxsevIeWGOfIvBcltYNmnUf8QCu06s8,11015
+additory/expressions/registry.py,sha256=DPkjg8YfQxjz0Tf6nif_e_8uTNAMfHd7LmUNL2GqZ-4,11024
 additory/expressions/samples.py,sha256=urBT2T5NZZM0KXriuW5xfCwC1SA3WHwraVMtz5qyw7Y,19800
 additory/synthetic/__init__.py,sha256=Zw0GqXXh5v6_1S6SxPcEYL7CzNmaRuVk1aC3qBOQ2RE,342
 additory/synthetic/column_name_resolver.py,sha256=-kh6bxitaSUwk28TZ5yPzbLUe6nxU7oYsazKEwumtRA,4913
+additory/synthetic/deduce.py,sha256=CjEw-mCHGO1GjQtb0i-YX8QlmHiJORwMqjnfp8Oxm68,7736
 additory/synthetic/distributions.py,sha256=jrwDGVy_Vcm5XXoGKy-V0LrpnxdGM5p84GklKq-0b_A,705
 additory/synthetic/forecast.py,sha256=F2XoKEDFDJ47W6bSzy2jXYWU3PN5X0l16YvtfxXc4GU,34820
 additory/synthetic/linked_list_parser.py,sha256=YysP1ODyABJzUe82QLEfbuxGknTCyWb81tf8Pueg-oE,13002
 additory/synthetic/namespace_lookup.py,sha256=4ILe1MWubGvRsF_xbQLybBbr3hG0iMTseypigB_66TI,4096
 additory/synthetic/smote.py,sha256=ub8pTA5Ez3WjXP15GtyUqCRztiPr7XfHbNGTucUFErA,9092
-additory/synthetic/strategies.py,sha256=k0gc5ic6LfJ2gjp8UiEP9txAqeIcen911jaAXhSkgGs,26269
+additory/synthetic/strategies.py,sha256=2Cn6wy-tRTj9CuBkhYizB6oQGev4EzxrprbQlKyxce8,28620
 additory/synthetic/synthesizer.py,sha256=9YHXyA9wfUyMZLse7nBMJ1hQ0F9SJmF4j01y4Oyebzg,26405
 additory/utilities/__init__.py,sha256=I28c5ZqqZ2VsMIG40fUBJhnc930cFXHJX22xQWARXq8,1679
 additory/utilities/encoding.py,sha256=DhTaTeUlJOSixQ3-hgUwSy1jMJAYadV2bQHuONVzzEY,20995
@@ -64,8 +65,8 @@ additory/utilities/resolvers.py,sha256=ykMfce2f9in9wqHgmljCFIil8xGcalT0FBwFIwHOl
 additory/utilities/settings.py,sha256=5XB2S3L7Ht486LZMDacYTuyB_ta7sVohUFEKzMo1nDU,4698
 additory/utilities/units.py,sha256=75VFSLCVhX3dcFokh-jbZepDRaFRuO2QpGZNQbG8fag,30526
 additory/utilities/validators.py,sha256=K1ZYsPL3W7XkIUECVWov4HZxTlzqs9Rbc61Vidh2F8o,4213
-additory-0.1.0a3.dist-info/licenses/LICENSE,sha256=ztobegtjJRyvQntGjQ1w80MGuTOeMmWkh5Be-pFyq3I,1079
-additory-0.1.0a3.dist-info/METADATA,sha256=4mlzxPW1q3nCdKAj27Fr3KVv4FTZhbrVtYOYRAcMdsw,8094
-additory-0.1.0a3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-additory-0.1.0a3.dist-info/top_level.txt,sha256=4zphwXiI6HEl40fdjMXoUp9JNIqQ-tgYWeo3zqKqvEk,9
-additory-0.1.0a3.dist-info/RECORD,,
+additory-0.1.0a4.dist-info/licenses/LICENSE,sha256=ztobegtjJRyvQntGjQ1w80MGuTOeMmWkh5Be-pFyq3I,1079
+additory-0.1.0a4.dist-info/METADATA,sha256=uYviUo6_AjdbVtV91hFZL7fyEwh4Pd_HsDqjgzxqDts,8729
+additory-0.1.0a4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+additory-0.1.0a4.dist-info/top_level.txt,sha256=4zphwXiI6HEl40fdjMXoUp9JNIqQ-tgYWeo3zqKqvEk,9
+additory-0.1.0a4.dist-info/RECORD,,