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

additory/common/validation.py

@@ -1,197 +1,377 @@
 """
-Common Validation Utilities
+Input validation utilities for Additory.
 
-Provides consistent validation across all additory modules.
+Provides consistent validation across all functions with clear error messages.
 """
 
-from typing import Any, List, Union
-from .backend import is_dataframe, detect_backend
-from .exceptions import ValidationError
+import re
+from typing import Any, Callable, List
 
 
-def validate_dataframe(df: Any, name: str = "dataframe") -> None:
+def is_dataframe(df: Any) -> bool:
     """
-    Validate that input is a supported dataframe type.
+    Check if input is a DataFrame (pandas/polars/cuDF).
+    
+    Args:
+        df: Input to check
+        
+    Returns:
+        True if input is a DataFrame, False otherwise
+        
+    Example:
+        >>> is_dataframe(pl.DataFrame({'a': [1, 2, 3]}))
+        True
+        >>> is_dataframe([1, 2, 3])
+        False
+    """
+    # Check for polars DataFrame
+    try:
+        import polars as pl
+        if isinstance(df, pl.DataFrame):
+            return True
+    except ImportError:
+        pass
+    
+    # Check for pandas DataFrame
+    try:
+        import pandas as pd
+        if isinstance(df, pd.DataFrame):
+            return True
+    except ImportError:
+        pass
+    
+    # Check for cuDF DataFrame
+    try:
+        import cudf
+        if isinstance(df, cudf.DataFrame):
+            return True
+    except ImportError:
+        pass
+    
+    return False
+
+
+def validate_dataframe(df: Any, param_name: str = 'df') -> Any:
+    """
+    Validate that input is a DataFrame (pandas/polars/cuDF).
     
     Args:
         df: Input to validate
-        name: Name for error messages
+        param_name: Parameter name for error messages
+        
+    Returns:
+        Input df if valid
         
     Raises:
-        ValidationError: If not a supported dataframe or empty
+        TypeError: If input is not a DataFrame
         
-    Examples:
-        >>> validate_dataframe(df, "input dataframe")
+    Example:
+        df = validate_dataframe(df, 'df')
     """
-    if not is_dataframe(df):
-        raise ValidationError(
-            f"{name} must be a DataFrame (pandas, polars, or cudf). "
-            f"Got: {type(df)}"
-        )
+    # Check for polars DataFrame
+    try:
+        import polars as pl
+        if isinstance(df, pl.DataFrame):
+            return df
+    except ImportError:
+        pass
+    
+    # Check for pandas DataFrame
+    try:
+        import pandas as pd
+        if isinstance(df, pd.DataFrame):
+            return df
+    except ImportError:
+        pass
+    
+    # Check for cuDF DataFrame
+    try:
+        import cudf
+        if isinstance(df, cudf.DataFrame):
+            return df
+    except ImportError:
+        pass
+    
+    # If we get here, it's not a valid DataFrame
+    raise TypeError(
+        f"Parameter '{param_name}' must be a DataFrame "
+        f"(pandas, polars, or cuDF), got {type(df).__name__}"
+    )
+
+
+def validate_not_empty(df: Any, param_name: str = 'df') -> bool:
+    """
+    Validate that DataFrame is not empty.
     
-    if len(df) == 0:
-        raise ValidationError(f"{name} is empty")
+    Args:
+        df: DataFrame to check
+        param_name: Parameter name for error messages
+        
+    Returns:
+        True if not empty
+        
+    Raises:
+        ValueError: If DataFrame is empty
+    """
+    # Check row count (works for pandas, polars, cuDF)
+    if hasattr(df, 'shape'):
+        if df.shape[0] == 0:
+            raise ValueError(f"Parameter '{param_name}' cannot be empty (0 rows)")
+    elif hasattr(df, '__len__'):
+        if len(df) == 0:
+            raise ValueError(f"Parameter '{param_name}' cannot be empty (0 rows)")
+    
+    return True
 
 
-def validate_columns_exist(df: Any, columns: Union[str, List[str]], 
-                          df_name: str = "dataframe") -> None:
+def validate_column_name(name: str) -> bool:
     """
-    Validate that columns exist in dataframe.
+    Validate that column name is valid.
     
     Args:
-        df: Dataframe to check
-        columns: Column name(s) to validate
-        df_name: Name for error messages
+        name: Column name to validate
+        
+    Returns:
+        True if valid
         
     Raises:
-        ValidationError: If columns don't exist
+        ValueError: If column name is invalid
         
-    Examples:
-        >>> validate_columns_exist(df, ['col1', 'col2'], "my_dataframe")
-        >>> validate_columns_exist(df, 'single_col')
+    Rules:
+        - Not empty
+        - No leading/trailing whitespace
+        - No special characters except underscore
+        - Not a reserved keyword
     """
-    if isinstance(columns, str):
-        columns = [columns]
+    if not name:
+        raise ValueError("Column name cannot be empty")
     
-    df_columns = list(df.columns)
-    missing_columns = [col for col in columns if col not in df_columns]
+    if name != name.strip():
+        raise ValueError(f"Column name '{name}' has leading/trailing whitespace")
     
-    if missing_columns:
-        raise ValidationError(
-            f"Column(s) {missing_columns} not found in {df_name}. "
-            f"Available columns: {df_columns}"
+    # Check for valid characters (alphanumeric and underscore only)
+    if not re.match(r'^[a-zA-Z_][a-zA-Z0-9_]*$', name):
+        raise ValueError(
+            f"Column name '{name}' contains invalid characters. "
+            "Only alphanumeric and underscore allowed, must start with letter or underscore"
         )
+    
+    # Check for reserved keywords (Python keywords)
+    reserved = [
+        'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del',
+        'elif', 'else', 'except', 'False', 'finally', 'for', 'from', 'global',
+        'if', 'import', 'in', 'is', 'lambda', 'None', 'nonlocal', 'not', 'or',
+        'pass', 'raise', 'return', 'True', 'try', 'while', 'with', 'yield'
+    ]
+    if name in reserved:
+        raise ValueError(f"Column name '{name}' is a reserved keyword")
+    
+    return True
 
 
-def validate_positive_number(value: Union[int, float], param_name: str) -> None:
+def validate_positive_integer(value: int, param_name: str) -> bool:
     """
-    Validate that value is a positive number.
+    Validate that value is a positive integer.
     
     Args:
         value: Value to validate
         param_name: Parameter name for error messages
         
-    Raises:
-        ValidationError: If not a positive number
+    Returns:
+        True if valid
         
-    Examples:
-        >>> validate_positive_number(10, "max_categories")
+    Raises:
+        TypeError: If value is not an integer
+        ValueError: If value is not positive
     """
-    if not isinstance(value, (int, float)):
-        raise ValidationError(f"{param_name} must be a number, got {type(value)}")
+    if not isinstance(value, int):
+        raise TypeError(f"Parameter '{param_name}' must be an integer, got {type(value).__name__}")
     
     if value <= 0:
-        raise ValidationError(f"{param_name} must be positive, got {value}")
+        raise ValueError(f"Parameter '{param_name}' must be positive, got {value}")
+    
+    return True
 
 
-def validate_non_negative_number(value: Union[int, float], param_name: str) -> None:
+def validate_percentage(value: str) -> bool:
     """
-    Validate that value is a non-negative number.
+    Validate that value is a valid percentage string.
     
     Args:
-        value: Value to validate
-        param_name: Parameter name for error messages
+        value: Percentage string to validate (e.g., '50%')
+        
+    Returns:
+        True if valid
         
     Raises:
-        ValidationError: If not a non-negative number
+        ValueError: If percentage is invalid
         
-    Examples:
-        >>> validate_non_negative_number(0, "min_value")
+    Example:
+        validate_percentage('50%')   # True
+        validate_percentage('150%')  # True
+        validate_percentage('abc')   # Raises ValueError
     """
-    if not isinstance(value, (int, float)):
-        raise ValidationError(f"{param_name} must be a number, got {type(value)}")
+    if not isinstance(value, str):
+        raise ValueError(f"Percentage must be a string, got {type(value).__name__}")
+    
+    if not value.endswith('%'):
+        raise ValueError(f"Percentage must end with '%', got '{value}'")
+    
+    # Extract numeric part
+    numeric_part = value[:-1].strip()
     
-    if value < 0:
-        raise ValidationError(f"{param_name} must be non-negative, got {value}")
+    try:
+        percent = float(numeric_part)
+    except ValueError:
+        raise ValueError(f"Invalid percentage value: '{value}'")
+    
+    if percent < 0:
+        raise ValueError(f"Percentage cannot be negative, got '{value}'")
+    
+    return True
 
 
-def validate_parameter_choice(value: Any, choices: List[Any], 
-                             param_name: str) -> None:
+def validate_mode(mode: str, allowed_modes: List[str], param_name: str = 'mode') -> bool:
     """
-    Validate that parameter value is in allowed choices.
+    Validate that mode is in allowed list.
     
     Args:
-        value: Value to validate
-        choices: List of allowed values
+        mode: Mode to validate
+        allowed_modes: List of allowed modes
         param_name: Parameter name for error messages
         
+    Returns:
+        True if valid
+        
     Raises:
-        ValidationError: If value not in choices
+        ValueError: If mode is not in allowed list
         
-    Examples:
-        >>> validate_parameter_choice('after', ['before', 'after', 'end'], 'position')
+    Example:
+        validate_mode('transpose', ['transpose', 'onehotencoding', 'extract'])
     """
-    if value not in choices:
-        raise ValidationError(
-            f"Invalid {param_name}: '{value}'. "
-            f"Must be one of: {choices}"
+    if mode not in allowed_modes:
+        raise ValueError(
+            f"Invalid {param_name} '{mode}'. "
+            f"Must be one of: {', '.join(allowed_modes)}"
         )
+    
+    return True
 
 
-def validate_ratio(value: float, param_name: str) -> None:
+def validate_dict(value: Any, param_name: str) -> bool:
     """
-    Validate that value is a ratio between 0 and 1.
+    Validate that value is a dictionary.
     
     Args:
         value: Value to validate
         param_name: Parameter name for error messages
         
-    Raises:
-        ValidationError: If not a valid ratio
+    Returns:
+        True if valid
         
-    Examples:
-        >>> validate_ratio(0.5, "max_cardinality_ratio")
+    Raises:
+        TypeError: If value is not a dictionary
     """
-    if not isinstance(value, (int, float)):
-        raise ValidationError(f"{param_name} must be a number, got {type(value)}")
+    if not isinstance(value, dict):
+        raise TypeError(
+            f"Parameter '{param_name}' must be a dictionary, got {type(value).__name__}"
+        )
     
-    if not 0.0 <= value <= 1.0:
-        raise ValidationError(f"{param_name} must be between 0.0 and 1.0, got {value}")
+    return True
 
 
-def validate_string_not_empty(value: str, param_name: str) -> None:
+def validate_list(value: Any, param_name: str, allow_empty: bool = False) -> bool:
     """
-    Validate that string is not empty.
+    Validate that value is a list.
     
     Args:
-        value: String to validate
+        value: Value to validate
         param_name: Parameter name for error messages
+        allow_empty: Whether to allow empty lists
+        
+    Returns:
+        True if valid
         
     Raises:
-        ValidationError: If string is empty or not a string
+        TypeError: If value is not a list
+        ValueError: If list is empty and allow_empty is False
+    """
+    if not isinstance(value, list):
+        raise TypeError(
+            f"Parameter '{param_name}' must be a list, got {type(value).__name__}"
+        )
+    
+    if not allow_empty and len(value) == 0:
+        raise ValueError(f"Parameter '{param_name}' cannot be an empty list")
+    
+    return True
+
+
+def validate_string(value: Any, param_name: str, allow_empty: bool = False) -> bool:
+    """
+    Validate that value is a string.
+    
+    Args:
+        value: Value to validate
+        param_name: Parameter name for error messages
+        allow_empty: Whether to allow empty strings
+        
+    Returns:
+        True if valid
         
-    Examples:
-        >>> validate_string_not_empty("column_name", "column")
+    Raises:
+        TypeError: If value is not a string
+        ValueError: If string is empty and allow_empty is False
     """
     if not isinstance(value, str):
-        raise ValidationError(f"{param_name} must be a string, got {type(value)}")
+        raise TypeError(
+            f"Parameter '{param_name}' must be a string, got {type(value).__name__}"
+        )
+    
+    if not allow_empty and len(value) == 0:
+        raise ValueError(f"Parameter '{param_name}' cannot be an empty string")
     
-    if not value.strip():
-        raise ValidationError(f"{param_name} cannot be empty")
+    return True
 
 
-def validate_integer_in_range(value: int, param_name: str, 
-                              min_val: int = None, max_val: int = None) -> None:
+def validate_boolean(value: Any, param_name: str) -> bool:
     """
-    Validate that integer is within specified range.
+    Validate that value is a boolean.
     
     Args:
-        value: Integer to validate
+        value: Value to validate
         param_name: Parameter name for error messages
-        min_val: Minimum allowed value (inclusive)
-        max_val: Maximum allowed value (inclusive)
         
-    Raises:
-        ValidationError: If not an integer or out of range
+    Returns:
+        True if valid
         
-    Examples:
-        >>> validate_integer_in_range(50, "max_categories", min_val=1, max_val=200)
+    Raises:
+        TypeError: If value is not a boolean
     """
-    if not isinstance(value, int):
-        raise ValidationError(f"{param_name} must be an integer, got {type(value)}")
+    if not isinstance(value, bool):
+        raise TypeError(
+            f"Parameter '{param_name}' must be a boolean, got {type(value).__name__}"
+        )
     
-    if min_val is not None and value < min_val:
-        raise ValidationError(f"{param_name} must be >= {min_val}, got {value}")
+    return True
+
+
+def validate_optional(value: Any, validator: Callable, param_name: str) -> bool:
+    """
+    Validate optional parameter (None or valid value).
+    
+    Args:
+        value: Value to validate
+        validator: Validation function to use if not None
+        param_name: Parameter name for error messages
+        
+    Returns:
+        True if valid (None or passes validator)
+        
+    Example:
+        validate_optional(strategy, validate_dict, 'strategy')
+    """
+    if value is None:
+        return True
     
-    if max_val is not None and value > max_val:
-        raise ValidationError(f"{param_name} must be <= {max_val}, got {value}")
+    return validator(value, param_name)

additory/core/__init__.py

@@ -1,27 +1,39 @@
-# core/__init__.py
-# Expose core engine components
+"""
+Core infrastructure for Additory.
 
-from .executor import execute_expression
-from .registry import (
-    resolve_formula,
-    set_formula_version,
-    set_formula_root,
-    set_custom_formula_path,
+This module provides essential infrastructure components:
+- logging: Transparent logging system
+- memory_manager: Memory cleanup utilities
+- backend: Backend detection and conversion
+- config: Global configuration settings
+"""
+
+from .logging import Logger, get_logger, set_log_level
+from .memory_manager import (
+    MemoryManager,
+    get_memory_manager,
+    cleanup_after_operation,
+    estimate_memory_usage
+)
+from .config import (
+    Config,
+    get_config,
+    set_expressions_folder,
+    set_default_backend,
+    derive_namespace_from_path
 )
-from .loader import load_expression
-from .parser import parse_expression
-from .validator import validate_expression
-from .logging import log_info, log_warning
 
 __all__ = [
-    "execute_expression",
-    "resolve_formula",
-    "set_formula_version",
-    "set_formula_root",
-    "set_custom_formula_path",
-    "load_expression",
-    "parse_expression",
-    "validate_expression",
-    "log_info",
-    "log_warning",
+    'Logger',
+    'get_logger',
+    'set_log_level',
+    'MemoryManager',
+    'get_memory_manager',
+    'cleanup_after_operation',
+    'estimate_memory_usage',
+    'Config',
+    'get_config',
+    'set_expressions_folder',
+    'set_default_backend',
+    'derive_namespace_from_path'
 ]