jesse 3.2.1__tar.gz → 3.2.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jesse
-Version: 3.2.1
+Version: 3.2.3
 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.3}/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.3}/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.3}/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.3}/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.3}/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.3}/jesse/modes/import_candles_mode/__init__.py

@@ -8,6 +8,7 @@ import pydash
 
 import jesse.helpers as jh
 from jesse.exceptions import CandleNotFoundInExchange
+from jesse.enums import live_session_modes
 from jesse.models.Candle import Candle
 from jesse.modes.import_candles_mode.drivers import (
     build_historical_provider_registry,
@@ -204,6 +205,35 @@ def _report_import_progress(
         _print_import_progressbar(exchange, symbol, percent, remaining_seconds, reached_date)
 
 
+def _missing_live_candle_ranges(
+    exchange: str, symbol: str, start: int, end: int, max_candles: int,
+) -> list[tuple[int, int]]:
+    """Cover absent live minutes with provider-sized pages, preserving sparse observations."""
+    ranges = []
+    cursor = start
+    for candle in candle_repository.fetch_candles_from_db(exchange, symbol, '1m', start, end - 60_000):
+        timestamp = int(candle[0])
+        if timestamp > cursor:
+            ranges.append((cursor, timestamp))
+        cursor = timestamp + 60_000
+    if cursor < end:
+        ranges.append((cursor, end))
+
+    # Thousands of isolated no-trade minutes must not cause thousands of requests
+    # on every restart. Re-reading stored rows is safe because inserts retain them.
+    page_span = max_candles * 60_000
+    pages = []
+    for missing_start, missing_end in ranges:
+        if pages and missing_start <= pages[-1][1]:
+            page_start, page_end = pages.pop()
+            missing_end = max(missing_end, page_end)
+        else:
+            page_start = missing_start
+        page_count = (missing_end - page_start + page_span - 1) // page_span
+        pages.append((page_start, min(end, page_start + page_count * page_span)))
+    return pages
+
+
 def run(
         client_id: str,
         exchange: str,
@@ -270,8 +300,10 @@ def _run(
     from jesse.services.db import database
     database.open_connection()
 
-    end_timestamp = arrow.utcnow().floor('day').int_timestamp * 1000
     provider = build_historical_provider_registry((exchange,)).get(exchange)
+    # Crypto startup needs today's closed bars. Provider ranges are half-open, so the
+    # current minute is excluded; traditional historical providers retain their daily cutoff.
+    end_timestamp = arrow.utcnow().floor('minute' if isinstance(provider, CandleExchange) else 'day').int_timestamp * 1000
     max_candles = provider.capabilities.max_candles_per_request
     if max_candles is None:
         raise ValueError(f'Historical provider {exchange!r} does not declare a request range limit')
@@ -310,6 +342,14 @@ def _run(
         latest_timestamp,
         interval,
     )
+    if isinstance(provider, CandleExchange) and mode in (
+        live_session_modes.LIVETRADE, live_session_modes.PAPERTRADE,
+    ):
+        # Stored endpoints do not prove live warm-up coverage: WebSocket writes may
+        # bracket a downtime gap. Historical imports still preserve intentional sparse gaps.
+        import_ranges = _missing_live_candle_ranges(
+            exchange, symbol, effective_start_timestamp, end_timestamp, max_candles,
+        )
     total_span = end_timestamp - effective_start_timestamp
     work_span = sum(range_end - range_start for range_start, range_end in import_ranges)
     completed_span = total_span - work_span

{jesse-3.2.1 → jesse-3.2.3}/jesse/modes/import_candles_mode/drivers/Bybit/BybitMain.py

@@ -1,10 +1,16 @@
 import requests
+import time
 from requests.adapters import HTTPAdapter
 from urllib3.util.retry import Retry
 import jesse.helpers as jh
 from jesse.modes.import_candles_mode.drivers.interface import CandleExchange
 from typing import Union
 from jesse import exceptions
+from jesse.services.historical_data.errors import (
+    ProviderRateLimitError,
+    ProviderRequestError,
+    ProviderUnavailableError,
+)
 from .bybit_utils import timeframe_to_interval
 
 
@@ -27,6 +33,50 @@ class BybitMain(CandleExchange):
         )
         self.session.mount('https://', HTTPAdapter(max_retries=retries, pool_maxsize=100))
 
+    def _get_kline_data(self, payload: dict) -> list:
+        """Retry transient JSON failures that HTTP-level retries cannot see."""
+        # Match the HTTP adapter's three-retry budget. Bybit's 10006 limit uses a
+        # rolling one-second window; exponential waits avoid immediately hitting it again.
+        for attempt in range(4):
+            response = self.session.get(self.endpoint + '/v5/market/kline', params=payload, timeout=10)
+            self.validate_response(response)
+            data = response.json()
+            code = data.get('retCode', 0)
+            message = f"{payload['symbol']} on {self.name}: {data['retMsg']} (retCode={code})"
+            # Bybit documents 10000 as a server timeout and 10016 as a server error.
+            if code in (10006, 10000, 10016):
+                error_type = ProviderRateLimitError if code == 10006 else ProviderUnavailableError
+                if attempt == 3:
+                    raise error_type(message)
+                delay = float(2 ** attempt)
+                reset = response.headers.get('X-Bapi-Limit-Reset-Timestamp') if code == 10006 else None
+                if reset:
+                    try:
+                        delay = max(delay, float(reset) / 1000 - time.time())
+                    except ValueError:
+                        pass  # A malformed reset header must not disable the bounded fallback.
+                # Do not block startup indefinitely on a bad or unusually distant reset timestamp.
+                if delay > 30:
+                    raise ProviderRateLimitError(
+                        f"Bybit rate limit for {payload['symbol']} on {self.name}; retry after its limit resets."
+                    )
+                time.sleep(delay)
+                continue
+            if code != 0 or data['retMsg'] != 'OK':
+                # 10001 also covers unrelated parameter errors; only symbol-specific
+                # messages (or the explicit invalid-symbol code) mean a missing market.
+                invalid_symbol_message = data['retMsg'].lower() in ('symbol invalid', 'invalid symbol')
+                if (
+                    code == 10029
+                    or (code == 10001 and 'symbol' in data['retMsg'].lower())
+                    # Retain explicit invalid-symbol errors even when the response omits its code.
+                    or ('retCode' not in data and invalid_symbol_message)
+                ):
+                    raise exceptions.SymbolNotFound(message)
+                raise ProviderRequestError(message)
+            return data['result']['list']
+        raise ProviderRateLimitError(f'Bybit rate limit on {self.name}')
+
     def get_starting_time(self, symbol: str) -> Union[int, None]:
         dashless_symbol = jh.dashless_symbol(symbol)
         # Bybit answers `start` in ascending order, so one 1m candle from 2018 is the exact
@@ -39,9 +89,7 @@ class BybitMain(CandleExchange):
             'start': 1514811660000
         }
 
-        response = self.session.get(self.endpoint + '/v5/market/kline', params=payload, timeout=10)
-        self.validate_response(response)
-        data = response.json()['result']['list']
+        data = self._get_kline_data(payload)
         if not data:
             return None
         return int(data[0][0])
@@ -57,11 +105,7 @@ class BybitMain(CandleExchange):
             'limit': self.count
         }
 
-        response = self.session.get(self.endpoint + '/v5/market/kline', params=payload, timeout=10)
-
-        if response.json()['retMsg'] != 'OK':
-            raise exceptions.SymbolNotFound(response.json()['retMsg'])
-        data = response.json()['result']['list']
+        data = self._get_kline_data(payload)
         # Reverse the data list
         data = data[::-1]
 

{jesse-3.2.1 → jesse-3.2.3}/jesse/services/candle_service.py

@@ -574,6 +574,9 @@ def add_candle(
     # initial
     if last_index == -1:
         arr.append(candle)
+        # A session with no warm-up still needs its first observed forming bucket.
+        if with_generation and timeframe == '1m':
+            _generate_bigger_timeframes(candle, exchange, symbol, with_execution)
         return
 
     # read the last candle's timestamp once as a plain scalar instead of
@@ -690,43 +693,17 @@ def _generate_bigger_timeframes(candle: np.ndarray, exchange: str, symbol: str,
         if timeframe == '1m':
             continue
 
-        last_candle = get_current_candle(exchange, symbol, timeframe)
-        generate_from_count = int((candle[0] - last_candle[0]) / 60_000)
-        number_of_candles = len(get_candles(exchange, symbol, '1m'))
-        short_candles = get_candles(exchange, symbol, '1m')[-1 - generate_from_count:]
-
-        if generate_from_count == -1:
-            # it's receiving an slightly older candle than the last one. Ignore it
-            return
-
-        if generate_from_count < 0:
-            current_1m = get_current_candle(exchange, symbol, '1m')
-            raise ValueError(
-                f'generate_from_count cannot be negative! '
-                f'generate_from_count:{generate_from_count}, candle[0]:{candle[0]}, '
-                f'last_candle[0]:{last_candle[0]}, current_1m:{current_1m[0]}, number_of_candles:{number_of_candles}')
-
-        if len(short_candles) == 0:
-            raise ValueError(
-                f'No candles were passed. More info:'
-                f'\nexchange:{exchange}, symbol:{symbol}, timeframe:{timeframe}, generate_from_count:{generate_from_count}'
-                f'\nlast_candle\'s timestamp: {last_candle[0]}'
-                f'\ncurrent timestamp: {jh.now()}'
-            )
-
-        # update latest candle
-        generated_candle = generate_candle_from_one_minutes(
-            timeframe,
-            short_candles,
-            accept_forming_candles=True
-        )
-
-        # Fix: force the generated candle's timestamp to the correct period-aligned boundary.
-        # Without this, when a live session starts mid-period (e.g. at 10:36 on an hourly
-        # timeframe), the 1m store only has that one candle, so generate_candle_from_one_minutes
-        # stamps the resulting 1h candle as 10:36 instead of the correct period start 10:00.
+        # Elapsed minutes are not row counts when an exchange omits no-trade bars.
+        # Select only observations in this candle's UTC bucket, including forming rows.
         timeframe_ms = jh.timeframe_to_one_minutes(timeframe) * 60_000
-        generated_candle[0] = candle[0] - (candle[0] % timeframe_ms)
+        bucket_start = int(candle[0]) - int(candle[0]) % timeframe_ms
+        short_candles = get_candles(exchange, symbol, '1m')
+        start_index = int(np.searchsorted(short_candles[:, 0], bucket_start, side='left'))
+        end_index = int(np.searchsorted(short_candles[:, 0], bucket_start + timeframe_ms, side='left'))
+        source_rows = short_candles[start_index:end_index]
+        if not len(source_rows):
+            continue
+        generated_candle = generate_candle_from_observed_minutes(timeframe, source_rows)
 
         add_candle(
             generated_candle, exchange, symbol, timeframe, with_execution, with_generation=False
@@ -847,6 +824,13 @@ def get_current_candle(exchange: str, symbol: str, timeframe: str) -> np.ndarray
         else:
             return arr[-1]
 
+    if jh.is_live():
+        # Live stores already hold native exchange bars or clock-aligned locally
+        # generated bars. Reconstructing by 1m row count would corrupt sparse history
+        # and could override native bars when local generation is disabled.
+        arr = store.candles.get_storage(exchange, symbol, timeframe)
+        return arr[-1] if len(arr) else np.zeros((0, 6))
+
     if store.candles.uses_timestamp_buckets:
         candles = _get_timestamp_bucket_candles(exchange, symbol, timeframe)
         return candles[-1] if len(candles) else np.zeros((0, 6))