opencode-pyneruntime 6.6.4__py3-none-any.whl

pynecore/pynesys/compiler.py

@@ -0,0 +1,112 @@
+"""
+Core compilation service for programmatic use.
+"""
+from pathlib import Path
+
+from pynecore.pynesys.api import (APIClient, APIError, AuthError, RateLimitError, CompilationError, UsageResponse,
+                                  TokenValidationResponse)
+from pynecore.utils.file_utils import is_updated
+
+
+class PyneComp:
+    """
+    Compiler through the PyneSys API.
+    """
+
+    api_client: APIClient
+
+    def __init__(self, api_key, base_url="https://api.pynesys.io", timeout=30):
+        """
+        Initialize the compilation service.
+
+        :param api_key: PyneSys API key
+        :param base_url: Base URL for the API
+        :param timeout: Request timeout in seconds
+        """
+        self.api_client = APIClient(api_key=api_key, base_url=base_url, timeout=timeout)
+
+    def compile(self, pine_path: Path, output_path: Path | None = None,
+                force: bool = False, strict: bool = False) -> Path:
+        """
+        Compile a .pine file to Python.
+
+        :param pine_path: Path to the .pine file
+        :param output_path: Optional output path (defaults to .py extension)
+        :param force: Force recompilation even if file hasn't changed
+        :param strict: Enable strict compilation mode
+        :return: Path to the compiled .py file
+        :raises FileNotFoundError: If pine file doesn't exist
+        :raises CompilationError: If compilation fails
+        :raises APIError: If API request fails
+        """
+        # Validate input file
+        if not pine_path.exists():
+            raise FileNotFoundError(f"Pine file not found: {pine_path}")
+
+        if pine_path.suffix != '.pine':
+            raise ValueError(f"This file format isn't supported: {pine_path.suffix}. "
+                             f"Only .pine files can be compiled!")
+
+        # Determine output path
+        resolved_output: Path = output_path if output_path is not None else pine_path.with_suffix('.py')
+
+        # Check if compilation is needed (unless forced)
+        if not force and not self.needs_compilation(pine_path, resolved_output):
+            return resolved_output
+
+        # Read Pine Script content
+        try:
+            with open(pine_path, 'r', encoding='utf-8') as f:
+                script_content = f.read()
+        except IOError as e:
+            raise IOError(f"Error reading Pine file {pine_path}: {e}")
+
+        # Compile via API
+        try:
+            response = self.api_client.compile_script(script_content, strict=strict)
+
+            if not response.success:
+                raise CompilationError(
+                    f"Compilation failed: {response.error_message}",
+                    status_code=response.status_code,
+                    validation_errors=response.validation_errors
+                )
+
+            # Write compiled code to output file
+            assert response.compiled_code is not None
+            resolved_output.parent.mkdir(parents=True, exist_ok=True)
+            with open(resolved_output, 'w', encoding='utf-8') as f:
+                f.write(response.compiled_code)
+
+            # No need to update tracking info with mtime approach
+            return resolved_output
+
+        except (APIError, AuthError, RateLimitError, CompilationError):
+            # Re-raise API-related errors as-is
+            raise
+        except Exception as e:
+            # Wrap unexpected errors
+            raise APIError(f"Unexpected error during compilation: {e}")
+
+    def get_usage(self) -> UsageResponse:
+        """
+        Get current usage statistics and limits for the authenticated user.
+        """
+        return self.api_client.get_usage()
+
+    def validate_api_key(self) -> TokenValidationResponse:
+        """
+        Validate API key.
+        """
+        return self.api_client.verify_token_local()
+
+    @staticmethod
+    def needs_compilation(pine_file_path: Path, output_file_path: Path) -> bool:
+        """
+        Check if a .pine file needs compilation using modification time comparison.
+
+        :param pine_file_path: Path to the .pine file
+        :param output_file_path: Path to the compiled .py file
+        :return: True if compilation is needed, False otherwise
+        """
+        return is_updated(pine_file_path, output_file_path)

pynecore/standalone.py

@@ -0,0 +1,99 @@
+"""Standalone runner for PyneComp-compiled Pyne code."""
+import sys
+from pathlib import Path
+
+
+def run(script_file: str) -> None:
+    """
+    Run compiled Pyne code in standalone mode.
+
+    Enables ``python script.py data.csv`` without a workdir or the ``pyne`` CLI.
+
+    :param script_file: The ``__file__`` of the calling script
+    """
+    if len(sys.argv) < 2:
+        script_name = Path(script_file).name
+        print(f"Usage: python {script_name} <data_file>", file=sys.stderr)
+        print(f"\n  data_file: Path to CSV or OHLCV data file", file=sys.stderr)
+        sys.exit(1)
+
+    data_arg = sys.argv[1]
+    data_path = Path(data_arg).resolve()
+    script_path = Path(script_file).resolve()
+
+    if not data_path.exists():
+        print(f"Error: Data file '{data_arg}' not found", file=sys.stderr)
+        sys.exit(1)
+
+    import shutil
+    import tempfile
+    from pynecore.core.data_converter import DataConverter, DataFormatError, ConversionError
+    from pynecore.core.ohlcv_file import OHLCVReader
+    from pynecore.core.syminfo import SymInfo
+    from pynecore.core.script_runner import ScriptRunner
+
+    temp_dir = None
+    ohlcv_path = data_path
+
+    try:
+        # CSV/TXT/JSON → OHLCV conversion in temp directory
+        if data_path.suffix != '.ohlcv':
+            try:
+                temp_dir = tempfile.mkdtemp(prefix="pyne_")
+                # Copy preserves filename for guess_symbol_from_filename heuristics
+                temp_copy = Path(temp_dir) / data_path.name
+                shutil.copy2(data_path, temp_copy)
+
+                converter = DataConverter()
+                detected_symbol, detected_provider = DataConverter.guess_symbol_from_filename(
+                    data_path
+                )
+                if not detected_symbol:
+                    detected_symbol = data_path.stem.upper()
+
+                print(f"Converting {data_path.name}...", file=sys.stderr)
+                converter.convert_to_ohlcv(
+                    temp_copy, provider=detected_provider,
+                    symbol=detected_symbol, force=True
+                )
+                ohlcv_path = temp_copy.with_suffix('.ohlcv')
+            except (DataFormatError, ConversionError) as e:
+                print(f"Error: {e}", file=sys.stderr)
+                sys.exit(1)
+
+        # Load symbol info
+        toml_path = ohlcv_path.with_suffix('.toml')
+        try:
+            syminfo = SymInfo.load_toml(toml_path)
+        except FileNotFoundError:
+            print(f"Error: Symbol info '{toml_path.name}' not found", file=sys.stderr)
+            sys.exit(1)
+
+        # Output paths next to script
+        out_dir = script_path.parent
+        plot_path = out_dir / f"{script_path.stem}.csv"
+        trade_path = out_dir / f"{script_path.stem}_trades.csv"
+        strat_path = out_dir / f"{script_path.stem}_strat.csv"
+
+        # Run using the standard ScriptRunner
+        with OHLCVReader(ohlcv_path) as reader:
+            start_ts: int = reader.start_timestamp  # type: ignore[assignment]
+            end_ts: int = reader.end_timestamp  # type: ignore[assignment]
+            size = reader.get_size(start_ts, end_ts)
+            ohlcv_iter = reader.read_from(start_ts, end_ts)
+            print(
+                f"Running {script_path.name} on {data_path.stem} ({size} bars)...",
+                file=sys.stderr
+            )
+
+            runner = ScriptRunner(
+                script_path, ohlcv_iter, syminfo, last_bar_index=size - 1,
+                plot_path=plot_path, strat_path=strat_path, trade_path=trade_path
+            )
+            runner.run()
+
+        print(f"Done. Output: {plot_path}", file=sys.stderr)
+
+    finally:
+        if temp_dir:
+            shutil.rmtree(temp_dir, ignore_errors=True)

pynecore/testing/__init__.py

@@ -0,0 +1 @@
+"""Testing helpers for PyneCore plugin authors."""

pynecore/testing/broker_lab/__init__.py

@@ -0,0 +1,41 @@
+"""Public API for deterministic offline broker conformance testing."""
+
+from .generate import pairwise_cases
+from .model import (
+    Scenario,
+    ScenarioInvariantError,
+    ScenarioResult,
+    Step,
+    VenueProfile,
+)
+from .reference import (
+    HedgedReferenceVenueProfile,
+    ReferenceBroker,
+    ReferenceVenueProfile,
+    VenueOrder,
+    VenueState,
+)
+from .runner import RunRuntime, ScenarioRunner
+from .scheduler import DeterministicScheduler, ScheduledEvent
+from .subprocess import SubprocessResult, run_subprocess, temporary_entry_point
+
+__all__ = [
+    "DeterministicScheduler",
+    "HedgedReferenceVenueProfile",
+    "ReferenceBroker",
+    "ReferenceVenueProfile",
+    "RunRuntime",
+    "Scenario",
+    "ScenarioInvariantError",
+    "ScenarioResult",
+    "ScenarioRunner",
+    "ScheduledEvent",
+    "Step",
+    "SubprocessResult",
+    "VenueProfile",
+    "VenueOrder",
+    "VenueState",
+    "pairwise_cases",
+    "run_subprocess",
+    "temporary_entry_point",
+]

pynecore/testing/broker_lab/__main__.py

@@ -0,0 +1,5 @@
+"""Module entry point for the opt-in broker lab."""
+
+from .cli import main
+
+raise SystemExit(main())

pynecore/testing/broker_lab/cli.py

@@ -0,0 +1,87 @@
+"""Opt-in command-line runner for broker conformance suites."""
+
+import argparse
+from collections.abc import Sequence
+import importlib.util
+import json
+import sys
+from pathlib import Path
+from types import ModuleType
+
+from .model import Scenario
+from .runner import ScenarioRunner
+
+
+def _load_suite(path: Path) -> ModuleType:
+    spec = importlib.util.spec_from_file_location(f"pyne_broker_lab_suite_{path.stem}", path)
+    if spec is None or spec.loader is None:
+        raise RuntimeError(f"cannot load broker-lab suite: {path}")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def _scenarios(module: ModuleType, mode: str, seed: int) -> Sequence[Scenario]:
+    builder = getattr(module, "build_suite", None)
+    if builder is not None:
+        return tuple(builder(mode=mode, seed=seed))
+    scenarios = tuple(getattr(module, "SCENARIOS", ()))
+    if mode == "smoke":
+        return tuple(s for s in scenarios if "smoke" in s.tags)
+    return scenarios
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="python -m pynecore.testing.broker_lab")
+    sub = parser.add_subparsers(dest="command", required=True)
+    run = sub.add_parser("run", help="run an opt-in broker-lab suite")
+    run.add_argument("suite", type=Path)
+    run.add_argument("--mode", choices=("smoke", "extended"), default="smoke")
+    run.add_argument("--seed", type=int, default=1337)
+    run.add_argument("--scenario")
+    run.add_argument("--report", type=Path)
+    args = parser.parse_args(argv)
+
+    module = _load_suite(args.suite.resolve())
+    scenarios = list(_scenarios(module, args.mode, args.seed))
+    if args.scenario:
+        scenarios = [scenario for scenario in scenarios if scenario.name == args.scenario]
+        if not scenarios:
+            parser.error(f"unknown scenario: {args.scenario}")
+    results = [ScenarioRunner().run(scenario) for scenario in scenarios]
+    for result in results:
+        status = "PASS" if result.passed else "FAIL"
+        print(f"{status} {result.name} seed={result.seed}")
+        if result.violation:
+            print(f"  {result.violation}")
+            print(
+                "  reproduce: python -m pynecore.testing.broker_lab run "
+                f"{args.suite} --mode {args.mode} {result.reproduction}"
+            )
+            for step in result.minimized_steps:
+                print(f"    {step.kind} run={step.run} values={step.values!r}")
+    if args.report:
+        args.report.parent.mkdir(parents=True, exist_ok=True)
+        args.report.write_text(
+            json.dumps(
+                [
+                    {
+                        "name": result.name,
+                        "passed": result.passed,
+                        "seed": result.seed,
+                        "violation": result.violation,
+                        "reproduction": result.reproduction,
+                        "minimized_steps": [
+                            {"kind": s.kind, "run": s.run, "values": s.values} for s in result.minimized_steps
+                        ],
+                    }
+                    for result in results
+                ],
+                indent=2,
+                sort_keys=True,
+            )
+            + "\n",
+            encoding="utf-8",
+        )
+    return 0 if all(result.passed for result in results) else 1

pynecore/testing/broker_lab/generate.py

@@ -0,0 +1,47 @@
+"""Deterministic scenario generation without third-party dependencies."""
+
+import random
+from collections.abc import Iterable, Mapping
+from itertools import combinations, product
+from typing import Any
+
+
+def pairwise_cases(
+    axes: Mapping[str, Iterable[Any]],
+    *,
+    seed: int = 0,
+) -> list[dict[str, Any]]:
+    """Return a deterministic greedy pairwise covering array.
+
+    Every value pair from every pair of axes appears in at least one returned
+    case. The seed only breaks equal-coverage ties, so the same seed is exactly
+    reproducible across processes.
+    """
+    names = list(axes)
+    values = {name: tuple(axes[name]) for name in names}
+    if any(not value for value in values.values()):
+        raise ValueError("pairwise axes must not be empty")
+    if not names:
+        return [{}]
+    all_cases = [dict(zip(names, case)) for case in product(*(values[n] for n in names))]
+    if len(names) == 1:
+        return all_cases
+
+    uncovered = {(a, repr(av), b, repr(bv)) for a, b in combinations(names, 2) for av in values[a] for bv in values[b]}
+    rng = random.Random(seed)
+    tie_order = list(range(len(all_cases)))
+    rng.shuffle(tie_order)
+    selected: list[dict[str, Any]] = []
+    while uncovered:
+        best_idx = max(
+            tie_order,
+            key=lambda idx: sum(
+                (a, repr(all_cases[idx][a]), b, repr(all_cases[idx][b])) in uncovered for a, b in combinations(names, 2)
+            ),
+        )
+        case = all_cases[best_idx]
+        selected.append(case)
+        for a, b in combinations(names, 2):
+            uncovered.discard((a, repr(case[a]), b, repr(case[b])))
+        tie_order.remove(best_idx)
+    return selected

pynecore/testing/broker_lab/model.py

@@ -0,0 +1,84 @@
+"""Public scenario model for the offline broker conformance lab."""
+
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Protocol
+
+
+@dataclass(frozen=True)
+class Step:
+    """One deterministic broker scenario transition."""
+
+    kind: str
+    run: str = "main"
+    values: dict[str, Any] = field(default_factory=dict)
+    check_invariants: bool = True
+
+
+class VenueProfile(Protocol):
+    """Venue semantics consumed by :class:`ScenarioRunner`.
+
+    Profiles may return a real plugin instance or a deliberately small broker
+    implementation. Plugin suites normally return the real plugin with only its
+    HTTP, WebSocket, or wire transport replaced.
+    """
+
+    plugin_name: str
+    account_id: str
+    symbol: str
+    timeframe: str
+
+    def create_broker(self, run_name: str, store_ctx: Any) -> Any:
+        """Create the broker used by one logical run."""
+        ...
+
+    def handle_step(self, runner: Any, step: Step) -> bool:
+        """Apply a profile-specific step and return whether it was handled."""
+        ...
+
+    def check_invariants(self, runner: Any) -> Sequence[str]:
+        """Return invariant violations after the current transition."""
+        ...
+
+    def close(self) -> None:
+        """Release profile-owned resources."""
+        ...
+
+
+ProfileFactory = Callable[[], VenueProfile]
+
+
+@dataclass(frozen=True)
+class Scenario:
+    """A reproducible sequence executed against a fresh venue profile."""
+
+    name: str
+    profile_factory: ProfileFactory
+    steps: tuple[Step, ...]
+    runs: tuple[str, ...] = ("main",)
+    seed: int = 0
+    tags: frozenset[str] = frozenset({"smoke"})
+    expected_violation: str | None = None
+
+
+@dataclass(frozen=True)
+class ScenarioResult:
+    """Outcome and reproduction data for one scenario."""
+
+    name: str
+    passed: bool
+    seed: int
+    executed_steps: tuple[Step, ...]
+    violation: str | None = None
+    minimized_steps: tuple[Step, ...] = ()
+    artifact_dir: Path | None = None
+
+    @property
+    def reproduction(self) -> str:
+        """Return the stable seed fragment used by CLI reproduction."""
+        return f"--scenario {self.name} --seed {self.seed}"
+
+
+class ScenarioInvariantError(AssertionError):
+    """Raised when a step violates a broker-lab invariant."""