opencode-pyneruntime 6.6.4__py3-none-any.whl

pynecore/cli/pluggable.py

@@ -0,0 +1,132 @@
+"""
+Typer Command subclass that supports dynamic parameter injection by plugins.
+
+Typer builds the command tree from its own ``TyperCommand``/``TyperOption``
+classes.  By passing ``cls=PluggableCommand`` to ``@app.command()``, plugins
+can register extra ``--flags`` that appear in ``--help`` and are parsed
+alongside built-in parameters.
+
+Plugins describe their options with :class:`~pynecore.core.plugin.CLIOption`
+and this module turns them into the parser objects Typer expects.  Plugins
+never construct those objects themselves: Click is not a PyneCore dependency,
+and since Typer 0.26 it is not a Typer dependency either — Typer vendors a
+reduced fork of it, whose parser cannot handle foreign ``click.Option``
+instances.
+
+Plugin parameters are separated from core parameters before the callback is
+invoked, so the original function signature does not need to change.  The
+injected values are stored on ``ctx.plugin_params``.
+
+Typer rebuilds the whole command tree on every invocation
+(``typer.main.get_command`` is not cached), so registrations cannot live on a
+single command instance — they would be lost the next time the tree is built.
+The registry is therefore class-level, keyed by command name, and every rebuilt
+:class:`PluggableCommand` reads its injected parameters back from it.
+"""
+
+from typing import Any, TypeAlias
+
+from typer.core import TyperCommand, TyperOption
+# Typer has no public choice type; ``typer.main`` only re-exports this one
+# noinspection PyProtectedMember
+from typer._types import TyperChoice
+
+from ..core.plugin import CLIOption
+
+__all__ = ['PluggableCommand']
+
+# The parser context class is Typer-version dependent — Click's own before
+# Typer 0.26, Typer's vendored fork from 0.26 on — so it cannot be named
+# portably here.
+Context: TypeAlias = Any
+
+
+def _build_option(spec: CLIOption) -> TyperOption:
+    """
+    Build the parser object Typer expects from a backend-agnostic option spec.
+
+    :param spec: The plugin-provided option description.
+    :return: A Typer option ready to be added to a command.
+    """
+    param_type: Any = TyperChoice(list(spec.choices)) if spec.choices is not None else spec.type
+    return TyperOption(
+        param_decls=list(spec.decls),
+        help=spec.help or None,
+        default=spec.default,
+        # ``None`` leaves the flag/value decision to Typer's own inference
+        is_flag=spec.is_flag or None,
+        type=param_type,
+        metavar=spec.metavar,
+        required=spec.required,
+        multiple=spec.multiple,
+        hidden=spec.hidden,
+        envvar=spec.envvar,
+        rich_help_panel=spec.rich_help_panel,
+    )
+
+
+class PluggableCommand(TyperCommand):
+    """
+    A Typer command that allows plugins to inject parameters.
+
+    Usage::
+
+        @app.command(cls=PluggableCommand)
+        def run(ctx: typer.Context, script: Path = ...):
+            live = ctx.plugin_params.get('live', False)
+
+    After the command is registered, call :meth:`register_plugin_param` to add
+    plugin-provided options.
+    """
+
+    # Command-name -> injected params. Class-level so it survives Typer
+    # rebuilding the command tree on each invocation. Command names are unique
+    # leaves (e.g. "run", "download"), so the leaf name is a safe key.
+    _plugin_param_registry: dict[str, list[TyperOption]] = {}
+
+    def register_plugin_param(self, spec: CLIOption) -> bool:
+        """
+        Register a plugin-provided parameter for this command.
+
+        Checks both parameter names and option strings (e.g. ``--from``, ``-f``)
+        against the core parameters and already-registered plugin parameters to
+        prevent conflicts.
+
+        :param spec: The option to inject.
+        :return: ``False`` if the name or any option string conflicts.
+        """
+        param = _build_option(spec)
+        registered = self._plugin_param_registry.setdefault(self.name or "", [])
+        all_params = [*self.params, *registered]
+
+        existing_names = {p.name for p in all_params}
+        if param.name in existing_names:
+            return False
+
+        existing_opts = {opt for p in all_params for opt in getattr(p, 'opts', ())}
+        new_opts = set(getattr(param, 'opts', ()))
+        if existing_opts & new_opts:
+            return False
+
+        registered.append(param)
+        return True
+
+    def _plugin_params(self) -> list[TyperOption]:
+        """Injected parameters registered for this command name."""
+        return self._plugin_param_registry.get(self.name or "", [])
+
+    def get_params(self, ctx: Context) -> list[Any]:
+        """Return core params + plugin params + help option."""
+        rv = [*self.params, *self._plugin_params()]
+        help_option = self.get_help_option(ctx)
+        if help_option is not None:
+            rv.append(help_option)
+        return rv
+
+    def invoke(self, ctx: Context) -> None:
+        """Pop plugin params from ctx.params before calling the callback."""
+        ctx.plugin_params = {}
+        for p in self._plugin_params():
+            if p.name in ctx.params:
+                ctx.plugin_params[p.name] = ctx.params.pop(p.name)
+        return super().invoke(ctx)

pynecore/cli/utils/api_error_handler.py

@@ -0,0 +1,168 @@
+"""Centralized API error handling utilities for CLI commands."""
+
+import re
+
+from rich.console import Console
+from typer import Exit
+
+from pynecore.pynesys.api import APIError, AuthError, RateLimitError, CompilationError
+
+
+class APIErrorHandler:
+    """Context manager that provides centralized API error handling."""
+
+    def __init__(self, console: Console | None = None):
+        self.console: Console = console or Console()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        if exc_type is None:
+            return False
+
+        if exc_type == CompilationError:
+            self._handle_compilation_error(exc_value)
+        elif exc_type == AuthError:
+            self._handle_auth_error(exc_value)
+        elif exc_type == RateLimitError:
+            self._handle_rate_limit_error(exc_value)
+        elif exc_type == APIError:
+            self._handle_api_error(exc_value)
+        else:
+            return False  # Let other exceptions propagate
+
+        raise Exit(1)
+
+    def _handle_compilation_error(self, e: CompilationError):
+        """Handle compilation-specific errors."""
+        self.console.print(f"[red]Oops! Compilation encountered an issue:[/red] {str(e)}")
+        if e.validation_errors:
+            self.console.print("[red]Validation errors:[/red]")
+            for error in e.validation_errors:
+                self.console.print(f"  [red]• {error}[/red]")
+
+    def _handle_auth_error(self, e: AuthError):
+        """Handle authentication errors."""
+        self.console.print(f"[red]Authentication issue:[/red] {str(e)}")
+        self.console.print("[yellow]To fix:[/yellow] Check [cyan]api_key[/cyan] in [cyan]api.toml[/cyan] "
+                           "in your working directory")
+
+    def _handle_rate_limit_error(self, e: RateLimitError):
+        """Handle rate limit errors."""
+        self.console.print("[red]Rate Limit Exceeded:[/red] You've hit your compilation limit")
+        if e.retry_after:
+            self.console.print(f"[yellow]Please try again in {e.retry_after} seconds[/yellow]")
+        self.console.print(
+            "[yellow]To increase your limits, consider upgrading your subscription at "
+            "[link=https://pynesys.io]https://pynesys.io[/link]")
+
+    def _handle_api_error(self, e: APIError):
+        """Handle general API errors with specific status code handling."""
+        error_msg = str(e).lower()
+
+        # Handle specific API error scenarios based on HTTP status codes
+        has_400_error = "400" in error_msg or "bad request" in error_msg
+        has_structured_error = (
+            '"detail":' in error_msg and 
+            '"error":' in error_msg and 
+            '"line":' in error_msg
+        )
+        
+        if has_400_error or has_structured_error:
+            if "compilation fails" in error_msg or "script is too large" in error_msg:
+                self.console.print("[red]Script Issue:[/red] Your Pine Script couldn't be compiled")
+                self.console.print("[yellow]Common fixes:[/yellow]")
+                self.console.print("  • Check if your script is too large (try breaking it into smaller parts)")
+                self.console.print("  • Verify your Pine Script syntax is correct")
+                self.console.print("  • Make sure you're using Pine Script v6 syntax")
+            else:
+                # Try to parse structured error response (JSON-like format)
+                error_str = str(e)
+                structured_error_parsed = False
+
+                # Check for structured JSON error format
+                has_error_and_line = (
+                    ("'error':" in error_str and "'line':" in error_str) or
+                    ('"error":' in error_str and '"line":' in error_str)
+                )
+                
+                if has_error_and_line:
+                    # Pattern for JSON format: {"detail":{"error":"...","line":...,"file":"..."}}
+                    json_pattern = (
+                        r'\{"detail":\{"status":"error","error":"([^"]+)",' +
+                        r'"line":(\d+),"file":"([^"]+)"\}\}'
+                    )
+                    match = re.search(json_pattern, error_str)
+                    if match:
+                        error_msg, line_num, file_name = match.groups()
+                        self.console.print(f"[red]Script Error:[/red] {error_msg}")
+                        self.console.print(
+                            f"[yellow]Location:[/yellow] Line {line_num} in {file_name}"
+                        )
+                        self.console.print(
+                            "[yellow]Quick fix:[/yellow] Check the variable declaration and spelling"
+                        )
+                        structured_error_parsed = True
+
+                # Fallback to generic error display if structured parsing failed
+                if not structured_error_parsed:
+                    self.console.print(f"[red]Script Error:[/red] {str(e)}")
+                    self.console.print("[yellow]Common causes:[/yellow]")
+                    self.console.print("  • Pine Script syntax errors")
+                    self.console.print("  • Unsupported Pine Script features")
+                    self.console.print("  • Incorrect variable declarations or usage")
+
+        elif "401" in error_msg or "authentication" in error_msg or "no permission" in error_msg:
+            self.console.print("[red]Authentication Failed:[/red] Your API credentials aren't working")
+            self.console.print("[yellow]Quick fixes:[/yellow]")
+            self.console.print("  • Check if your API key is valid and active")
+            self.console.print("  • Verify your token type is allowed for compilation")
+            self.console.print(
+                "Get a new API key at [link=https://pynesys.io]https://pynesys.io[/link]")
+            self.console.print(
+                "Then run [cyan]'pyne api configure'[/cyan] to update your configuration")
+
+        elif "404" in error_msg or "not found" in error_msg:
+            self.console.print("[red]Not Found:[/red] The API endpoint or user wasn't found")
+            self.console.print("[yellow]This might indicate:[/yellow]")
+            self.console.print("  • Your account may not exist or be accessible")
+            self.console.print("  • There might be a temporary service issue")
+
+        elif "422" in error_msg or "validation error" in error_msg:
+            self.console.print("[red]Validation Error:[/red] Your request data has validation issues")
+            self.console.print("[yellow]Common causes:[/yellow]")
+            self.console.print("  • Invalid Pine Script syntax or structure")
+            self.console.print("  • Missing required parameters")
+            self.console.print("  • Incorrect data format")
+            self.console.print(f"[dim]Details: {str(e)}[/dim]")
+
+        elif "429" in error_msg or "rate limit" in error_msg or "too many requests" in error_msg:
+            self.console.print("[red]Rate Limit Exceeded:[/red] You've hit your compilation limit")
+            self.console.print("[yellow]What you can do:[/yellow]")
+            self.console.print("  • Wait a bit before trying again")
+            self.console.print("  • Consider upgrading your plan for higher limits")
+
+        elif "500" in error_msg or "server" in error_msg or "internal" in error_msg:
+            self.console.print("[red]Server Error:[/red] Something went wrong on our end")
+            self.console.print("  • This is a temporary server issue")
+            self.console.print("  • Please try again in a few moments")
+
+        elif "unsupported pinescript version" in error_msg:
+            self.console.print("[red]Version Issue:[/red] Your Pine Script version isn't supported")
+            if "version 5" in error_msg:
+                self.console.print("[yellow]Pine Script v5 → v6 Migration:[/yellow]")
+                self.console.print("  • Update your script to Pine Script version 6")
+                self.console.print("  • Most v5 scripts need minimal changes")
+            else:
+                self.console.print("[yellow]Only Pine Script version 6 is currently supported[/yellow]")
+
+        elif "api key" in error_msg:
+            self.console.print("[red]API Key Issue:[/red] There's a problem with your API key")
+            self.console.print("Get your API key at [link=https://pynesys.io]https://pynesys.io[/link]")
+            self.console.print(
+                "Then run [cyan]'pyne api configure'[/cyan] to set up your configuration")
+
+        else:
+            # Generic API error fallback
+            self.console.print(f"[red]API Error:[/red] {str(e)}")

pynecore/cli/utils/broker_picker.py

@@ -0,0 +1,330 @@
+"""
+Interactive broker / exchange picker TUI for multi-broker data providers.
+
+Multi-broker providers (CCXT serves ~100 crypto exchanges, cTrader serves every
+broker the user holds an account with) need a backend chosen before a symbol can
+be browsed. This module renders a single-pane, filterable, scrollable list on the
+alternate screen buffer via ``rich.live`` and returns the chosen broker id, or
+``None`` if the user quits without picking.
+
+Navigation mirrors :class:`~pynecore.cli.utils.symbol_browser.SymbolBrowser`:
+arrow keys / PgUp / PgDn / Home / End move the cursor, ``/`` starts a substring
+filter, ENTER selects, ``q`` / ESC quits.
+"""
+import shutil
+import sys
+import threading
+from typing import Protocol, Sequence
+
+from rich.console import Console, Group
+from rich.layout import Layout
+from rich.live import Live
+from rich.panel import Panel
+from rich.text import Text
+
+from .keyreader import Key, KeyOrChar, raw_terminal, read_key
+
+# Footer block is one line of help text inside a Panel (2 border lines).
+_FOOTER_HEIGHT = 3
+
+# Panel top + bottom border lines deducted from the list panel height.
+_LIST_CHROME_LINES = 2
+
+
+class PickerItem(Protocol):
+    """Structural type for an item shown by :class:`BrokerPicker`."""
+
+    @property
+    def id(self) -> str:
+        ...
+
+    @property
+    def name(self) -> str:
+        ...
+
+
+class BrokerPicker:
+    """Single-pane filterable list of broker / exchange ids.
+
+    Each row shows the id selector and, when the provider supplies one, a
+    human-readable name in a second column. Filtering matches either column;
+    selection returns the chosen broker's id.
+
+    :ivar selected: The chosen broker id once :meth:`run` returns, else ``None``.
+    """
+
+    def __init__(self, brokers: Sequence[PickerItem], *, provider_name: str,
+                 item_name: str = "brokers"):
+        """
+        :param brokers: The brokers / exchanges to choose from.
+        :param provider_name: Provider name shown in the panel title.
+        :param item_name: Plural name shown after ``provider_name`` in the title.
+        """
+        self.brokers: list[PickerItem] = list(brokers)
+        self.provider_name = provider_name
+        self.item_name = item_name
+
+        # View state.
+        self.filtered: list[PickerItem] = list(self.brokers)
+        self.cursor: int = 0
+        self.scroll_offset: int = 0
+        self.filter_text: str = ''
+        self.filter_active: bool = False
+
+        # Result.
+        self.selected: str | None = None
+
+        # Optional error shown above the help footer. The caller sets it before
+        # re-running the picker when the chosen broker could not be opened (e.g.
+        # an exchange that needs API credentials), so the user can pick another
+        # without the command exiting.
+        self.error: str | None = None
+
+        # Resize state (Unix uses SIGWINCH; Windows polls size).
+        self.resize_event: threading.Event = threading.Event()
+        self.last_size: object = shutil.get_terminal_size()
+        self._old_sigwinch = None
+
+    # ---- filter + navigation -----------------------------------------
+
+    def _apply_filter(self) -> None:
+        if self.filter_text:
+            needle = self.filter_text.lower()
+            self.filtered = [b for b in self.brokers
+                             if needle in b.id.lower() or needle in b.name.lower()]
+        else:
+            self.filtered = list(self.brokers)
+        if self.cursor >= len(self.filtered):
+            self.cursor = max(0, len(self.filtered) - 1)
+        self.scroll_offset = 0
+
+    def _move_cursor(self, delta: int) -> None:
+        if not self.filtered:
+            self.cursor = 0
+            return
+        self.cursor = max(0, min(len(self.filtered) - 1, self.cursor + delta))
+
+    def _ensure_cursor_visible(self, list_height: int) -> None:
+        if list_height <= 0:
+            return
+        if self.cursor < self.scroll_offset:
+            self.scroll_offset = self.cursor
+        elif self.cursor >= self.scroll_offset + list_height:
+            self.scroll_offset = self.cursor - list_height + 1
+
+    # ---- key handling -------------------------------------------------
+
+    def _handle_key(self, key: KeyOrChar) -> bool:
+        """Return False to request exit, True to continue."""
+        prev_cursor = self.cursor
+        prev_filter = self.filter_text
+        if self.filter_active:
+            result = self._handle_filter_key(key)
+        else:
+            result = self._handle_normal_key(key)
+        # A broker-open error belongs to the row it was raised on; once the user
+        # moves the highlight or changes the filter it is stale and misleading,
+        # so clear it as soon as the view selection changes.
+        if self.cursor != prev_cursor or self.filter_text != prev_filter:
+            self.error = None
+        return result
+
+    def _select_current(self) -> bool:
+        """Commit the highlighted broker's id and request exit."""
+        if self.filtered:
+            self.selected = self.filtered[self.cursor].id
+        return False
+
+    def _handle_filter_key(self, key: KeyOrChar) -> bool:
+        if key is Key.ESC:
+            self.filter_active = False
+            if self.filter_text:
+                self.filter_text = ''
+                self._apply_filter()
+            return True
+        if key is Key.ENTER:
+            self.filter_active = False
+            return self._select_current()
+        if key is Key.BACKSPACE:
+            if self.filter_text:
+                self.filter_text = self.filter_text[:-1]
+                self._apply_filter()
+            else:
+                self.filter_active = False
+            return True
+        # Navigation keys exit the filter (keeping the typed text as the active
+        # list filter) and move the cursor, mirroring the symbol browser.
+        if key is Key.UP:
+            self.filter_active = False
+            self._move_cursor(-1)
+            return True
+        if key is Key.DOWN:
+            self.filter_active = False
+            self._move_cursor(1)
+            return True
+        if key is Key.PAGE_UP:
+            self.filter_active = False
+            self._move_cursor(-10)
+            return True
+        if key is Key.PAGE_DOWN:
+            self.filter_active = False
+            self._move_cursor(10)
+            return True
+        if isinstance(key, str) and key.isprintable():
+            self.filter_text += key
+            self._apply_filter()
+            return True
+        return True
+
+    def _handle_normal_key(self, key: KeyOrChar) -> bool:
+        if isinstance(key, str):
+            if key == 'q':
+                return False
+            if key == '/':
+                self.filter_active = True
+            return True
+        if key is Key.ESC:
+            return False
+        if key is Key.ENTER:
+            return self._select_current()
+        if key is Key.UP:
+            self._move_cursor(-1)
+        elif key is Key.DOWN:
+            self._move_cursor(1)
+        elif key is Key.PAGE_UP:
+            self._move_cursor(-10)
+        elif key is Key.PAGE_DOWN:
+            self._move_cursor(10)
+        elif key is Key.HOME:
+            self.cursor = 0
+        elif key is Key.END:
+            self.cursor = max(0, len(self.filtered) - 1)
+        return True
+
+    # ---- rendering ----------------------------------------------------
+
+    def _render_list(self, height: int) -> Panel:
+        list_height = max(1, height - _LIST_CHROME_LINES)
+        self._ensure_cursor_visible(list_height)
+        end = self.scroll_offset + list_height
+        visible = self.filtered[self.scroll_offset:end]
+        # Align the name column to the widest id in the full list so it stays
+        # put while scrolling/filtering; only pad when at least one name exists.
+        id_width = max((len(b.id) for b in self.brokers), default=0)
+        has_names = any(b.name for b in self.brokers)
+        lines: list[Text] = []
+        for i, broker in enumerate(visible):
+            idx = self.scroll_offset + i
+            if has_names:
+                label = f"{broker.id:<{id_width}}  {broker.name}".rstrip()
+            else:
+                label = broker.id
+            if idx == self.cursor:
+                lines.append(Text(f"> {label}", style="bold reverse"))
+            else:
+                lines.append(Text(f"  {label}"))
+        if not lines:
+            lines.append(Text("  (no matches)", style="dim"))
+        title_parts = [f"{self.provider_name} {self.item_name} "
+                       f"({len(self.filtered)}/{len(self.brokers)})"]
+        if self.filter_active or self.filter_text:
+            cursor_marker = "_" if self.filter_active else ""
+            title_parts.append(f"/{self.filter_text}{cursor_marker}")
+        title = "  ".join(title_parts)
+        return Panel(Group(*lines), title=title, title_align="left")
+
+    def _footer_height(self) -> int:
+        """Footer grows by one row when an error line is shown."""
+        return _FOOTER_HEIGHT + (1 if self.error else 0)
+
+    def _render_footer(self) -> Panel:
+        help_text = Text(
+            "Up Down: navigate  -  PgUp PgDn: jump 10  -  /: search  -  "
+            "Enter: select  -  q: quit",
+            style="dim",
+        )
+        if self.error:
+            return Panel(Group(Text(self.error, style="red"), help_text),
+                         height=self._footer_height())
+        return Panel(help_text, height=_FOOTER_HEIGHT)
+
+    def _build_layout(self, console: Console) -> Layout:
+        footer_height = self._footer_height()
+        height = max(footer_height + 3, console.size.height)
+        list_height = height - footer_height
+        layout = Layout()
+        layout.split_column(
+            Layout(self._render_list(list_height), name="list"),
+            Layout(self._render_footer(), name="footer", size=footer_height),
+        )
+        return layout
+
+    # ---- resize handling ---------------------------------------------
+
+    def _install_sigwinch(self) -> None:
+        if sys.platform == 'win32':
+            return
+        import signal
+        self._old_sigwinch = signal.signal(
+            signal.SIGWINCH, lambda *_: self.resize_event.set()
+        )
+
+    def _restore_sigwinch(self) -> None:
+        if sys.platform == 'win32' or self._old_sigwinch is None:
+            return
+        import signal
+        signal.signal(signal.SIGWINCH, self._old_sigwinch)
+        self._old_sigwinch = None
+
+    def _check_size_change(self) -> bool:
+        """Windows fallback: detect resize by polling terminal size."""
+        if sys.platform != 'win32':
+            return False
+        current = shutil.get_terminal_size()
+        if current != self.last_size:
+            self.last_size = current
+            return True
+        return False
+
+    # ---- run loop -----------------------------------------------------
+
+    def run(self) -> str | None:
+        """Render the picker and block until the user selects or quits.
+
+        :return: The chosen broker id, or ``None`` if the user quit.
+        """
+        if not self.brokers:
+            print(f"No {self.item_name} available.", file=sys.stderr)
+            return None
+
+        # Reset so the picker can be re-run after a failed broker attempt.
+        self.selected = None
+
+        console = Console()
+        self._install_sigwinch()
+        try:
+            with raw_terminal():
+                with Live(
+                    self._build_layout(console),
+                    console=console,
+                    screen=True,
+                    auto_refresh=False,
+                ) as live:
+                    self._main_loop(live, console)
+        except KeyboardInterrupt:
+            return None
+        finally:
+            self._restore_sigwinch()
+        return self.selected
+
+    def _main_loop(self, live: Live, console: Console) -> None:
+        while True:
+            key = read_key(timeout=0.05)
+            if key is not None:
+                if not self._handle_key(key):
+                    return
+            if self.resize_event.is_set():
+                self.resize_event.clear()
+            self._check_size_change()
+            live.update(self._build_layout(console))
+            live.refresh()

pynecore/cli/utils/error_hook.py

@@ -0,0 +1,28 @@
+import sys
+import traceback
+from pathlib import Path
+
+
+def setup_global_error_logging(log_path: Path):
+    """
+    Sets up a global error logging mechanism that writes uncaught exceptions to a logfile.
+
+    :param log_path: Path to the log file where uncaught exceptions will be written.
+    """
+    # Creating the log file directory
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+    # Remove last error file if exists
+    if log_path.exists():
+        log_path.unlink()
+
+    # Save the original excepthook
+    original_excepthook = sys.excepthook
+
+    # Exception handler – saves the raw stack trace to a file
+    def log_and_reraise(exc_type, exc_value, tb):
+        tb_str = ''.join(traceback.format_exception(exc_type, exc_value, tb))
+        log_path.write_text(tb_str, encoding="utf-8")
+        original_excepthook(exc_type, exc_value, tb)
+
+    # Set the new excepthook
+    sys.excepthook = log_and_reraise