Qubx 0.5.8__cp312-cp312-manylinux_2_39_x86_64.whl → 0.6.0__cp312-cp312-manylinux_2_39_x86_64.whl

qubx/__init__.py

@@ -5,13 +5,33 @@ from typing import Callable
 import stackprinter
 from loguru import logger
 
-from qubx.core.lookups import FeesLookup, GlobalLookup, InstrumentsLookup
-from qubx.utils import runtime_env, set_mpl_theme
-from qubx.utils.misc import install_pyx_recompiler_for_dev
-
 # - TODO: import some main methods from packages
 
 
+def runtime_env():
+    """
+    Check what environment this script is being run under
+    :return: environment name, possible values:
+             - 'notebook' jupyter notebook
+             - 'shell' any interactive shell (ipython, PyCharm's console etc)
+             - 'python' standard python interpreter
+             - 'unknown' can't recognize environment
+    """
+    try:
+        from IPython.core.getipython import get_ipython
+
+        shell = get_ipython().__class__.__name__
+
+        if shell == "ZMQInteractiveShell":  # Jupyter notebook or qtconsole
+            return "notebook"
+        elif shell.endswith("TerminalInteractiveShell"):  # Terminal running IPython
+            return "shell"
+        else:
+            return "unknown"  # Other type (?)
+    except (NameError, ImportError):
+        return "python"  # Probably standard Python interpreter
+
+
 def formatter(record):
     end = record["extra"].get("end", "\n")
     fmt = "<lvl>{message}</lvl>%s" % end
@@ -47,6 +67,11 @@ class QubxLogConfig:
     @staticmethod
     def setup_logger(level: str | None = None, custom_formatter: Callable | None = None):
         global logger
+
+        # First, remove all existing handlers to prevent resource leaks
+        # Use a safer approach that doesn't rely on internal attributes
+        logger.remove()
+
         config = {
             "handlers": [
                 {"sink": sys.stdout, "format": "{time} - {message}"},
@@ -54,24 +79,42 @@ class QubxLogConfig:
             "extra": {"user": "someone"},
         }
         logger.configure(**config)
-        logger.remove(None)
+
         level = level or QubxLogConfig.get_log_level()
-        logger.add(sys.stdout, format=custom_formatter or formatter, colorize=True, level=level, enqueue=True)
+        # Add stdout handler with enqueue=True for thread/process safety
+        logger.add(
+            sys.stdout,
+            format=custom_formatter or formatter,
+            colorize=True,
+            level=level,
+            enqueue=True,
+            backtrace=True,
+            diagnose=True,
+        )
         logger = logger.opt(colors=True)
 
 
 QubxLogConfig.setup_logger()
 
 
-# - global lookup helper
-lookup = GlobalLookup(InstrumentsLookup(), FeesLookup())
-
-
 # registering magic for jupyter notebook
 if runtime_env() in ["notebook", "shell"]:
     from IPython.core.getipython import get_ipython
     from IPython.core.magic import Magics, line_cell_magic, line_magic, magics_class
 
+    from qubx.utils.charting.lookinglass import LookingGlass  # noqa: F401
+    from qubx.utils.charting.mpl_helpers import (  # noqa: F401
+        ellips,
+        fig,
+        hline,
+        ohlc_plot,
+        plot_trends,
+        sbp,
+        set_mpl_theme,
+        vline,
+    )
+    from qubx.utils.misc import install_pyx_recompiler_for_dev
+
     @magics_class
     class QubxMagics(Magics):
         # process data manager
@@ -119,7 +162,7 @@ if runtime_env() in ["notebook", "shell"]:
                         exec(_vscode_clr_trick, self.shell.user_ns)
 
                 elif "light" in line.lower():
-                    set_mpl_theme("light")
+                    sort: skip_mpl_theme("light")
 
         def _get_manager(self):
             if self.__manager is None:

qubx/_nb_magic.py

@@ -3,7 +3,7 @@ Here stuff we want to have in every Jupyter notebook after calling %qubx magic
 """
 
 import qubx
-from qubx.utils import runtime_env
+from qubx import runtime_env
 from qubx.utils.misc import add_project_to_system_path, logo
 
 

qubx/backtester/simulator.py

@@ -4,13 +4,14 @@ import numpy as np
 import pandas as pd
 from joblib import delayed
 
-from qubx import QubxLogConfig, logger, lookup
+from qubx import QubxLogConfig, logger
 from qubx.core.basics import SW, DataType
 from qubx.core.context import StrategyContext
 from qubx.core.exceptions import SimulationConfigError, SimulationError
 from qubx.core.helpers import extract_parameters_from_object, full_qualified_class_name
 from qubx.core.interfaces import IStrategy
 from qubx.core.loggers import InMemoryLogsWriter, StrategyLogging
+from qubx.core.lookups import lookup
 from qubx.core.metrics import TradingSessionResult
 from qubx.data.readers import DataReader
 from qubx.pandaz.utils import _frame_to_str

qubx/backtester/utils.py

@@ -6,7 +6,7 @@ import numpy as np
 import pandas as pd
 import stackprinter
 
-from qubx import logger, lookup
+from qubx import logger
 from qubx.core.basics import (
     CtrlChannel,
     DataType,
@@ -20,6 +20,7 @@ from qubx.core.basics import (
 from qubx.core.exceptions import SimulationConfigError, SimulationError
 from qubx.core.helpers import BasicScheduler
 from qubx.core.interfaces import IStrategy, IStrategyContext, PositionsTracker
+from qubx.core.lookups import lookup
 from qubx.core.series import OHLCV, Bar, Quote, Trade
 from qubx.core.utils import time_delta_to_str
 from qubx.data.helpers import InMemoryCachedReader, TimeGuardedWrapper

qubx/cli/commands.py

@@ -1,17 +1,50 @@
+import os
+import sys
 from pathlib import Path
 
 import click
 
-from qubx.utils.misc import add_project_to_system_path, logo
-from qubx.utils.runner.runner import run_strategy_yaml, run_strategy_yaml_in_jupyter, simulate_strategy
+from qubx import QubxLogConfig, logger
 
 
 @click.group()
-def main():
+@click.option(
+    "--debug",
+    "-d",
+    is_flag=True,
+    help="Enable debug mode.",
+)
+@click.option(
+    "--debug-port",
+    "-p",
+    type=int,
+    help="Debug port.",
+    default=5678,
+)
+@click.option(
+    "--log-level",
+    "-l",
+    type=str,
+    help="Log level.",
+    default="INFO",
+)
+def main(debug: bool, debug_port: int, log_level: str):
     """
     Qubx CLI.
     """
-    pass
+    log_level = log_level.upper() if not debug else "DEBUG"
+
+    QubxLogConfig.set_log_level(log_level)
+
+    if debug:
+        os.environ["PYDEVD_DISABLE_FILE_VALIDATION"] = "1"
+
+        import debugpy
+
+        logger.info(f"Waiting for debugger to attach (port {debug_port})")
+
+        debugpy.listen(debug_port)
+        debugpy.wait_for_client()
 
 
 @main.command()
@@ -36,6 +69,9 @@ def run(config_file: Path, account_file: Path | None, paper: bool, jupyter: bool
     - If exists, accounts.toml located in the same folder with the config searched.\n
     - If neither of the above are provided, the accounts.toml in the ~/qubx/accounts.toml path is searched.
     """
+    from qubx.utils.misc import add_project_to_system_path, logo
+    from qubx.utils.runner.runner import run_strategy_yaml, run_strategy_yaml_in_jupyter
+
     add_project_to_system_path()
     add_project_to_system_path(str(config_file.parent))
     if jupyter:
@@ -57,11 +93,190 @@ def run(config_file: Path, account_file: Path | None, paper: bool, jupyter: bool
     "--output", "-o", default="results", type=str, help="Output directory for simulation results.", show_default=True
 )
 def simulate(config_file: Path, start: str | None, end: str | None, output: str | None):
+    """
+    Simulates the strategy with the given configuration file.
+    """
+    from qubx.utils.misc import add_project_to_system_path, logo
+    from qubx.utils.runner.runner import simulate_strategy
+
     add_project_to_system_path()
     add_project_to_system_path(str(config_file.parent))
     logo()
     simulate_strategy(config_file, output, start, end)
 
 
+@main.command()
+@click.argument(
+    "directory",
+    type=click.Path(exists=True, resolve_path=True),
+    default=".",
+    callback=lambda ctx, param, value: os.path.abspath(os.path.expanduser(value)),
+)
+def ls(directory: str):
+    """
+    Lists all strategies in the given directory.
+
+    Strategies are identified by the inheritance from IStrategy interface.
+    """
+    from .release import ls_strats
+
+    ls_strats(directory)
+
+
+@main.command()
+@click.argument(
+    "directory",
+    type=click.Path(exists=False),
+    default=".",
+    callback=lambda ctx, param, value: os.path.abspath(os.path.expanduser(value)),
+)
+@click.option(
+    "--strategy",
+    "-s",
+    type=click.STRING,
+    help="Strategy name to release (should match the strategy class name) or path to a config YAML file",
+    required=True,
+)
+@click.option(
+    "--output-dir",
+    "-o",
+    type=click.STRING,
+    help="Output directory to put zip file.",
+    default="releases",
+    show_default=True,
+)
+@click.option(
+    "--tag",
+    "-t",
+    type=click.STRING,
+    help="Additional tag for this release (e.g. 'v1.0.0')",
+    required=False,
+)
+@click.option(
+    "--message",
+    "-m",
+    type=click.STRING,
+    help="Release message (added to the info yaml file).",
+    required=False,
+    default=None,
+    show_default=True,
+)
+@click.option(
+    "--commit",
+    "-c",
+    is_flag=True,
+    default=False,
+    help="Commit changes and create tag in repo (default: False)",
+    show_default=True,
+)
+@click.option(
+    "--default-exchange",
+    type=click.STRING,
+    help="Default exchange to use in the generated config.",
+    default="BINANCE.UM",
+    show_default=True,
+)
+@click.option(
+    "--default-connector",
+    type=click.STRING,
+    help="Default connector to use in the generated config.",
+    default="ccxt",
+    show_default=True,
+)
+@click.option(
+    "--default-instruments",
+    type=click.STRING,
+    help="Default instruments to use in the generated config (comma-separated).",
+    default="BTCUSDT",
+    show_default=True,
+)
+def release(
+    directory: str,
+    strategy: str,
+    tag: str | None,
+    message: str | None,
+    commit: bool,
+    output_dir: str,
+    default_exchange: str,
+    default_connector: str,
+    default_instruments: str,
+) -> None:
+    """
+    Releases the strategy to a zip file.
+
+    The strategy can be specified in two ways:
+    1. As a strategy name (class name) - strategies are scanned in the given directory
+    2. As a path to a config YAML file containing the strategy configuration in StrategyConfig format
+
+    If a strategy name is provided, a default configuration will be generated with:
+    - The strategy parameters from the strategy class
+    - Default exchange, connector, and instruments from the command options
+    - Standard logging configuration
+
+    If a config file is provided, it must follow the StrategyConfig structure with:
+    - strategy: The strategy name or path
+    - parameters: Dictionary of strategy parameters
+    - exchanges: Dictionary of exchange configurations
+    - aux: Auxiliary configuration
+    - logging: Logging configuration
+
+    All of the dependencies are included in the zip file.
+    """
+    from .release import release_strategy
+
+    # Parse default instruments
+    instruments = [instr.strip() for instr in default_instruments.split(",")]
+
+    release_strategy(
+        directory=directory,
+        strategy_name=strategy,
+        tag=tag,
+        message=message,
+        commit=commit,
+        output_dir=output_dir,
+        default_exchange=default_exchange,
+        default_connector=default_connector,
+        default_instruments=instruments,
+    )
+
+
+@main.command()
+@click.argument(
+    "zip-file",
+    type=click.Path(exists=True, resolve_path=True),
+    callback=lambda ctx, param, value: os.path.abspath(os.path.expanduser(value)),
+)
+@click.option(
+    "--output-dir",
+    "-o",
+    type=click.Path(exists=False),
+    help="Output directory to unpack the zip file. Defaults to the directory containing the zip file.",
+    default=None,
+)
+@click.option(
+    "--force",
+    "-f",
+    is_flag=True,
+    default=False,
+    help="Force overwrite if the output directory already exists.",
+    show_default=True,
+)
+def deploy(zip_file: str, output_dir: str | None, force: bool):
+    """
+    Deploys a strategy from a zip file created by the release command.
+
+    This command:
+    1. Unpacks the zip file to the specified output directory
+    2. Creates a Poetry virtual environment in the .venv folder
+    3. Installs dependencies from the poetry.lock file
+
+    If no output directory is specified, the zip file is unpacked in the same directory
+    as the zip file, in a folder with the same name as the zip file (without the .zip extension).
+    """
+    from .deploy import deploy_strategy
+
+    deploy_strategy(zip_file, output_dir, force)
+
+
 if __name__ == "__main__":
     main()

qubx/cli/deploy.py

@@ -0,0 +1,232 @@
+import os
+import shutil
+import subprocess
+import zipfile
+from pathlib import Path
+
+from qubx import logger
+
+
+def validate_zip_file(zip_file: str) -> bool:
+    """
+    Validates that the provided file is a zip file.
+
+    Args:
+        zip_file: Path to the zip file to validate
+
+    Returns:
+        bool: True if valid, False otherwise
+    """
+    if not zip_file.endswith(".zip"):
+        logger.error("The file must be a zip file with .zip extension")
+        return False
+    return True
+
+
+def determine_output_directory(zip_file: str, output_dir: str | None) -> str:
+    """
+    Determines the output directory for the deployment.
+
+    Args:
+        zip_file: Path to the zip file to deploy
+        output_dir: User-specified output directory or None
+
+    Returns:
+        str: The resolved output directory path
+    """
+    zip_path = Path(zip_file)
+    zip_name = zip_path.stem
+
+    if output_dir is None:
+        return str(zip_path.parent / zip_name)
+
+    output_dir = os.path.abspath(os.path.expanduser(output_dir))
+    # If output_dir is a directory that exists, create a subdirectory with the zip name
+    if os.path.isdir(output_dir):
+        return os.path.join(output_dir, zip_name)
+
+    return output_dir
+
+
+def prepare_output_directory(output_dir: str, force: bool) -> bool:
+    """
+    Prepares the output directory, handling existing directories based on the force flag.
+
+    Args:
+        output_dir: The output directory path
+        force: Whether to force overwrite if the directory exists
+
+    Returns:
+        bool: True if successful, False otherwise
+    """
+    if os.path.exists(output_dir):
+        if not force:
+            logger.error(f"Output directory {output_dir} already exists. Use --force to overwrite.")
+            return False
+        logger.warning(f"Removing existing directory {output_dir}")
+        shutil.rmtree(output_dir)
+
+    os.makedirs(output_dir, exist_ok=True)
+    return True
+
+
+def extract_zip_file(zip_file: str, output_dir: str) -> bool:
+    """
+    Extracts the zip file to the output directory.
+
+    Args:
+        zip_file: Path to the zip file to extract
+        output_dir: Directory to extract to
+
+    Returns:
+        bool: True if successful, False otherwise
+    """
+    logger.info(f"Unpacking {zip_file} to {output_dir}")
+    try:
+        with zipfile.ZipFile(zip_file, "r") as zip_ref:
+            zip_ref.extractall(output_dir)
+        return True
+    except zipfile.BadZipFile:
+        logger.error(f"The file {zip_file} is not a valid zip file")
+        return False
+    except Exception as e:
+        logger.error(f"Failed to unpack zip file: {e}")
+        return False
+
+
+def ensure_poetry_lock_exists(output_dir: str) -> bool:
+    """
+    Ensures that a poetry.lock file exists in the output directory.
+    If not, attempts to generate one.
+
+    Args:
+        output_dir: The directory to check/generate in
+
+    Returns:
+        bool: True if successful, False otherwise
+    """
+    poetry_lock_path = os.path.join(output_dir, "poetry.lock")
+    if not os.path.exists(poetry_lock_path):
+        logger.warning("poetry.lock not found in the zip file. Attempting to generate it.")
+        try:
+            subprocess.run(
+                ["poetry", "lock", "--no-update"], cwd=output_dir, check=True, capture_output=True, text=True
+            )
+            return True
+        except subprocess.CalledProcessError as e:
+            logger.error(f"Failed to generate poetry.lock: {e.stderr}")
+            return False
+    return True
+
+
+def setup_poetry_environment(output_dir: str) -> bool:
+    """
+    Sets up the Poetry virtual environment in the output directory.
+
+    Args:
+        output_dir: The directory to set up the environment in
+
+    Returns:
+        bool: True if successful, False otherwise
+    """
+    logger.info("Creating Poetry virtual environment")
+    try:
+        # Configure Poetry to create a virtual environment in the .venv directory
+        logger.info("Configuring Poetry")
+        subprocess.run(
+            ["poetry", "config", "virtualenvs.in-project", "true", "--local"],
+            cwd=output_dir,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+
+        # Check if we're already in a Poetry shell
+        in_poetry_env = "POETRY_ACTIVE" in os.environ or "VIRTUAL_ENV" in os.environ
+
+        if in_poetry_env:
+            logger.debug(
+                "Detected active Poetry environment. "
+                "Will explicitly create a new environment for the deployed strategy."
+            )
+
+        # Install dependencies
+        logger.info("Installing dependencies")
+
+        # If we're in a Poetry shell, we need to be more explicit about creating a new environment
+        install_cmd = ["poetry", "install"]
+        if in_poetry_env:
+            # Force Poetry to create a new environment even if we're in an active one
+            env = os.environ.copy()
+            # Temporarily unset Poetry environment variables to avoid interference
+            for var in ["POETRY_ACTIVE", "VIRTUAL_ENV"]:
+                if var in env:
+                    del env[var]
+
+            subprocess.run(install_cmd, cwd=output_dir, check=True, capture_output=True, text=True, env=env)
+        else:
+            # Normal case - not in a Poetry shell
+            subprocess.run(install_cmd, cwd=output_dir, check=True, capture_output=True, text=True)
+
+        # Verify that the virtual environment was created
+        venv_path = os.path.join(output_dir, ".venv")
+        if not os.path.exists(venv_path):
+            logger.warning(
+                "Virtual environment directory (.venv) not found. "
+                "This might happen if you're already in a Poetry shell. "
+                "You may need to run 'cd %s && poetry env use python' to create it manually.",
+                output_dir,
+            )
+
+        return True
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Failed to set up Poetry environment: {e.stderr}")
+        return False
+
+
+def deploy_strategy(zip_file: str, output_dir: str | None, force: bool) -> bool:
+    """
+    Deploys a strategy from a zip file created by the release command.
+
+    This function:
+    1. Unpacks the zip file to the specified output directory
+    2. Creates a Poetry virtual environment in the .venv folder
+    3. Installs dependencies from the poetry.lock file
+
+    Args:
+        zip_file: Path to the zip file to deploy
+        output_dir: Output directory to unpack the zip file. If None, uses the directory containing the zip file.
+        force: Whether to force overwrite if the output directory already exists
+
+    Returns:
+        bool: True if deployment was successful, False otherwise
+    """
+    # Validate the zip file
+    if not validate_zip_file(zip_file):
+        return False
+
+    # Determine the output directory
+    resolved_output_dir = determine_output_directory(zip_file, output_dir)
+
+    # Prepare the output directory
+    if not prepare_output_directory(resolved_output_dir, force):
+        return False
+
+    # Extract the zip file
+    if not extract_zip_file(zip_file, resolved_output_dir):
+        return False
+
+    # Ensure poetry.lock exists
+    if not ensure_poetry_lock_exists(resolved_output_dir):
+        return False
+
+    # Set up the Poetry environment
+    if not setup_poetry_environment(resolved_output_dir):
+        return False
+
+    # Success messages
+    logger.info(f"Strategy deployed successfully to {resolved_output_dir}")
+    logger.info(
+        f"To run the strategy (paper mode): <cyan>cd {resolved_output_dir} && poetry run qubx run config.yml --paper</cyan>"
+    )
+    return True