opencode-pyneruntime 6.6.4__py3-none-any.whl

pynecore/cli/commands/__init__.py

@@ -0,0 +1,343 @@
+import logging
+from pathlib import Path
+
+import typer
+from typer.core import TyperGroup
+
+from ..app import app, app_state
+from ..pluggable import PluggableCommand
+from ..utils.error_hook import setup_global_error_logging
+
+# Import commands
+from . import run, data, compile, benchmark, debug, plugin, optimize
+
+__all__ = ['run', 'data', 'compile', 'benchmark', 'debug', 'plugin', 'optimize']
+
+logger = logging.getLogger(__name__)
+
+
+@app.callback()
+def setup(
+        ctx: typer.Context,
+        workdir: Path = typer.Option(
+            app_state.workdir,
+            "--workdir", "-w",
+            envvar="PYNE_WORK_DIR",
+            help="Working directory",
+            file_okay=False, dir_okay=True,
+            resolve_path=True,
+        ),
+        recreate_demo: bool = typer.Option(
+            False,
+            "--recreate-demo",
+            help="Recreate demo.py and demo.ohlcv files even if workdir exists",
+        ),
+        recreate_provider_config: bool = typer.Option(
+            False,
+            "--recreate-provider-config",
+            help="Recreate provider.toml file even if workdir exists",
+        ),
+        recreate_api_config: bool = typer.Option(
+            False,
+            "--recreate-api-config",
+            help="Recreate api.toml file even if workdir exists",
+        )
+):
+    """
+    Pyne Command Line Interface
+    """
+    if ctx.resilient_parsing:
+        return
+
+    # If no subcommand is provided, show complete help like --help
+    if ctx.invoked_subcommand is None:
+        typer.echo(ctx.get_help())
+        raise typer.Exit(0)
+
+    typer.echo("")
+
+    # Check if workdir is available
+    workdir_existed = Path(workdir).exists()
+    if not workdir_existed:
+        typer.echo(f"Working directory '{workdir}' does not exist.")
+        typer.confirm("Do you want to create it?", abort=True)
+
+        # Create workdir
+        Path(workdir).mkdir(parents=True, exist_ok=False)
+
+    # Create the .pyne marker file so the directory is recognized as a workdir by content
+    marker_file = Path(workdir) / '.pyne'
+    if not marker_file.exists():
+        marker_file.write_text(
+            "# PyneCore workdir marker. The version refers to the workdir structure, "
+            "not your project.\n"
+            'workdir_version = "1.0"\n'
+        )
+
+    # Create scripts directory
+    scripts_dir = Path(workdir) / 'scripts' / 'lib'
+    scripts_dir.mkdir(parents=True, exist_ok=True)
+
+    # Create demo.py file only if we created the workdir in this run or recreate_demo is True
+    if not workdir_existed or recreate_demo:
+        demo_file = Path(workdir) / 'scripts' / 'demo.py'
+        if not demo_file.exists() or recreate_demo:
+            if recreate_demo and demo_file.exists():
+                typer.echo("Recreating demo.py...")
+            with demo_file.open('w') as f:
+                f.write('''"""
+@pyne
+Simple Pyne code Demo
+
+A basic demo showing a 12 and 26 period EMA crossover system.
+"""
+from pynecore import Series
+from pynecore.lib import script, input, plot, color, ta
+
+
+@script.indicator(
+    title="Simple EMA Crossover Demo",
+    shorttitle="EMA Demo",
+    overlay=True
+)
+def main(
+    src: Series[float] = input.source("close", title="Price Source"),
+    fast_length: int = input.int(12, title="Fast EMA Length"),
+    slow_length: int = input.int(26, title="Slow EMA Length")
+):
+    """
+    A simple EMA crossover demo
+    """
+    # Calculate EMAs
+    fast_ema = ta.ema(src, fast_length)
+    slow_ema = ta.ema(src, slow_length)
+
+    # Plot our indicators
+    plot(fast_ema, title="Fast EMA", color=color.blue)
+    plot(slow_ema, title="Slow EMA", color=color.red)
+''')
+
+    # Create data directory
+    data_dir = Path(workdir) / 'data'
+    data_dir.mkdir(exist_ok=True)
+
+    # Create demo.ohlcv file only if we created the workdir in this run or recreate_demo is True
+    if not workdir_existed or recreate_demo:
+        from datetime import datetime, timedelta, time as dt_time
+        from ...core.ohlcv_file import OHLCVWriter
+        from ...core.syminfo import SymInfo, SymInfoInterval, SymInfoSession
+        from ...types.ohlcv import OHLCV
+        import random
+
+        demo_file = data_dir / 'demo.ohlcv'
+        if not demo_file.exists() or recreate_demo:
+            if recreate_demo and demo_file.exists():
+                typer.echo("Recreating demo.ohlcv and demo.toml...")
+                # Remove existing files to start fresh
+                demo_file.unlink(missing_ok=True)
+                toml_path = demo_file.with_suffix(".toml")
+                toml_path.unlink(missing_ok=True)
+            # Create opening hours, session starts and ends for 24/7 trading
+            opening_hours = []
+            session_starts = []
+            session_ends = []
+
+            for day in range(7):  # 0 = Monday, 6 = Sunday
+                opening_hours.append(SymInfoInterval(
+                    day=day,
+                    start=dt_time(0, 0, 0),
+                    end=dt_time(23, 59, 59)
+                ))
+                session_starts.append(SymInfoSession(
+                    day=day,
+                    time=dt_time(0, 0, 0)
+                ))
+                session_ends.append(SymInfoSession(
+                    day=day,
+                    time=dt_time(23, 59, 59)
+                ))
+
+            # Create symbol info
+            syminfo = SymInfo(
+                prefix="DEMO",
+                description="Demo Benchmark Asset",
+                ticker="DEMOBTC",
+                currency="BTC",
+                basecurrency="DEMO",
+                period="1D",
+                type="crypto",
+                volumetype="base",
+                mintick=0.01,
+                pricescale=100,
+                minmove=1,
+                pointvalue=1.0,
+                mincontract=0.0001,
+                opening_hours=opening_hours,
+                session_starts=session_starts,
+                session_ends=session_ends,
+                timezone="UTC",
+                avg_spread=None,
+                taker_fee=0.001,
+                maker_fee=0.0005
+            )
+
+            # Save symbol info
+            toml_path = demo_file.with_suffix(".toml")
+            syminfo.save_toml(toml_path)
+
+            # Generate synthetic OHLCV data (2000 candles) with random walk
+            start_time = datetime(2020, 1, 1, 0, 0, 0)
+            base_price = 100.0
+
+            # Use fixed seed for reproducibility
+            random.seed(42)
+
+            with OHLCVWriter(demo_file) as writer:
+                current_price = base_price
+
+                for i in range(2000):
+                    timestamp = int((start_time + timedelta(days=i)).timestamp())
+
+                    # Random walk with slight upward bias
+                    change_percent = random.gauss(0.0002, 0.02)  # 0.02% mean, 2% std dev
+                    current_price *= (1 + change_percent)
+
+                    # Generate OHLC with some volatility
+                    daily_volatility = random.uniform(0.01, 0.03)
+
+                    open_price = current_price
+                    high_price = open_price * (1 + daily_volatility * random.random())
+                    low_price = open_price * (1 - daily_volatility * random.random())
+                    close_price = low_price + (high_price - low_price) * random.random()
+
+                    # Update current price for next candle
+                    current_price = close_price
+
+                    # Volume with some randomness
+                    volume = 1000000 * (1 + random.uniform(-0.5, 1.0))
+
+                    ohlcv = OHLCV(
+                        timestamp=timestamp,
+                        open=open_price,
+                        high=high_price,
+                        low=low_price,
+                        close=close_price,
+                        volume=volume,
+                        extra_fields=None
+                    )
+                    writer.write(ohlcv)
+    # Create output and logs directory
+    output_dir = Path(workdir) / 'output' / 'logs'
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Create cache directory (machine-written runtime state: auth sessions, etc.)
+    cache_dir = Path(workdir) / 'cache'
+    cache_dir.mkdir(exist_ok=True)
+
+    # Create config directory
+    config_dir = Path(workdir) / 'config'
+    config_dir.mkdir(exist_ok=True)
+
+    # Generate per-plugin config files for all installed plugins
+    from ...core.plugin import discover_plugins
+    from ...core.config import ensure_config
+
+    plugins_dir = config_dir / 'plugins'
+    plugins_dir.mkdir(exist_ok=True)
+
+    for name, ep in discover_plugins().items():
+        config_path = plugins_dir / f'{name}.toml'
+        if not config_path.exists() or recreate_provider_config:
+            try:
+                plugin_cls = ep.load()
+                if hasattr(plugin_cls, 'Config') and plugin_cls.Config is not None:
+                    ensure_config(plugin_cls.Config, config_path)
+            except Exception as e:
+                logger.warning("Failed to load plugin config '%s': %s", name, e)
+
+    # Create api.toml file for PyneSys API (if not exists)
+    api_file = config_dir / 'api.toml'
+    if not api_file.exists() or recreate_api_config:
+        with api_file.open('w') as f:
+            f.write("""[api]
+api_key = ""
+timeout = 30
+""")
+
+    # Set workdir in app_state
+    app_state.workdir = workdir
+
+    # Setup global error logging
+    setup_global_error_logging(workdir / "output" / "logs" / "error.log")
+
+
+# ---------------------------------------------------------------------------
+# CLIPlugin loading: subcommands and parameter hooks
+# ---------------------------------------------------------------------------
+_BUILTIN_COMMANDS = {'run', 'data', 'compile', 'benchmark', 'debug', 'plugin', 'optimize'}
+# Commands plugins may inject parameters into, as space-separated paths so a
+# nested subcommand (e.g. ``data download``) can be reached as well.
+_PLUGGABLE_COMMANDS = ('run', 'data download')
+
+
+def _resolve_command(group: TyperGroup, path: str) -> PluggableCommand | None:
+    """Walk a space-separated command path down to a pluggable command."""
+    parts = path.split()
+    node = group
+    for part in parts[:-1]:
+        child = node.commands.get(part)
+        if not isinstance(child, TyperGroup):
+            return None
+        node = child
+    leaf = node.commands.get(parts[-1])
+    return leaf if isinstance(leaf, PluggableCommand) else None
+
+
+def _register_cli_plugins():
+    """Load CLIPlugin subcommands and parameter hooks from installed plugins."""
+    from ...core.plugin import discover_plugins, CLIPlugin
+
+    for name, ep in discover_plugins().items():
+        try:
+            plugin_cls = ep.load()
+
+            if not (isinstance(plugin_cls, type) and issubclass(plugin_cls, CLIPlugin)):
+                continue
+
+            # 1. CLI subcommand registration
+            cli_app = plugin_cls.cli()
+            if cli_app is not None:
+                if name in _BUILTIN_COMMANDS:
+                    typer.secho(
+                        f"Warning: plugin '{name}' CLI name conflicts with "
+                        f"built-in command, skipping",
+                        fg="yellow", err=True,
+                    )
+                else:
+                    app.add_typer(cli_app, name=name)
+
+            # 2. Parameter hook registration
+            for cmd_path in _PLUGGABLE_COMMANDS:
+                params = plugin_cls.cli_params(cmd_path)
+                if not params:
+                    continue
+
+                group = typer.main.get_command(app)
+                assert isinstance(group, TyperGroup)
+                command = _resolve_command(group, cmd_path)
+                if command is None:
+                    continue
+
+                for param in params:
+                    if not command.register_plugin_param(param):
+                        typer.secho(
+                            f"Warning: plugin '{name}' param '{param.decls[0]}' "
+                            f"conflicts on '{cmd_path}'",
+                            fg="yellow", err=True,
+                        )
+
+        except Exception as e:
+            logger.warning("Failed to load CLI plugin '%s': %s", name, e)
+
+
+_register_cli_plugins()

pynecore/cli/commands/benchmark.py

@@ -0,0 +1,186 @@
+import time
+import gc
+from pathlib import Path
+import statistics
+
+from typer import Option, Argument, secho, Exit
+from rich.table import Table
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn
+
+from ..app import app, app_state
+from ...core.ohlcv_file import OHLCVReader
+from ...core.syminfo import SymInfo
+from ...core.script_runner import ScriptRunner
+
+__all__ = []
+
+
+@app.command(name="benchmark")
+def benchmark(
+        script: Path = Argument("demo", help="Script to benchmark"),
+        data: Path = Argument("demo", help="Data file to use"),
+        iterations: int = Option(10, "--iterations", "-i", help="Number of iterations to run"),
+        candles: int = Option(5000, "--candles", "-c", help="Number of candles to process"),
+        warmup: int = Option(2, "--warmup", "-w", help="Number of warmup iterations"),
+        no_output: bool = Option(True, "--no-output", help="Don't write CSV output"),
+):
+    """
+    Benchmark script execution performance
+
+    This command runs a script multiple times to measure performance.
+    By default, it uses demo.py and demo.ohlcv files from the workdir.
+    """
+
+    console = Console()
+
+    # Process script path - use same logic as run command
+    # Ensure .py extension
+    if script.suffix != ".py":
+        script = script.with_suffix(".py")
+    # Expand script path
+    if len(script.parts) == 1:
+        script = app_state.scripts_dir / script
+    # Check if script exists
+    if not script.exists():
+        secho(f"Script file '{script}' not found!", fg="red", err=True)
+        raise Exit(1)
+
+    # Process data path - similar logic
+    # Check file format and extension
+    if data.suffix == "":
+        # No extension, add .ohlcv
+        data = data.with_suffix(".ohlcv")
+    elif data.suffix != ".ohlcv":
+        # Has extension but not .ohlcv
+        secho(f"Cannot run with '{data.suffix}' files. The PyneCore runtime requires .ohlcv format.",
+              fg="red", err=True)
+        secho("If you're trying to use a different data format, please convert it first:", fg="red")
+        symbol_placeholder = "YOUR_SYMBOL"
+        timeframe_placeholder = "YOUR_TIMEFRAME"
+        secho(f"pyne data convert-from {data} --symbol {symbol_placeholder} --timeframe {timeframe_placeholder}",
+              fg="yellow")
+        raise Exit(1)
+
+    # Expand data path
+    if len(data.parts) == 1:
+        data = app_state.data_dir / data
+
+    if not data.exists():
+        secho(f"Data file '{data}' not found!", fg="red", err=True)
+        raise Exit(1)
+
+    # Load symbol info
+    try:
+        syminfo = SymInfo.load_toml(data.with_suffix(".toml"))
+    except FileNotFoundError:
+        secho(f"Symbol info file '{data.with_suffix('.toml')}' not found!", fg="red", err=True)
+        raise Exit(1)
+
+    secho(f"\nBenchmarking: {script.name}", fg="cyan")
+    secho(f"Data: {data.name} ({candles} candles)", fg="cyan")
+    secho(f"Iterations: {iterations} (warmup: {warmup})", fg="cyan")
+    secho("")
+
+    # Timing results
+    import_times = []
+    run_times = []
+    total_times = []
+
+    # Total iterations including warmup
+    total_iterations = warmup + iterations
+
+    with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+    ) as progress:
+        task = progress.add_task("Running benchmark...", total=total_iterations)
+
+        for i in range(total_iterations):
+            # Force garbage collection before each run
+            gc.collect()
+
+            # Time the whole process
+            total_start = time.perf_counter()
+
+            # Time the import
+            import_start = time.perf_counter()
+
+            # Open data file and get iterator
+            with OHLCVReader(data) as reader:
+                start_ts = reader.start_timestamp
+                assert start_ts is not None
+                # Get only the requested number of candles
+                ohlcv_list = []
+                # Use read_from to get all data from the beginning
+                for idx, ohlcv in enumerate(reader.read_from(start_ts, reader.end_timestamp)):
+                    if idx >= candles:
+                        break
+                    ohlcv_list.append(ohlcv)
+
+                # Create runner
+                runner = ScriptRunner(
+                    script,
+                    iter(ohlcv_list),
+                    syminfo,
+                    last_bar_index=len(ohlcv_list) - 1,
+                    plot_path=None if no_output else app_state.output_dir / f"benchmark_{i}.csv"
+                )
+
+                import_time = time.perf_counter() - import_start
+
+                # Time the execution
+                run_start = time.perf_counter()
+                runner.run()
+                run_time = time.perf_counter() - run_start
+
+                total_time = time.perf_counter() - total_start
+
+                # Only collect times after warmup
+                if i >= warmup:
+                    import_times.append(import_time)
+                    run_times.append(run_time)
+                    total_times.append(total_time)
+
+            progress.update(task, advance=1)
+
+            # Clean up output files if no_output
+            if no_output and (app_state.output_dir / f"benchmark_{i}.csv").exists():
+                (app_state.output_dir / f"benchmark_{i}.csv").unlink()
+
+    # Calculate statistics
+    avg_import = statistics.mean(import_times)
+    avg_run = statistics.mean(run_times)
+    avg_total = statistics.mean(total_times)
+
+    min_run = min(run_times)
+    max_run = max(run_times)
+    std_run = statistics.stdev(run_times) if len(run_times) > 1 else 0
+
+    # Candles per second
+    candles_per_second = candles / avg_run if avg_run > 0 else 0
+
+    # Create results table
+    table = Table(title="Benchmark Results", show_header=True, header_style="bold magenta")
+    table.add_column("Metric", style="cyan", no_wrap=True)
+    table.add_column("Value", justify="right", style="green")
+
+    table.add_row("Script", script.name)
+    table.add_row("Candles", str(candles))
+    table.add_row("Iterations", str(iterations))
+    table.add_row("", "")
+    table.add_row("Avg Import Time", f"{avg_import * 1000:.2f} ms")
+    table.add_row("Avg Run Time", f"{avg_run * 1000:.2f} ms")
+    table.add_row("Avg Total Time", f"{avg_total * 1000:.2f} ms")
+    table.add_row("", "")
+    table.add_row("Min Run Time", f"{min_run * 1000:.2f} ms")
+    table.add_row("Max Run Time", f"{max_run * 1000:.2f} ms")
+    table.add_row("Std Dev", f"{std_run * 1000:.2f} ms")
+    table.add_row("", "")
+    table.add_row("Candles/Second", f"{candles_per_second:.0f}")
+    table.add_row("Time per Candle", f"{avg_run / candles * 1000:.3f} ms")
+
+    console.print("")
+    console.print(table)