additory 0.1.0a4__py3-none-any.whl → 0.1.1a1__py3-none-any.whl

additory/utilities/resolvers.py

@@ -1,286 +0,0 @@
-# additory/ops/resolvers.py
-
-import pandas as pd
-from typing import List, Dict, Any
-from collections import Counter
-
-def resolve_strict(matches, ref_df, cols):
-    """
-    Only accept exactly one match.
-    If 0 or >1 matches → return None for all columns.
-    """
-    if len(matches) != 1:
-        return {col: None for col in cols}
-
-    row = ref_df.iloc[matches[0]]
-    return {col: row[col] for col in cols}
-
-
-def resolve_first(matches, ref_df, cols):
-    """
-    Excel VLOOKUP behavior:
-    - If no matches → None
-    - If multiple → take the first
-    """
-    if not matches:
-        return {col: None for col in cols}
-
-    row = ref_df.iloc[matches[0]]
-    return {col: row[col] for col in cols}
-
-
-def resolve_last(matches, ref_df, cols):
-    """
-    Take the last match:
-    - If no matches → None
-    - If multiple → take the last
-    """
-    if not matches:
-        return {col: None for col in cols}
-
-    row = ref_df.iloc[matches[-1]]
-    return {col: row[col] for col in cols}
-
-
-def resolve_majority(matches, ref_df, cols):
-    """
-    For each column:
-    - pick the most frequent value among duplicates
-    - ties → first occurring
-    """
-    out = {}
-
-    for col in cols:
-        values = [ref_df.iloc[i][col] for i in matches]
-
-        if not values:
-            out[col] = None
-            continue
-
-        # Count frequency, handling NaN values
-        non_null_values = [v for v in values if pd.notna(v)]
-        
-        if not non_null_values:
-            out[col] = None
-            continue
-
-        # Use Counter for frequency counting
-        freq = Counter(non_null_values)
-        
-        # Pick the value with highest frequency (first in case of tie)
-        out[col] = freq.most_common(1)[0][0]
-
-    return out
-
-
-def resolve_max(matches, ref_df, cols):
-    """
-    For numeric or date-like columns:
-    - pick the maximum value
-    """
-    out = {}
-
-    for col in cols:
-        values = [ref_df.iloc[i][col] for i in matches]
-
-        if not values:
-            out[col] = None
-        else:
-            try:
-                # Filter out NaN values
-                non_null_values = [v for v in values if pd.notna(v)]
-                if non_null_values:
-                    out[col] = max(non_null_values)
-                else:
-                    out[col] = None
-            except (TypeError, ValueError):
-                out[col] = None
-
-    return out
-
-
-def resolve_min(matches, ref_df, cols):
-    """
-    For numeric or date-like columns:
-    - pick the minimum value
-    """
-    out = {}
-
-    for col in cols:
-        values = [ref_df.iloc[i][col] for i in matches]
-
-        if not values:
-            out[col] = None
-        else:
-            try:
-                # Filter out NaN values
-                non_null_values = [v for v in values if pd.notna(v)]
-                if non_null_values:
-                    out[col] = min(non_null_values)
-                else:
-                    out[col] = None
-            except (TypeError, ValueError):
-                out[col] = None
-
-    return out
-
-
-def resolve_longest(matches, ref_df, cols):
-    """
-    For text columns:
-    - pick the longest string representation
-    """
-    out = {}
-
-    for col in cols:
-        values = [ref_df.iloc[i][col] for i in matches]
-
-        if not values:
-            out[col] = None
-        else:
-            # Filter out NaN values and convert to string
-            non_null_values = [v for v in values if pd.notna(v)]
-            if non_null_values:
-                out[col] = max(non_null_values, key=lambda x: len(str(x)))
-            else:
-                out[col] = None
-
-    return out
-
-
-def resolve_shortest(matches, ref_df, cols):
-    """
-    For text columns:
-    - pick the shortest string representation
-    """
-    out = {}
-
-    for col in cols:
-        values = [ref_df.iloc[i][col] for i in matches]
-
-        if not values:
-            out[col] = None
-        else:
-            # Filter out NaN values and convert to string
-            non_null_values = [v for v in values if pd.notna(v)]
-            if non_null_values:
-                out[col] = min(non_null_values, key=lambda x: len(str(x)))
-            else:
-                out[col] = None
-
-    return out
-
-
-def resolve_sum(matches, ref_df, cols):
-    """
-    For numeric columns:
-    - sum all matching values
-    """
-    out = {}
-
-    for col in cols:
-        values = [ref_df.iloc[i][col] for i in matches]
-
-        if not values:
-            out[col] = None
-        else:
-            try:
-                # Filter out NaN values
-                non_null_values = [v for v in values if pd.notna(v)]
-                if non_null_values:
-                    # Try to sum numeric values
-                    numeric_values = [float(v) for v in non_null_values]
-                    out[col] = sum(numeric_values)
-                else:
-                    out[col] = None
-            except (TypeError, ValueError):
-                out[col] = None
-
-    return out
-
-
-def resolve_count(matches, ref_df, cols):
-    """
-    Count the number of matches for each column
-    """
-    out = {}
-
-    for col in cols:
-        values = [ref_df.iloc[i][col] for i in matches]
-        # Count non-null values
-        non_null_count = sum(1 for v in values if pd.notna(v))
-        out[col] = non_null_count
-
-    return out
-
-
-def resolve_avg(matches, ref_df, cols):
-    """
-    For numeric columns:
-    - calculate average of all matching values
-    """
-    out = {}
-
-    for col in cols:
-        values = [ref_df.iloc[i][col] for i in matches]
-
-        if not values:
-            out[col] = None
-        else:
-            try:
-                # Filter out NaN values
-                non_null_values = [v for v in values if pd.notna(v)]
-                if non_null_values:
-                    # Try to average numeric values
-                    numeric_values = [float(v) for v in non_null_values]
-                    out[col] = sum(numeric_values) / len(numeric_values)
-                else:
-                    out[col] = None
-            except (TypeError, ValueError):
-                out[col] = None
-
-    return out
-
-
-def resolve_concat(matches, ref_df, cols):
-    """
-    For text columns:
-    - concatenate all matching values with separator
-    """
-    out = {}
-
-    for col in cols:
-        values = [ref_df.iloc[i][col] for i in matches]
-
-        if not values:
-            out[col] = None
-        else:
-            # Filter out NaN values and convert to string
-            non_null_values = [str(v) for v in values if pd.notna(v)]
-            if non_null_values:
-                out[col] = "; ".join(non_null_values)
-            else:
-                out[col] = None
-
-    return out
-
-
-RESOLVERS = {
-    # Single value selection
-    "strict": resolve_strict,
-    "first": resolve_first,
-    "last": resolve_last,
-    "majority": resolve_majority,
-    
-    # Numeric aggregation
-    "max": resolve_max,
-    "min": resolve_min,
-    "sum": resolve_sum,
-    "avg": resolve_avg,
-    "count": resolve_count,
-    
-    # Text aggregation
-    "longest": resolve_longest,
-    "shortest": resolve_shortest,
-    "concat": resolve_concat,
-}

additory/utilities/settings.py

@@ -1,167 +0,0 @@
-# additory/utilities/settings.py
-# Global settings management
-
-"""
-Settings Utilities Module
-
-This module provides global settings management for the additory library:
-- Backend preferences
-- Path configurations
-- Performance settings
-- User preferences
-"""
-
-from typing import Optional, Dict, Any
-import os
-
-# Global settings storage
-_global_settings = {
-    "backend": "auto",  # auto, pandas, polars, cudf
-    "precision": "auto",  # auto, float32, float64
-    "my_expressions_path": None,
-    "my_schemas_path": None,
-    "cache_enabled": True,
-    "memory_threshold_mb": 100,
-    "performance_mode": "balanced"  # fast, balanced, memory_optimized
-}
-
-
-def set_global_settings(**kwargs) -> Dict[str, Any]:
-    """
-    Set global settings for additory
-    
-    Args:
-        backend: Preferred backend ("auto", "pandas", "polars", "cudf")
-        precision: Numeric precision ("auto", "float32", "float64")
-        my_expressions_path: Path to user expressions
-        my_schemas_path: Path to user schemas
-        cache_enabled: Enable/disable caching
-        memory_threshold_mb: Memory cleanup threshold
-        performance_mode: Performance mode ("fast", "balanced", "memory_optimized")
-        
-    Returns:
-        Dictionary with updated settings
-    """
-    global _global_settings
-    
-    valid_backends = ["auto", "pandas", "polars", "cudf"]
-    valid_precisions = ["auto", "float32", "float64"]
-    valid_performance_modes = ["fast", "balanced", "memory_optimized"]
-    
-    for key, value in kwargs.items():
-        if key == "backend" and value not in valid_backends:
-            raise ValueError(f"Invalid backend: {value}. Must be one of {valid_backends}")
-        elif key == "precision" and value not in valid_precisions:
-            raise ValueError(f"Invalid precision: {value}. Must be one of {valid_precisions}")
-        elif key == "performance_mode" and value not in valid_performance_modes:
-            raise ValueError(f"Invalid performance_mode: {value}. Must be one of {valid_performance_modes}")
-        elif key in ["my_expressions_path", "my_schemas_path"] and value is not None:
-            if not os.path.exists(value):
-                raise ValueError(f"Path does not exist: {value}")
-        
-        if key in _global_settings:
-            _global_settings[key] = value
-        else:
-            raise ValueError(f"Unknown setting: {key}")
-    
-    return _global_settings.copy()
-
-
-def get_global_settings() -> Dict[str, Any]:
-    """
-    Get current global settings
-    
-    Returns:
-        Dictionary with current settings
-    """
-    return _global_settings.copy()
-
-
-def get_setting(key: str, default: Any = None) -> Any:
-    """
-    Get a specific setting value
-    
-    Args:
-        key: Setting key
-        default: Default value if key not found
-        
-    Returns:
-        Setting value or default
-    """
-    return _global_settings.get(key, default)
-
-
-def reset_settings():
-    """Reset all settings to defaults"""
-    global _global_settings
-    _global_settings = {
-        "backend": "auto",
-        "precision": "auto", 
-        "my_expressions_path": None,
-        "my_schemas_path": None,
-        "cache_enabled": True,
-        "memory_threshold_mb": 100,
-        "performance_mode": "balanced"
-    }
-
-
-def set_my_expressions_path(path: str):
-    """
-    Set path for user expressions
-    
-    Args:
-        path: Path to user expressions directory
-    """
-    if not os.path.exists(path):
-        raise ValueError(f"Path does not exist: {path}")
-    
-    _global_settings["my_expressions_path"] = path
-
-
-def set_my_schemas_path(path: str):
-    """
-    Set path for user schemas
-    
-    Args:
-        path: Path to user schemas directory
-    """
-    if not os.path.exists(path):
-        raise ValueError(f"Path does not exist: {path}")
-    
-    _global_settings["my_schemas_path"] = path
-
-
-def get_my_expressions_path() -> Optional[str]:
-    """Get current user expressions path"""
-    return _global_settings.get("my_expressions_path")
-
-
-def get_my_schemas_path() -> Optional[str]:
-    """Get current user schemas path"""
-    return _global_settings.get("my_schemas_path")
-
-
-# Convenience functions for common settings
-def set_backend(backend: str):
-    """Set preferred backend"""
-    set_global_settings(backend=backend)
-
-
-def set_precision(precision: str):
-    """Set numeric precision"""
-    set_global_settings(precision=precision)
-
-
-def enable_cache():
-    """Enable caching"""
-    set_global_settings(cache_enabled=True)
-
-
-def disable_cache():
-    """Disable caching"""
-    set_global_settings(cache_enabled=False)
-
-
-def set_performance_mode(mode: str):
-    """Set performance mode"""
-    set_global_settings(performance_mode=mode)