Qubx 1.0.6.dev7__tar.gz → 1.1.1.dev1__tar.gz

{qubx-1.0.6.dev7 → qubx-1.1.1.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Qubx
-Version: 1.0.6.dev7
+Version: 1.1.1.dev1
 Summary: Qubx - Quantitative Trading Framework
 Project-URL: homepage, https://xlydian.com
 Project-URL: repository, https://github.com/xLydianSoftware/Qubx

{qubx-1.0.6.dev7 → qubx-1.1.1.dev1}/src/qubx/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.0.6.dev7'
-__version_tuple__ = version_tuple = (1, 0, 6, 'dev7')
+__version__ = version = '1.1.1.dev1'
+__version_tuple__ = version_tuple = (1, 1, 1, 'dev1')
 
 __commit_id__ = commit_id = None

{qubx-1.0.6.dev7 → qubx-1.1.1.dev1}/src/qubx/backtester/management.py

@@ -502,6 +502,87 @@ class BacktestStorage:
             return []
         return df["backtest_id"].tolist()
 
+    def delete(self, backtest_id: str) -> None:
+        """
+        Delete a single backtest run directory.
+
+        Args:
+            backtest_id: Relative path within base_path,
+                        e.g. "my_strategy/Nimble/20240301_120000"
+        """
+        path = f"{self.base_path}{backtest_id.strip('/')}/"
+        if self._is_cloud:
+            S3Client(storage_options=self._storage_options).rm(path, recursive=True)
+        else:
+            import shutil
+
+            shutil.rmtree(path, ignore_errors=True)
+        self._reset_conn()
+
+    def delete_group(self, group_path: str) -> None:
+        """
+        Delete an entire group directory (class-level or config-level).
+
+        Args:
+            group_path: Relative path within base_path,
+                       e.g. "my_strategy/Nimble" (config) or "Nimble" (class)
+        """
+        path = f"{self.base_path}{group_path.strip('/')}/"
+        if self._is_cloud:
+            S3Client(storage_options=self._storage_options).rm(path, recursive=True)
+        else:
+            import shutil
+
+            shutil.rmtree(path, ignore_errors=True)
+        self._reset_conn()
+
+    def _reset_conn(self) -> None:
+        """Reset DuckDB connection to clear cached file metadata after mutations."""
+        self._conn.close()
+        self._conn = self._duckdb.connect()
+        if self._is_cloud:
+            self._setup_cloud_duckdb()
+
+    def get_log(self, backtest_id: str, config_name: str | None = None) -> str | None:
+        """
+        Read the log file for a backtest run.
+
+        Args:
+            backtest_id: Relative path within base_path.
+            config_name: Config name (used for log filename).
+                        If None, searches for any .log file.
+
+        Returns:
+            Log file content as string, or None if not found.
+        """
+        run_dir = f"{self.base_path}{backtest_id.strip('/')}/"
+
+        if config_name:
+            log_path = f"{run_dir}{config_name}.log"
+        else:
+            try:
+                files_df = self._conn.execute(f"SELECT file FROM glob('{run_dir}*.log')").df()
+                if files_df.empty:
+                    return None
+                log_path = files_df["file"].iloc[0]
+            except Exception:
+                return None
+
+        if self._is_cloud:
+            try:
+                from qubx.utils.s3 import strip_scheme
+
+                client = S3Client(storage_options=self._storage_options)
+                with client.fs.open_input_stream(strip_scheme(log_path)) as f:
+                    return f.read().decode("utf-8")
+            except Exception:
+                return None
+        else:
+            from pathlib import Path
+
+            p = Path(log_path)
+            return p.read_text(encoding="utf-8", errors="replace") if p.is_file() else None
+
     def export_backtests_to_markdown(self, backtest_id: str, path: str, tags: tuple[str] | None = None):
         if tsr := self.load(backtest_id):
             tsr.to_markdown(path, list(tags) if tags else None)

{qubx-1.0.6.dev7 → qubx-1.1.1.dev1}/src/qubx/cli/commands.py

@@ -496,21 +496,27 @@ def browse(results_path: str | None):
 
         qubx browse /backtests/momentum/
 
+        qubx browse r2:backtests
+
         qubx browse s3://my-bucket/backtests/
     """
     from qubx.config import get_settings
-    from qubx.utils.s3 import is_cloud_path
+    from qubx.utils.s3 import S3Client, is_account_uri, is_cloud_path
 
     from .tui import run_backtest_browser
 
     if results_path is None:
         results_path = get_settings().default_browse_path or "results"
 
-    # - only resolve local paths; cloud URIs (s3://, gs://, az://) are passed as-is
-    if not is_cloud_path(results_path):
+    storage_options: dict | None = None
+    if is_account_uri(results_path):
+        client, s3_path = S3Client.from_uri(results_path)
+        storage_options = client.storage_options
+        results_path = f"s3://{s3_path}"
+    elif not is_cloud_path(results_path):
         results_path = os.path.abspath(os.path.expanduser(results_path))
 
-    run_backtest_browser(results_path)
+    run_backtest_browser(results_path, storage_options=storage_options)
 
 
 @main.command()
@@ -571,6 +577,12 @@ def browse(results_path: str | None):
     is_flag=True,
     help="List all available built-in templates",
 )
+@click.option("--description", "-d", type=str, default=None, help="Project description (repo template)")
+@click.option("--author", type=str, default=None, help="Author name (repo template)")
+@click.option("--email", type=str, default=None, help="Author email (repo template)")
+@click.option("--github-org", type=str, default=None, help="GitHub org or username (repo template)")
+@click.option("--create-repo", is_flag=True, default=False, help="Create GitHub repository (repo template)")
+@click.option("--private/--public", default=True, help="Repository visibility (repo template)")
 def init(
     template: str,
     template_path: str | None,
@@ -580,6 +592,12 @@ def init(
     timeframe: str,
     output_dir: str,
     list_templates: bool,
+    description: str | None,
+    author: str | None,
+    email: str | None,
+    github_org: str | None,
+    create_repo: bool,
+    private: bool,
 ):
     """
     Create a new strategy from a template.
@@ -589,9 +607,14 @@ def init(
     - Configuration file for qubx run command
     - Package structure for proper imports
 
+    Use --template repo for a full repository with CI, tests, and justfile.
+
     The generated strategy can be run immediately with:
     uv run qubx run --config config.yml --paper
     """
+    import subprocess
+    import sys
+
     from qubx.templates import TemplateError, TemplateManager
 
     try:
@@ -604,40 +627,147 @@ def init(
                 return
 
             click.echo("Available templates:")
-            for template_name, metadata in templates.items():
-                description = metadata.get("description", "No description")
-                click.echo(f"  {template_name:<15} - {description}")
+            for tpl_name, metadata in templates.items():
+                tpl_desc = metadata.get("description", "No description")
+                click.echo(f"  {tpl_name:<15} - {tpl_desc}")
             return
 
-        # Generate strategy
-        strategy_path = manager.generate_strategy(
-            template_name=template if not template_path else None,
-            template_path=template_path,
-            output_dir=output_dir,
-            name=name,
-            exchange=exchange,
-            symbols=symbols,
-            timeframe=timeframe,
-        )
-
-        click.echo(f"✅ Strategy '{name}' created successfully!")
-        click.echo(f"📁 Location: {strategy_path}")
-        click.echo()
-        click.echo("To run your strategy:")
-        click.echo(f"  cd {strategy_path}")
-        click.echo("  uv run qubx run config.yml --paper")
-        click.echo()
-        click.echo("To run in Jupyter mode:")
-        click.echo("  ./jpaper.sh")
+        if template == "repo":
+            _init_repo(
+                manager, name, description, author, email, github_org,
+                exchange, symbols, timeframe, output_dir, create_repo, private,
+            )
+        else:
+            strategy_path = manager.generate_strategy(
+                template_name=template if not template_path else None,
+                template_path=template_path,
+                output_dir=output_dir,
+                name=name,
+                exchange=exchange,
+                symbols=symbols,
+                timeframe=timeframe,
+            )
+
+            click.echo(f"Strategy '{name}' created successfully!")
+            click.echo(f"Location: {strategy_path}")
+            click.echo()
+            click.echo("To run your strategy:")
+            click.echo(f"  cd {strategy_path}")
+            click.echo("  uv run qubx run config.yml --paper")
+            click.echo()
+            click.echo("To run in Jupyter mode:")
+            click.echo("  ./jpaper.sh")
 
     except TemplateError as e:
-        click.echo(f"❌ Template error: {e}", err=True)
+        click.echo(f"Error: {e}", err=True)
         raise click.Abort()
     except Exception as e:
-        click.echo(f"❌ Unexpected error: {e}", err=True)
+        click.echo(f"Unexpected error: {e}", err=True)
         raise click.Abort()
 
 
+def _init_repo(
+    manager,
+    name: str,
+    description: str | None,
+    author: str | None,
+    email: str | None,
+    github_org: str | None,
+    exchange: str,
+    symbols: str,
+    timeframe: str,
+    output_dir: str,
+    create_repo: bool,
+    private: bool,
+):
+    """Interactive wizard for creating a full strategy repository."""
+    import subprocess
+    import sys
+
+    from qubx.cli.user_config import load_init_config, save_init_config
+    from qubx.templates import TemplateError
+
+    config = load_init_config()
+    interactive = sys.stdin.isatty()
+
+    if interactive:
+        click.echo("\n  Strategy Repository Setup\n")
+        name = click.prompt("  Strategy name", default=name)
+        description = click.prompt("  Description", default=description or "")
+        author = click.prompt("  Author name", default=author or config.get("author_name", ""))
+        email = click.prompt("  Author email", default=email or config.get("author_email", ""))
+        github_org = click.prompt(
+            "  GitHub organization",
+            default=github_org or config.get("github_org", ""),
+        )
+        exchange = click.prompt("  Exchange", default=exchange)
+        symbols = click.prompt("  Symbols (comma-separated)", default=symbols)
+        timeframe = click.prompt("  Timeframe", default=timeframe)
+        if not create_repo:
+            create_repo = click.confirm("\n  Create GitHub repository?", default=False)
+            if create_repo:
+                private = click.confirm("  Private repository?", default=True)
+        click.echo()
+    else:
+        description = description or ""
+        author = author or config.get("author_name", "")
+        email = email or config.get("author_email", "")
+        github_org = github_org or config.get("github_org", "")
+
+    # Save preferences for next time
+    save_init_config({
+        "author_name": author,
+        "author_email": email,
+        "github_org": github_org,
+    })
+
+    # Generate project from template
+    strategy_path = manager.generate_strategy(
+        template_name="repo",
+        output_dir=output_dir,
+        name=name,
+        description=description,
+        author_name=author,
+        author_email=email,
+        github_org=github_org,
+        exchange=exchange,
+        symbols=symbols,
+        timeframe=timeframe,
+    )
+
+    # Initialize git repo with main as default branch
+    subprocess.run(["git", "init", "-b", "main"], cwd=strategy_path, capture_output=True)
+    subprocess.run(["git", "add", "-A"], cwd=strategy_path, capture_output=True)
+    subprocess.run(
+        ["git", "commit", "-m", "Initial project setup"],
+        cwd=strategy_path,
+        capture_output=True,
+    )
+
+    click.echo(f"Strategy '{name}' created at {strategy_path}")
+
+    # Create GitHub repo if requested
+    if create_repo and github_org:
+        repo_name = f"{github_org}/{name}"
+        visibility = "--private" if private else "--public"
+        result = subprocess.run(
+            ["gh", "repo", "create", repo_name, visibility, "--source=.", "--push"],
+            cwd=strategy_path,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode == 0:
+            click.echo(f"GitHub repository created: {repo_name}")
+        else:
+            click.echo(f"Failed to create GitHub repo: {result.stderr.strip()}", err=True)
+
+    click.echo()
+    click.echo("Next steps:")
+    click.echo(f"  cd {strategy_path}")
+    click.echo("  just install")
+    click.echo("  just test")
+
+
 @main.group()
 def kernel():
     """