Qubx 1.0.0.dev6__tar.gz → 1.0.1.dev2__tar.gz

{qubx-1.0.0.dev6 → qubx-1.0.1.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Qubx
-Version: 1.0.0.dev6
+Version: 1.0.1.dev2
 Summary: Qubx - Quantitative Trading Framework
 Project-URL: homepage, https://xlydian.com
 Project-URL: repository, https://github.com/xLydianSoftware/Qubx

{qubx-1.0.0.dev6 → qubx-1.0.1.dev2}/pyproject.toml

@@ -133,7 +133,7 @@ extend-select = ["I"]
 ignore = ["E731", "E722", "E741"]
 
 [tool.ruff.lint.extend-per-file-ignores]
-"*.ipynb" = [ "F405", "F401", "E701", "E402", "F403", "E401", "E702", "F821", "E731", ]
+"*.ipynb" = [ "F405", "F401", "E701", "E402", "F403", "E401", "E702", "F821", "E731", "I001", ]
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"

{qubx-1.0.0.dev6 → qubx-1.0.1.dev2}/src/qubx/__init__.py

@@ -1,3 +1,4 @@
+import json as _json
 import os
 import sys
 from typing import Callable
@@ -32,15 +33,30 @@ def runtime_env():
         return "python"  # Probably standard Python interpreter
 
 
+def format_platform_identity(record) -> str:
+    """Return a colored identity prefix from record extras (bot_id / instance_id)."""
+    bot_id = record["extra"].get("bot_id")
+    instance_id = record["extra"].get("instance_id")
+    if bot_id or instance_id:
+        parts = []
+        if bot_id:
+            parts.append(f"bot={bot_id}")
+        if instance_id:
+            parts.append(f"inst={instance_id}")
+        return "<magenta>[%s]</magenta> " % " ".join(parts)
+    return ""
+
+
 def formatter(record):
     end = record["extra"].get("end", "\n")
     fmt = "<lvl>{message}</lvl>%s" % end
     if record["level"].name in {"WARNING", "SNAKY"}:
         fmt = "<cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - %s" % fmt
 
+    identity = format_platform_identity(record)
     prefix = (
-        "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> [ <level>%s</level> ] <cyan>({module})</cyan> "
-        % record["level"].icon
+        "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> [ <level>%s</level> ] %s<cyan>({module})</cyan> "
+        % (record["level"].icon, identity)
     )
 
     if record["exception"] is not None:
@@ -70,6 +86,38 @@ class QubxLogConfig:
         os.environ["QUBX_LOG_LEVEL"] = level
         QubxLogConfig.setup_logger(level)
 
+    _COLOR_TAG_RE = None
+
+    @staticmethod
+    def _strip_color_tags(text: str) -> str:
+        """Remove loguru color markup tags like <yellow>...</yellow> from text."""
+        import re
+
+        if QubxLogConfig._COLOR_TAG_RE is None:
+            QubxLogConfig._COLOR_TAG_RE = re.compile(r"</?[a-z_]+>")
+        return QubxLogConfig._COLOR_TAG_RE.sub("", text)
+
+    @staticmethod
+    def _json_sink(message):
+        """Emit one JSON line per log record for Loki/Promtail ingestion."""
+        record = message.record
+        entry = {
+            "timestamp": record["time"].strftime("%Y-%m-%dT%H:%M:%S.%fZ"),
+            "level": record["level"].name,
+            "module": record["module"],
+            "function": record["function"],
+            "line": record["line"],
+            "message": QubxLogConfig._strip_color_tags(record["message"]),
+        }
+        # Merge platform identity and any other extras (skip internal loguru keys)
+        for key, val in record["extra"].items():
+            if key not in ("user", "end", "stack"):
+                entry[key] = val
+        if record["exception"] is not None:
+            entry["exception"] = stackprinter.format(record["exception"], style="plaintext")
+        sys.stdout.write(_json.dumps(entry, default=str) + "\n")
+        sys.stdout.flush()
+
     @staticmethod
     def setup_logger(level: str | None = None, custom_formatter: Callable | None = None, colorize: bool = True):
         global logger
@@ -84,7 +132,21 @@ class QubxLogConfig:
         logger.remove(None)
 
         level = level or QubxLogConfig.get_log_level()
-        # Add stdout handler with enqueue=True for thread/process safety
+
+        # Check if JSON format is requested (for Loki/container deployments)
+        log_format = os.getenv("QUBX_LOG_FORMAT", "text").lower()
+        if log_format == "json":
+            logger.add(
+                QubxLogConfig._json_sink,
+                level=level,
+                enqueue=True,
+                backtrace=True,
+                diagnose=True,
+            )
+            # No colorize opt needed for JSON
+            return
+
+        # Default: human-readable text format
         logger.add(
             sys.stdout,
             format=custom_formatter or formatter,
@@ -96,6 +158,17 @@ class QubxLogConfig:
         )
         logger = logger.opt(colors=colorize)
 
+    @staticmethod
+    def bind_platform_identity(bot_id: str | None = None, instance_id: str | None = None):
+        """Bind platform identity fields (bot_id, instance_id) to all log messages globally."""
+        def patcher(record):
+            if bot_id:
+                record["extra"]["bot_id"] = bot_id
+            if instance_id:
+                record["extra"]["instance_id"] = instance_id
+
+        logger.configure(patcher=patcher)
+
 
 QubxLogConfig.setup_logger()
 

{qubx-1.0.0.dev6 → qubx-1.0.1.dev2}/src/qubx/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.0.0.dev6'
-__version_tuple__ = version_tuple = (1, 0, 0, 'dev6')
+__version__ = version = '1.0.1.dev2'
+__version_tuple__ = version_tuple = (1, 0, 1, 'dev2')
 
 __commit_id__ = commit_id = None

{qubx-1.0.0.dev6 → qubx-1.0.1.dev2}/src/qubx/backtester/utils.py

@@ -133,8 +133,10 @@ class SimulatedLogFormatter:
         else:
             now = self.time_provider.time().astype("datetime64[us]").item().strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
 
-        # prefix = "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> [ <level>%s</level> ] " % record["level"].icon
-        prefix = f"<lc>{now}</lc> [<level>{record['level'].icon}</level>] <cyan>({{module}})</cyan> "
+        from qubx import format_platform_identity
+
+        identity = format_platform_identity(record)
+        prefix = f"<lc>{now}</lc> [<level>{record['level'].icon}</level>] {identity}<cyan>({{module}})</cyan> "
 
         if record["exception"] is not None:
             record["extra"]["stack"] = stackprinter.format(record["exception"], style="darkbg3")

{qubx-1.0.0.dev6 → qubx-1.0.1.dev2}/src/qubx/cli/commands.py

@@ -109,6 +109,7 @@ def main(debug: bool, debug_port: int, log_level: str):
 @click.option("--no-emission", is_flag=True, default=False, help="Disable metric emission.", show_default=True)
 @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)
 def run(
     config_file: Path,
     account_file: Path | None,
@@ -127,6 +128,7 @@ def run(
     no_emission: bool,
     no_notifiers: bool,
     no_exporters: bool,
+    override: Path | None,
 ):
     """
     Starts the strategy with the given configuration file. If paper mode is enabled, account is not required.
@@ -210,6 +212,7 @@ def run(
             no_emission=no_emission,
             no_notifiers=no_notifiers,
             no_exporters=no_exporters,
+            config_overrides=override,
         )
 
 
@@ -236,8 +239,23 @@ def run(
     help="Write simulation logs to a file in the output directory.",
     show_default=True,
 )
+@click.option(
+    "--name",
+    "-n",
+    default=None,
+    type=str,
+    help="Override the run name used for output folder (e.g. 'smoketest', '01_reference'). "
+    "Overrides the 'name:' field from the config file.",
+    show_default=True,
+)
 def simulate(
-    config_file: Path, start: str | None, end: str | None, output: str | None, report: str | None, log_to_file: bool
+    config_file: Path,
+    start: str | None,
+    end: str | None,
+    output: str | None,
+    report: str | None,
+    log_to_file: bool,
+    name: str | None,
 ):
     """
     Simulates the strategy with the given configuration file.
@@ -249,7 +267,7 @@ def simulate(
     add_project_to_system_path(str(config_file.parent))
     logo()
     logger.info(f"Process PID: <g>{os.getpid()}</g>")
-    simulate_strategy(config_file, output, start, end, report, log_to_file)
+    simulate_strategy(config_file, output, start, end, report, log_to_file, name=name)
 
 
 @main.command()

{qubx-1.0.0.dev6 → qubx-1.0.1.dev2}/src/qubx/cli/release.py

@@ -534,9 +534,9 @@ def release_strategy(
             config_file=config_file,
         )
     except ValueError as e:
-        logger.error(f"<r>{str(e)}</r>")
+        logger.error(f"<r>{str(e).replace('<', chr(92) + '<')}</r>")
     except Exception as e:
-        logger.error(f"<r>Error releasing strategy: {e}</r>")
+        logger.error(f"<r>Error releasing strategy: {str(e).replace('<', chr(92) + '<')}</r>")
 
 
 def create_released_pack(
@@ -814,7 +814,217 @@ def _create_metadata(stg_name: str, git_info: ReleaseInfo, release_dir: str) ->
         fs.write(f"Commit: {git_info.commit}\n")
 
 
-def _clean_pyproject_for_release(pyproject_data: dict) -> dict:
+def _version_exists_on_pypi(pkg_name: str, version: str) -> bool:
+    """Check if a specific package version is available on public PyPI."""
+    import urllib.request
+
+    try:
+        url = f"https://pypi.org/pypi/{pkg_name}/{version}/json"
+        with urllib.request.urlopen(url, timeout=5) as response:
+            return response.status == 200
+    except Exception:
+        return False
+
+
+def _get_index_url(index_name: str, pyproject_data: dict) -> str | None:
+    """Get URL for a named uv index from [[tool.uv.index]] entries."""
+    indexes = pyproject_data.get("tool", {}).get("uv", {}).get("index", [])
+    for idx in indexes:
+        if idx.get("name") == index_name:
+            return idx.get("url")
+    return None
+
+
+def _find_version_in_pyproject(pkg_name: str, pyproject_data: dict) -> str | None:
+    """
+    Find a package's pinned version from pyproject.toml deps (regular + optional).
+    Returns the version string (e.g. "0.1.0") or None if not found.
+    """
+    all_deps: list[str] = list(pyproject_data.get("project", {}).get("dependencies", []))
+    for group_deps in pyproject_data.get("project", {}).get("optional-dependencies", {}).values():
+        all_deps.extend(group_deps)
+
+    for dep in all_deps:
+        dep_pkg = dep.split(">=")[0].split("==")[0].split("<")[0].strip()
+        if dep_pkg.lower() == pkg_name.lower():
+            if "==" in dep:
+                return dep.split("==")[1].strip()
+            if ">=" in dep:
+                return dep.split(">=")[1].split(",")[0].strip()
+    return None
+
+
+def _bundle_source_overrides(
+    pyproject_data: dict,
+    pyproject_root: str,
+    release_dir: str,
+    required_packages: set[str],
+) -> list[str]:
+    """
+    For each [tool.uv.sources] entry that is required by this release:
+    - path source + installed version on public PyPI → skip (will resolve from PyPI)
+    - path source + NOT on public PyPI → build wheel from local path and bundle in wheels/
+    - index source (private registry) → download wheel from that index and bundle in wheels/
+
+    Returns list of bundled package names (lowercase).
+    """
+    import subprocess
+    from importlib.metadata import PackageNotFoundError
+    from importlib.metadata import version as get_version
+
+    sources = pyproject_data.get("tool", {}).get("uv", {}).get("sources", {})
+    if not sources:
+        return []
+
+    wheels_dir = os.path.join(release_dir, "wheels")
+    bundled: list[str] = []
+
+    for pkg_name, source in sources.items():
+        if pkg_name.lower() not in required_packages:
+            continue
+
+        if "path" in source:
+            local_path = os.path.normpath(os.path.join(pyproject_root, source["path"]))
+
+            try:
+                installed_ver = get_version(pkg_name)
+            except PackageNotFoundError:
+                logger.warning(f"  {pkg_name} not installed, skipping bundle")
+                continue
+
+            if _version_exists_on_pypi(pkg_name, installed_ver):
+                logger.info(f"  {pkg_name}=={installed_ver} found on public PyPI, will resolve from registry")
+                continue
+
+            logger.info(f"  Bundling {pkg_name}=={installed_ver} from local path {local_path} ...")
+            os.makedirs(wheels_dir, exist_ok=True)
+            try:
+                # Run from the package's own directory so uv reads its [tool.uv.sources]
+                # (needed when the package has local-path build deps like qubx)
+                subprocess.run(
+                    ["uv", "build", "--wheel", ".", "--out-dir", wheels_dir],
+                    cwd=local_path,
+                    check=True, capture_output=True, text=True,
+                )
+                # Warn if the wheel is platform-specific (compiled extensions)
+                for whl in os.listdir(wheels_dir):
+                    if whl.lower().startswith(pkg_name.lower().replace("-", "_")) and "none-any" not in whl:
+                        logger.warning(
+                            f"  {whl} is platform-specific. "
+                            "Ensure the container architecture matches the build machine."
+                        )
+                bundled.append(pkg_name.lower())
+                logger.info(f"  Bundled {pkg_name}")
+            except subprocess.CalledProcessError as e:
+                err_msg = (e.stderr or str(e)).replace("<", r"\<")
+                logger.warning(f"  Failed to build wheel for {pkg_name}: {err_msg}")
+
+        elif "index" in source:
+            index_name = source["index"]
+            index_url = _get_index_url(index_name, pyproject_data)
+            if not index_url:
+                logger.warning(f"  Index '{index_name}' not found in [[tool.uv.index]] (needed for {pkg_name})")
+                continue
+
+            try:
+                installed_ver = get_version(pkg_name)
+            except PackageNotFoundError:
+                # Package not installed (e.g. optional dep not synced) — fall back to
+                # the version declared in pyproject optional-deps or regular deps
+                installed_ver = _find_version_in_pyproject(pkg_name, pyproject_data)
+                if not installed_ver:
+                    logger.warning(
+                        f"  {pkg_name} not installed and no version found in pyproject deps, skipping bundle"
+                    )
+                    continue
+                logger.info(f"  {pkg_name} not installed; using declared version {installed_ver} from pyproject")
+
+            if _version_exists_on_pypi(pkg_name, installed_ver):
+                logger.info(f"  {pkg_name}=={installed_ver} found on public PyPI, will resolve from registry")
+                continue
+
+            logger.info(f"  Downloading {pkg_name}=={installed_ver} from private index '{index_name}' ...")
+            os.makedirs(wheels_dir, exist_ok=True)
+            try:
+                import shutil
+
+                pip_exe = shutil.which("pip") or shutil.which("pip3")
+                if not pip_exe:
+                    raise RuntimeError("pip not found — cannot download wheel from private index")
+                subprocess.run(
+                    [
+                        pip_exe, "download",
+                        f"{pkg_name}=={installed_ver}",
+                        "--index-url", index_url,
+                        "--dest", wheels_dir,
+                        "--no-deps",
+                        "--quiet",
+                    ],
+                    check=True, capture_output=True, text=True,
+                )
+                bundled.append(pkg_name.lower())
+                logger.info(f"  Downloaded {pkg_name}=={installed_ver}")
+            except subprocess.CalledProcessError as e:
+                err_msg = (e.stderr or str(e)).replace("<", r"\<")
+                logger.warning(f"  Failed to download wheel for {pkg_name}: {err_msg}")
+
+    return bundled
+
+
+def _get_plugin_deps(stg_config: "StrategyConfig", pyproject_data: dict) -> list[str]:
+    """
+    Extract package dependency specs for plugin modules listed in the strategy config.
+
+    Maps plugin module names (e.g. qubx_lighter) to package specs
+    (e.g. qubx-lighter==0.1.0) by looking in [project.optional-dependencies].
+    Falls back to the installed version if not found there.
+
+    Returns list of dep specs like ["qubx-lighter==0.1.0"].
+    """
+    from importlib.metadata import PackageNotFoundError
+    from importlib.metadata import version as get_version
+
+    if not stg_config.plugins or not stg_config.plugins.modules:
+        return []
+
+    optional_deps: dict[str, list[str]] = pyproject_data.get("project", {}).get("optional-dependencies", {})
+
+    plugin_deps: list[str] = []
+    for module_name in stg_config.plugins.modules:
+        pkg_name = module_name.replace("_", "-")
+
+        # Search in optional-dependency groups first
+        found = False
+        for group_name, group_deps in optional_deps.items():
+            for dep in group_deps:
+                dep_pkg = dep.split(">=")[0].split("==")[0].split("<")[0].strip()
+                if dep_pkg.lower() == pkg_name.lower():
+                    plugin_deps.append(dep)
+                    logger.info(f"  Plugin '{module_name}' -> adding '{dep}' (from optional-deps [{group_name}])")
+                    found = True
+                    break
+            if found:
+                break
+
+        if not found:
+            try:
+                ver = get_version(pkg_name)
+                spec = f"{pkg_name}>={ver}"
+                plugin_deps.append(spec)
+                logger.warning(
+                    f"  Plugin '{module_name}' not in optional-deps; "
+                    f"adding '{spec}' from installed packages"
+                )
+            except PackageNotFoundError:
+                logger.warning(
+                    f"  Plugin '{module_name}' ({pkg_name}) not found in "
+                    "optional-deps or installed packages - skipping"
+                )
+
+    return plugin_deps
+
+
+def _clean_pyproject_for_release(pyproject_data: dict, bundled_packages: list[str] | None = None) -> dict:
     """
     Remove dev-only and local-path-dependent sections from pyproject.toml for release.
 
@@ -852,10 +1062,24 @@ def _clean_pyproject_for_release(pyproject_data: dict) -> dict:
                 del pyproject_data["tool"][key]
                 logger.debug(f"Removed [tool.{key}] from release pyproject.toml")
 
+    # If any wheels were bundled, add find-links so uv can resolve them
+    if bundled_packages:
+        if "tool" not in pyproject_data:
+            pyproject_data["tool"] = {}
+        if "uv" not in pyproject_data["tool"]:
+            pyproject_data["tool"]["uv"] = {}
+        pyproject_data["tool"]["uv"]["find-links"] = ["./wheels"]
+        logger.debug("Added find-links = ['./wheels'] to [tool.uv]")
+
     return pyproject_data
 
 
-def _modify_pyproject_toml(pyproject_path: str, package_name: str) -> None:
+def _modify_pyproject_toml(
+    pyproject_path: str,
+    package_name: str,
+    bundled_packages: list[str] | None = None,
+    plugin_deps: list[str] | None = None,
+) -> None:
     """
     Modify the pyproject.toml file to include the project package as a dependency.
 
@@ -873,7 +1097,7 @@ def _modify_pyproject_toml(pyproject_path: str, package_name: str) -> None:
             pyproject_data = toml.load(f)
 
         # Clean up dev-only and local-path-dependent sections
-        pyproject_data = _clean_pyproject_for_release(pyproject_data)
+        pyproject_data = _clean_pyproject_for_release(pyproject_data, bundled_packages)
 
         # Handle PEP 621 format
         if "project" in pyproject_data:
@@ -886,15 +1110,29 @@ def _modify_pyproject_toml(pyproject_path: str, package_name: str) -> None:
                 python_version = f"{sys.version_info.major}.{sys.version_info.minor}"
                 pyproject_data["project"]["requires-python"] = f">={python_version}"
 
-            # Special case when we have dev dependencies for Qubx or QuantKit
+            # Pin qubx/quantkit versions only if bare (no version constraint specified)
             deps = pyproject_data["project"]["dependencies"]
             for i, dep in enumerate(deps):
                 dep_name = dep.split(">=")[0].split("==")[0].split("<")[0].strip()
                 if dep_name.lower().startswith("qubx") or dep_name.lower().startswith("quantkit"):
-                    try:
-                        deps[i] = f"{dep_name}>={version(dep_name)}"
-                    except Exception:
-                        pass
+                    if dep.strip() == dep_name:
+                        # Bare package name — add installed version
+                        try:
+                            deps[i] = f"{dep_name}>={version(dep_name)}"
+                        except Exception:
+                            pass
+
+            # Add plugin dependencies (from config's plugins.modules)
+            if plugin_deps:
+                for pdep in plugin_deps:
+                    pdep_pkg = pdep.split(">=")[0].split("==")[0].split("<")[0].strip().lower()
+                    already_present = any(
+                        d.split(">=")[0].split("==")[0].split("<")[0].strip().lower() == pdep_pkg
+                        for d in deps
+                    )
+                    if not already_present:
+                        deps.append(pdep)
+                        logger.debug(f"Added plugin dep: {pdep}")
 
             # Check if build-system section exists
             if "build-system" not in pyproject_data:
@@ -1007,6 +1245,21 @@ def _configure_pyproject_for_external_deps(pyproject_path: str, packages: list[s
                         logger.warning(f"Could not determine version for {package}: {e}")
                         deps.append(package)
 
+            # No custom code to package — disable package building
+            if "tool" not in pyproject_data:
+                pyproject_data["tool"] = {}
+            if "uv" not in pyproject_data["tool"]:
+                pyproject_data["tool"]["uv"] = {}
+            pyproject_data["tool"]["uv"]["package"] = False
+
+            # Also disable poetry package mode if present
+            if "poetry" in pyproject_data["tool"]:
+                poetry_config = pyproject_data["tool"]["poetry"]
+                poetry_config["package-mode"] = False
+                if "packages" in poetry_config:
+                    del poetry_config["packages"]
+            logger.debug("Set package = false (external deps only, no custom code)")
+
             # Write updated pyproject.toml
             with open(pyproject_path, "w") as f:
                 toml.dump(pyproject_data, f)
@@ -1095,13 +1348,10 @@ def _handle_project_files(
 ) -> None:
     """
     Handle project files like pyproject.toml and generate lock file.
-
-    Args:
-        pyproject_root: Root directory containing pyproject.toml
-        release_dir: Destination directory for release
-        stg_info: Strategy info with config (optional, for dependency extraction)
     """
-    # Copy pyproject.toml if it exists
+    import toml
+
+    # Copy pyproject.toml
     pyproject_src = os.path.join(pyproject_root, "pyproject.toml")
     if not os.path.exists(pyproject_src):
         raise FileNotFoundError(f"pyproject.toml not found in {pyproject_root}")
@@ -1110,25 +1360,51 @@ def _handle_project_files(
     logger.debug(f"Copying pyproject.toml from {pyproject_src} to {pyproject_dest}")
     shutil.copy2(pyproject_src, pyproject_dest)
 
-    # If no classes exist, configure pyproject.toml for external dependencies only
+    # Read original data once for analysis (before any modifications)
+    with open(pyproject_dest, "r") as f:
+        pyproject_data = toml.load(f)
+
+    # --- Plugin deps from config ---
+    plugin_deps: list[str] = []
+    if stg_info and stg_info.config:
+        plugin_deps = _get_plugin_deps(stg_info.config, pyproject_data)
+        if plugin_deps:
+            logger.info(f"Plugin dependencies from config: {plugin_deps}")
+
+    # --- Build required_packages set for targeted bundling ---
+    # Start from declared project deps
+    required_packages: set[str] = set()
+    for dep in pyproject_data.get("project", {}).get("dependencies", []):
+        name = dep.split(">=")[0].split("==")[0].split("<")[0].strip().lower()
+        required_packages.add(name)
+    # Add plugin packages
+    for pdep in plugin_deps:
+        name = pdep.split(">=")[0].split("==")[0].split("<")[0].strip().lower()
+        required_packages.add(name)
+
+    # --- Bundle private/local wheels ---
+    bundled_packages: list[str] = []
+    if required_packages:
+        logger.info("Resolving private/local source dependencies...")
+        bundled_packages = _bundle_source_overrides(pyproject_data, pyproject_root, release_dir, required_packages)
+        if bundled_packages:
+            logger.info(f"Bundled {len(bundled_packages)} package(s): {', '.join(bundled_packages)}")
+
+    # --- Handle external-deps-only configs (no custom strategy classes) ---
     if stg_info and not stg_info.classes:
         current_package = get_project_package_name(pyproject_root)
         external_deps = extract_external_dependencies(stg_info.config, current_package)
-
         if external_deps:
             logger.info(f"Configuring pyproject.toml for external dependencies: {external_deps}")
             _configure_pyproject_for_external_deps(pyproject_dest, external_deps)
 
-    # Copy build.py if it exists
+    # --- Copy build.py ---
     build_src = os.path.join(pyproject_root, "build.py")
     if not os.path.exists(build_src):
         logger.info(f"build.py not found in {pyproject_root} using default one")
         build_src = load_qubx_resources_as_text("_build.py")
-
-        # - setup project's name in default build.py
         prj_name = os.path.basename(pyproject_root)
         build_src = build_src.replace("<<PROJECT_NAME>>", prj_name)
-
         with open(os.path.join(release_dir, "build.py"), "wt") as fs:
             fs.write(build_src)
     else:
@@ -1136,13 +1412,11 @@ def _handle_project_files(
         logger.debug(f"Copying build.py from {build_src} to {build_dest}")
         shutil.copy2(build_src, build_dest)
 
-    # Get the basename of the pyproject_root as the package name
+    # --- Modify pyproject: clean sources, pin versions, add find-links + plugin deps ---
     package_name = os.path.basename(pyproject_root)
+    _modify_pyproject_toml(pyproject_dest, package_name, bundled_packages=bundled_packages, plugin_deps=plugin_deps)
 
-    # Modify the pyproject.toml to include the project package
-    _modify_pyproject_toml(pyproject_dest, package_name)
-
-    # Generate the uv.lock file
+    # --- Generate lock file ---
     _generate_lock_file(release_dir)
 
 

{qubx-1.0.0.dev6 → qubx-1.0.1.dev2}/src/qubx/config.py

@@ -86,6 +86,14 @@ class QubxSettings(BaseSettings):
     instrument_lookup: LookupConfig = LookupConfig()
     fees_lookup: LookupConfig = LookupConfig()
 
+    # Platform integration (all settable via QUBX_* env vars or ~/.qubx/config.json)
+    account_file: str | None = None
+    bot_id: str | None = None
+    instance_id: str | None = None
+    metrics_port: int | None = None
+    health_port: int | None = None
+    log_format: str = "text"  # "text" or "json"
+
     model_config = {"env_prefix": "QUBX_", "env_nested_delimiter": "__"}
 
     @classmethod