feat(strategy): major strategy system improvements and optimizations (#37)

# Squash Merge Commit Message

## Title
feat(strategy): major strategy system improvements and optimizations

## Body
Major improvements to the PyneCore strategy system with enhanced performance and functionality.

### Key Features
- Implemented PriceOrderBook for O(log n) price-based order operations
- Added complete OCA (One-Cancels-All) group support with cancel/reduce functionality
- Enhanced risk management with max intraday filled orders tracking
- Migrated comprehensive slippage test suite from PyneComp

### Bug Fixes
- Fixed commission calculations for percentage-based commissions
- Corrected NA handling in qty validation
- Fixed order processing logic for stop/limit orders
- Resolved pyramiding logic issues

### Performance Optimizations
- Optimized Position class with __slots__ for 20-40% memory reduction
- Improved order book operations with bisect-based price level management
- Enhanced bar_index tracking for better debugging

### Testing
- Added 4 new slippage test strategies with full CSV validation
- All existing tests pass with improved performance
- Trade validation matches TradingView behavior exactly

Closes #37

Author: wallneradam

src/pynecore/core/overload.py

@@ -141,7 +141,7 @@ def dispatcher(*args: Any, **kwargs: Any) -> Any:
                 except TypeError:
                     continue
 
-            raise TypeError(f"No matching implementation found for {qualname}")
+            raise TypeError(f"No matching implementation found for {qualname}: {args}, {kwargs}")
 
         # Store implementation and dispatcher
         _registry[qualname].append(impl)

src/pynecore/core/safe_convert.py

@@ -1,7 +1,7 @@
 from ..types import NA
 
 
-def safe_div(a, b):
+def safe_div(a: float | NA[float], b: float | NA[float]):
     """
     Safe division that returns NA for division by zero.
     Mimics Pine Script behavior where division by zero returns NA.
@@ -20,7 +20,7 @@ def safe_div(a, b):
         return NA(float)
 
 
-def safe_float(value):
+def safe_float(value: float | NA[float]) -> float | NA[float]:
     """
     Safe float conversion that returns NA for NA inputs.
     Catches TypeError (thrown by NA values) but allows ValueError to propagate normally.
@@ -35,7 +35,7 @@ def safe_float(value):
         return NA(float)
 
 
-def safe_int(value):
+def safe_int(value: int | NA[int]) -> int | NA[int]:
     """
     Safe int conversion that returns NA for NA inputs.
     Catches TypeError (thrown by NA values) but allows ValueError to propagate normally.

src/pynecore/core/script.py

@@ -30,7 +30,7 @@
 TEnum = TypeVar('TEnum', bound=StrEnum)
 
 
-@dataclass(kw_only=True)
+@dataclass(kw_only=True, slots=True)
 class InputData:
     """
     Input dataclass
@@ -50,12 +50,12 @@ class InputData:
     display: _display.Display | None = None
 
 
-old_input_values: dict[str, Any] = {}
+_old_input_values: dict[str, Any] = {}
 inputs: dict[str | None, InputData] = {}
 
 
 # noinspection PyShadowingBuiltins,PyShadowingNames
-@dataclass(kw_only=True)
+@dataclass(kw_only=True, slots=True)
 class Script:
     """
     Script parameters dataclass
@@ -73,7 +73,7 @@ class Script:
     format: _format.Format = _format.inherit
     precision: int | None = None
     scale: _scale.Scale | None = None
-    pyramiding: int = 0
+    pyramiding: int = 1
     calc_on_order_fills: bool = False
     calc_on_every_tick: bool = False
     max_bars_back: int = 0
@@ -137,7 +137,10 @@ def _format_value(value) -> str:
         ]
 
         # Save general settings
-        for key, value in self.__dict__.items():
+        from dataclasses import fields
+        for field in fields(self):
+            key = field.name
+            value = getattr(self, key)
             if key.startswith('_') or key in self._SKIP_FIELDS:
                 continue
             if value is None:
@@ -153,11 +156,17 @@ def _format_value(value) -> str:
 
         # Save inputs
         for arg_name, input_data in self.inputs.items():
+            # Skip None keys (can happen with some input configurations)
+            if arg_name is None:
+                continue
             lines.append(f"\n[inputs.{arg_name.removesuffix('__global__')}]")
             lines.append("# Input metadata, cannot be modified")
 
             # Add all metadata as comments
-            for key, value in input_data.__dict__.items():
+            from dataclasses import fields as input_fields
+            for field in input_fields(input_data):
+                key = field.name
+                value = getattr(input_data, key)
                 if key == 'id':
                     continue
                 if value is not None:
@@ -167,8 +176,8 @@ def _format_value(value) -> str:
             lines.append("# Change here to modify the input value")
 
             # Add the actual value
-            if input_data.defval is not None and arg_name in old_input_values:
-                lines.append(f"value = {_format_value(old_input_values[arg_name])}")
+            if input_data.defval is not None and arg_name in _old_input_values:
+                lines.append(f"value = {_format_value(_old_input_values[arg_name])}")
             else:
                 lines.append("#value =")
 
@@ -207,8 +216,8 @@ def load(self, path: str | Path) -> None:
         for arg_name, arg_data in data['inputs'].items():
             if 'value' not in arg_data:
                 continue
-            old_input_values[arg_name] = arg_data['value']
-            old_input_values[arg_name + '__global__'] = arg_data['value']  # For strict mode
+            _old_input_values[arg_name] = arg_data['value']
+            _old_input_values[arg_name + '__global__'] = arg_data['value']  # For strict mode
 
     #
     # decorators
@@ -223,6 +232,10 @@ def _decorate(self):
         if toml_path.exists():
             self.load(toml_path)
 
+        # Pyramiding must be at least 1
+        if self.pyramiding <= 0:
+            self.pyramiding = 1
+
         def decorator(func):
             # Save inputs to script instance then clear inputs (for next script)
             self.inputs = inputs.copy()  # type: ignore
@@ -236,7 +249,7 @@ def decorator(func):
                 if os.environ.get('PYNE_SAVE_SCRIPT_TOML', '1') == '1' and 'pytest' not in sys.modules:
                     self.save(toml_path)
 
-            old_input_values.clear()
+            _old_input_values.clear()
             return func
 
         return decorator
@@ -523,7 +536,7 @@ def __call__(self, defval: Any, title: str | None = None, *,
             group=group,
             display=display,
         )
-        return defval if _id not in old_input_values else old_input_values[_id]
+        return defval if _id not in _old_input_values else _old_input_values[_id]
 
     @classmethod
     def _int(cls, defval: int, title: str | None = None, *,
@@ -564,7 +577,7 @@ def _int(cls, defval: int, title: str | None = None, *,
             options=options,
             display=display,
         )
-        return defval if _id not in old_input_values else safe_convert.safe_int(old_input_values[_id])
+        return defval if _id not in _old_input_values else safe_convert.safe_int(_old_input_values[_id])
 
     @classmethod
     def _bool(cls, defval: bool, title: str | None = None, *,
@@ -596,7 +609,7 @@ def _bool(cls, defval: bool, title: str | None = None, *,
             confirm=confirm,
             display=display,
         )
-        return defval if _id not in old_input_values else bool(old_input_values[_id])
+        return defval if _id not in _old_input_values else bool(_old_input_values[_id])
 
     @classmethod
     def _float(cls, defval: float, title: str | None = None, *,
@@ -637,7 +650,7 @@ def _float(cls, defval: float, title: str | None = None, *,
             options=options,
             display=display,
         )
-        return defval if _id not in old_input_values else safe_convert.safe_float(old_input_values[_id])
+        return defval if _id not in _old_input_values else safe_convert.safe_float(_old_input_values[_id])
 
     @classmethod
     def string(cls, defval: str, title: str | None = None, *,
@@ -673,7 +686,7 @@ def string(cls, defval: str, title: str | None = None, *,
             display=display,
             options=options,
         )
-        return defval if _id not in old_input_values else str(old_input_values[_id])
+        return defval if _id not in _old_input_values else str(_old_input_values[_id])
 
     @classmethod
     def color(cls, defval: Color, title: str | None = None, *,
@@ -705,7 +718,7 @@ def color(cls, defval: Color, title: str | None = None, *,
             confirm=confirm,
             display=display,
         )
-        return defval if _id not in old_input_values else Color(old_input_values[_id])
+        return defval if _id not in _old_input_values else Color(_old_input_values[_id])
 
     @classmethod
     def source(cls, defval: str | Source, title: str | None = None, *,
@@ -740,7 +753,7 @@ def source(cls, defval: str | Source, title: str | None = None, *,
             display=display,
         )
         # We actually return a string here, but the InputTransformer will add a `getattr()` call to get the
-        return cast(Series[float], defval if _id not in old_input_values else old_input_values[_id])
+        return cast(Series[float], defval if _id not in _old_input_values else _old_input_values[_id])
 
     @classmethod
     def enum(cls, defval: TEnum, title: str | None = None, *,
@@ -776,11 +789,11 @@ def enum(cls, defval: TEnum, title: str | None = None, *,
             display=display,
             options=options,
         )
-        if _id not in old_input_values:
+        if _id not in _old_input_values:
             return defval
         else:
             # Convert string value back to the specific enum type
-            value = old_input_values[_id]
+            value = _old_input_values[_id]
             if isinstance(value, str):
                 try:
                     return defval.__class__(value)

src/pynecore/core/script_runner.py

@@ -72,7 +72,7 @@ def _round_price(price: float, lib: ModuleType):
         from .. import lib
     syminfo = lib.syminfo
     scaled = round(price * syminfo.pricescale)
-    return scaled * syminfo.mintick
+    return scaled / syminfo.pricescale
 
 
 # noinspection PyShadowingNames
@@ -108,10 +108,11 @@ def _set_lib_syminfo_properties(syminfo: SymInfo, lib: ModuleType):
     if TYPE_CHECKING:  # This is needed for the type checker to work
         from .. import lib
 
-    for key, value in syminfo.__dict__.items():
+    for slot_name in syminfo.__slots__:  # type: ignore
+        value = getattr(syminfo, slot_name)
         if value is not None:
             try:
-                setattr(lib.syminfo, key, value)
+                setattr(lib.syminfo, slot_name, value)
             except AttributeError:
                 pass
 
@@ -396,7 +397,7 @@ def run_iter(self, on_progress: Callable[[datetime], None] | None = None) \
                 if self.trades_writer and position.open_trades:
                     for trade in position.open_trades:
                         trade_num += 1  # Continue numbering from closed trades
-                        # Export only the entry part for open trades
+                        # Export the entry part
                         self.trades_writer.write(
                             trade_num,
                             trade.entry_bar_index,
@@ -415,6 +416,37 @@ def run_iter(self, on_progress: Callable[[datetime], None] | None = None) \
                             "0.00",  # No max drawdown percent yet
                         )
 
+                        # Export the exit part with "Open" signal (TradingView compatibility)
+                        # This simulates automatic closing at the end of backtest
+                        # Use the last price from the iteration
+                        exit_price = self.last_price
+
+                        if exit_price is not None:
+                            # Calculate profit/loss using the same formula as Position._fill_order
+                            # For closing, size is negative of the position
+                            closing_size = -trade.size
+                            pnl = -closing_size * (exit_price - trade.entry_price)
+                            pnl_percent = (pnl / (trade.entry_price * abs(trade.size))) * 100 \
+                                if trade.entry_price != 0 else 0
+
+                            self.trades_writer.write(
+                                trade_num,
+                                self.bar_index - 1,  # Last bar index
+                                "Exit long" if trade.size > 0 else "Exit short",
+                                "Open",  # TradingView uses "Open" signal for automatic closes
+                                string.format_time(lib._time),  # type: ignore
+                                exit_price,
+                                abs(trade.size),
+                                pnl,
+                                f"{pnl_percent:.2f}",
+                                pnl,  # Same as profit for last trade
+                                f"{pnl_percent:.2f}",
+                                max(0.0, pnl),  # Runup
+                                f"{max(0, pnl_percent):.2f}",
+                                max(0.0, -pnl),  # Drawdown
+                                f"{max(0, -pnl_percent):.2f}",
+                            )
+
                 # Write strategy statistics
                 if self.strat_writer and position:
                     try:

src/pynecore/core/syminfo.py

@@ -7,7 +7,7 @@
 SymInfoSession = NamedTuple("SymInfoSession", [('day', int), ('time', time)])
 
 
-@dataclass(kw_only=True)
+@dataclass(kw_only=True, slots=True)
 class SymInfo:
     """
     Symbol information dataclass
@@ -41,7 +41,7 @@ class SymInfo:
     avg_spread: float | None = None
     taker_fee: float | None = None
     maker_fee: float | None = None
-    
+
     # Analyst price target information (added 2025-07-08)
     target_price_average: float | None = None
     target_price_high: float | None = None

src/pynecore/lib/log.py

@@ -29,6 +29,8 @@ def render(self, *, record, traceback, message_renderable):
             """Override render to use Pine Script time and timezone"""
             from ..types import NA
             from datetime import UTC
+            from rich.text import Text
+            from rich.table import Table
 
             # Get the datetime in the correct timezone
             if lib._time:
@@ -43,22 +45,49 @@ def render(self, *, record, traceback, message_renderable):
                 # No Pine time, use current time
                 log_time = datetime.fromtimestamp(record.created)
 
-            # Call parent's _log_render with our log_time
+            # Format the time
             path = Path(record.pathname).name
             level = self.get_level_text(record)
             time_format = None if self.formatter is None else self.formatter.datefmt
 
-            log_renderable = self._log_render(
-                self.console,
-                [message_renderable] if not traceback else [message_renderable, traceback],
-                log_time=log_time,
-                time_format=time_format,
-                level=level,
-                path=path,
-                line_no=record.lineno,
-                link_path=record.pathname if self.enable_link_path else None,
-            )
-            return log_renderable
+            # Create custom log output with colored bar_index
+            if hasattr(lib, 'bar_index') and lib.bar_index is not None:
+                # Format the base time
+                time_str = log_time.strftime(time_format or "[%Y-%m-%d %H:%M:%S]")
+
+                # Create table for log output
+                output = Table.grid(padding=(0, 1))
+                output.expand = True
+
+                # Add columns - no style for first two columns to allow Text styling
+                output.add_column()  # Time column
+                output.add_column()  # Bar index column
+                output.add_column(style="log.level", width=8)  # Level column
+                output.add_column(ratio=1, style="log.message", overflow="fold")  # Message column
+
+                # Build row with styled Text objects
+                row = [
+                    Text(time_str, style="log.time"),
+                    Text(f"bar: {lib.bar_index:6}", style="cyan"),
+                    level,
+                    message_renderable,
+                ]
+
+                output.add_row(*row)
+                return output
+            else:
+                # Standard rendering without bar_index
+                log_renderable = self._log_render(
+                    self.console,
+                    [message_renderable] if not traceback else [message_renderable, traceback],
+                    log_time=log_time,
+                    time_format=time_format,
+                    level=level,
+                    path=path,
+                    line_no=record.lineno,
+                    link_path=record.pathname if self.enable_link_path else None,
+                )
+                return log_renderable
 
 
 # noinspection PyProtectedMember
@@ -85,9 +114,15 @@ def formatTime(self, record: logging.LogRecord, datefmt: str = None) -> str:
 
         # Format the datetime
         if datefmt:
-            return dt.strftime(datefmt)
+            time_str = dt.strftime(datefmt)
         else:
-            return dt.strftime("%Y-%m-%d %H:%M:%S,%f")[:-3]
+            time_str = dt.strftime("%Y-%m-%d %H:%M:%S,%f")[:-3]
+
+        # Add bar_index to the time string
+        if hasattr(lib, 'bar_index') and lib.bar_index is not None:
+            time_str = f"{time_str} bar: {lib.bar_index:6}"
+
+        return time_str
 
     def format(self, record: logging.LogRecord) -> Any:
         """Format log record in Pine style: [timestamp]: message"""