Qubx 1.1.3.dev23__tar.gz → 1.1.3.dev24__tar.gz

{qubx-1.1.3.dev23 → qubx-1.1.3.dev24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Qubx
-Version: 1.1.3.dev23
+Version: 1.1.3.dev24
 Summary: Qubx - Quantitative Trading Framework
 Project-URL: homepage, https://xlydian.com
 Project-URL: repository, https://github.com/xLydianSoftware/Qubx

{qubx-1.1.3.dev23 → qubx-1.1.3.dev24}/src/qubx/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '1.1.3.dev23'
-__version_tuple__ = version_tuple = (1, 1, 3, 'dev23')
+__version__ = version = '1.1.3.dev24'
+__version_tuple__ = version_tuple = (1, 1, 3, 'dev24')
 
 __commit_id__ = commit_id = None

{qubx-1.1.3.dev23 → qubx-1.1.3.dev24}/src/qubx/cli/commands.py

@@ -110,6 +110,20 @@ def main(debug: bool, debug_port: int, log_level: str):
 @click.option("--no-notifiers", is_flag=True, default=False, help="Disable lifecycle notifiers.", show_default=True)
 @click.option("--no-exporters", is_flag=True, default=False, help="Disable trade exporters.", show_default=True)
 @click.option("--override", type=Path, default=None, help="Sparse YAML file to deep-merge on top of config.", show_default=False)
+@click.option(
+    "--from-sources",
+    is_flag=True,
+    default=False,
+    help="Clone the repo pinned in config.release.source and run the strategy from that checkout.",
+    show_default=True,
+)
+@click.option(
+    "--refresh-sources",
+    is_flag=True,
+    default=False,
+    help="Force re-clone of the source cache (only with --from-sources).",
+    show_default=True,
+)
 def run(
     config_file: Path,
     account_file: Path | None,
@@ -129,6 +143,8 @@ def run(
     no_notifiers: bool,
     no_exporters: bool,
     override: Path | None,
+    from_sources: bool,
+    refresh_sources: bool,
 ):
     """
     Starts the strategy with the given configuration file. If paper mode is enabled, account is not required.
@@ -137,6 +153,11 @@ def run(
     - If provided, the account file is searched first.\n
     - 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.
+
+    With --from-sources, the repo pinned in ``config.release.source`` is cloned into
+    ``.releases/sources/<repo>_<ref>/``, its dependencies installed via ``uv sync``,
+    and then ``qubx run`` is re-invoked inside that checkout. Useful for verifying
+    that a release config actually boots against its pinned strategy code.
     """
     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
@@ -147,6 +168,68 @@ def run(
         click.echo("Error: --jupyter and --textual cannot be used together.", err=True)
         raise click.Abort()
 
+    if from_sources:
+        import subprocess
+        import sys
+
+        from .release import prepare_source_checkout
+
+        abs_config = str(config_file.resolve())
+        try:
+            clone_dir, _ = prepare_source_checkout(
+                config_file=abs_config,
+                refresh=refresh_sources,
+                install_project=True,
+            )
+        except Exception as e:
+            click.echo(click.style(f"Failed to prepare source checkout: {e}", fg="red"), err=True)
+            raise click.Abort()
+
+        # Re-invoke `qubx run` inside the cloned venv. Forward every flag the user passed,
+        # minus --from-sources/--refresh-sources, and replace the config path with its
+        # absolute form so the inner invocation finds it regardless of CWD.
+        forwarded: list[str] = []
+        if account_file:
+            forwarded += ["--account-file", str(Path(account_file).resolve())]
+        if paper:
+            forwarded.append("--paper")
+        if jupyter:
+            forwarded.append("--jupyter")
+        if textual:
+            forwarded.append("--textual")
+        if textual_dev:
+            forwarded.append("--textual-dev")
+        if textual_web:
+            forwarded.append("--textual-web")
+        if textual_port is not None:
+            forwarded += ["--textual-port", str(textual_port)]
+        if textual_host and textual_host != "0.0.0.0":
+            forwarded += ["--textual-host", textual_host]
+        if kernel_only:
+            forwarded.append("--kernel-only")
+        if connect:
+            forwarded += ["--connect", str(Path(connect).resolve())]
+        if restore:
+            forwarded.append("--restore")
+        if no_color:
+            forwarded.append("--no-color")
+        if dev:
+            forwarded.append("--dev")
+        if no_emission:
+            forwarded.append("--no-emission")
+        if no_notifiers:
+            forwarded.append("--no-notifiers")
+        if no_exporters:
+            forwarded.append("--no-exporters")
+        if override:
+            forwarded += ["--override", str(Path(override).resolve())]
+
+        cmd = ["uv", "run", "qubx", "run", abs_config, *forwarded]
+        logger.info(f"Running inside source checkout: <cyan>{clone_dir}</cyan>")
+        logger.info(f"<dim>$ {' '.join(cmd)}</dim>")
+        result = subprocess.run(cmd, cwd=str(clone_dir))
+        sys.exit(result.returncode)
+
     if dev:
         add_project_to_system_path()  # Adds ~/projects in dev mode
     add_project_to_system_path(config_file.parent)
@@ -378,6 +461,20 @@ def validate(config_file: Path, no_check_imports: bool):
     help="Commit changes and create tag in repo (default: False)",
     show_default=True,
 )
+@click.option(
+    "--from-sources",
+    is_flag=True,
+    default=False,
+    help="Clone the repo pinned in config.release.source and build the release from that checkout.",
+    show_default=True,
+)
+@click.option(
+    "--refresh-sources",
+    is_flag=True,
+    default=False,
+    help="Force re-clone of the source cache (only with --from-sources).",
+    show_default=True,
+)
 def release(
     directory: str,
     config: str,
@@ -385,6 +482,8 @@ def release(
     message: str | None,
     commit: bool,
     output_dir: str,
+    from_sources: bool,
+    refresh_sources: bool,
 ) -> None:
     """
     Releases the strategy to a zip file.
@@ -399,8 +498,26 @@ def release(
     - logging: Logging configuration
 
     All of the dependencies are included in the zip file.
+
+    With --from-sources, the config's ``release.source`` section is used to clone
+    the referenced repo at the specified ref and build the release from that
+    checkout instead of the local ``directory``. Used for CI-driven releases
+    where the config lives in a separate repo from the strategy code.
     """
-    from .release import release_strategy
+    from .release import release_from_source, release_strategy
+
+    if from_sources:
+        zip_path = release_from_source(
+            config_file=config,
+            output_dir=output_dir,
+            tag=tag,
+            refresh=refresh_sources,
+        )
+        if zip_path:
+            click.echo(zip_path)
+        else:
+            raise click.Abort()
+        return
 
     release_strategy(
         directory=directory,
@@ -412,47 +529,6 @@ def release(
     )
 
 
-@main.command("release-from-source")
-@click.option(
-    "--config",
-    "-c",
-    type=click.Path(exists=True, resolve_path=True),
-    help="Path to a config YAML file with a release.source section",
-    required=True,
-)
-@click.option(
-    "--output-dir",
-    "-o",
-    type=click.Path(exists=False),
-    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",
-    required=False,
-)
-def release_from_source_cmd(config: str, output_dir: str, tag: str | None) -> None:
-    """
-    Build a release by cloning the source repo specified in the config's release.source section.
-
-    Used for CI-driven releases where the config lives in a separate repo from the strategy code.
-    The config must have a release.source section specifying the GitHub repo and ref.
-    """
-    from .release import release_from_source
-
-    zip_path = release_from_source(
-        config_file=config,
-        output_dir=output_dir,
-        tag=tag,
-    )
-    if zip_path:
-        click.echo(zip_path)
-
-
 @main.command()
 @click.argument(
     "zip-file",

{qubx-1.1.3.dev23 → qubx-1.1.3.dev24}/src/qubx/cli/release.py

@@ -562,102 +562,146 @@ def release_strategy(
         logger.opt(colors=False).error(f"Error releasing strategy: {e}")
 
 
-def release_from_source(
+def prepare_source_checkout(
     config_file: str,
-    output_dir: str,
-    tag: str | None = None,
-) -> str | None:
+    cache_root: str | Path = ".releases/sources",
+    refresh: bool = False,
+    install_project: bool = True,
+) -> tuple[Path, StrategyConfig]:
     """
-    Build a release by cloning the source repo specified in the config's release.source section.
+    Prepare a source checkout for --from-sources workflows.
 
-    This is the entry point for CI-driven releases (e.g., from xrelease GitHub Action).
-    It reads the release.source.repo and release.source.ref from the config YAML,
-    clones that repo at the specified ref into a temp directory, copies the config
-    into the clone, and runs the standard release flow.
+    Clones the repo specified in ``config.release.source`` into a cached dir
+    (reusing it across invocations) and runs ``uv sync --all-extras`` so
+    dependencies are resolved and the strategy package is importable.
 
     Args:
-        config_file: Path to the strategy config YAML (must have a release.source section)
-        output_dir: Directory to write the release ZIP
-        tag: Optional tag suffix for the release name
+        config_file: Path to the strategy config YAML (must have release.source).
+        cache_root: Root dir for cached checkouts. Relative paths are resolved
+            against the current working directory.
+        refresh: If True, wipe any existing cached checkout and re-clone.
+        install_project: If True (default), install the project package into the
+            cloned venv (needed for ``qubx run``). Set to False for release flows
+            that only need deps in the uv git cache.
 
     Returns:
-        Path to the created ZIP file, or None on failure
+        Tuple of (clone_dir, parsed_strategy_config).
     """
     import subprocess
-    import tempfile
 
-    from qubx import QubxLogConfig
-
-    QubxLogConfig.set_log_level("INFO")
+    config_path = os.path.abspath(os.path.expanduser(config_file))
+    if not is_config_file(config_path):
+        raise ValueError(f"Not a valid config file: {config_file}")
 
-    try:
-        config_path = os.path.abspath(os.path.expanduser(config_file))
-        if not is_config_file(config_path):
-            raise ValueError(f"Not a valid config file: {config_file}")
+    stg_config = load_strategy_config_from_yaml(config_path, resolve_env=False)
+    if not stg_config.release or not stg_config.release.source:
+        raise ValueError("Config must have a release.source section with repo and ref")
 
-        # Parse the config to extract release.source
-        stg_config = load_strategy_config_from_yaml(config_path, resolve_env=False)
-        if not stg_config.release or not stg_config.release.source:
-            raise ValueError("Config must have a release.source section with repo and ref")
+    source = stg_config.release.source
+    repo_url = f"https://github.com/{source.repo}.git"
+    ref = source.ref
 
-        source = stg_config.release.source
-        repo_url = f"https://github.com/{source.repo}.git"
-        ref = source.ref
+    # Cache key: <owner>_<name>_<ref>, with ref sanitized for the filesystem.
+    owner, name = source.repo.split("/", 1)
+    safe_ref = re.sub(r"[^A-Za-z0-9._-]", "_", ref)
+    cache_dir = Path(cache_root).expanduser().resolve() / f"{owner}_{name}_{safe_ref}"
 
-        logger.info(f"Cloning {source.repo} at ref '{ref}' ...")
-        clone_dir = tempfile.mkdtemp(prefix="qubx-release-")
+    if refresh and cache_dir.exists():
+        logger.info(f"Refreshing cached checkout at <cyan>{cache_dir}</cyan>")
+        shutil.rmtree(cache_dir)
 
+    if not cache_dir.exists():
+        cache_dir.parent.mkdir(parents=True, exist_ok=True)
+        logger.info(f"Cloning <cyan>{source.repo}</cyan> at ref '<yellow>{ref}</yellow>' to {cache_dir}")
         try:
             subprocess.run(
-                ["git", "clone", "--depth", "1", "--branch", ref, repo_url, clone_dir],
+                ["git", "clone", "--depth", "1", "--branch", ref, repo_url, str(cache_dir)],
                 check=True,
                 capture_output=True,
                 text=True,
             )
         except subprocess.CalledProcessError:
-            # --branch doesn't work with commit SHAs, fall back to full clone + checkout
+            # --branch doesn't work with commit SHAs; fall back to full clone + checkout.
             logger.info(f"Shallow clone failed for ref '{ref}', trying full clone...")
-            shutil.rmtree(clone_dir, ignore_errors=True)
-            os.makedirs(clone_dir)
+            if cache_dir.exists():
+                shutil.rmtree(cache_dir)
+            cache_dir.mkdir(parents=True, exist_ok=True)
             subprocess.run(
-                ["git", "clone", repo_url, clone_dir],
+                ["git", "clone", repo_url, str(cache_dir)],
                 check=True,
                 capture_output=True,
                 text=True,
             )
             subprocess.run(
                 ["git", "checkout", ref],
-                cwd=clone_dir,
+                cwd=str(cache_dir),
                 check=True,
                 capture_output=True,
                 text=True,
             )
+    else:
+        logger.info(f"Reusing cached checkout at <cyan>{cache_dir}</cyan>")
 
-        # Resolve and fetch dependencies in the cloned project.
-        # uv sync populates the git checkout cache (needed for _find_uv_git_checkout),
-        # while uv lock alone does not. Use --all-extras to include optional deps
-        # (plugins like qubx-lighter, xmetals are typically in optional extras).
-        logger.info("Resolving and fetching dependencies in cloned project...")
-        result = subprocess.run(
-            ["uv", "sync", "--no-install-project", "--all-extras"],
-            cwd=clone_dir,
-            capture_output=True,
-            text=True,
+    # Resolve and install dependencies in the cloned project.
+    # --all-extras pulls in optional extras (qubx-lighter, xmetals plugins).
+    # Skipping --no-install-project installs the strategy package itself into
+    # the cloned venv — required for `qubx run` to import the strategy.
+    sync_args = ["uv", "sync", "--all-extras"]
+    if not install_project:
+        sync_args.insert(2, "--no-install-project")
+    logger.info(f"Running <cyan>{' '.join(sync_args)}</cyan> in {cache_dir}")
+    result = subprocess.run(sync_args, cwd=str(cache_dir), capture_output=True, text=True)
+    if result.returncode != 0:
+        logger.opt(colors=False).error(f"uv sync failed:\n{result.stderr}")
+        raise subprocess.CalledProcessError(result.returncode, result.args, output=result.stdout, stderr=result.stderr)
+
+    return cache_dir, stg_config
+
+
+def release_from_source(
+    config_file: str,
+    output_dir: str,
+    tag: str | None = None,
+    refresh: bool = False,
+) -> str | None:
+    """
+    Build a release by cloning the source repo specified in ``config.release.source``.
+
+    Thin wrapper around ``prepare_source_checkout`` + the standard release flow.
+    Used by ``qubx release --from-sources``.
+
+    Args:
+        config_file: Path to the strategy config YAML (must have a release.source section)
+        output_dir: Directory to write the release ZIP
+        tag: Optional tag suffix for the release name
+        refresh: Force re-clone of the source cache
+
+    Returns:
+        Path to the created ZIP file, or None on failure
+    """
+    from qubx import QubxLogConfig
+
+    QubxLogConfig.set_log_level("INFO")
+
+    try:
+        config_path = os.path.abspath(os.path.expanduser(config_file))
+        # release flow reads source files directly from the clone; no need to install the project.
+        clone_dir, stg_config = prepare_source_checkout(
+            config_file=config_path,
+            refresh=refresh,
+            install_project=False,
         )
-        if result.returncode != 0:
-            logger.error(f"uv sync failed:\n{result.stderr}")
-            raise subprocess.CalledProcessError(result.returncode, result.args)
+        assert stg_config.release and stg_config.release.source  # verified in helper
+        ref = stg_config.release.source.ref
 
-        # Copy the config into the clone root so release can find it
+        # Copy the config into the clone root so the release flow can find it.
         config_basename = os.path.basename(config_path)
-        cloned_config = os.path.join(clone_dir, config_basename)
+        cloned_config = os.path.join(str(clone_dir), config_basename)
         shutil.copy2(config_path, cloned_config)
 
-        # Run the standard release flow from the cloned project
-        logger.info(f"Running release from {clone_dir} ...")
+        logger.info(f"Running release from <cyan>{clone_dir}</cyan>")
         output_dir = os.path.abspath(output_dir)
-        stg_info = load_strategy_from_config(Path(cloned_config), clone_dir)
-        pyproject_root = clone_dir
+        stg_info = load_strategy_from_config(Path(cloned_config), str(clone_dir))
 
         git_info = ReleaseInfo(
             tag=generate_tag(stg_info.name, tag),
@@ -670,12 +714,11 @@ def release_from_source(
         create_released_pack(
             stg_info=stg_info,
             git_info=git_info,
-            pyproject_root=pyproject_root,
+            pyproject_root=str(clone_dir),
             output_dir=output_dir,
             config_file=cloned_config,
         )
 
-        # Find the created ZIP
         zip_path = os.path.join(output_dir, f"{git_info.tag}.zip")
         if os.path.exists(zip_path):
             logger.info(f"Release created: {zip_path}")
@@ -687,10 +730,6 @@ def release_from_source(
     except Exception as e:
         logger.opt(colors=False).error(f"Error in release_from_source: {e}")
         return None
-    finally:
-        # Clean up temp clone
-        if "clone_dir" in locals():
-            shutil.rmtree(clone_dir, ignore_errors=True)
 
 
 def _find_source_root(pyproject_root: str, project_name: str) -> str | None: