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

additory/common/sample_data.py

@@ -1,182 +0,0 @@
-"""
-Centralized Sample Dataset Management
-
-Provides sample datasets for demonstrations across all additory modules.
-Sample datasets are stored as .add files in reference/ directories and
-loaded on-demand using the existing .add file parser.
-
-Usage:
-    from additory.common.sample_data import get_sample_dataset
-    
-    # For synthetic
-    df = get_sample_dataset("synthetic", "sample")
-    
-    # For expressions (future)
-    df = get_sample_dataset("expressions", "sample")
-    df_unclean = get_sample_dataset("expressions", "sample_unclean")
-"""
-
-import polars as pl
-from pathlib import Path
-from typing import Optional
-import yaml
-
-from additory.common.exceptions import ValidationError
-
-
-def get_sample_dataset(
-    module: str = "synthetic",
-    block: str = "sample",
-    dataset_type: str = "clean"
-) -> pl.DataFrame:
-    """
-    Load a sample dataset from .add files.
-    
-    This function provides centralized access to sample datasets across
-    all additory modules (synthetic, expressions, utilities). Sample datasets
-    are stored as .add files in the reference/ directory structure.
-    
-    Args:
-        module: Module name ("synthetic", "expressions", "utilities")
-        block: Block name within the .add file ("sample" for synthetic)
-        dataset_type: Type of sample data ("clean" or "unclean")
-    
-    Returns:
-        Polars DataFrame with sample data
-    
-    Raises:
-        ValidationError: If module, block, or dataset_type not found
-    
-    Examples:
-        >>> # Load synthetic sample dataset
-        >>> df = get_sample_dataset("synthetic", "sample")
-        >>> print(df.shape)
-        (50, 10)
-        
-        >>> # Load expressions sample dataset (future)
-        >>> df = get_sample_dataset("expressions", "sample", "clean")
-        >>> df_unclean = get_sample_dataset("expressions", "sample", "unclean")
-    
-    Sample Dataset Structure (synthetic):
-        - id: Sequential numeric IDs (1-50)
-        - emp_id: Employee IDs with pattern (EMP_001 - EMP_050)
-        - order_id: Order IDs with different padding (ORD_0001 - ORD_0050)
-        - age: Age values (18-65 range)
-        - salary: Salary values (40k-120k range)
-        - first_name: First names from builtin list
-        - last_name: Last names from builtin list
-        - department: Departments from builtin list
-        - status: Status values from builtin list
-        - region: Geographic regions (North, South, East, West)
-    """
-    # Construct path to .add file
-    base_path = Path(__file__).parent.parent.parent / "reference"
-    
-    if module == "synthetic":
-        add_file_path = base_path / "synthetic_definitions" / f"{block}_0.1.add"
-    elif module == "expressions":
-        add_file_path = base_path / "expressions_definitions" / f"{block}_0.1.add"
-    elif module == "utilities":
-        add_file_path = base_path / "utilities_definitions" / f"{block}_0.1.add"
-    else:
-        raise ValidationError(
-            f"Unknown module '{module}'. "
-            f"Valid modules: synthetic, expressions, utilities"
-        )
-    
-    # Check if file exists
-    if not add_file_path.exists():
-        raise ValidationError(
-            f"Sample dataset file not found: {add_file_path}\n"
-            f"Module: {module}, Block: {block}"
-        )
-    
-    # Load and parse .add file
-    try:
-        with open(add_file_path, 'r') as f:
-            content = yaml.safe_load(f)
-    except Exception as e:
-        raise ValidationError(
-            f"Failed to parse sample dataset file: {add_file_path}\n"
-            f"Error: {e}"
-        )
-    
-    # Extract sample data
-    sample_section = content.get("sample", {})
-    
-    if not sample_section:
-        raise ValidationError(
-            f"No 'sample' section found in {add_file_path}"
-        )
-    
-    # Get the requested dataset type (clean or unclean)
-    dataset = sample_section.get(dataset_type)
-    
-    if dataset is None:
-        available_types = list(sample_section.keys())
-        raise ValidationError(
-            f"Dataset type '{dataset_type}' not found in {add_file_path}\n"
-            f"Available types: {available_types}"
-        )
-    
-    # Convert to Polars DataFrame
-    try:
-        df = pl.DataFrame(dataset)
-    except Exception as e:
-        raise ValidationError(
-            f"Failed to create DataFrame from sample data: {e}"
-        )
-    
-    return df
-
-
-def list_available_samples() -> dict:
-    """
-    List all available sample datasets.
-    
-    Returns:
-        Dictionary mapping module names to available samples
-    
-    Example:
-        >>> samples = list_available_samples()
-        >>> print(samples)
-        {
-            'synthetic': ['sample'],
-            'expressions': ['sample'],
-            'utilities': []
-        }
-    """
-    base_path = Path(__file__).parent.parent.parent / "reference"
-    available = {}
-    
-    # Check synthetic
-    synthetic_path = base_path / "synthetic_definitions"
-    if synthetic_path.exists():
-        available['synthetic'] = [
-            f.stem.rsplit('_', 1)[0]  # Remove version suffix
-            for f in synthetic_path.glob("*.add")
-        ]
-    else:
-        available['synthetic'] = []
-    
-    # Check expressions
-    expressions_path = base_path / "expressions_definitions"
-    if expressions_path.exists():
-        available['expressions'] = [
-            f.stem.rsplit('_', 1)[0]  # Remove version suffix
-            for f in expressions_path.glob("*.add")
-        ]
-    else:
-        available['expressions'] = []
-    
-    # Check utilities
-    utilities_path = base_path / "utilities_definitions"
-    if utilities_path.exists():
-        available['utilities'] = [
-            f.stem.rsplit('_', 1)[0]  # Remove version suffix
-            for f in utilities_path.glob("*.add")
-        ]
-    else:
-        available['utilities'] = []
-    
-    return available

additory/core/ast_builder.py

@@ -1,165 +0,0 @@
-# ast_builder.py
-#
-# Extended AST builder for additory DSL.
-# Backward compatible with minimal arithmetic DSL.
-# Adds:
-#   - comparisons
-#   - boolean logic
-#   - ternary (Python-style: a if cond else b)
-#   - function calls (min, max, abs, log, exp)
-#
-
-import ast
-
-
-def build_ast_from_expression(expr: str) -> dict:
-    """
-    Convert a Python-like expression string into our internal AST format.
-    Uses Python's ast module as a parser, then transforms nodes.
-    """
-
-    if not expr or not expr.strip():
-        return None
-
-    py_ast = ast.parse(expr, mode="eval")
-    return _convert(py_ast.body)
-
-
-def _convert(node):
-    """Convert Python AST → additory AST."""
-
-    # ------------------------------------------------------------
-    # Literals
-    # ------------------------------------------------------------
-    if isinstance(node, ast.Constant):
-        return {"type": "literal", "value": node.value}
-
-    # ------------------------------------------------------------
-    # Column reference
-    # ------------------------------------------------------------
-    if isinstance(node, ast.Name):
-        return {"type": "column", "name": node.id}
-
-    # ------------------------------------------------------------
-    # Binary arithmetic: + - * / **
-    # ------------------------------------------------------------
-    if isinstance(node, ast.BinOp):
-        return {
-            "type": "binary",
-            "op": _op_symbol(node.op),
-            "left": _convert(node.left),
-            "right": _convert(node.right),
-        }
-
-    # ------------------------------------------------------------
-    # Unary arithmetic: -x, +x
-    # ------------------------------------------------------------
-    if isinstance(node, ast.UnaryOp):
-        if isinstance(node.op, ast.UAdd):
-            return _convert(node.operand)
-        if isinstance(node.op, ast.USub):
-            return {
-                "type": "binary",
-                "op": "*",
-                "left": {"type": "literal", "value": -1},
-                "right": _convert(node.operand),
-            }
-        if isinstance(node.op, ast.Not):
-            return {
-                "type": "unary_bool",
-                "op": "not",
-                "value": _convert(node.operand),
-            }
-
-    # ------------------------------------------------------------
-    # Boolean operations: and/or
-    # ------------------------------------------------------------
-    if isinstance(node, ast.BoolOp):
-        op = "and" if isinstance(node.op, ast.And) else "or"
-        return {
-            "type": "bool_op",
-            "op": op,
-            "values": [_convert(v) for v in node.values],
-        }
-
-    # ------------------------------------------------------------
-    # Comparisons: == != > < >= <=
-    # ------------------------------------------------------------
-    if isinstance(node, ast.Compare):
-        # Python allows chained comparisons: a < b < c
-        # We only support simple binary comparisons
-        if len(node.ops) != 1 or len(node.comparators) != 1:
-            raise NotImplementedError("Chained comparisons not supported")
-
-        op = _cmp_symbol(node.ops[0])
-        return {
-            "type": "cmp",
-            "op": op,
-            "left": _convert(node.left),
-            "right": _convert(node.comparators[0]),
-        }
-
-    # ------------------------------------------------------------
-    # Ternary: a if cond else b
-    # ------------------------------------------------------------
-    if isinstance(node, ast.IfExp):
-        return {
-            "type": "if_expr",
-            "cond": _convert(node.test),
-            "then": _convert(node.body),
-            "else": _convert(node.orelse),
-        }
-
-    # ------------------------------------------------------------
-    # Function calls: min, max, abs, log, exp
-    # ------------------------------------------------------------
-    if isinstance(node, ast.Call):
-        if not isinstance(node.func, ast.Name):
-            raise NotImplementedError("Only simple function calls supported")
-
-        name = node.func.id
-        args = [_convert(a) for a in node.args]
-
-        return {
-            "type": "call",
-            "name": name,
-            "args": args,
-        }
-
-    raise NotImplementedError(f"Unsupported AST node: {type(node)}")
-
-
-def _op_symbol(op):
-    """Map Python AST operator → string symbol."""
-    if isinstance(op, ast.Add):
-        return "+"
-    if isinstance(op, ast.Sub):
-        return "-"
-    if isinstance(op, ast.Mult):
-        return "*"
-    if isinstance(op, ast.Div):
-        return "/"
-    if isinstance(op, ast.Pow):
-        return "**"
-    if isinstance(op, ast.Mod):
-        return "%"
-    if isinstance(op, ast.FloorDiv):
-        return "//"
-    raise NotImplementedError(f"Unsupported operator: {type(op)}")
-
-
-def _cmp_symbol(op):
-    """Map Python AST comparison operator → string symbol."""
-    if isinstance(op, ast.Eq):
-        return "=="
-    if isinstance(op, ast.NotEq):
-        return "!="
-    if isinstance(op, ast.Gt):
-        return ">"
-    if isinstance(op, ast.Lt):
-        return "<"
-    if isinstance(op, ast.GtE):
-        return ">="
-    if isinstance(op, ast.LtE):
-        return "<="
-    raise NotImplementedError(f"Unsupported comparison operator: {type(op)}")

additory/core/backends/__init__.py

@@ -1,23 +0,0 @@
-# additory/core/backends/__init__.py
-# Backend support system
-
-"""
-Backend Support Module
-
-This module provides universal backend support for dataframes:
-- Arrow bridge for cross-backend compatibility
-- Enhanced cuDF support with GPU acceleration
-- Memory management and cleanup
-"""
-
-# Backend functionality
-from .arrow_bridge import EnhancedArrowBridge, ArrowBridgeError
-from .cudf_bridge import get_cudf_bridge, EnhancedCuDFBridge, CuDFBridgeError
-
-__all__ = [
-    'EnhancedArrowBridge',
-    'ArrowBridgeError', 
-    'get_cudf_bridge',
-    'EnhancedCuDFBridge',
-    'CuDFBridgeError'
-]