jesse 3.2.1__tar.gz → 3.2.2__tar.gz

{jesse-3.2.1/jesse.egg-info → jesse-3.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jesse
-Version: 3.2.1
+Version: 3.2.2
 Summary: A trading framework for cryptocurrencies
 Home-page: https://jesse.trade
 Author: Saleh Mir
@@ -48,7 +48,7 @@ Requires-Dist: ray
 Requires-Dist: eth-account~=0.13.5
 Requires-Dist: msgpack~=1.1.0
 Requires-Dist: starkbank-ecdsa~=1.1.0
-Requires-Dist: jesse-rust==1.2.0
+Requires-Dist: jesse-rust==1.3.0
 Requires-Dist: mcp==1.28.1
 Requires-Dist: joblib~=1.5.3
 Requires-Dist: scikit-learn~=1.7.2; python_version < "3.11"

{jesse-3.2.1 → jesse-3.2.2}/jesse/cli.py

@@ -40,7 +40,13 @@ def install_live(strict: bool) -> None:
     default=False,
     help="Skip syncing the agent rules file (AGENTS.md / CLAUDE.md / mcp-rules.md) in the project directory.",
 )
-def run(skip_agent_rules: bool) -> None:
+@click.option(
+    "--skip-lsp",
+    is_flag=True,
+    default=False,
+    help="Skip the Python Language Server for this run (disables editor code intelligence).",
+)
+def run(skip_agent_rules: bool, skip_lsp: bool) -> None:
     """Start the Jesse application server."""
     from jesse.services.env import is_test_env
 
@@ -102,11 +108,14 @@ def run(skip_agent_rules: bool) -> None:
         time.sleep(sleep_seconds)
         run_migrations()
 
-    if not is_test_env():
+    if skip_lsp:
+        click.echo("Skipping Python Language Server for this run. Editor code intelligence will be unavailable.")
+
+    if not is_test_env() and not skip_lsp:
         try:
             from jesse.services.lsp import install_lsp_server
 
-            install_lsp_server()
+            skip_lsp = not install_lsp_server(allow_skip=True)
         except Exception as e:
             print(jh.color(f"Error installing Python Language Server: {str(e)}", "red"))
             pass
@@ -124,7 +133,7 @@ def run(skip_agent_rules: bool) -> None:
 
     # Set global Jesse API configuration for MCP and other services
 
-    if not is_test_env():
+    if not is_test_env() and not skip_lsp:
         try:
             from jesse.services.lsp import run_lsp_server
 

{jesse-3.2.1 → jesse-3.2.2}/jesse/mcp/agent_rules.md

@@ -56,7 +56,7 @@ Jesse provides comprehensive documentation through MCP resources.
 
 Key resources include:
 
-- jesse://strategy - Strategy structure and required methods and How strategies execute candle-by-candle
+- jesse://strategy - Strategy structure, candle-by-candle execution, and Trading Hours workflow for adapting traditional-market research to 24/7 exchanges
 - jesse://strategy_examples - Library of complete, worked example strategies (full, runnable references)
 - jesse://charts - Strategy chart APIs, update_chart lifecycle, and live intrabar behavior
 - jesse://indicator - Step-by-step guide for discovering and using indicators and Essential indicators and candle data access
@@ -114,10 +114,10 @@ High-signal Jesse strategy-authoring gotchas (full detail in jesse://strategy):
 - On **spot**, shorting is unsupported: `should_short()` must return `False`, leverage is always `1`, and `stop_loss`/`take_profit` must be set in `on_open_position()` (not `go_long()`).
 - Size from `self.available_margin` (or balance/capital), price, and `self.fee_rate` via sizing utilities (`size_to_qty`, `risk_to_qty`) — never hardcode a fixed quantity.
 - Market hours, sessions, "skip weekends", or a stock-linked instrument on a 24/7 exchange: define `trading_hours()` returning a dict with `timezone` and `hours` (days always explicit, no preset names), gate entries with `self.is_trading_hours`, and feed entry indicators `utils.filter_candles_by_hours(self.candles, self.trading_hours())`. Never hand-roll UTC-hour math or reassign `self.candles`, and never gate `update_position()`/exits by the schedule. See the Trading Hours section of jesse://strategy.
+- For requests to adapt traditional-market research to 24/7 crypto trading, follow the Trading Hours adaptation workflow in `jesse://strategy`, even when the user does not mention sessions.
 
 For full structure, lifecycle, and complete runnable examples see jesse://strategy and jesse://strategy_examples.
 
-
 === STRATEGY DEVELOPMENT ===
 
 Improvement Workflow:

{jesse-3.2.1 → jesse-3.2.2}/jesse/mcp/resources/strategy.md

@@ -432,6 +432,66 @@ Rules:
 
 A complete class is in `jesse://strategy_examples` (SessionBreakout).
 
+### Adapting traditional-market research to 24/7 execution
+
+Use this workflow for requests to prepare, adapt, port or make a strategy live-ready when
+its research used traditional-market candles and its target is a continuously traded
+crypto-exchange instrument. Examples include stock, index, forex or commodity research
+moved to a corresponding tokenized instrument or perpetual. Recognize the intent even
+without the words "trading hours". Ordinary crypto strategies do not acquire a session
+restriction merely because their data came from a CSV.
+
+Treat the session adaptation as one coordinated change, even when it needs several edits;
+preserve the trading idea rather than performing unrelated strategy optimization.
+
+Reference: [Trading Hours](https://docs.jesse.trade/docs/strategies/trading-hours).
+
+1. **Read the strategy and identify the mismatch.** Use MCP to inspect the strategy,
+   research settings and available route/data context. Distinguish the historical source
+   (for example Massive or Custom Data) from the execution venue and verify the target
+   symbol and spot/futures type. Determine the underlying market, timezone and the session
+   actually used in research, including regular versus extended hours. Ask for missing
+   material details rather than guessing a calendar or silently imposing US equity hours.
+2. **Define the intended schedule.** Implement `trading_hours()` using the dict above and
+   an IANA timezone, not fixed UTC offsets. Account for market breaks and overnight windows
+   where applicable. `closed` and `overrides` are explicit, year-specific dates: neither
+   holidays nor early closes are populated automatically. Do not claim complete holiday
+   coverage from a weekday schedule or copy example dates into a different trading year.
+3. **Make the history choice deliberate.** For consistent session selection, use the same
+   schedule in backtests and live trading. Imported data can include extended-hours bars;
+   it is not automatically regular-session-only. Returning `None` in backtests is an
+   intentional alternative when retaining the provider's own session is desired, not a
+   default migration shortcut. Revalidate if session selection changes the original research.
+4. **Adapt both entry decisions and their inputs.** Gate each enabled entry direction in
+   `should_long()`/`should_short()` with `self.is_trading_hours`. Create a `@property` plus
+   `@cached` session-candle accessor using `utils.filter_candles_by_hours(...)`. Trace the
+   signal's indicators, direct candle indexing, features and auxiliary `get_candles()`
+   inputs; filter the relevant history using the appropriate underlying market's schedule.
+   Do not blindly apply a stock calendar to an unrelated crypto input. Preserve existing
+   indicator parameters, signal rules and risk sizing. Never overwrite `self.candles`,
+   fabricate closure candles, or substitute a historical session close for the live price.
+5. **Check timeframe alignment and warm-up.** Candle filtering uses candle **open times**,
+   while the entry gate uses the current **decision time**, `self.time`. A bar opening
+   before the session is excluded even if it partly overlaps it. Intraday windows can
+   discard every UTC-midnight `1D` bar; use an appropriate full-day calendar for daily
+   routes and verify the local date mapping. Filtering does not realign or rebuild bars.
+   `warm_up_candles` counts raw candles before filtering: size it for the longest required
+   lookback on each relevant input, including weekends/closures, and verify enough retained
+   candles remain. Do not assume one fixed multiplier works across timeframes and calendars.
+6. **Keep risk management active.** Do not gate `update_position()`, stop-loss, take-profit
+   or exits by market hours, and do not flatten at the close unless requested. Make the
+   unfilled-entry policy explicit: cancel at the first execution outside the session or
+   retain overnight orders as intended. Preserve other cancellation conditions when adding
+   the close condition. Cancellation is evaluated on execution ticks, not guaranteed at
+   the exact wall-clock close. Preserve the target venue's spot/futures order rules.
+7. **Verify and explain the adaptation.** Read back the saved code and use MCP backtests
+   with the selected session and adequate warm-up. Check session boundaries, weekend gaps
+   and relevant date exceptions in the available data. State when target-venue history or
+   another required check is unavailable. Matching session selection does not make prices,
+   bar alignment, liquidity, fees or fills identical between underlying and tokenized
+   instruments. Report the calendar, history choice, cancellation policy and actual
+   validation performed; preparing a strategy is not evidence of a running live session.
+
 ## Charting Helpers
 
 These `Strategy` methods add lines and levels to interactive backtest, paper,

{jesse-3.2.1 → jesse-3.2.2}/jesse/mcp/server.py

@@ -52,8 +52,16 @@ mcp_config.JESSE_PASSWORD = args.password
 mcp_config.MCP_PORT = args.port
 mcp_config.MCP_URL = f"http://localhost:{args.port}/mcp"
 
-# Create the MCP server instance
-mcp = FastMCP("Jesse MCP Server", host=MCP_HOST, port=args.port, json_response=True)
+# Advertise this workflow during initialization, including to clients without local agent rules.
+mcp = FastMCP(
+    "Jesse MCP Server", host=MCP_HOST, port=args.port, json_response=True,
+    instructions=(
+        "When asked to prepare, adapt, port, or deploy a strategy researched on traditional-market "
+        "data for a 24/7 crypto exchange (including tokenized or stock-linked instruments), read "
+        "jesse://strategy, especially Trading Hours and its adaptation workflow, before editing. "
+        "Recognize equivalent requests even when the user does not mention trading hours."
+    ),
+)
 
 # Register all available resources
 from jesse.mcp.resources import register_resources

{jesse-3.2.1 → jesse-3.2.2}/jesse/mcp/tools/strategy.py

@@ -50,6 +50,11 @@ def register_strategy_tools(mcp):
         The provided content must be valid Python code following Jesse's Strategy
         class structure with proper imports and method implementations.
 
+        Traditional-market adaptation:
+            When preparing traditional-market research for a 24/7 crypto exchange,
+            read the Trading Hours adaptation workflow in `jesse://strategy` first,
+            even if the user does not explicitly request session filtering.
+
         Parameters:
             name (str): Name for the new strategy class and file
                 Requirements: Valid Python identifier, no spaces, unique within Jesse
@@ -268,6 +273,11 @@ def register_strategy_tools(mcp):
         Use after create_strategy() to see the template, or to examine existing
         strategies before modification with write_strategy().
 
+        Traditional-market adaptation:
+            For requests to port research to tokenized instruments or a 24/7 crypto
+            exchange, also read the Trading Hours adaptation workflow in `jesse://strategy`.
+            Inspect every indicator's candle source and the existing entry/exit policies.
+
         Parameters:
             name (str): Exact name of the strategy to read (case-sensitive)
                 Must match the class name and filename exactly
@@ -399,6 +409,12 @@ def register_strategy_tools(mcp):
         Use read_strategy() first to get current content, modify it, then save
         with this function. Changes take effect immediately for new backtests.
 
+        Traditional-market adaptation:
+            Follow the Trading Hours adaptation workflow in `jesse://strategy` when
+            porting traditional-market research to a 24/7 crypto exchange. Entry gates
+            alone are insufficient: use session-filtered history for the relevant
+            indicators, verify warm-up, and preserve round-the-clock position management.
+
         Parameters:
             name (str): Exact name of the strategy to update (case-sensitive)
                 Must match existing strategy name exactly

{jesse-3.2.1 → jesse-3.2.2}/jesse/services/lsp.py

@@ -1,4 +1,13 @@
 import os
+import json
+import select
+import subprocess
+import sys
+import time
+from contextlib import contextmanager
+from typing import Callable, Iterator
+
+import click
 import platform
 import requests
 import shutil
@@ -129,138 +138,143 @@ def is_lsp_update_available() -> bool:
         raise Exception(f"Error checking for LSP update: {str(e)}")
 
 
-def install_lsp_server() -> None:
-    """
-    Downloads and installs the Python Language Server from GitHub releases
-    based on the current platform and architecture.
-    """        
-    # Define the target directory
-    from jesse import JESSE_DIR
-    
-    target_dir = os.path.join(JESSE_DIR, 'lsp')
-    
-    #Update process
-    # If the lsp directory exists(installed), check if an update is available, if so, delete the lsp directory and all its contents and re-install it
-    if os.path.exists(target_dir):
-        try:
-            should_update_lsp = is_lsp_update_available() # Check if an update is available  
+class _SkipLSP(Exception):
+    """Signal that startup should continue without the optional language server."""
 
-            if should_update_lsp:
-                # Delete the lsp directory and all its contents
-                shutil.rmtree(target_dir, ignore_errors=True)
-                # Re-install the Python Language Server
-                return install_lsp_server()
-        except Exception as e:
-            print(jh.color(f"Error checking for LSP update: {str(e)}", 'yellow'))
-            pass
-     
-    #Normal installation process
-    #Define the start script based on the platform
-    start_script = None
-    if platform.system().lower() == 'windows':
-        start_script = os.path.join(target_dir, 'start.bat')
-    else:
-        start_script = os.path.join(target_dir, 'start.sh')
-    
-    
-    # Skip if already exists 
-    if os.path.exists(target_dir) and os.path.exists(start_script):
-        if jh.is_debuggable('lsp_installer'):
-            print(f"Python Language Server already exists at {target_dir}")
+
+@contextmanager
+def _skip_key_reader(enabled: bool) -> Iterator[Callable[[], bool]]:
+    """Read a single key without Enter, restoring terminal settings on every exit."""
+    if not enabled or not sys.stdin.isatty():
+        yield lambda: False
         return
-    
-    # If the start script does not exist, delete the lsp directory and all its contents and re-install it
-    if not os.path.exists(start_script):
+
+    if os.name == 'nt':
+        # These modules are platform-specific and cannot be imported unconditionally.
+        import msvcrt
+
+        def skip_pressed() -> bool:
+            return msvcrt.kbhit() and msvcrt.getwch().lower() == 's'
+
+        yield skip_pressed
+    else:
+        import termios
+        import tty
+
+        fd = sys.stdin.fileno()
+        original = termios.tcgetattr(fd)
         try:
-            #delete the lsp directory and all its contents
-            shutil.rmtree(target_dir, ignore_errors=True)
-        except Exception as e:
-            pass    
-        
-    # Install the Python Language Server
-    try:
-        # Determine the platform-specific package name
+            # cbreak keeps Ctrl+C functional while allowing S without a newline.
+            tty.setcbreak(fd)
+            yield lambda: bool(select.select([fd], [], [], 0)[0]) and os.read(fd, 1).lower() == b's'
+        finally:
+            termios.tcsetattr(fd, termios.TCSADRAIN, original)
+
+
+def _download_lsp_file(url: str, destination: str, skip_pressed: Callable[[], bool]) -> None:
+    """Keep stalled network I/O in a disposable process so skipping is immediate."""
+    downloader = os.path.join(os.path.dirname(__file__), 'lsp_download.py')
+    with subprocess.Popen(
+        [sys.executable, downloader, url, destination],
+        stdin=subprocess.DEVNULL,
+    ) as process:
         try:
+            while process.poll() is None:
+                if skip_pressed():
+                    raise _SkipLSP()
+                # Poll often enough for responsive keys without busy-waiting.
+                time.sleep(0.1)
+            if process.returncode:
+                raise Exception("Failed to download Python Language Server files")
+        finally:
+            if process.poll() is None:
+                process.terminate()
+                try:
+                    # Bound cleanup even if a child cannot shut down normally.
+                    process.wait(timeout=1)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    process.wait()
+
+
+def install_lsp_server(allow_skip: bool = False) -> bool:
+    """Install/update the language server; return False when startup skips it."""
+    from jesse import JESSE_DIR
+
+    target_dir = os.path.join(JESSE_DIR, 'lsp')
+    start_name = 'start.bat' if platform.system().lower() == 'windows' else 'start.sh'
+    installed = os.path.isfile(os.path.join(target_dir, start_name))
+    interactive = allow_skip and sys.stdin.isatty()
+    if interactive:
+        click.echo("Checking Python Language Server. Press S at any time while downloading to skip for this run.")
+    elif allow_skip:
+        click.echo("Checking Python Language Server. Use 'jesse run --skip-lsp' to skip it.")
+
+    try:
+        with _skip_key_reader(interactive) as skip_pressed, tempfile.TemporaryDirectory() as temp_dir:
+            release_file = os.path.join(temp_dir, 'release.json')
+            try:
+                _download_lsp_file(LSP_RELEASE_URL, release_file, skip_pressed)
+                with open(release_file) as f:
+                    release_data = json.load(f)
+            except _SkipLSP:
+                raise
+            except Exception:
+                if installed:
+                    click.echo(jh.color("Could not check for LSP updates. Using the installed version.", 'yellow'))
+                    return True
+                raise
+
+            latest_version = release_data.get('tag_name', '').lstrip('v')
+            current_version = _get_lsp_version()
+            if installed and (not current_version or _compare_versions(current_version, latest_version) >= 0):
+                return True
+
             package_name = _get_platform_package_name()
-        except Exception as e:
-            raise Exception(f"Cannot determine platform package name: {str(e)}")
-        
-        print(f"Detected platform package: {package_name}")
-        
-        # Get the latest release
-        global LSP_RELEASE_URL
-        response = requests.get(LSP_RELEASE_URL, timeout=10)
-        response.raise_for_status()
-        
-        release_data = response.json()
-        
-        # Find the appropriate asset for this platform
-        download_url = None
-        for asset in release_data.get('assets', []):
-            if asset['name'] == package_name:
-                download_url = asset['browser_download_url']
-                break
-        
-        if not download_url:
-            raise Exception(f"Package '{package_name}' not found in latest release")        
-        
-        print(f"Downloading Python Language Server from {download_url}...")
-        
-        # Download the package
-        with tempfile.TemporaryDirectory() as temp_dir:
+            click.echo(f"Detected platform package: {package_name}")
+            download_url = next((asset['browser_download_url'] for asset in release_data.get('assets', [])
+                                 if asset['name'] == package_name), None)
+            if not download_url:
+                raise Exception(f"Package '{package_name}' not found in latest release")
+
+            click.echo(f"Downloading Python Language Server from {download_url}...")
             temp_file = os.path.join(temp_dir, package_name)
-            extract_temp_dir = os.path.join(temp_dir, 'extracted')
-            
-            with requests.get(download_url, stream=True, timeout=30) as r:
-                r.raise_for_status()
-                with open(temp_file, 'wb') as f:
-                    for chunk in r.iter_content(chunk_size=8192):
-                        f.write(chunk)
-            
-            # Extract to temporary directory first
-            os.makedirs(extract_temp_dir, exist_ok=True)
-            
+            _download_lsp_file(download_url, temp_file, skip_pressed)
+            if skip_pressed():
+                raise _SkipLSP()
+
+            extract_dir = os.path.join(temp_dir, 'extracted')
+            os.makedirs(extract_dir)
             if package_name.endswith('.tar.gz'):
                 with tarfile.open(temp_file, 'r:gz') as tar:
-                    tar.extractall(extract_temp_dir)
-            elif package_name.endswith('.zip'):
-                with zipfile.ZipFile(temp_file, 'r') as zip_ref:
-                    zip_ref.extractall(extract_temp_dir)
-            
-            # Flatten the directory structure
-            # If there's a single top-level directory, move its contents up
-            extracted_items = os.listdir(extract_temp_dir)
-            
-            if len(extracted_items) == 1 and os.path.isdir(os.path.join(extract_temp_dir, extracted_items[0])):
-                # Single directory - move its contents
-                source_dir = os.path.join(extract_temp_dir, extracted_items[0])
+                    tar.extractall(extract_dir)
             else:
-                # Multiple items at top level - use as is
-                source_dir = extract_temp_dir
-            
-            # Create target directory and move contents
-            os.makedirs(target_dir, exist_ok=True)
-            
-            for item in os.listdir(source_dir):
-                source_path = os.path.join(source_dir, item)
-                dest_path = os.path.join(target_dir, item)
-                if os.path.isdir(source_path):
-                    shutil.copytree(source_path, dest_path)
-                else:
-                    shutil.copy2(source_path, dest_path)
-            
-            # Save the lsp version to file
-            lsp_version = release_data.get('tag_name', '').lstrip('v')
-            _save_lsp_version(lsp_version)
-            
-            print(jh.color("✓ Python Language Server installed successfully", 'green'))
-    
-    except requests.RequestException as e:
-        raise Exception(f"Failed to download LSP server: {str(e)}")
-    except Exception as e:
-        raise Exception(f"Error installing LSP server: {str(e)}")
-        
-        
+                with zipfile.ZipFile(temp_file, 'r') as archive:
+                    archive.extractall(extract_dir)
+
+            extracted_items = os.listdir(extract_dir)
+            if len(extracted_items) == 1 and os.path.isdir(os.path.join(extract_dir, extracted_items[0])):
+                source_dir = os.path.join(extract_dir, extracted_items[0])
+            else:
+                source_dir = extract_dir
+            if not os.path.isfile(os.path.join(source_dir, start_name)):
+                raise Exception("Downloaded Python Language Server package has no start script")
+
+            # Keep any working installation intact until the download and extraction succeed.
+            # Key cancellation ends before publishing files into the installation directory.
+            if skip_pressed():
+                raise _SkipLSP()
+            if os.path.exists(target_dir):
+                shutil.rmtree(target_dir)
+            shutil.copytree(source_dir, target_dir)
+            _save_lsp_version(latest_version)
+            click.echo(jh.color("✓ Python Language Server installed successfully", 'green'))
+            return True
+    except _SkipLSP:
+        click.echo("Skipping Python Language Server for this run. Editor code intelligence will be unavailable.")
+        return False
+
+
 def run_lsp_server():
     """
     Runs the Python Language Server.

jesse-3.2.2/jesse/services/lsp_download.py

@@ -0,0 +1,23 @@
+"""Standalone download worker; avoids importing Jesse or touching its installation."""
+import sys
+
+import requests
+
+
+def download(url: str, destination: str) -> None:
+    """Stream into a caller-owned temporary file that is removed after cancellation."""
+    # Bound connection and stalled reads; the parent can terminate us sooner on S.
+    with requests.get(url, stream=True, timeout=(10, 30)) as response:
+        response.raise_for_status()
+        with open(destination, 'wb') as output:
+            # Small chunks bound memory usage regardless of the package size.
+            for chunk in response.iter_content(chunk_size=8192):
+                output.write(chunk)
+
+
+if __name__ == '__main__':
+    try:
+        download(sys.argv[1], sys.argv[2])
+    except Exception as exc:
+        sys.stderr.write(f"Python Language Server download failed: {exc}\n")
+        sys.exit(1)

{jesse-3.2.1 → jesse-3.2.2}/jesse/services/trading_hours.py

@@ -27,6 +27,7 @@ from typing import Dict, List, Optional, Tuple
 from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
 
 import numpy as np
+from jesse_rust import filter_candles_by_intervals, trading_hours_mask
 
 TradingHoursSpec = Optional[dict]
 
@@ -227,29 +228,30 @@ class TradingHours:
                     return True
         return False
 
+    def _intervals_for_timestamps(self, timestamps: np.ndarray) -> Tuple[np.ndarray, np.ndarray]:
+        """Compile the enclosing local dates, including yesterday's overnight windows."""
+        first_day = self._local_date(int(timestamps.min())) - _ONE_DAY
+        last_day = self._local_date(int(timestamps.max()))
+        return self._merged_intervals(first_day, last_day)
+
     def mask(self, timestamps: np.ndarray) -> np.ndarray:
         """Boolean mask marking which UTC-millisecond timestamps are inside the schedule."""
         timestamps = np.asarray(timestamps, dtype=np.int64)
-        result = np.zeros(len(timestamps), dtype=bool)
         if len(timestamps) == 0:
-            return result
-
-        first_day = self._local_date(int(timestamps.min())) - _ONE_DAY
-        last_day = self._local_date(int(timestamps.max()))
-        starts, ends = self._merged_intervals(first_day, last_day)
-        if len(starts) == 0:
-            return result
-
-        index = np.searchsorted(starts, timestamps, side='right') - 1
-        inside_some_start = index >= 0
-        result[inside_some_start] = timestamps[inside_some_start] < ends[index[inside_some_start]]
-        return result
+            return np.zeros(0, dtype=bool)
+        starts, ends = self._intervals_for_timestamps(timestamps)
+        return trading_hours_mask(timestamps, starts, ends)
 
     def filter_candles(self, candles: np.ndarray) -> np.ndarray:
         """Rows whose open timestamp (column 0) is inside the schedule, in original order."""
         if len(candles) == 0:
             return candles
-        return candles[self.mask(candles[:, 0])]
+        timestamps = np.asarray(candles[:, 0], dtype=np.int64)
+        starts, ends = self._intervals_for_timestamps(timestamps)
+        if candles.dtype == np.float64:
+            return filter_candles_by_intervals(candles, timestamps, starts, ends)
+        # Research arrays may have another dtype; retain it instead of coercing OHLCV.
+        return candles[trading_hours_mask(timestamps, starts, ends)]
 
 
 # ---- lookup -------------------------------------------------------------------

jesse-3.2.2/jesse/version.py

@@ -0,0 +1 @@
+__version__ = "3.2.2"

{jesse-3.2.1 → jesse-3.2.2/jesse.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jesse
-Version: 3.2.1
+Version: 3.2.2
 Summary: A trading framework for cryptocurrencies
 Home-page: https://jesse.trade
 Author: Saleh Mir
@@ -48,7 +48,7 @@ Requires-Dist: ray
 Requires-Dist: eth-account~=0.13.5
 Requires-Dist: msgpack~=1.1.0
 Requires-Dist: starkbank-ecdsa~=1.1.0
-Requires-Dist: jesse-rust==1.2.0
+Requires-Dist: jesse-rust==1.3.0
 Requires-Dist: mcp==1.28.1
 Requires-Dist: joblib~=1.5.3
 Requires-Dist: scikit-learn~=1.7.2; python_version < "3.11"

{jesse-3.2.1 → jesse-3.2.2}/jesse.egg-info/SOURCES.txt

@@ -447,6 +447,7 @@ jesse/services/jesse_trade.py
 jesse/services/live_chart_service.py
 jesse/services/logger.py
 jesse/services/lsp.py
+jesse/services/lsp_download.py
 jesse/services/metrics.py
 jesse/services/migrator.py
 jesse/services/multiprocessing.py

{jesse-3.2.1 → jesse-3.2.2}/jesse.egg-info/requires.txt

@@ -31,7 +31,7 @@ ray
 eth-account~=0.13.5
 msgpack~=1.1.0
 starkbank-ecdsa~=1.1.0
-jesse-rust==1.2.0
+jesse-rust==1.3.0
 mcp==1.28.1
 joblib~=1.5.3
 matplotlib~=3.10.3

{jesse-3.2.1 → jesse-3.2.2}/requirements.txt

@@ -31,7 +31,7 @@ ray
 eth-account~=0.13.5
 msgpack~=1.1.0
 starkbank-ecdsa~=1.1.0
-jesse-rust==1.2.0
+jesse-rust==1.3.0
 mcp==1.28.1
 joblib~=1.5.3
 scikit-learn~=1.7.2; python_version < "3.11"

{jesse-3.2.1 → jesse-3.2.2}/setup.py

@@ -3,7 +3,7 @@ from pathlib import Path
 from setuptools import setup, find_packages
 
 # also change in version.py
-VERSION = "3.2.1"
+VERSION = "3.2.2"
 DESCRIPTION = "A trading framework for cryptocurrencies"
 BASE_DIR = Path(__file__).resolve().parent
 

jesse-3.2.1/jesse/version.py

@@ -1 +0,0 @@
-__version__ = "3.2.1"