pycheck-neuron 1.1.2__tar.gz → 1.2.0__tar.gz

{pycheck_neuron-1.1.2/pycheck_neuron.egg-info → pycheck_neuron-1.2.0}/PKG-INFO

@@ -1,21 +1,20 @@
 Metadata-Version: 2.4
 Name: pycheck-neuron
-Version: 1.1.2
+Version: 1.2.0
 Summary: 37-rule static AST analyzer catching temporal lookahead bias, causal confusion, and uncertainty bugs in Python ML code. Zero dependencies.
 Author-email: Fayo Ibrahim <contact@neuron-lab.org>
-License-Expression: MIT
+License: MIT
 Project-URL: Homepage, https://github.com/neuronlabs-ai/pycheck
 Project-URL: Documentation, https://github.com/neuronlabs-ai/pycheck#readme
 Project-URL: Repository, https://github.com/neuronlabs-ai/pycheck
 Project-URL: Bug Tracker, https://github.com/neuronlabs-ai/pycheck/issues
 Keywords: machine-learning,data-leakage,temporal-bias,lookahead-bias,backtesting,quantitative-finance,algorithmic-trading,linter,static-analysis,causal-inference,time-series,pandas,sklearn,scikit-learn,uncertainty,neuron,ml-safety,data-science,feature-engineering
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-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
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Software Development :: Quality Assurance
 Classifier: Topic :: Software Development :: Testing
@@ -26,7 +25,7 @@ Classifier: Intended Audience :: Financial and Insurance Industry
 Classifier: Intended Audience :: Developers
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
-Requires-Python: >=3.7
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: test
@@ -239,6 +238,29 @@ Returns structured output for automated pipelines:
 ]
 ```
 
+### Project Configuration (`pyproject.toml` or `.pycheck.toml`)
+
+PyCheck automatically detects and respects project-level configuration in `pyproject.toml` or `.pycheck.toml`:
+
+```toml
+[tool.pycheck]
+ignore = ["C001", "U002"]
+exclude = ["tests", "legacy"]
+info = false
+quiet = false
+```
+
+Or override dynamically via CLI flags:
+```bash
+pycheck . --ignore C001,U002 --select T001,T010 -c pyproject.toml
+```
+
+### Modern Quant Stack Support (Polars, PyTorch, JAX)
+
+PyCheck natively guards both Pandas and modern high-performance quantitative computing pipelines:
+- **Polars Expression Engine**: Detects lookaheads in `pl.col("close").shift(n=-1)`, `pct_change(n=-1)`, `diff(n=-1)`, `backward_fill()`, `fill_null(strategy="backward")`, `rolling_mean(center=True)`, and `join_asof(strategy="forward" | "nearest")`.
+- **Deep Learning Time Series**: Detects future tensor index rotation via `torch.roll(tensor, shifts=-N)` and `jnp.roll(arr, -N)`.
+
 ### Exit Codes
 
 - `0` — Verified clean / no errors found

{pycheck_neuron-1.1.2 → pycheck_neuron-1.2.0}/README.md

@@ -200,6 +200,29 @@ Returns structured output for automated pipelines:
 ]
 ```
 
+### Project Configuration (`pyproject.toml` or `.pycheck.toml`)
+
+PyCheck automatically detects and respects project-level configuration in `pyproject.toml` or `.pycheck.toml`:
+
+```toml
+[tool.pycheck]
+ignore = ["C001", "U002"]
+exclude = ["tests", "legacy"]
+info = false
+quiet = false
+```
+
+Or override dynamically via CLI flags:
+```bash
+pycheck . --ignore C001,U002 --select T001,T010 -c pyproject.toml
+```
+
+### Modern Quant Stack Support (Polars, PyTorch, JAX)
+
+PyCheck natively guards both Pandas and modern high-performance quantitative computing pipelines:
+- **Polars Expression Engine**: Detects lookaheads in `pl.col("close").shift(n=-1)`, `pct_change(n=-1)`, `diff(n=-1)`, `backward_fill()`, `fill_null(strategy="backward")`, `rolling_mean(center=True)`, and `join_asof(strategy="forward" | "nearest")`.
+- **Deep Learning Time Series**: Detects future tensor index rotation via `torch.roll(tensor, shifts=-N)` and `jnp.roll(arr, -N)`.
+
 ### Exit Codes
 
 - `0` — Verified clean / no errors found

{pycheck_neuron-1.1.2 → pycheck_neuron-1.2.0}/pycheck/__init__.py

@@ -3,7 +3,7 @@ PyCheck — NEURON ML Safety Analyzer
 Catches temporal leaks, causal confusion, and uncertainty bugs in Python ML scripts.
 """
 
-__version__ = "1.1.2"
+__version__ = "1.2.0"
 
 from pycheck.analyzer import analyze_file, analyze_code, format_output
 from pycheck.rules import ALL_RULES, RULES_BY_CODE

{pycheck_neuron-1.1.2 → pycheck_neuron-1.2.0}/pycheck/analyzer.py

@@ -7,7 +7,7 @@ causal confusion, and uncertainty bugs in Python ML scripts.
 import ast
 import sys
 import json
-from typing import List, Tuple
+from typing import List, Tuple, Optional, Set
 
 from pycheck.rules import ALL_RULES, RULES_BY_CODE, AnalysisContext, Diagnostic
 from pycheck.flow import TaintTracker
@@ -105,7 +105,9 @@ def parse_suppressions(source_lines: List[str]) -> dict:
                 suppressions.setdefault(lineno + 1, set()).update(codes)
     return suppressions
 
-def analyze_code(source: str, filepath: str = "<string>") -> Tuple[List[dict], List[str]]:
+def analyze_code(source: str, filepath: str = "<string>",
+                 ignore: Optional[Set[str]] = None,
+                 select: Optional[Set[str]] = None) -> Tuple[List[dict], List[str]]:
     """
     Analyze Python source code for ML safety issues.
     Returns (diagnostics_list, source_lines).
@@ -144,6 +146,10 @@ def analyze_code(source: str, filepath: str = "<string>") -> Tuple[List[dict], L
             seen.add(key)
             line_suppressed = suppressed_map.get(d.line, set())
             if 'ALL' not in line_suppressed and d.code not in line_suppressed:
+                if ignore and d.code in ignore:
+                    continue
+                if select is not None and d.code not in select:
+                    continue
                 unique.append(d)
     
     # Sort by line number
@@ -152,7 +158,9 @@ def analyze_code(source: str, filepath: str = "<string>") -> Tuple[List[dict], L
     return [d.to_dict() for d in unique], source_lines
 
 
-def analyze_file(filepath: str) -> Tuple[List[dict], List[str]]:
+def analyze_file(filepath: str,
+                 ignore: Optional[Set[str]] = None,
+                 select: Optional[Set[str]] = None) -> Tuple[List[dict], List[str]]:
     """
     Analyze a Python (.py) or Jupyter notebook (.ipynb) file for ML safety issues.
     Returns (diagnostics_list, source_lines).
@@ -178,7 +186,7 @@ def analyze_file(filepath: str) -> Tuple[List[dict], List[str]]:
         with open(filepath, 'r', encoding='utf-8') as f:
             source = f.read()
     
-    return analyze_code(source, filepath=filepath)
+    return analyze_code(source, filepath=filepath, ignore=ignore, select=select)
 
 
 def format_output(filepath: str, diagnostics: List[dict], source_lines: List[str],

{pycheck_neuron-1.1.2 → pycheck_neuron-1.2.0}/pycheck/cli.py

@@ -5,21 +5,31 @@ import hashlib
 from pycheck.analyzer import analyze_file, format_output
 from pycheck.rules import ALL_RULES
 from pycheck.audit import generate_proof_of_causality_certificate, format_certificate_text
+from pycheck.config import load_config
 
 
 def main():
     args = sys.argv[1:]
+
+    if '--version' in args or '-V' in args:
+        from pycheck import __version__
+        print(f"pycheck {__version__}")
+        sys.exit(0)
     
     if not args or '--help' in args or '-h' in args:
         print("PyCheck — NEURON ML Safety Analyzer")
         print(f"  {len(ALL_RULES)} rules for temporal leaks, causal confusion, and uncertainty bugs\n")
         print("Usage: pycheck <path> [options]\n")
         print("Options:")
+        print("  --version, -V        Show version and exit")
         print("  --json               Output diagnostics as JSON")
         print("  --gitlab             Output diagnostics in GitLab Code Quality JSON format")
         print("  --audit, -a          Generate a verifiable Proof-of-Causality Audit Certificate")
         print("                       Exit codes: 0 = verified pass, 1 = leakage detected, 3 = unverifiable (dynamic code or unscanned imports)")
         print("  -o, --output <file>  Write JSON / GitLab report directly to specified file")
+        print("  -c, --config <file>  Path to configuration file (.pycheck.toml or pyproject.toml)")
+        print("  --ignore <codes>     Comma-separated rule codes to ignore (e.g. C001,U002)")
+        print("  --select <codes>     Comma-separated rule codes to exclusively run (e.g. T001,T010)")
         print("  --info               Include info-level diagnostics")
         print("  --quiet              Only show errors (no warnings)")
         print("  --list               List all available rules")
@@ -37,8 +47,6 @@ def main():
         print()
         sys.exit(0)
     
-    show_info = '--info' in args
-    is_quiet = '--quiet' in args
     is_json = '--json' in args
     is_gitlab = '--gitlab' in args
     is_audit = '--audit' in args or '-a' in args or (len(args) > 0 and args[0] == 'audit')
@@ -53,6 +61,28 @@ def main():
         if idx + 1 < len(args):
             output_file = args[idx + 1]
 
+    cli_config = None
+    if '--config' in args:
+        idx = args.index('--config')
+        if idx + 1 < len(args):
+            cli_config = args[idx + 1]
+    elif '-c' in args:
+        idx = args.index('-c')
+        if idx + 1 < len(args):
+            cli_config = args[idx + 1]
+
+    cli_ignore = set()
+    if '--ignore' in args:
+        idx = args.index('--ignore')
+        if idx + 1 < len(args):
+            cli_ignore = {c.strip().upper() for c in args[idx + 1].split(',') if c.strip()}
+
+    cli_select = None
+    if '--select' in args:
+        idx = args.index('--select')
+        if idx + 1 < len(args):
+            cli_select = {c.strip().upper() for c in args[idx + 1].split(',') if c.strip()}
+
     # Get target path (first non-flag argument not consumed by an option)
     filepath = None
     skip_next = False
@@ -60,7 +90,7 @@ def main():
         if skip_next:
             skip_next = False
             continue
-        if a in ('--output', '-o'):
+        if a in ('--output', '-o', '--config', '-c', '--ignore', '--select'):
             skip_next = True
             continue
         if a == 'audit':
@@ -76,6 +106,21 @@ def main():
         print(f"Error: Path not found: {filepath}")
         sys.exit(1)
 
+    abs_path = os.path.abspath(filepath)
+    # Prevent accidental recursive scan of entire root filesystem
+    if abs_path in ('/', 'C:\\', 'c:\\', 'D:\\', 'd:\\'):
+        print(f"Error: Refusing to scan root filesystem '{filepath}'. Please specify a project directory or file.")
+        sys.exit(1)
+
+    # Load configuration
+    cfg = load_config(filepath, explicit_config_path=cli_config)
+    if cli_ignore:
+        cfg.ignore.update(cli_ignore)
+    if cli_select is not None:
+        cfg.select = cli_select
+    show_info = '--info' in args or cfg.show_info
+    is_quiet = '--quiet' in args or cfg.quiet
+
     # Collect target files
     files_to_scan = []
     if os.path.isdir(filepath):
@@ -88,8 +133,28 @@ def main():
     else:
         files_to_scan = [filepath]
 
+    if cfg.exclude:
+        filtered = []
+        for f in files_to_scan:
+            rel = os.path.relpath(f, filepath).replace('\\', '/')
+            if not any(ex in rel or rel.startswith(ex.rstrip('/')) for ex in cfg.exclude):
+                filtered.append(f)
+        files_to_scan = filtered
+
     if not files_to_scan:
-        if not is_json and not is_gitlab:
+        if is_json:
+            if output_file:
+                with open(output_file, 'w', encoding='utf-8') as f:
+                    f.write("{}\n")
+            else:
+                print("{}")
+        elif is_gitlab:
+            if output_file:
+                with open(output_file, 'w', encoding='utf-8') as f:
+                    f.write("[]\n")
+            else:
+                print("[]")
+        else:
             print(f"No Python (.py) or notebook (.ipynb) files found in {filepath}")
         sys.exit(0)
 
@@ -102,7 +167,7 @@ def main():
 
     for f_path in files_to_scan:
         try:
-            diagnostics, source_lines = analyze_file(f_path)
+            diagnostics, source_lines = analyze_file(f_path, ignore=cfg.ignore, select=cfg.select)
         except SyntaxError as e:
             if not is_json and (not is_gitlab or output_file):
                 print(f"Syntax error in {f_path}: {e}")

pycheck_neuron-1.2.0/pycheck/config.py

@@ -0,0 +1,132 @@
+"""
+PyCheck Configuration Loader
+Supports pyproject.toml ([tool.pycheck]) and .pycheck.toml.
+"""
+
+import os
+import re
+from dataclasses import dataclass, field
+from typing import Optional, Set, List
+
+try:
+    import tomllib
+except ImportError:
+    try:
+        import tomli as tomllib
+    except ImportError:
+        tomllib = None
+
+
+@dataclass
+class PyCheckConfig:
+    ignore: Set[str] = field(default_factory=set)
+    select: Optional[Set[str]] = None
+    exclude: List[str] = field(default_factory=list)
+    show_info: bool = False
+    quiet: bool = False
+
+
+def _parse_simple_toml_section(content: str, section_name: str) -> dict:
+    """Lightweight pure-Python fallback parser for basic TOML sections."""
+    lines = content.splitlines()
+    in_section = False
+    data = {}
+    for line in lines:
+        line = line.strip()
+        if not line or line.startswith('#'):
+            continue
+        if line.startswith('[') and line.endswith(']'):
+            sec = line[1:-1].strip()
+            in_section = (sec == section_name)
+            continue
+        if in_section and '=' in line:
+            k, v = line.split('=', 1)
+            k = k.strip()
+            v = v.strip()
+            if v.lower() == 'true':
+                data[k] = True
+            elif v.lower() == 'false':
+                data[k] = False
+            elif v.startswith('[') and v.endswith(']'):
+                items = re.findall(r'["\']([^"\']+)["\']', v)
+                data[k] = items
+            elif (v.startswith('"') and v.endswith('"')) or (v.startswith("'") and v.endswith("'")):
+                data[k] = v[1:-1]
+    return data
+
+
+def _load_from_file(filepath: str, is_pyproject: bool) -> Optional[PyCheckConfig]:
+    try:
+        with open(filepath, 'r', encoding='utf-8') as f:
+            content = f.read()
+    except Exception:
+        return None
+
+    raw_cfg = {}
+    if tomllib is not None:
+        try:
+            parsed = tomllib.loads(content)
+            if is_pyproject:
+                raw_cfg = parsed.get("tool", {}).get("pycheck", {})
+            else:
+                raw_cfg = parsed.get("pycheck", parsed)
+        except Exception:
+            raw_cfg = {}
+    else:
+        section = "tool.pycheck" if is_pyproject else "pycheck"
+        raw_cfg = _parse_simple_toml_section(content, section)
+
+    if not raw_cfg and is_pyproject:
+        return None
+
+    ignore_list = raw_cfg.get("ignore", [])
+    select_list = raw_cfg.get("select", None)
+    exclude_list = raw_cfg.get("exclude", [])
+
+    return PyCheckConfig(
+        ignore={c.strip().upper() for c in ignore_list},
+        select={c.strip().upper() for c in select_list} if select_list is not None else None,
+        exclude=list(exclude_list),
+        show_info=bool(raw_cfg.get("info", False)),
+        quiet=bool(raw_cfg.get("quiet", False))
+    )
+
+
+def load_config(start_path: Optional[str] = None, explicit_config_path: Optional[str] = None) -> PyCheckConfig:
+    """Find and load configuration from explicit path, .pycheck.toml, or pyproject.toml."""
+    if explicit_config_path:
+        if os.path.isfile(explicit_config_path):
+            is_pyproject = explicit_config_path.endswith('pyproject.toml')
+            cfg = _load_from_file(explicit_config_path, is_pyproject=is_pyproject)
+            if cfg is not None:
+                return cfg
+        return PyCheckConfig()
+
+    if start_path is None:
+        start_dir = os.getcwd()
+    elif os.path.isfile(start_path):
+        start_dir = os.path.dirname(os.path.abspath(start_path))
+    else:
+        start_dir = os.path.abspath(start_path)
+
+    search_dirs = [start_dir]
+    parent = os.path.dirname(start_dir)
+    if parent and parent != start_dir:
+        search_dirs.append(parent)
+
+    for d in search_dirs:
+        # 1. .pycheck.toml
+        pycheck_toml = os.path.join(d, ".pycheck.toml")
+        if os.path.isfile(pycheck_toml):
+            cfg = _load_from_file(pycheck_toml, is_pyproject=False)
+            if cfg is not None:
+                return cfg
+
+        # 2. pyproject.toml
+        pyproject_toml = os.path.join(d, "pyproject.toml")
+        if os.path.isfile(pyproject_toml):
+            cfg = _load_from_file(pyproject_toml, is_pyproject=True)
+            if cfg is not None:
+                return cfg
+
+    return PyCheckConfig()

{pycheck_neuron-1.1.2 → pycheck_neuron-1.2.0}/pycheck/flow.py

@@ -157,13 +157,47 @@ class TaintTracker:
                                     self.train_vars.add(t_name)
                                 elif sl.id in self.test_vars or any(m in sl.id.lower() for m in self.test_markers):
                                     self.test_vars.add(t_name)
+                    elif isinstance(sl, ast.Compare):
+                        # Detect semantic filtering: df[df['date'] > cutoff] vs df[df['date'] < cutoff]
+                        if len(sl.ops) == 1:
+                            op = sl.ops[0]
+                            temporal_hints = ('date', 'time', 'timestamp', 'year', 'day', 'dt', 'ts', 'cutoff', 'split')
+                            comp_str = ast.dump(sl).lower()
+                            if any(h in comp_str for h in temporal_hints):
+                                for target in stmt.targets:
+                                    t_name = self._get_var_name(target)
+                                    if t_name:
+                                        if isinstance(op, (ast.Gt, ast.GtE)):
+                                            self.test_vars.add(t_name)
+                                            self.train_vars.discard(t_name)
+                                            self.test_contaminated_vars[t_name] = "partition filtered with future condition (date > cutoff)"
+                                        elif isinstance(op, (ast.Lt, ast.LtE)):
+                                            self.train_vars.add(t_name)
+                                            self.test_vars.discard(t_name)
+                                            self.test_contaminated_vars.pop(t_name, None)
+                elif isinstance(stmt.value, ast.Call) and isinstance(stmt.value.func, ast.Attribute) and stmt.value.func.attr == 'query':
+                    if len(stmt.value.args) >= 1 and isinstance(stmt.value.args[0], ast.Constant) and isinstance(stmt.value.args[0].value, str):
+                        q_str = stmt.value.args[0].value.lower()
+                        temporal_hints = ('date', 'time', 'timestamp', 'year', 'day', 'dt', 'ts', 'cutoff', 'split')
+                        if any(h in q_str for h in temporal_hints):
+                            for target in stmt.targets:
+                                t_name = self._get_var_name(target)
+                                if t_name:
+                                    if '>' in q_str:
+                                        self.test_vars.add(t_name)
+                                        self.train_vars.discard(t_name)
+                                        self.test_contaminated_vars[t_name] = "partition filtered via .query() with future condition"
+                                    elif '<' in q_str:
+                                        self.train_vars.add(t_name)
+                                        self.test_vars.discard(t_name)
+                                        self.test_contaminated_vars.pop(t_name, None)
 
                 # 3. Register naming evidence
                 for target in stmt.targets:
                     t_name = self._get_var_name(target)
                     if t_name:
                         t_lower = t_name.lower()
-                        if any(m in t_lower for m in self.train_markers) and t_name not in self.test_contaminated_vars:
+                        if any(m in t_lower for m in self.train_markers) and t_name not in self.test_contaminated_vars and t_name not in self.test_vars:
                             self.train_vars.add(t_name)
                         elif any(m in t_lower for m in self.test_markers):
                             self.test_vars.add(t_name)

{pycheck_neuron-1.1.2 → pycheck_neuron-1.2.0}/pycheck/rules.py

@@ -74,10 +74,12 @@ class Rule:
 
         temporal_call_methods = {
             'rolling', 'expanding', 'shift', 'pct_change', 'diff',
-            'resample', 'merge_asof', 'to_datetime', 'date_range'
+            'resample', 'merge_asof', 'to_datetime', 'date_range',
+            'join_asof', 'backward_fill', 'rolling_mean', 'rolling_std'
         }
         temporal_call_names = {'timeseriessplit', 'to_datetime', 'date_range',
-                               'fromisoformat', 'strptime', 'strftime'}
+                               'fromisoformat', 'strptime', 'strftime',
+                               'join_asof', 'backward_fill'}
         temporal_columns = {
             'date', 'datetime', 'timestamp', 'time', 'day', 'dt',
             'close', 'open', 'high', 'low', 'volume', 'vwap', 'ohlc',
@@ -292,6 +294,18 @@ class T001_ShiftNegative(Rule):
                                 f"Manual lead via np.append(arr[{arg0.slice.lower.value}:], nan) accesses future values",
                                 "Use backward lag features .shift(1)")]
 
+        # B18: index-offset lead via .set_index(key - k)
+        if isinstance(node.func, ast.Attribute) and node.func.attr == 'set_index':
+            if len(node.args) >= 1:
+                arg = node.args[0]
+                if isinstance(arg, ast.BinOp) and isinstance(arg.op, ast.Sub):
+                    if isinstance(arg.right, ast.Constant) and isinstance(arg.right.value, (int, float)) and arg.right.value > 0:
+                        val = arg.right.value
+                        return [Diagnostic(
+                            node.lineno, node.col_offset, self.severity, self.code,
+                            f".set_index(key - {val}) shifts lookup keys to access future records {val} steps ahead (lookahead bias)",
+                            "Use .shift(1) for past lookups or avoid backward index arithmetic on lookup/merge keys")]
+
         if not (is_shift or is_getattr_shift or is_alias_shift):
             return []
         results = []
@@ -308,15 +322,15 @@ class T001_ShiftNegative(Rule):
                 # Taint the assignment target
                 self._taint_parent(node, ctx, f"shift(-{val}) future data")
         for kw in node.keywords:
-            if kw.arg == 'periods':
+            if kw.arg in ('periods', 'n'):
                 val = self._get_negative_value(kw.value, ctx)
                 if val is not None and val > 0:
                     if self._is_target_construction(node):
                         return []
                     results.append(Diagnostic(
                         node.lineno, node.col_offset, self.severity, self.code,
-                        f".shift(periods=-{val}) accesses data {val} rows INTO THE FUTURE",
-                        f"Use .shift(periods={val}) to access past data instead"))
+                        f".shift({kw.arg}=-{val}) accesses data {val} rows INTO THE FUTURE",
+                        f"Use .shift({kw.arg}={val}) to access past data instead"))
         return results
 
     def _get_negative_value(self, arg, ctx=None):
@@ -493,20 +507,20 @@ class T005_PctChangeNegative(Rule):
                     node.lineno, node.col_offset, self.severity, self.code,
                     f"pct_change({int(arg.value)}) accesses future data",
                     "Use positive periods to look backwards in time")]
-        # Also check keyword arg: pct_change(periods=-1)
+        # Also check keyword arg: pct_change(periods=-1) or Polars pct_change(n=-1)
         for kw in node.keywords:
-            if kw.arg == 'periods':
+            if kw.arg in ('periods', 'n'):
                 if isinstance(kw.value, ast.UnaryOp) and isinstance(kw.value.op, ast.USub):
                     if isinstance(kw.value.operand, ast.Constant):
                         val = kw.value.operand.value
                         return [Diagnostic(
                             node.lineno, node.col_offset, self.severity, self.code,
-                            f"pct_change(periods=-{val}) accesses future data",
+                            f"pct_change({kw.arg}=-{val}) accesses future data",
                             "Use positive periods to look backwards in time")]
                 if isinstance(kw.value, ast.Constant) and isinstance(kw.value.value, (int, float)) and kw.value.value < 0:
                     return [Diagnostic(
                         node.lineno, node.col_offset, self.severity, self.code,
-                        f"pct_change(periods={int(kw.value.value)}) accesses future data",
+                        f"pct_change({kw.arg}={int(kw.value.value)}) accesses future data",
                         "Use positive periods to look backwards in time")]
                 # Resolve variable reference
                 if isinstance(kw.value, ast.Name) and ctx is not None and hasattr(ctx, 'constants'):
@@ -514,7 +528,7 @@ class T005_PctChangeNegative(Rule):
                     if val is not None and isinstance(val, (int, float)) and val < 0:
                         return [Diagnostic(
                             node.lineno, node.col_offset, self.severity, self.code,
-                            f"pct_change(periods={int(val)}) accesses future data",
+                            f"pct_change({kw.arg}={int(val)}) accesses future data",
                             "Use positive periods to look backwards in time")]
         return []
 
@@ -589,7 +603,7 @@ class T007_BackfillLeak(Rule):
     def check_node(self, node, ctx):
         if not isinstance(node, ast.Call):
             return []
-        if isinstance(node.func, ast.Attribute) and node.func.attr in ('fillna', 'bfill', 'backfill', 'ffill'):
+        if isinstance(node.func, ast.Attribute) and node.func.attr in ('fillna', 'bfill', 'backfill', 'ffill', 'backward_fill', 'fill_null'):
             # B14: ffill on reversed frame is equivalent to bfill
             if node.func.attr == 'ffill':
                 for child in ast.walk(node.func.value):
@@ -599,11 +613,11 @@ class T007_BackfillLeak(Rule):
                             ".ffill() on reversed slice [::-1] is equivalent to .bfill() and fills with FUTURE data",
                             "Use forward fill on chronological data")]
 
-            if node.func.attr in ('bfill', 'backfill'):
+            if node.func.attr in ('bfill', 'backfill', 'backward_fill'):
                 return [Diagnostic(
                     node.lineno, node.col_offset, self.severity, self.code,
                     f".{node.func.attr}() fills missing values with FUTURE data",
-                    "Use .ffill() (forward fill) or .fillna(0) instead")]
+                    "Use forward fill (e.g. .ffill() or .forward_fill()) or .fillna(0) instead")]
             # Check fillna(method='bfill') or fillna(method='backfill')
             for kw in node.keywords:
                 if kw.arg == 'method' and isinstance(kw.value, ast.Constant):
@@ -612,6 +626,19 @@ class T007_BackfillLeak(Rule):
                             node.lineno, node.col_offset, self.severity, self.code,
                             f".fillna(method='{kw.value.value}') fills missing values with FUTURE data",
                             "Use .fillna(method='ffill') or .fillna(0) instead")]
+                # Polars fill_null(strategy='backward')
+                if kw.arg == 'strategy' and isinstance(kw.value, ast.Constant):
+                    if kw.value.value in ('backward', 'bfill'):
+                        return [Diagnostic(
+                            node.lineno, node.col_offset, self.severity, self.code,
+                            f".{node.func.attr}(strategy='{kw.value.value}') fills missing values with FUTURE data",
+                            "Use strategy='forward' or fill with a constant value instead")]
+            for arg in node.args:
+                if isinstance(arg, ast.Constant) and isinstance(arg.value, str) and arg.value in ('backward', 'bfill'):
+                    return [Diagnostic(
+                        node.lineno, node.col_offset, self.severity, self.code,
+                        f".{node.func.attr}('{arg.value}') fills missing values with FUTURE data",
+                        "Use strategy='forward' or fill with a constant value instead")]
         return []
 
 
@@ -652,13 +679,13 @@ class T009_CenteredRolling(Rule):
     def check_node(self, node, ctx):
         if not isinstance(node, ast.Call):
             return []
-        if isinstance(node.func, ast.Attribute) and node.func.attr == 'rolling':
+        if isinstance(node.func, ast.Attribute) and (node.func.attr == 'rolling' or node.func.attr.startswith('rolling_')):
             for kw in node.keywords:
                 if kw.arg == 'center' and isinstance(kw.value, ast.Constant) and kw.value.value is True:
                     return [Diagnostic(
                         node.lineno, node.col_offset, self.severity, self.code,
-                        ".rolling(center=True) uses future data on both sides of the window",
-                        "Use .rolling(center=False) for causal (backward-looking) windows")]
+                        f".{node.func.attr}(center=True) uses future data on both sides of the window",
+                        f"Use .{node.func.attr}(center=False) for causal (backward-looking) windows")]
         return []
 
 
@@ -758,6 +785,40 @@ class T010_FitBeforeSplit(Rule):
             return self._is_train_data(node.value, ctx)
         return False
 
+    def _is_performance_metric(self, node):
+        """Check if this division (mean/std) is part of a portfolio performance metric
+        (e.g., Sharpe, Sortino, Information Ratio) rather than an ML feature standardizer."""
+        cur = node
+        metric_markers = {'sharpe', 'sortino', 'information_ratio', 'info_ratio', 'treynor', 'calmar', 'omega', 'pnl', 'returns'}
+        while cur is not None:
+            p = getattr(cur, 'parent', None)
+            if p is None:
+                break
+            # 1. Multiplied by annualization factor (sqrt(252), sqrt(365), 252**0.5, etc.)
+            if isinstance(p, ast.BinOp) and isinstance(p.op, ast.Mult):
+                dumped = ast.dump(p).lower()
+                if any(k in dumped for k in ('252', '365', 'sqrt', 'annualize', 'annualized', 'sharpe', 'sortino')):
+                    return True
+            # 2. Assigned to a metric variable (e.g. sharpe = ..., res['sharpe'] = ...)
+            if isinstance(p, ast.Assign):
+                for tgt in p.targets:
+                    if isinstance(tgt, ast.Name):
+                        tgt_lower = tgt.id.lower()
+                        if any(m in tgt_lower for m in metric_markers):
+                            return True
+                    elif isinstance(tgt, ast.Subscript) and isinstance(tgt.slice, ast.Constant):
+                        if isinstance(tgt.slice.value, str):
+                            slice_lower = tgt.slice.value.lower()
+                            if any(m in slice_lower for m in metric_markers):
+                                return True
+            # 3. Inside a function explicitly calculating metrics
+            if isinstance(p, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                f_lower = p.name.lower()
+                if any(m in f_lower for m in ('sharpe', 'sortino')):
+                    return True
+            cur = p
+        return False
+
     def check_node(self, node, ctx):
         if not isinstance(node, ast.Call):
             return []
@@ -779,6 +840,8 @@ class T010_FitBeforeSplit(Rule):
                 if parent is not None and isinstance(parent, ast.BinOp):
                     # Z-score / variance scaling: / std()
                     if isinstance(parent.op, ast.Div) and node.func.attr in ('std', 'var'):
+                        if self._is_performance_metric(node):
+                            return []
                         return [Diagnostic(
                             node.lineno, node.col_offset, self.severity, self.code,
                             "Manual full-sample z-score (.std() / .mean()) computed on un-split dataset leaks test statistics",
@@ -1078,13 +1141,13 @@ class T014_DiffNegative(Rule):
                     f".diff(-{val}) computes difference using future data",
                     f"Use .diff({val}) to compute backward differences"))
         for kw in node.keywords:
-            if kw.arg == 'periods':
+            if kw.arg in ('periods', 'n'):
                 val = self._get_negative_value(kw.value, ctx)
                 if val is not None and val > 0:
                     results.append(Diagnostic(
                         node.lineno, node.col_offset, self.severity, self.code,
-                        f".diff(periods=-{val}) computes difference using future data",
-                        f"Use .diff(periods={val}) to compute backward differences"))
+                        f".diff({kw.arg}=-{val}) computes difference using future data",
+                        f"Use .diff({kw.arg}={val}) to compute backward differences"))
         return results
 
 
@@ -1122,23 +1185,26 @@ class T016_MergeAsofDirection(Rule):
         if not isinstance(node, ast.Call):
             return []
         is_merge_asof = False
-        if isinstance(node.func, ast.Attribute) and node.func.attr == 'merge_asof':
+        call_name = 'merge_asof'
+        if isinstance(node.func, ast.Attribute) and node.func.attr in ('merge_asof', 'join_asof'):
             is_merge_asof = True
-        elif isinstance(node.func, ast.Name) and node.func.id == 'merge_asof':
+            call_name = node.func.attr
+        elif isinstance(node.func, ast.Name) and node.func.id in ('merge_asof', 'join_asof'):
             is_merge_asof = True
+            call_name = node.func.id
         
         if not is_merge_asof:
             return []
         
         for kw in node.keywords:
-            if kw.arg == 'direction':
+            if kw.arg in ('direction', 'strategy'):
                 if isinstance(kw.value, ast.Constant) and isinstance(kw.value.value, str):
                     val = kw.value.value.lower()
                     if val in ('nearest', 'forward'):
                         return [Diagnostic(
                             node.lineno, node.col_offset, self.severity, self.code,
-                            f"pd.merge_asof() with direction='{kw.value.value}' matches future timestamps (lookahead bias)",
-                            "Use direction='backward' for point-in-time causal event joins")]
+                            f"{call_name}() with {kw.arg}='{kw.value.value}' matches future timestamps (lookahead bias)",
+                            f"Use {kw.arg}='backward' for point-in-time causal event joins")]
         return []
 
 
@@ -1336,25 +1402,31 @@ class T019_NpRollNegative(Rule):
     def check_node(self, node, ctx):
         if not isinstance(node, ast.Call):
             return []
-        # Detect np.roll(arr, -N) or numpy.roll(arr, -N)
+        # Detect np.roll(arr, -N), numpy.roll(arr, -N), torch.roll(arr, -N), jnp.roll(arr, -N)
         if isinstance(node.func, ast.Attribute) and node.func.attr == 'roll':
             obj = node.func.value
-            if isinstance(obj, ast.Name) and obj.id in ('np', 'numpy'):
+            caller_name = ""
+            if isinstance(obj, ast.Name):
+                caller_name = obj.id
+            elif isinstance(obj, ast.Attribute) and isinstance(obj.value, ast.Name) and obj.value.id == 'jax':
+                caller_name = f"jax.{obj.attr}"
+            
+            if caller_name in ('np', 'numpy', 'torch', 'jnp', 'jax', 'jax.numpy'):
                 if len(node.args) >= 2:
                     val = self._get_negative_value(node.args[1], ctx)
                     if val is not None and val > 0:
                         return [Diagnostic(
                             node.lineno, node.col_offset, self.severity, self.code,
-                            f"np.roll(array, -{val}) rotates data {val} positions from the FUTURE (no NaN boundary)",
+                            f"{caller_name}.roll(array, -{val}) rotates data {val} positions from the FUTURE (no NaN boundary)",
                             f"Use pd.Series.shift({val}) which inserts NaN at boundaries, or slice manually")]
-                # Also check keyword: shift=... (numpy uses 'shift' param)
+                # Also check keyword: shift=... (numpy) or shifts=... (torch)
                 for kw in node.keywords:
-                    if kw.arg == 'shift':
+                    if kw.arg in ('shift', 'shifts'):
                         val = self._get_negative_value(kw.value, ctx)
                         if val is not None and val > 0:
                             return [Diagnostic(
                                 node.lineno, node.col_offset, self.severity, self.code,
-                                f"np.roll(shift=-{val}) rotates data {val} positions from the FUTURE (no NaN boundary)",
+                                f"{caller_name}.roll({kw.arg}=-{val}) rotates data {val} positions from the FUTURE (no NaN boundary)",
                                 f"Use pd.Series.shift({val}) which inserts NaN at boundaries")]
         return []
 

{pycheck_neuron-1.1.2 → pycheck_neuron-1.2.0/pycheck_neuron.egg-info}/PKG-INFO

@@ -1,21 +1,20 @@
 Metadata-Version: 2.4
 Name: pycheck-neuron
-Version: 1.1.2
+Version: 1.2.0
 Summary: 37-rule static AST analyzer catching temporal lookahead bias, causal confusion, and uncertainty bugs in Python ML code. Zero dependencies.
 Author-email: Fayo Ibrahim <contact@neuron-lab.org>
-License-Expression: MIT
+License: MIT
 Project-URL: Homepage, https://github.com/neuronlabs-ai/pycheck
 Project-URL: Documentation, https://github.com/neuronlabs-ai/pycheck#readme
 Project-URL: Repository, https://github.com/neuronlabs-ai/pycheck
 Project-URL: Bug Tracker, https://github.com/neuronlabs-ai/pycheck/issues
 Keywords: machine-learning,data-leakage,temporal-bias,lookahead-bias,backtesting,quantitative-finance,algorithmic-trading,linter,static-analysis,causal-inference,time-series,pandas,sklearn,scikit-learn,uncertainty,neuron,ml-safety,data-science,feature-engineering
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.7
-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
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Software Development :: Quality Assurance
 Classifier: Topic :: Software Development :: Testing
@@ -26,7 +25,7 @@ Classifier: Intended Audience :: Financial and Insurance Industry
 Classifier: Intended Audience :: Developers
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
-Requires-Python: >=3.7
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: test
@@ -239,6 +238,29 @@ Returns structured output for automated pipelines:
 ]
 ```
 
+### Project Configuration (`pyproject.toml` or `.pycheck.toml`)
+
+PyCheck automatically detects and respects project-level configuration in `pyproject.toml` or `.pycheck.toml`:
+
+```toml
+[tool.pycheck]
+ignore = ["C001", "U002"]
+exclude = ["tests", "legacy"]
+info = false
+quiet = false
+```
+
+Or override dynamically via CLI flags:
+```bash
+pycheck . --ignore C001,U002 --select T001,T010 -c pyproject.toml
+```
+
+### Modern Quant Stack Support (Polars, PyTorch, JAX)
+
+PyCheck natively guards both Pandas and modern high-performance quantitative computing pipelines:
+- **Polars Expression Engine**: Detects lookaheads in `pl.col("close").shift(n=-1)`, `pct_change(n=-1)`, `diff(n=-1)`, `backward_fill()`, `fill_null(strategy="backward")`, `rolling_mean(center=True)`, and `join_asof(strategy="forward" | "nearest")`.
+- **Deep Learning Time Series**: Detects future tensor index rotation via `torch.roll(tensor, shifts=-N)` and `jnp.roll(arr, -N)`.
+
 ### Exit Codes
 
 - `0` — Verified clean / no errors found

{pycheck_neuron-1.1.2 → pycheck_neuron-1.2.0}/pycheck_neuron.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ pycheck/__main__.py
 pycheck/analyzer.py
 pycheck/audit.py
 pycheck/cli.py
+pycheck/config.py
 pycheck/flow.py
 pycheck/rules.py
 pycheck/server.py
@@ -17,5 +18,6 @@ pycheck_neuron.egg-info/requires.txt
 pycheck_neuron.egg-info/top_level.txt
 tests/test_audit.py
 tests/test_cli.py
+tests/test_config.py
 tests/test_regression.py
 tests/test_rules.py

{pycheck_neuron-1.1.2 → pycheck_neuron-1.2.0}/pyproject.toml

@@ -4,21 +4,20 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pycheck-neuron"
-version = "1.1.2"
+version = "1.2.0"
 description = "37-rule static AST analyzer catching temporal lookahead bias, causal confusion, and uncertainty bugs in Python ML code. Zero dependencies."
 readme = "README.md"
 authors = [
     { name = "Fayo Ibrahim", email = "contact@neuron-lab.org" }
 ]
-license = "MIT"
+license = { text = "MIT" }
 classifiers = [
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.7",
-    "Programming Language :: Python :: 3.8",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Operating System :: OS Independent",
     "Topic :: Software Development :: Quality Assurance",
     "Topic :: Software Development :: Testing",
@@ -37,7 +36,7 @@ keywords = [
     "pandas", "sklearn", "scikit-learn", "uncertainty", "neuron",
     "ml-safety", "data-science", "feature-engineering"
 ]
-requires-python = ">=3.7"
+requires-python = ">=3.9"
 dependencies = []
 
 [project.optional-dependencies]

pycheck_neuron-1.2.0/tests/test_config.py

@@ -0,0 +1,98 @@
+"""
+Unit tests for PyCheck configuration file support (.pycheck.toml and pyproject.toml)
+and CLI --ignore, --select, --config options.
+"""
+
+import json
+import subprocess
+import pytest
+from pycheck.config import load_config, PyCheckConfig
+from pycheck.analyzer import analyze_code
+
+
+def test_load_config_from_pyproject_toml(tmp_path):
+    pyproject = tmp_path / "pyproject.toml"
+    pyproject.write_text("""
+[tool.pycheck]
+ignore = ["C001", "U002"]
+exclude = ["legacy/", "tests/"]
+info = true
+quiet = false
+""")
+    cfg = load_config(str(tmp_path))
+    assert cfg.ignore == {"C001", "U002"}
+    assert cfg.exclude == ["legacy/", "tests/"]
+    assert cfg.show_info is True
+    assert cfg.quiet is False
+
+
+def test_load_config_from_pycheck_toml(tmp_path):
+    cfg_file = tmp_path / ".pycheck.toml"
+    cfg_file.write_text("""
+[pycheck]
+ignore = ["T001"]
+select = ["T001", "T002"]
+quiet = true
+""")
+    cfg = load_config(str(tmp_path))
+    assert cfg.ignore == {"T001"}
+    assert cfg.select == {"T001", "T002"}
+    assert cfg.quiet is True
+
+
+def test_analyze_code_with_ignore_and_select():
+    code = """
+import pandas as pd
+df['y'] = df['close'].shift(-1)
+corr = df['close'].corr()
+"""
+    # Without filter: both T001 and C001
+    diags, _ = analyze_code(code)
+    codes = {d['code'] for d in diags}
+    assert 'T001' in codes
+    assert 'C001' in codes
+
+    # With ignore T001
+    diags_ignored, _ = analyze_code(code, ignore={"T001"})
+    codes_ignored = {d['code'] for d in diags_ignored}
+    assert 'T001' not in codes_ignored
+    assert 'C001' in codes_ignored
+
+    # With select only T001
+    diags_selected, _ = analyze_code(code, select={"T001"})
+    codes_selected = {d['code'] for d in diags_selected}
+    assert 'T001' in codes_selected
+    assert 'C001' not in codes_selected
+
+
+def test_cli_ignore_flag(tmp_path):
+    f = tmp_path / "test_leak.py"
+    f.write_text("import pandas as pd\ndf['feat'] = df['close'].shift(-1)\n")
+
+    # Run without ignore -> exits 1
+    r1 = subprocess.run(["pycheck", str(f), "--json"], capture_output=True, text=True)
+    assert r1.returncode == 1
+    assert "T001" in r1.stdout
+
+    # Run with --ignore T001 -> exits 0
+    r2 = subprocess.run(["pycheck", str(f), "--ignore", "T001", "--json"], capture_output=True, text=True)
+    assert r2.returncode == 0
+    data = json.loads(r2.stdout)
+    assert len(data) == 0
+
+
+def test_cli_exclude_config(tmp_path):
+    subdir = tmp_path / "legacy"
+    subdir.mkdir()
+    f = subdir / "old_model.py"
+    f.write_text("df['feat'] = df['close'].shift(-1)\n")
+
+    pyproj = tmp_path / "pyproject.toml"
+    pyproj.write_text("""
+[tool.pycheck]
+exclude = ["legacy"]
+""")
+    r = subprocess.run(["pycheck", str(tmp_path), "--config", str(pyproj), "--json"], capture_output=True, text=True)
+    assert r.returncode == 0
+    data = json.loads(r.stdout)
+    assert len(data) == 0

{pycheck_neuron-1.1.2 → pycheck_neuron-1.2.0}/tests/test_rules.py

@@ -1134,3 +1134,109 @@ model.fit(X, df['target'])
         code_train_perc = "df['clipped'] = df['x'].clip(upper=np.percentile(train['x'], 99))"
         diags_train, _ = analyze_code(code_train_perc, "test.py")
         assert not [d for d in diags_train if d['code'] == 'T010'], "np.percentile on train data must be clean"
+
+
+class TestModernQuantStackSupport:
+    """Verify lookahead detection across Polars, PyTorch, and JAX time-series pipelines."""
+
+    def test_polars_shift_negative_n_fires_t001(self):
+        code = """
+import polars as pl
+df = pl.read_csv("prices.csv")
+df = df.with_columns(next_close=pl.col("close").shift(n=-1))
+"""
+        diags, _ = analyze_code(code)
+        assert any(d['code'] == 'T001' for d in diags)
+
+    def test_polars_pct_change_negative_n_fires_t005(self):
+        code = """
+import polars as pl
+df = pl.read_csv("prices.csv")
+df = df.with_columns(fwd_ret=pl.col("close").pct_change(n=-1))
+"""
+        diags, _ = analyze_code(code)
+        assert any(d['code'] == 'T005' for d in diags)
+
+    def test_polars_diff_negative_n_fires_t014(self):
+        code = """
+import polars as pl
+df = pl.read_csv("prices.csv")
+df = df.with_columns(fwd_diff=pl.col("close").diff(n=-1))
+"""
+        diags, _ = analyze_code(code)
+        assert any(d['code'] == 'T014' for d in diags)
+
+    def test_polars_backward_fill_fires_t007(self):
+        code = """
+import polars as pl
+df = pl.read_csv("prices.csv")
+df = df.with_columns(filled=pl.col("close").backward_fill())
+"""
+        diags, _ = analyze_code(code)
+        assert any(d['code'] == 'T007' for d in diags)
+
+    def test_polars_fill_null_backward_fires_t007(self):
+        code = """
+import polars as pl
+df = pl.read_csv("prices.csv")
+df = df.with_columns(filled=pl.col("close").fill_null(strategy="backward"))
+"""
+        diags, _ = analyze_code(code)
+        assert any(d['code'] == 'T007' for d in diags)
+
+    def test_polars_rolling_mean_centered_fires_t009(self):
+        code = """
+import polars as pl
+df = pl.read_csv("prices.csv")
+df = df.with_columns(centered=pl.col("close").rolling_mean(window_size=10, center=True))
+"""
+        diags, _ = analyze_code(code)
+        assert any(d['code'] == 'T009' for d in diags)
+
+    def test_polars_join_asof_forward_fires_t016(self):
+        code = """
+import polars as pl
+trades = pl.read_csv("trades.csv")
+quotes = pl.read_csv("quotes.csv")
+merged = trades.join_asof(quotes, on="timestamp", strategy="forward")
+"""
+        diags, _ = analyze_code(code)
+        assert any(d['code'] == 'T016' for d in diags)
+
+    def test_torch_roll_negative_fires_t019(self):
+        code = """
+import torch
+seq = torch.randn(100, 10)
+future = torch.roll(seq, -1, dims=0)
+"""
+        diags, _ = analyze_code(code)
+        assert any(d['code'] == 'T019' for d in diags)
+
+    def test_torch_roll_keyword_shifts_negative_fires_t019(self):
+        code = """
+import torch
+seq = torch.randn(100, 10)
+future = torch.roll(seq, shifts=-1, dims=0)
+"""
+        diags, _ = analyze_code(code)
+        assert any(d['code'] == 'T019' for d in diags)
+
+    def test_jax_roll_negative_fires_t019(self):
+        code = """
+import jax.numpy as jnp
+arr = jnp.arange(100)
+fwd = jnp.roll(arr, -1)
+"""
+        diags, _ = analyze_code(code)
+        assert any(d['code'] == 'T019' for d in diags)
+
+    def test_sharpe_ratio_calculation_is_exempt_from_t010(self):
+        code = """
+import numpy as np
+daily_pnls = [10.0, -5.0, 15.0, -2.0]
+sharpe = (np.mean(daily_pnls) / np.std(daily_pnls)) * np.sqrt(252)
+"""
+        diags, _ = analyze_code(code)
+        assert not any(d['code'] == 'T010' for d in diags), "Sharpe ratio formula must not be flagged as T010"
+
+