feat: Complete factor engine with 80+ operators

- Core: Factor class, context management, lazy evaluation
- Time-series: ts_mean, ts_rank, ts_corr, ts_skewness, ts_kurtosis, etc.
- Cross-sectional: rank, zscore, scale, normalize, quantile, etc.
- Math: log, sqrt, power, clip, where, etc.
- Neutralization: vector_neut, regression_neut, group_demean, winsorize, etc.
- ~80x faster than pandas-based implementation
- MIT License

Author: quantbai

README.md

@@ -1,22 +1,47 @@
 # Elvers
 
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
+[![Polars](https://img.shields.io/badge/Polars-1.35+-green.svg)](https://pola.rs/)
+
 High-performance multi-factor quantitative framework built on Polars.
 
 Named after **ELVES** (Emission of Light and Very Low Frequency perturbations due to Electromagnetic Pulse Sources), the atmospheric lightning phenomenon that occurs at extreme speed.
 
-## Features (Coming Soon)
+## Features
 
 - Pure Polars-based lazy evaluation
 - Expression-based factor computation
-- Lightning-fast backtesting engine
-- Professional-grade IC/ICIR analysis
+- ~80x faster than pandas-based alternatives
+- Professional-grade operators (time-series, cross-sectional, neutralization)
 
 ## Installation
 
 ```bash
 pip install elvers
 ```
 
+## Quick Start
+
+```python
+from elvers import load, col, collect_all
+from elvers import ts_mean, ts_rank, rank, zscore
+
+load("data.csv")
+
+close = col("close")
+momentum = ts_rank(close, 20)
+alpha = zscore(rank(momentum))
+
+result = collect_all(alpha)
+```
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
 ## Author
 
 Phantom Management
+
+

elvers/__init__.py

@@ -1,13 +1,75 @@
 """
-Elvers - High-performance multi-factor quantitative framework.
+Elvers - Polars-native factor expression engine.
 
-Built on Polars for lightning-fast factor research and backtesting.
-Named after ELVES (Emission of Light and Very Low Frequency perturbations),
-the atmospheric lightning phenomenon.
+Ultra-minimal, maximum performance WQ-style factor expressions.
+Built on Polars for lightning-fast factor research.
 
 Author: Phantom Management
 """
 
-__version__ = "0.0.1"
+__version__ = "0.1.0"
 __author__ = "Phantom Management"
 
+from .core import (
+    Factor,
+    load,
+    lf,
+    col,
+    collect,
+    collect_all,
+    to_csv,
+    to_pandas,
+)
+
+from .ops import (
+    add, sub, mul, div, reverse,
+    
+    ts_delay, ts_delta, ts_mean, ts_sum, ts_std_dev,
+    ts_min, ts_max, ts_median, ts_rank, ts_skewness, ts_kurtosis,
+    ts_zscore, ts_corr, ts_covariance, ts_product,
+    ts_arg_max, ts_arg_min, ts_decay_linear, ts_av_diff, ts_scale,
+    ts_var, ts_quantile_val, ts_cv, ts_autocorr,
+    ts_return, ts_log_return, ts_pct_change,
+    ts_count_nulls, ts_step,
+    ts_ewm_mean, ts_ewm_std, ts_ewm_var,
+    
+    rank, zscore, mean, median, sum_, std,
+    scale, normalize, quantile, spread, signal,
+    
+    log, ln, sqrt, abs_, sign, power, signed_power,
+    inverse, s_log_1p, maximum, minimum, where,
+    clip, nan_to_value, fill_null,
+    
+    vector_neut, regression_neut, demean, market_neut,
+    group_demean, group_rank, group_zscore, group_scale,
+    group_normalize, winsorize, mad_winsorize,
+)
+
+__all__ = [
+    "__version__",
+    "__author__",
+    "Factor",
+    "load", "lf", "col", "collect", "collect_all", "to_csv", "to_pandas",
+    
+    "add", "sub", "mul", "div", "reverse",
+    
+    "ts_delay", "ts_delta", "ts_mean", "ts_sum", "ts_std_dev",
+    "ts_min", "ts_max", "ts_median", "ts_rank", "ts_skewness", "ts_kurtosis",
+    "ts_zscore", "ts_corr", "ts_covariance", "ts_product",
+    "ts_arg_max", "ts_arg_min", "ts_decay_linear", "ts_av_diff", "ts_scale",
+    "ts_var", "ts_quantile_val", "ts_cv", "ts_autocorr",
+    "ts_return", "ts_log_return", "ts_pct_change",
+    "ts_count_nulls", "ts_step",
+    "ts_ewm_mean", "ts_ewm_std", "ts_ewm_var",
+    
+    "rank", "zscore", "mean", "median", "sum_", "std",
+    "scale", "normalize", "quantile", "spread", "signal",
+    
+    "log", "ln", "sqrt", "abs_", "sign", "power", "signed_power",
+    "inverse", "s_log_1p", "maximum", "minimum", "where",
+    "clip", "nan_to_value", "fill_null",
+    
+    "vector_neut", "regression_neut", "demean", "market_neut",
+    "group_demean", "group_rank", "group_zscore", "group_scale",
+    "group_normalize", "winsorize", "mad_winsorize",
+]

elvers/core/__init__.py

@@ -0,0 +1,15 @@
+"""Core module exports."""
+
+from .factor import Factor
+from .context import load, lf, col, collect, collect_all, to_csv, to_pandas
+
+__all__ = [
+    "Factor",
+    "load",
+    "lf",
+    "col",
+    "collect",
+    "collect_all",
+    "to_csv",
+    "to_pandas",
+]

elvers/core/context.py

@@ -0,0 +1,123 @@
+"""Global LazyFrame context management."""
+
+from __future__ import annotations
+import polars as pl
+from typing import Union
+from pathlib import Path
+
+from .factor import Factor
+
+
+_LF: pl.LazyFrame | None = None
+
+
+def load(source: Union[str, Path, pl.LazyFrame, pl.DataFrame]) -> pl.LazyFrame:
+    """Load data and set as global LazyFrame context.
+    
+    Data is automatically sorted by (symbol, timestamp) to ensure
+    correct per-symbol rolling operations.
+    
+    Parameters
+    ----------
+    source : str, Path, LazyFrame, or DataFrame
+        CSV path, Parquet path, or existing Polars object
+    
+    Returns
+    -------
+    pl.LazyFrame
+        The loaded LazyFrame (also set as global context)
+    """
+    global _LF
+    
+    if isinstance(source, pl.LazyFrame):
+        _LF = source.sort(["symbol", "timestamp"])
+    elif isinstance(source, pl.DataFrame):
+        _LF = source.lazy().sort(["symbol", "timestamp"])
+    elif isinstance(source, (str, Path)):
+        path = str(source)
+        if path.endswith(".parquet"):
+            _LF = pl.scan_parquet(path).sort(["symbol", "timestamp"])
+        else:
+            _LF = pl.scan_csv(path).sort(["symbol", "timestamp"])
+    else:
+        raise TypeError(f"Unsupported source type: {type(source)}")
+    
+    return _LF
+
+
+def lf() -> pl.LazyFrame:
+    """Get the current global LazyFrame context."""
+    if _LF is None:
+        raise RuntimeError("No data loaded. Call load() first.")
+    return _LF
+
+
+def col(name: str) -> Factor:
+    """Create a Factor from a column name.
+    
+    This is the primary entry point for accessing data columns.
+    
+    Parameters
+    ----------
+    name : str
+        Column name in the loaded data
+    
+    Returns
+    -------
+    Factor
+        Factor wrapping pl.col(name)
+    """
+    return Factor(pl.col(name), name)
+
+
+def collect(*factors: Factor) -> pl.DataFrame:
+    """Execute computation and return DataFrame with factor columns.
+    
+    Parameters
+    ----------
+    *factors : Factor
+        Factors to compute
+    
+    Returns
+    -------
+    pl.DataFrame
+        DataFrame with timestamp, symbol, and factor columns
+    """
+    if _LF is None:
+        raise RuntimeError("No data loaded. Call load() first.")
+    
+    base_cols = [pl.col("timestamp"), pl.col("symbol")]
+    factor_cols = [f.expr.alias(f.name) for f in factors]
+    
+    return _LF.select(base_cols + factor_cols).collect()
+
+
+def collect_all(*factors: Factor) -> pl.DataFrame:
+    """Execute computation and return DataFrame with all original columns plus factors.
+    
+    Parameters
+    ----------
+    *factors : Factor
+        Factors to compute
+    
+    Returns
+    -------
+    pl.DataFrame
+        DataFrame with all original columns plus factor columns
+    """
+    if _LF is None:
+        raise RuntimeError("No data loaded. Call load() first.")
+    
+    factor_cols = [f.expr.alias(f.name) for f in factors]
+    
+    return _LF.with_columns(factor_cols).collect()
+
+
+def to_csv(*factors: Factor, path: str) -> None:
+    """Compute factors and write to CSV."""
+    collect(*factors).write_csv(path)
+
+
+def to_pandas(*factors: Factor):
+    """Compute factors and convert to pandas DataFrame."""
+    return collect(*factors).to_pandas()