pycheck-neuron 1.0.1__tar.gz → 1.0.3__tar.gz

{pycheck_neuron-1.0.1/pycheck_neuron.egg-info → pycheck_neuron-1.0.3}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: pycheck-neuron
-Version: 1.0.1
-Summary: 32-rule static AST analyzer catching temporal lookahead bias, causal confusion, and uncertainty bugs in Python ML code. Zero dependencies.
+Version: 1.0.3
+Summary: 33-rule static AST analyzer catching temporal lookahead bias, causal confusion, and uncertainty bugs in Python ML code. Zero dependencies.
 Author: NEURON Team
 Author-email: Fayo Ibrahim <fayo@neuron-lab.org>
 License-Expression: MIT
@@ -38,7 +38,7 @@ Dynamic: license-file
 
 # PyCheck — ML Safety Analyzer
 
-**30 rules. Zero dependencies. Catches the bugs that cost millions.**
+**33 rules. Zero dependencies. Catches the bugs that cost millions.**
 
 PyCheck is a static AST analyzer that detects **temporal lookahead bias**, **causal confusion**, and **unguarded uncertainty** in Python ML and trading scripts — before you run a single line of code.
 
@@ -68,7 +68,7 @@ PyCheck catches all three before execution:
 =================================================================
   PyCheck — NEURON ML Safety Analyzer
   Scanning: strategy.py
-  Rules: 30 active
+  Rules: 33 active + Data Flow & Provenance Engine
 =================================================================
 
   ERROR[T001]: .shift(-1) accesses data 1 rows INTO THE FUTURE
@@ -100,7 +100,7 @@ PyCheck catches all three before execution:
 
 ## What It Catches
 
-### Temporal Leak Rules (17 rules — `T001`–`T017`)
+### Temporal Leak Rules (18 rules — `T001`–`T018`)
 
 | Rule | What It Catches | Severity |
 |------|----------------|----------|
@@ -121,6 +121,7 @@ PyCheck catches all three before execution:
 | `T015` | Negative `.shift()` inside `groupby().transform()` | **Error** |
 | `T016` | `pd.merge_asof()` with `direction='nearest'` or `'forward'` | **Error** |
 | `T017` | Target laundering & un-split target encoding (`regime_success_rate`) | **Error** |
+| `T018` | In-sample target encoding (`groupby().transform('mean')`, `TargetEncoder(cv=None)`) | **Error** |
 
 ### Causal Confusion Rules (7 rules — `C001`–`C007`)
 
@@ -154,17 +155,30 @@ PyCheck catches all three before execution:
 
 ---
 
-## Taint Flow Analysis
+## Data Flow & Provenance Tracking Engine
 
-Beyond pattern matching, PyCheck traces how future-contaminated data **flows through your codebase**:
+Beyond syntactic pattern matching, PyCheck includes a two-pass AST data flow engine that traces data lineage across reassignments, aliases, joins, and helper functions:
 
+### 1. Future Taint Propagation (`F001`)
+Traces future-leaked signals across multi-level variable indirection:
 ```python
-future_ret = df['close'].shift(-1)        # Tainted source
-signal     = future_ret - df['close']     # Taint propagates
-model.fit(X, signal)                      # ERROR: tainted label reaches .fit() sink
+future_ret = df['close'].shift(-1)        # Future taint source
+signal     = future_ret - df['close']     # Taint propagates through arithmetic
+model.fit(X, signal)                      # ERROR[F001]: tainted data reaches .fit() sink
 ```
 
-The taint engine follows assignments across three levels of variable indirection.
+### 2. Partition Provenance & Contamination (`F002`)
+Identifies training partitions, test partitions, and cross-fold leakage:
+```python
+# Naming conventions alone are insufficient when variables get reassigned:
+X_train = pd.concat([X_train, X_test])    # Tainted with test fold data
+scaler.fit_transform(X_train)             # ERROR[F002]: test partition data in training sink
+```
+
+PyCheck follows:
+- **Concatenation & Merges**: `pd.concat`, `np.concatenate`, `.append()`, `.merge()`, `.join()`.
+- **Aliases**: `X_eval = X_test` followed by combination or fitting.
+- **Inter-Procedural Helper Functions**: Functions returning expressions derived from test partition arguments.
 
 ---
 
@@ -175,7 +189,7 @@ pycheck script.py              # Errors + warnings (default)
 pycheck script.py --info       # Include info-level diagnostics
 pycheck script.py --quiet      # Errors only
 pycheck script.py --json       # JSON output — pipe into CI/CD
-pycheck --list                 # List all 30 rules
+pycheck --list                 # List all 33 rules
 pycheck --help
 ```
 
@@ -269,21 +283,43 @@ The `pycheck-vscode` extension gives you **real-time red/yellow squiggles** as y
 
 ---
 
-## Beyond Python: the NEURON Language
+---
+
+## Automated CI/CD Gatekeeping & Invariant Verification
+
+For quant teams, machine learning desks, and algorithmic trading funds, **PyCheck** provides continuous compliance and automated gatekeeping:
+
+* **Automated PR / MR Gatekeeping**: GitHub App & GitLab integration that automatically blocks pull requests containing temporal leaks, lookahead joins, or cross-fold contamination before they reach production.
+* **Proof-of-Causality Audit Certificates**: Cryptographically verifiable backtest audit reports (PDF & JSON) certifying that quantitative strategies and feature pipelines are provably free of temporal lookahead bias for LP allocators and risk committees.
+* **Firm-Wide Policy Engine**: Author proprietary firm-specific invariants, restrict internal data feed schemas, and monitor leak incident trends across 50+ quant researchers.
+* **Air-Gapped & On-Prem Deployment**: Private VPC and on-premise Kubernetes support for proprietary trading strategies that cannot leave your internal network.
+
+> See the [Enterprise CI/CD Integration](#enterprise-cicd--gitlab-integration) section or visit [https://github.com/neuronlabs-ai/pycheck](https://github.com/neuronlabs-ai/pycheck) to learn more or request institutional access.
+
+---
+
+## PyCheck & NEURON: Working Hand-in-Hand
 
-PyCheck catches these bugs **after you write them**.
+PyCheck and the **[NEURON Programming Language](https://github.com/neuronlabs-ai/neuron-lang)** represent a dual-defense ecosystem against algorithmic failures:
 
-[NEURON](https://github.com/neuronlabs-ai/neuron-lang) prevents them **before the program compiles** — by encoding time horizons, causal modes, and uncertainty directly into the type system:
+| System | Role | Mechanism | Guarantee |
+| :--- | :--- | :--- | :--- |
+| **PyCheck** | **The Diagnostic Layer** for existing Python code | 2-pass AST data flow & provenance static analysis | Flags known leakage patterns & contamination in seconds |
+| **NEURON** | **The Permanent Cure** for future algorithmic systems | Type-theoretic stochastic filtration proofs ($\mathcal{F}_t$) | **100% mathematical compile-time proof**; zero runtime overhead |
 
+### The Migration Pathway
+1. **Audit Today with PyCheck**: Run `pycheck` across existing Python/Pandas/PyTorch repositories to identify lookahead leaks and target laundering.
+2. **Transpile with `py2nr`**: Use the automated transpiler to convert validated feature pipelines into typed NEURON modules.
+3. **Deploy with 100% Compile-Time Safety**:
 ```python
-# In NEURON, this is a compile-time error — not a runtime surprise:
+# In NEURON, lookahead bias is a compile-time type error — not a runtime surprise:
 fn strategy(prices: Temporal[Tensor, 0]) -> Tensor:
-  let future = prices.shift(-1)
-  # error[TemporalLeak]: shift(-1) produces offset +1 > 0
-  # Lookahead bias detected at compile time.
+  let future = prices.shift(1)  # NEURON uses causal algebraic offsets (+1 is future)
+  # error[TemporalLeak]: operation requires filtration F_{t+1}, but context is F_t (offset 0)
+  # Lookahead bias rejected at compile time before execution.
 ```
 
-For 100% compile-time temporal proofs, type-checked do-calculus, and native ahead-of-time compilation, see the [NEURON language](https://github.com/neuronlabs-ai/neuron-lang).
+Explore the language: [https://github.com/neuronlabs-ai/neuron-lang](https://github.com/neuronlabs-ai/neuron-lang)
 
 ---