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

additory/functions/transform/onehotencoding.py

@@ -0,0 +1,68 @@
+"""
+One-hot encode categorical columns.
+
+This module provides one-hot encoding functionality for the transform function.
+"""
+
+import polars as pl
+from typing import List, Union
+
+from additory.common.validation import validate_dataframe, validate_not_empty
+from additory.core.logging import Logger
+
+
+def perform_onehotencoding(
+    df: pl.DataFrame,
+    columns: Union[str, List[str]]
+) -> pl.DataFrame:
+    """
+    One-hot encode categorical columns.
+    
+    Args:
+        df: Input DataFrame
+        columns: Column(s) to encode
+        
+    Returns:
+        DataFrame with one-hot encoded columns
+        
+    Example:
+        >>> # Before: ['category'] = ['A', 'B', 'C']
+        >>> # After: ['category_A', 'category_B', 'category_C'] = [1, 0, 0]
+        >>> result = perform_onehotencoding(df, columns=['category'])
+    """
+    logger = Logger()
+    
+    # Validate
+    validate_dataframe(df)
+    validate_not_empty(df)
+    
+    # Normalize to list
+    columns_list = [columns] if isinstance(columns, str) else columns
+    
+    # Validate columns exist
+    missing = [col for col in columns_list if col not in df.columns]
+    if missing:
+        raise ValueError(f"Columns not found: {missing}")
+    
+    logger.info(f"One-hot encoding {len(columns_list)} columns")
+    
+    result = df
+    
+    # Encode each column
+    for col in columns_list:
+        # Get unique values
+        unique_vals = df[col].unique().drop_nulls().sort().to_list()
+        
+        # Create binary columns for each unique value
+        for val in unique_vals:
+            new_col_name = f"{col}_{val}"
+            result = result.with_columns(
+                (pl.col(col) == val).cast(pl.Int8).alias(new_col_name)
+            )
+        
+        # Drop original column
+        result = result.drop(col)
+    
+    logger.info(f"One-hot encoding complete: {len(result.columns)} columns")
+    
+    return result

additory/functions/transform/transpose.py

@@ -0,0 +1,42 @@
+"""
+Transpose DataFrame (rows ↔ columns).
+
+This module provides transpose functionality for the transform function.
+"""
+
+import polars as pl
+from additory.common.validation import validate_dataframe, validate_not_empty
+from additory.core.logging import Logger
+
+
+def perform_transpose(df: pl.DataFrame) -> pl.DataFrame:
+    """
+    Transpose DataFrame (swap rows and columns).
+    
+    Args:
+        df: Input DataFrame
+        
+    Returns:
+        Transposed DataFrame
+        
+    Example:
+        >>> # Before: 3 rows × 4 columns
+        >>> # After: 4 rows × 3 columns
+        >>> result = perform_transpose(df)
+    """
+    logger = Logger()
+    
+    # Validate
+    validate_dataframe(df)
+    validate_not_empty(df)
+    
+    logger.info(f"Transposing DataFrame: {df.shape[0]} rows × {df.shape[1]} columns")
+    
+    # Transpose using Polars
+    # The transpose method in Polars swaps rows and columns
+    # include_header=True keeps the original column names as the first column
+    result = df.transpose(include_header=True, header_name='column')
+    
+    logger.info(f"Transpose complete: {result.shape[0]} rows × {result.shape[1]} columns")
+    
+    return result

additory-0.1.1a1.dist-info/METADATA

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: additory
+Version: 0.1.1a1
+Summary: Data augmentation library with Polars backend
+Author-email: Additory Team <team@additory.dev>
+License: MIT
+Project-URL: Homepage, https://github.com/additory/additory
+Project-URL: Documentation, https://additory.readthedocs.io
+Project-URL: Repository, https://github.com/additory/additory
+Keywords: data,augmentation,polars,dataframe,synthetic
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: polars>=0.20.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: numpy>=1.24.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: hypothesis>=6.0.0; extra == "dev"
+Provides-Extra: gpu
+Requires-Dist: cudf>=23.0.0; extra == "gpu"
+
+# Additory v0.1.1a1
+
+Data augmentation library with Polars backend.
+
+## Installation
+
+```bash
+pip install additory
+```
+
+## Quick Start
+
+```python
+import additory
+import polars as pl
+
+# Add columns from reference DataFrame
+result = additory.add.to(df, reference_df, on='id', bring='price')
+
+# Transform columns
+result = additory.add.transform(df, mode='onehotencoding', columns=['category'])
+
+# Filter data
+result = additory.add.snapshot(df, where='age > 18')
+
+# Generate synthetic data
+result = additory.add.synthetic(df, rows=1000)
+
+# Analyze data
+result = additory.add.analyze(df, preset='quick')
+
+# Evaluate expressions
+result = additory.add.expressions(df, 'inbuilt:bmi')
+```
+
+## Features
+
+- **Blazing Fast**: Built on Polars for maximum performance
+- **Simple API**: Clean, intuitive API with `additory.add.function()` pattern
+- **Flexible**: Works with Polars, pandas, and cuDF
+- **Comprehensive**: 6 main functions covering all data augmentation needs
+- **Well Tested**: 1,023 tests with 90% coverage
+
+## Documentation
+
+Visit [https://additory.dev](https://additory.dev) for full documentation.
+
+## License
+
+MIT

additory-0.1.1a1.dist-info/RECORD

@@ -0,0 +1,62 @@
+additory/__init__.py,sha256=Ogj8nwpu_ERDNTNVGVxCLpI2O8LaPRI6YD9VC3mugVM,1810
+additory/common/__init__.py,sha256=b70Ksk5yOw5Lb1hyO3m0iEzoMGnBnxKAHkof9s1B7yw,957
+additory/common/column_selector.py,sha256=lWoK7sbrUy9m7F9Ya3zKjAvt7LCqJDjWfqv_qblAwqQ,6944
+additory/common/distributions.py,sha256=aE8oXUXKdtJooeLiRALV2l40lMkxRghvb4bIW30b4mM,11245
+additory/common/extractors.py,sha256=j10qoEXFWlKfCo0J7HfTC9dbE6eJefFUPaMAtIuQ_No,10756
+additory/common/knn_imputation.py,sha256=Z0g5MAc88_yqDEph-pP20k8Njw83CA7RmFErTF478Lo,10756
+additory/common/result.py,sha256=ug68SLnP9qS4qayYhWpFRvSfbz-hJV_GxrrFPLojdqE,12221
+additory/common/strategy_parser.py,sha256=PE6kaW8JNOGTPOdxbGfCp8LBvK03USfInAt-C1LiOSw,8226
+additory/common/unit_conversions.py,sha256=H3gaJTFFeIQJK3B7Xo23TX4cA0HfuPAWa79tuT5MciQ,9558
+additory/common/validation.py,sha256=oOnPR_kQ8Eh5oWyd9z33UglYjgMy0HXV8HOBFqJdV94,9862
+additory/core/__init__.py,sha256=ZOsJigoh78Mx_KlOPO-HquIYTyZK9jXQEw9AGFFg9us,885
+additory/core/backend.py,sha256=_EknNteiK5gNJXmWrrTQRMYWQu5eCQEbfkZOL-uexio,6407
+additory/core/config.py,sha256=Rs9A8wMPFcK0-n07L1I28jVCMJwO8_yUaO4k6t6OOHs,5826
+additory/core/logging.py,sha256=o5mjEQywAghOO0XdMpyHxOcx-m-RHh7YJo4N0XjeRHI,6811
+additory/core/memory_manager.py,sha256=xl9ROwHq55th5KAXbC2bf4l5z-6a1dARz1ccUS8g8zA,5898
+additory/expressions/__init__.py,sha256=V02W3bbG4Nslh3hpCGZvmp6t6g8_Qp2Y8I6KrcaKF7M,99
+additory/expressions/compiler.py,sha256=cj97jFQpOLkn-7KAqZHXJ0em3CM1rd0a9njkJ2CXDPA,15774
+additory/expressions/engine.py,sha256=FtM0oB0RI06Zx1tsX68wAKx8uutzHrgxO-bnuQBTdz8,10397
+additory/expressions/integrity.py,sha256=c52D4GrDAfEZhZAbJuzmkAZ-r-VljtrnYV_PTd2WCio,4769
+additory/expressions/loader.py,sha256=gx9SVTquQJjqUVDHkDmk04UglPGdto0oehiDk5Xr_F4,7694
+additory/expressions/parser.py,sha256=_nFam3o-O3wNLptb--XLFkKVACE1mnC_dW6NiVBGwNQ,12907
+additory/expressions/resolver.py,sha256=AblxnXrSQvaSQYzNKBE-VdJC9l0kyj1nQhUd3KYMB78,8021
+additory/functions/__init__.py,sha256=ZBYLMHRabOvOGTI1ORTRzYJcAGuYWJJiwiDU_P8xt8Y,25
+additory/functions/analyze/__init__.py,sha256=OZipi8VCr45Fnd-t3cVR85JhEn6_O4oy3RIVmYDE3Yk,4645
+additory/functions/analyze/cardinality.py,sha256=_u4NUGs_FjtYZlO5Wdf1KZLkC2E-NXjPf7WbC6jUdh4,2151
+additory/functions/analyze/correlations.py,sha256=jnZrN05HG4bqR9b_0gQmytx4G2CjiZ_k5sAcK_x5A1o,2159
+additory/functions/analyze/distributions.py,sha256=lPHPM64RolwJQ_AhhtdZBCsxguzkAfJQDme1JL2sx2U,1880
+additory/functions/analyze/duplicates.py,sha256=klL4Agi_iyqU7puQu5pK9ljTemN_A32fPFkTH6pWeYM,1486
+additory/functions/analyze/features.py,sha256=Gx6irn2y6C5Ld-Evdsu2YTc_GKvSzwlVgmEkFOrcFJw,1968
+additory/functions/analyze/imputation.py,sha256=3aFzGsGbLcB5vzqVUh0N4i85S4wQ5TpF-C-jvRlGsys,2050
+additory/functions/analyze/outliers.py,sha256=uPEy7pu4TcAmY1CD6thytbL21QHMAEqIMTbqkmwQtYE,2078
+additory/functions/analyze/patterns.py,sha256=gLGxTn1g0z5W2aHuXXWRGrffA2q0a9NPi79RaaWlXcc,1937
+additory/functions/analyze/presets.py,sha256=KBNTlPo5A85hxOEsw0pWpisDbWOxyNOGbIh86qDzhAc,1740
+additory/functions/analyze/quality.py,sha256=0l6rqTEowrKpXvFD1C-2Fh6GbryJFk3o9zxZ3eNPWFE,1886
+additory/functions/analyze/timeseries.py,sha256=-qgBBieqKzvgXK20Zn5VR8NtCgDUg99yIhRQvAZK3do,1606
+additory/functions/analyze/types.py,sha256=8CK7XyzWgkjm1U-_8zyqmUV3xbeSp69ZUsItV6ffyoQ,1534
+additory/functions/expressions/__init__.py,sha256=vwjnlSojjv-ommwXlzztQecRtZj1EViUNrDtbYSOIKM,4499
+additory/functions/snapshot/__init__.py,sha256=kjp53VzQ1hf9r_WJCRZ9PyaU35YFwzcpV0b1VFWdwLs,2525
+additory/functions/snapshot/filter.py,sha256=IWSUpX945KGCIJ6xUmoUcD86EHEqLKKC8_LHHxTyUig,3136
+additory/functions/synthetic/__init__.py,sha256=J67FkrgfebEWc0abwq3sz0Aj3UY0m4mTDn7mbxXrGfg,3728
+additory/functions/synthetic/mode_detector.py,sha256=3IueJBSaMmGAEmVvZBmRlLHCvu52sI4edE0HsqbAIvw,1332
+additory/functions/synthetic/strategies/__init__.py,sha256=XjLa6W6DSHK1Z4x1LhzpfAi5BYMVmksYCABpuqcRPM8,30
+additory/functions/synthetic/strategies/advanced.py,sha256=I4mZiHWGKRTwTDCQhdE5xvqW-CC9y79Br_fMUeL7uQ8,901
+additory/functions/synthetic/strategies/augmentative.py,sha256=H6T2FFyYBGhv58VmLVf9LS1-2_kih4lMJi8VH4cqzeM,4862
+additory/functions/synthetic/strategies/generative.py,sha256=VZNnCgkzAuTZVjcDH7G2UaDJsWmnGAouWyWIlJ_1vhc,4967
+additory/functions/synthetic/strategies/presets.py,sha256=FxeBAo2KYXb-n2QGf5nW8amNDA7tSSVzo1fzCE6HzF0,2917
+additory/functions/to/__init__.py,sha256=XlG_qayorYwSceKKJy95CiCyiG067WUUwQjSNNVmfYM,6217
+additory/functions/to/lookup.py,sha256=csVndLKcSYqSlKHqA4MzPE5-7E1Yxv-WKAfclDuen4o,10126
+additory/functions/to/merge.py,sha256=Y-OcMT3J9Wubz8rGNjiPwG2CjRGEGOzVMeeG_A_LbR0,5320
+additory/functions/to/sort.py,sha256=QVSSVWdYx9EpFhVjZAoCL_cUd2b6ASMS2CjlNzhhJ7w,2506
+additory/functions/to/summarize.py,sha256=1l8k8Wjl4W6VDoGHcHz6YoQsTqiAHkWwvwlPiWsEK1k,4816
+additory/functions/transform/__init__.py,sha256=5XuEyn9LsS8pyxntEnzV8KF2YBernRw7bXkjf9owp-o,5468
+additory/functions/transform/datetime.py,sha256=LUeh7kwzdYfw8veaQE_U1IXM0P-DKpRPJBHhVRnu2RU,2214
+additory/functions/transform/extract.py,sha256=XF1ZA0Pdnxri1sh0J6OJDUQwXK5V4FkhJqDdUI0fBUg,2616
+additory/functions/transform/harmonize.py,sha256=TY0ZYedhGh95GVpbG1-EgauT2e__amBKZkGDeNf9nVk,3150
+additory/functions/transform/knn.py,sha256=wWay5L8Vgg8nDf_HwzJ7PSa27RdsvfvKLUqYw1125Gk,1676
+additory/functions/transform/onehotencoding.py,sha256=LibYOfphxrESKNNm-XTByBkjOhaKeitTfvO5mVVC8Rc,1891
+additory/functions/transform/transpose.py,sha256=Jy-50GgQbBsidBHY-F9YIBmwai1bPSSNzkN5X8n-sUk,1177
+additory-0.1.1a1.dist-info/METADATA,sha256=R2A_EU0OTYn5OFJUrSPQfrDgAzs8YWta0Z0TY6b5jn4,2432
+additory-0.1.1a1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+additory-0.1.1a1.dist-info/top_level.txt,sha256=4zphwXiI6HEl40fdjMXoUp9JNIqQ-tgYWeo3zqKqvEk,9
+additory-0.1.1a1.dist-info/RECORD,,

additory/analysis/__init__.py

@@ -1,48 +0,0 @@
-"""
-Analysis Module for Data Profiling
-
-Provides comprehensive data analysis capabilities:
-- Distribution detection and fitting
-- Correlation analysis
-- Cardinality analysis
-- Data quality metrics
-- Data profiling and scanning
-"""
-
-from additory.analysis.distributions import (
-    detect_distributions,
-    fit_distribution,
-    DistributionFit
-)
-from additory.analysis.correlations import (
-    calculate_correlations,
-    CorrelationResult
-)
-from additory.analysis.cardinality import (
-    analyze_cardinality,
-    CardinalityInfo
-)
-from additory.analysis.quality import (
-    analyze_quality,
-    QualityMetrics
-)
-from additory.analysis.scan import (
-    scan,
-    ScanResult,
-    ColumnInfo
-)
-
-__all__ = [
-    'detect_distributions',
-    'fit_distribution',
-    'DistributionFit',
-    'calculate_correlations',
-    'CorrelationResult',
-    'analyze_cardinality',
-    'CardinalityInfo',
-    'analyze_quality',
-    'QualityMetrics',
-    'scan',
-    'ScanResult',
-    'ColumnInfo',
-]

additory/analysis/cardinality.py

@@ -1,126 +0,0 @@
-"""
-Cardinality Analysis
-
-Analyzes unique values and cardinality of columns.
-"""
-
-from dataclasses import dataclass
-from typing import List, Any, Dict
-import polars as pl
-
-
-@dataclass
-class CardinalityInfo:
-    """Cardinality information for a column."""
-    unique_count: int
-    total_count: int
-    ratio: float
-    top_values: List[tuple]  # [(value, count), ...]
-    classification: str  # 'constant', 'low', 'medium', 'high'
-    
-    def __repr__(self) -> str:
-        return (
-            f"CardinalityInfo(unique={self.unique_count}, "
-            f"ratio={self.ratio:.2%}, class='{self.classification}')"
-        )
-
-
-def classify_cardinality(ratio: float, unique_count: int) -> str:
-    """
-    Classify cardinality based on ratio and unique count.
-    
-    Args:
-        ratio: Unique count / total count
-        unique_count: Number of unique values
-        
-    Returns:
-        Classification: 'constant', 'low', 'medium', 'high'
-    """
-    if unique_count == 1:
-        return 'constant'
-    elif ratio >= 0.5:
-        return 'high'
-    elif ratio >= 0.1:
-        return 'medium'
-    else:
-        return 'low'
-
-
-def analyze_cardinality(
-    df: pl.DataFrame,
-    column: str,
-    top_n: int = 10
-) -> CardinalityInfo:
-    """
-    Analyze cardinality of a column.
-    
-    Args:
-        df: Polars DataFrame
-        column: Column name
-        top_n: Number of top values to return
-        
-    Returns:
-        CardinalityInfo object
-    """
-    # Get total count (excluding nulls)
-    total_count = df[column].count()
-    
-    if total_count == 0:
-        return CardinalityInfo(
-            unique_count=0,
-            total_count=0,
-            ratio=0.0,
-            top_values=[],
-            classification='constant'
-        )
-    
-    # Get unique count (excluding nulls)
-    unique_count = df[column].drop_nulls().n_unique()
-    
-    # Calculate ratio
-    ratio = unique_count / total_count if total_count > 0 else 0.0
-    
-    # Get top values
-    value_counts = (
-        df
-        .group_by(column)
-        .agg(pl.len().alias('count'))
-        .sort('count', descending=True)
-        .head(top_n)
-    )
-    
-    top_values = [
-        (row[column], row['count'])
-        for row in value_counts.iter_rows(named=True)
-    ]
-    
-    # Classify
-    classification = classify_cardinality(ratio, unique_count)
-    
-    return CardinalityInfo(
-        unique_count=unique_count,
-        total_count=total_count,
-        ratio=ratio,
-        top_values=top_values,
-        classification=classification
-    )
-
-
-def analyze_all_cardinality(
-    df: pl.DataFrame,
-    top_n: int = 10
-) -> Dict[str, CardinalityInfo]:
-    """
-    Analyze cardinality for all columns.
-    
-    Args:
-        df: Polars DataFrame
-        top_n: Number of top values to return per column
-        
-    Returns:
-        Dictionary mapping column names to CardinalityInfo
-    """
-    return {
-        col: analyze_cardinality(df, col, top_n)
-        for col in df.columns
-    }

additory/analysis/correlations.py

@@ -1,124 +0,0 @@
-"""
-Correlation Analysis
-
-Calculates correlations between numeric columns.
-"""
-
-from dataclasses import dataclass
-from typing import Dict, List, Tuple
-import numpy as np
-import polars as pl
-from scipy import stats
-
-
-@dataclass
-class CorrelationResult:
-    """Result of correlation analysis between two columns."""
-    column1: str
-    column2: str
-    correlation: float
-    method: str
-    p_value: float = 0.0
-
-
-def calculate_correlations(
-    df: pl.DataFrame,
-    columns: List[str],
-    methods: List[str] = ['pearson', 'spearman'],
-    threshold: float = 0.0
-) -> List[CorrelationResult]:
-    """
-    Calculate correlations between numeric columns with optimized batch processing.
-    
-    Args:
-        df: Polars DataFrame
-        columns: List of numeric column names
-        methods: Correlation methods to calculate
-        threshold: Minimum correlation threshold to report
-        
-    Returns:
-        List of CorrelationResult objects (changed from single object for scan.py compatibility)
-    """
-    from concurrent.futures import ThreadPoolExecutor, as_completed
-    import itertools
-    
-    if len(columns) < 2:
-        return []
-    
-    # Pre-extract all data as numpy arrays for efficiency
-    data_arrays = {}
-    for col in columns:
-        arr = df[col].to_numpy()
-        data_arrays[col] = arr
-    
-    # Generate all column pairs
-    column_pairs = list(itertools.combinations(columns, 2))
-    
-    results = []
-    
-    def calculate_pair_correlations(pair):
-        """Calculate correlations for a single pair of columns."""
-        col1, col2 = pair
-        arr1 = data_arrays[col1]
-        arr2 = data_arrays[col2]
-        
-        # Get common non-NaN indices
-        mask = ~(np.isnan(arr1) | np.isnan(arr2))
-        arr1_clean = arr1[mask]
-        arr2_clean = arr2[mask]
-        
-        if len(arr1_clean) < 3:
-            return None
-        
-        pair_results = {}
-        
-        # Calculate all requested methods for this pair
-        for method in methods:
-            try:
-                if method == 'pearson':
-                    corr, p_value = stats.pearsonr(arr1_clean, arr2_clean)
-                elif method == 'spearman':
-                    corr, p_value = stats.spearmanr(arr1_clean, arr2_clean)
-                elif method == 'kendall':
-                    corr, p_value = stats.kendalltau(arr1_clean, arr2_clean)
-                else:
-                    continue
-                
-                # Only include if above threshold
-                if abs(corr) >= threshold:
-                    pair_results[method] = {
-                        'correlation': float(corr),
-                        'p_value': float(p_value)
-                    }
-            except Exception:
-                continue
-        
-        if pair_results:
-            return (col1, col2, pair_results)
-        return None
-    
-    # Use ThreadPoolExecutor for parallel processing of correlation pairs
-    with ThreadPoolExecutor(max_workers=min(4, len(column_pairs))) as executor:
-        # Submit all pair processing tasks
-        future_to_pair = {
-            executor.submit(calculate_pair_correlations, pair): pair 
-            for pair in column_pairs
-        }
-        
-        # Collect results as they complete
-        for future in as_completed(future_to_pair):
-            result = future.result()
-            if result is not None:
-                col1, col2, pair_results = result
-                
-                # Create CorrelationResult objects for each method
-                for method, corr_data in pair_results.items():
-                    results.append(CorrelationResult(
-                        column1=col1,
-                        column2=col2,
-                        correlation=corr_data['correlation'],
-                        method=method,
-                        p_value=corr_data['p_value']
-                    ))
-    
-    return results