opencode-pyneruntime 6.6.4__py3-none-any.whl

pynecore/types/strategy.py

@@ -0,0 +1,45 @@
+from .base import StrLiteral
+
+ADOPTED_STARTUP_ENTRY_ID = "__adopted_startup__"
+"""Synthetic FIFO parent-trade id seeded by startup adoption.
+
+When a fresh process restarts over an existing broker position and the real
+Pine parent entry id cannot be recovered (no bracket, or a pyramided
+multi-parent position), the sync engine seeds the adopted size under this
+synthetic id. The id deliberately does NOT match any real ``strategy.entry``
+id, so both the close-quantity clamp and the ``strategy.close(id)`` binding
+must treat an open FIFO that carries it as untracked exposure: a keyed
+``strategy.close(id)`` that misses every faithful id must still be allowed to
+flatten the adopted position rather than be dropped.
+"""
+
+ADOPTED_STARTUP_EXTRA_KEY = "adopted_startup"
+"""``OrderRow.extras`` flag marking a store row a plugin synthesized at startup
+for an *untracked* live venue leg (one this run has no durable journal for).
+
+Such rows exist purely so the normal close/exit paths have a confirmed
+``position`` row to route a DELETE/opposite-close against — they are NOT a
+product of THIS run's own orders. Startup run-ownership reconstruction
+(:meth:`OrderSyncEngine._durable_owned_signed_size`) must therefore exclude
+them: on a one-way (netting) account two runs share one venue net, and a leg
+this run merely adopted for bookkeeping belongs to another run. Counting it as
+owned would re-inflate the ownership clamp and let the run copy a foreign
+run's exposure into ``_position`` — the very cross-run double count the clamp
+exists to prevent.
+"""
+
+
+class QtyType(StrLiteral):
+    ...
+
+
+class Direction(StrLiteral):
+    ...
+
+
+class Commission(StrLiteral):
+    ...
+
+
+class Oca(StrLiteral):
+    ...

pynecore/types/table.py

@@ -0,0 +1,87 @@
+from typing import Optional, Dict, Tuple
+from dataclasses import dataclass, field
+
+from ..lib import (color as _color, position as _position, size as _size, text as _text, font as _font)
+
+
+@dataclass(slots=True)
+class TableCell:
+    """Represents a single cell in a table."""
+    text: str = ""
+    width: int | float = 0
+    height: int | float = 0
+    text_color: Optional[_color.Color] = None
+    text_halign: Optional[_text.AlignEnum] = None
+    text_valign: Optional[_text.AlignEnum] = None
+    text_size: int | str = _size.normal
+    bgcolor: Optional[_color.Color] = None
+    tooltip: str = ""
+    text_font_family: Optional[_font.FontFamilyEnum] = None
+    text_formatting: Optional[_text.FormatEnum] = None
+
+    # Merge information
+    is_merged: bool = False
+    merge_start_col: int = -1
+    merge_start_row: int = -1
+    merge_end_col: int = -1
+    merge_end_row: int = -1
+
+
+@dataclass(slots=True, eq=False)
+class Table:
+    # Required parameters
+    position: _position.Position  # Position of the table
+    columns: int  # Number of columns
+    rows: int  # Number of rows
+
+    # Optional parameters with defaults
+    bgcolor: Optional[_color.Color] = None
+    frame_color: Optional[_color.Color] = None
+    frame_width: int = 0
+    border_color: Optional[_color.Color] = None
+    border_width: int = 0
+    force_overlay: bool = False
+
+    # Cell data storage - using (column, row) as key
+    cells: Dict[Tuple[int, int], TableCell] = field(default_factory=dict)
+
+    vid: int = -1
+
+    def get_cell(self, column: int, row: int) -> TableCell:
+        """Get or create a cell at the specified position."""
+        if (column, row) not in self.cells:
+            self.cells[(column, row)] = TableCell()
+        return self.cells[(column, row)]
+
+    def set_cell(self, column: int, row: int, cell: TableCell) -> None:
+        """Set a cell at the specified position."""
+        self.cells[(column, row)] = cell
+
+    def clear_cell(self, column: int, row: int) -> None:
+        """Clear a cell at the specified position."""
+        if (column, row) in self.cells:
+            del self.cells[(column, row)]
+
+    def clear_cells(self, start_column: int, start_row: int, end_column: int, end_row: int) -> None:
+        """Clear a range of cells."""
+        for col in range(start_column, end_column + 1):
+            for row in range(start_row, end_row + 1):
+                self.clear_cell(col, row)
+
+    def merge_cells(self, start_column: int, start_row: int, end_column: int, end_row: int) -> None:
+        """Merge a range of cells."""
+        # Create or get the main cell (top-left)
+        main_cell = self.get_cell(start_column, start_row)
+
+        # Mark cells in the range as merged
+        for col in range(start_column, end_column + 1):
+            for row in range(start_row, end_row + 1):
+                cell = self.get_cell(col, row)
+                cell.is_merged = True
+                cell.merge_start_col = start_column
+                cell.merge_start_row = start_row
+                cell.merge_end_col = end_column
+                cell.merge_end_row = end_row
+
+        # The main cell retains its content, others are effectively hidden
+        main_cell.is_merged = True

pynecore/types/text.py

@@ -0,0 +1,13 @@
+from .base import StrLiteral
+
+
+class AlignEnum(StrLiteral):
+    ...
+
+
+class FormatEnum(StrLiteral):
+    ...
+
+
+class WrapEnum(StrLiteral):
+    ...

pynecore/types/type_checker.py

@@ -0,0 +1,7 @@
+from builtins import float, int, bool  # noqa
+
+__all__ = [
+    "float",
+    "int",
+    "bool"
+]

pynecore/types/type_checker.pyi

@@ -0,0 +1,48 @@
+"""
+Pine Script type checker compatibility layer.
+
+In Pine Script (and PyneCore), every variable is implicitly a Series — meaning even a plain
+``float`` supports historical indexing like ``close[1]`` (the previous bar's value). At runtime
+the AST transformer handles this, but IDEs (PyCharm, etc.) only see the static types. Since
+``Series[float]`` is a transparent alias for ``float`` (see series.pyi), strict type checkers
+complain that ``float`` has no ``__getitem__``.
+
+This module solves it by re-exporting ``float``, ``int``, and ``bool`` as enhanced subclasses
+**only under TYPE_CHECKING** (i.e., only visible to the IDE, zero runtime cost). The enhanced
+versions inherit from their builtins and add ``__getitem__``, so every member of the Series union
+becomes indexable in the IDE's eyes.
+
+Usage in @pyne files (via the TypeCheckingStripperTransformer, these are removed at runtime)::
+
+    from typing import TYPE_CHECKING
+    if TYPE_CHECKING:
+        from pynecore.types.type_checker import *
+
+Or import via ``pine_types`` which re-exports these automatically::
+
+    from pynecore.types import PyneFloat  # already includes the enhanced float
+
+Pyright/basedpyright: set ``"defineConstant": {"TYPECHECKER": "pyright"}`` in pyrightconfig.json
+PyCharm: set ``TYPECHECKER=pycharm`` environment variable
+"""
+import builtins
+
+TYPECHECKER: str
+
+if TYPECHECKER == "pycharm":
+    # noinspection PyPep8Naming,PyRedeclaration,PyShadowingBuiltins
+    class float(builtins.float):
+        def __getitem__(self, index: builtins.int) -> builtins.float: ...
+
+    # noinspection PyPep8Naming,PyRedeclaration,PyShadowingBuiltins
+    class int(builtins.int):
+        def __getitem__(self, index: builtins.int) -> builtins.int: ...
+
+    # noinspection PyPep8Naming,PyRedeclaration,PyShadowingBuiltins
+    class bool(builtins.bool):  # type: ignore
+        def __getitem__(self, index: builtins.int) -> builtins.bool: ...
+
+else:
+    float = builtins.float
+    int = builtins.int
+    bool = builtins.bool

pynecore/types/volume_row.py

@@ -0,0 +1,36 @@
+from dataclasses import dataclass
+
+
+@dataclass(slots=True)
+class VolumeRow:
+    """
+    Represents a single price row within a footprint bar. Contains volume data
+    for a specific price level, including buy/sell volume and price boundaries.
+
+    Returned by footprint methods such as ``footprint.vah()``, ``footprint.val()``,
+    and ``footprint.poc()``.
+    """
+
+    def up_price(self) -> float:
+        """Upper price boundary of the row."""
+        raise NotImplementedError("VolumeRow.up_price() is not yet implemented in PyneCore")
+
+    def down_price(self) -> float:
+        """Lower price boundary of the row."""
+        raise NotImplementedError("VolumeRow.down_price() is not yet implemented in PyneCore")
+
+    def buy_volume(self) -> float:
+        """Buy volume for this row."""
+        raise NotImplementedError("VolumeRow.buy_volume() is not yet implemented in PyneCore")
+
+    def sell_volume(self) -> float:
+        """Sell volume for this row."""
+        raise NotImplementedError("VolumeRow.sell_volume() is not yet implemented in PyneCore")
+
+    def delta(self) -> float:
+        """Volume delta (buy - sell) for this row."""
+        raise NotImplementedError("VolumeRow.delta() is not yet implemented in PyneCore")
+
+    def total_volume(self) -> float:
+        """Total volume for this row."""
+        raise NotImplementedError("VolumeRow.total_volume() is not yet implemented in PyneCore")

pynecore/types/weekdays.py

@@ -0,0 +1,11 @@
+from enum import IntEnum
+
+
+class Weekdays(IntEnum):
+    Sun = 6
+    Mon = 0
+    Tue = 1
+    Wed = 2
+    Thu = 3
+    Fri = 4
+    Sat = 5

pynecore/types/xloc.py

@@ -0,0 +1,5 @@
+from .base import StrLiteral
+
+
+class XLoc(StrLiteral):
+    ...

pynecore/types/yloc.py

@@ -0,0 +1,5 @@
+from .base import StrLiteral
+
+
+class YLoc(StrLiteral):
+    ...

pynecore/utils/file_utils.py

@@ -0,0 +1,50 @@
+"""
+File utilities
+"""
+import os
+from pathlib import Path
+
+
+def copy_mtime(source_path: Path, target_path: Path) -> bool:
+    """Copy modification time from source to target file.
+
+    :param source_path: Source file to copy mtime from
+    :param target_path: Target file to set mtime on
+    :return: True if successful, False otherwise
+    """
+    try:
+        source_mtime = source_path.stat().st_mtime
+    except (OSError, FileNotFoundError):
+        return False
+
+    try:
+        os.utime(target_path, (source_mtime, source_mtime))
+        return True
+    except (OSError, FileNotFoundError):
+        return False
+
+
+def is_updated(src_path: Path, dest_path: Path) -> bool:
+    """
+    Check if a file is updated using modification time comparison.
+
+    :param src_path: Path to the .pine file
+    :param dest_path: Path to the compiled .py file
+    :return: True if compilation is needed, False otherwise
+    :raises FileNotFoundError: If pine file doesn't exist
+    :raises OSError: If we can't get modification times
+    """
+
+    # If output file doesn't exist, compilation is needed
+    if not dest_path.exists():
+        return True
+    # If source file doesn't exist, assume compilation is needed
+    if not src_path.exists():
+        raise FileNotFoundError(f"Source file not found: {src_path}")
+
+    # Get modification times
+    src_mtime = os.path.getmtime(src_path)
+    dst_mtime = os.path.getmtime(dest_path)
+
+    # If source is newer than output, compilation is needed
+    return src_mtime > dst_mtime

pynecore/utils/rich/date_column.py

@@ -0,0 +1,25 @@
+from datetime import datetime, timedelta
+
+from rich.text import Text
+from rich.progress import ProgressColumn
+
+
+class DateColumn(ProgressColumn):
+    """Custom progress column showing the current date being processed.
+
+    The start time can come from the constructor (when the task spans a
+    single fixed range) or from a per-task ``start_time`` field — useful
+    for retry loops that re-anchor the start as they extend the request
+    window without spawning a new spinner each time.
+    """
+
+    def __init__(self, start_time: datetime | None = None):
+        super().__init__()
+        self.start_time = start_time
+
+    def render(self, task) -> Text:
+        start_time = task.fields.get('start_time', self.start_time)
+        if start_time is None:
+            return Text("")
+        current_date = start_time + timedelta(seconds=task.completed)
+        return Text(current_date.strftime("%Y-%m-%d %H:%M"), style="magenta")

pynecore/utils/sequence_view.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+from collections.abc import MutableSequence
+from typing import TypeVar, Iterator, cast, overload
+
+T = TypeVar('T')
+
+
+class SequenceView(MutableSequence[T]):
+    """
+    A view for list slice
+
+    Useful for creating a slice of list but modifying the slice will modify the original list.
+    And vice versa.
+
+    Mutating operations (append/insert/pop/remove/etc. — provided by the
+    ``MutableSequence`` mixin on top of ``insert`` and ``__delitem__``) write
+    through to the parent sequence, matching Pine's ``array.slice`` semantics
+    where pushing to or removing from a slice also grows or shrinks the original
+    array. ``array.slice`` always builds a contiguous, forward (step 1) range.
+    """
+
+    __slots__ = ('sequence', 'range')
+
+    def __init__(self, sequence: MutableSequence[T], range_object: range | None = None) -> None:
+        self.range: range = range_object if range_object is not None else range(len(sequence))
+        self.sequence = sequence
+
+    @overload
+    def __getitem__(self, key: int) -> T: ...
+
+    @overload
+    def __getitem__(self, key: slice) -> SequenceView[T]: ...
+
+    def __getitem__(self, key: int | slice) -> T | SequenceView[T]:
+        if isinstance(key, slice):
+            return SequenceView(self.sequence, self.range[key])
+        else:
+            return self.sequence[self.range[key]]
+
+    def __setitem__(self, key: int | slice, value: T) -> None:
+        if isinstance(key, slice):
+            for i in self.range[key]:
+                self.sequence[i] = value
+        else:
+            self.sequence[self.range[key]] = value
+
+    def __delitem__(self, key: int | slice) -> None:
+        if isinstance(key, slice):
+            # Delete from the parent at the mapped indices, highest first so the
+            # earlier indices stay valid; then shrink this view's range.
+            removed = 0
+            for i in sorted(self.range[key], reverse=True):
+                del self.sequence[i]
+                removed += 1
+            self.range = range(self.range.start, self.range.stop - removed)
+        else:
+            n = len(self.range)
+            if key < 0:
+                key += n
+            if not 0 <= key < n:
+                raise IndexError("SequenceView index out of range")
+            del self.sequence[self.range[key]]
+            self.range = range(self.range.start, self.range.stop - 1)
+
+    def insert(self, index: int, value: T) -> None:
+        # Insert into the parent at the mapped position and extend this view's
+        # range by one. Index is clamped like list.insert (append maps to the
+        # slice end, i.e. parent index range.stop — Pine's array.push on a slice).
+        n = len(self.range)
+        if index < 0:
+            index += n
+        index = max(0, min(index, n))
+        self.sequence.insert(self.range.start + index, value)
+        self.range = range(self.range.start, self.range.stop + 1)
+
+    def __len__(self) -> int:
+        return len(self.range)
+
+    def __iter__(self) -> Iterator[T]:
+        for i in self.range:
+            yield self.sequence[i]
+
+    def __repr__(self) -> str:
+        return f"SequenceView({self.sequence!r}, {self.range!r})"
+
+    def __str__(self) -> str:
+        if isinstance(self.sequence, str):
+            return ''.join(cast('Iterator[str]', self))
+        elif isinstance(self.sequence, (list, tuple)):
+            return str(type(self.sequence)(self))
+        else:
+            return repr(self)

pynecore/utils/stdlib_checker.py

@@ -0,0 +1,17 @@
+import sys
+
+
+def is_stdlib(module_name: str) -> bool:
+    """
+    Check whether a module belongs to Python's standard library.
+
+    Resolution is name-based via ``sys.stdlib_module_names`` (a frozenset of
+    every stdlib top-level module name on Python 3.10+; PyneCore requires
+    3.11+). This is authoritative and independent of the install layout: a
+    path-based check misclassifies packages under
+    ``<prefix>/lib/pythonX.Y/site-packages`` as stdlib.
+
+    :param module_name: Full module path (e.g. ``os.path``).
+    :return: True if the module's top-level package is part of the stdlib.
+    """
+    return module_name.split('.', 1)[0] in sys.stdlib_module_names