intelliseq-iflow 0.2.7__tar.gz → 0.2.9__tar.gz

{intelliseq_iflow-0.2.7 → intelliseq_iflow-0.2.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: intelliseq-iflow
-Version: 0.2.7
+Version: 0.2.9
 Summary: CLI tool for iFlow - genomic data management and workflow execution
 Project-URL: Homepage, https://intelliseq.com
 Project-URL: Documentation, https://docs.iflow.intelliseq.com

{intelliseq_iflow-0.2.7 → intelliseq_iflow-0.2.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "intelliseq-iflow"
-version = "0.2.7"
+version = "0.2.9"
 description = "CLI tool for iFlow - genomic data management and workflow execution"
 readme = "README.md"
 requires-python = ">=3.10"

{intelliseq_iflow-0.2.7 → intelliseq_iflow-0.2.9}/src/iflow/__init__.py

@@ -1,3 +1,3 @@
 """iseq-flow - CLI tool for IntelliSeq Flow cloud file management."""
 
-__version__ = "0.2.7"
+__version__ = "0.2.9"

{intelliseq_iflow-0.2.7 → intelliseq_iflow-0.2.9}/src/iflow/api.py

@@ -98,6 +98,14 @@ class RunOutput:
     description: str | None = None
 
 
+@dataclass
+class RunOutputsResponse:
+    """Response from run outputs endpoint."""
+
+    outputs: list[RunOutput]
+    message: str | None = None  # Informational message (e.g., why outputs may be empty)
+
+
 # Miner service models
 
 
@@ -480,14 +488,14 @@ class ComputeAPIClient:
         data = await self._request("GET", f"/api/v1/runs/by-order/{order_id}")
         return [self._parse_run(r) for r in data]
 
-    async def get_run_outputs(self, run_id: str) -> list[RunOutput]:
+    async def get_run_outputs(self, run_id: str) -> RunOutputsResponse:
         """Get semantic outputs for a run.
 
         Parses metadata.json and maps to semantic names from meta.json.
         Only available for WDL runs that have completed.
         """
         data = await self._request("GET", f"/api/v1/runs/{run_id}/outputs")
-        return [
+        outputs = [
             RunOutput(
                 name=o["name"],
                 display_name=o["display_name"],
@@ -497,6 +505,10 @@ class ComputeAPIClient:
             )
             for o in data.get("outputs", [])
         ]
+        return RunOutputsResponse(
+            outputs=outputs,
+            message=data.get("message"),
+        )
 
     def _parse_run(self, data: dict, project_id: str | None = None) -> Run:
         """Parse run data from API response.

{intelliseq_iflow-0.2.7 → intelliseq_iflow-0.2.9}/src/iflow/commands/auth.py

@@ -68,9 +68,6 @@ async def auto_configure_after_login(
             p = projects[0]
             set_project_context(p.id, p.name, p.org_id, p.org_name, p.bucket_name)
             console.print(f"[dim]Project:[/dim] {p.name} (auto-selected)")
-            if p.bucket_name:
-                bucket = normalize_bucket_name(p.bucket_name)
-                console.print(f"[dim]Bucket:[/dim] gs://{bucket}/")
         elif len(projects) > 1:
             console.print(f"[dim]Found {len(projects)} projects.[/dim]")
             console.print("Run [cyan]iflow config select-project[/cyan] to choose one.")

{intelliseq_iflow-0.2.7 → intelliseq_iflow-0.2.9}/src/iflow/commands/config.py

@@ -39,9 +39,6 @@ def show_config():
         console.print(f"  Organization: [cyan]{settings.org_name or 'Unknown'}[/cyan]")
         console.print(f"  Project: [cyan]{settings.project_name or 'Unknown'}[/cyan]")
         console.print(f"  Project ID: [dim]{settings.project_id}[/dim]")
-        if settings.bucket_name:
-            bucket = normalize_bucket_name(settings.bucket_name)
-            console.print(f"  Bucket: [cyan]gs://{bucket}/[/cyan]")
         console.print()
     else:
         console.print("[yellow]No default project set.[/yellow]")
@@ -258,12 +255,9 @@ def select_project(project_id: str | None, curl: bool):
             console.print(f"[green]Selected project:[/green] {selected.name}")
             console.print(f"  Organization: {selected.org_name}")
             console.print(f"  Project ID: {selected.id}")
-            if selected.bucket_name:
-                bucket = normalize_bucket_name(selected.bucket_name)
-                console.print(f"  Bucket: gs://{bucket}/")
             console.print()
             console.print("You can now run commands without specifying -p/--project.")
-            console.print("File paths will be relative to your project bucket.")
+            console.print("File paths are relative to your project.")
 
         except APIError as e:
             console.print(f"[red]Error:[/red] {e}")

{intelliseq_iflow-0.2.7 → intelliseq_iflow-0.2.9}/src/iflow/commands/files.py

@@ -56,10 +56,11 @@ def list_files(project: str | None, path: str, curl: bool):
     try:
         result = asyncio.run(_list())
 
-        # Display bucket info
-        console.print(f"[dim]Bucket:[/dim] {result.bucket_name}")
+        # Display current path (relative to project)
         if result.path:
             console.print(f"[dim]Path:[/dim] {result.path}")
+        else:
+            console.print(f"[dim]Path:[/dim] /")
         console.print()
 
         if not result.folders and not result.files:
@@ -157,7 +158,10 @@ def download(
 def _download_by_path(project_id: str, path: str, output: str | None, curl: bool):
     """Download file by direct GCS path."""
     if curl:
-        print(files_curl("GET", f"/files/download?path={path}", project_id))
+        print(files_curl("GET", "/files/download-url", project_id, params={"path": path}))
+        print("\n# Then download with curl or wget:")
+        print(f"# curl -o '{Path(path).name}' '<url>'")
+        print(f"# wget -O '{Path(path).name}' '<url>'")
         return
 
     async def _download():
@@ -240,14 +244,15 @@ def _download_by_output(
 
         # 4. Get outputs for this run
         console.print("[dim]Getting run outputs...[/dim]")
-        outputs = await compute_client.get_run_outputs(latest_run.id)
-        if not outputs:
-            raise APIError("No outputs found for run (may not be a WDL run)")
+        response = await compute_client.get_run_outputs(latest_run.id)
+        if not response.outputs:
+            msg = response.message or "may not be a WDL run"
+            raise APIError(f"No outputs found for run ({msg})")
 
         # 5. Find matching output
-        matching = [o for o in outputs if o.name == output_name]
+        matching = [o for o in response.outputs if o.name == output_name]
         if not matching:
-            available = ", ".join(o.name for o in outputs)
+            available = ", ".join(o.name for o in response.outputs)
             raise APIError(f"Output '{output_name}' not found. Available: {available}")
 
         output_info = matching[0]
@@ -329,13 +334,12 @@ def upload(project: str | None, file: str, remote_path: str, curl: bool):
     if curl:
         print(files_curl(
             "POST",
-            "/files/upload",
+            "/files/upload-url",
             project_id,
             data={"path": final_remote_path, "content_type": content_type},
         ))
-        print("\n# Then upload to the returned signed URL:")
-        print(f"# curl -X PUT -H 'Content-Type: {content_type}' \\")
-        print(f"#   --data-binary @{file} '<signed_url>'")
+        print("\n# Then upload to the signed URL from response:")
+        print(f"# curl -X PUT -H 'Content-Type: {content_type}' --data-binary @{file} '<url>'")
         return
 
     async def _upload():

{intelliseq_iflow-0.2.7 → intelliseq_iflow-0.2.9}/src/iflow/commands/runs.py

@@ -6,7 +6,7 @@ import time
 import click
 
 from iflow.api import APIError, ComputeAPIClient
-from iflow.config import require_project, resolve_gcs_path
+from iflow.config import require_project, resolve_gcs_path, to_relative_path
 from iflow.curl import compute_curl
 
 
@@ -114,7 +114,7 @@ def last_run(
                 click.echo(run.name)
             elif show_output:
                 if run.output_path:
-                    click.echo(run.output_path)
+                    click.echo(to_relative_path(run.output_path))
                 else:
                     click.echo("", err=True)  # Empty if no output
                     raise SystemExit(1)
@@ -124,7 +124,7 @@ def last_run(
                 click.echo(f"  ID: {run.id}")
                 click.echo(f"  Status: {run.status}")
                 if run.output_path:
-                    click.echo(f"  Output: {run.output_path}")
+                    click.echo(f"  Output: {to_relative_path(run.output_path)}")
 
         except APIError as e:
             click.echo(f"Error: {e}", err=True)
@@ -293,7 +293,7 @@ def run_status(run_id: str, curl: bool):
                 click.echo(f"  Finished: {run.finished_at}")
 
             if run.output_path:
-                click.echo(f"  Output: {run.output_path}")
+                click.echo(f"  Output: {to_relative_path(run.output_path)}")
             if run.error_message:
                 click.echo(f"  Error: {run.error_message}")
 
@@ -354,24 +354,31 @@ def run_outputs(run_id: str, download: str | None, output: str | None, curl: boo
       iflow runs outputs RUN_ID -d annotated_vcf_gz
       iflow runs outputs RUN_ID -d top20_tsv -o results.tsv
     """
-    if curl and not download:
+    if curl:
+        # Show curl command regardless of download flag
         print(compute_curl("GET", f"/runs/{run_id}/outputs"))
+        if download:
+            print("\n# To download a specific output, use the path from the response above with:")
+            print("# iflow files download <path> --curl")
         return
 
     async def _outputs():
         client = ComputeAPIClient()
         try:
-            outputs = await client.get_run_outputs(run_id)
+            response = await client.get_run_outputs(run_id)
 
-            if not outputs:
-                click.echo("No outputs found (run may not have completed or is not a WDL run).")
+            if not response.outputs:
+                if response.message:
+                    click.echo(f"No outputs: {response.message}")
+                else:
+                    click.echo("No outputs found.")
                 return
 
             if download:
                 # Find output by name
-                matching = [o for o in outputs if o.name == download]
+                matching = [o for o in response.outputs if o.name == download]
                 if not matching:
-                    available = ", ".join(o.name for o in outputs)
+                    available = ", ".join(o.name for o in response.outputs)
                     click.echo(f"Error: Output '{download}' not found.", err=True)
                     click.echo(f"Available outputs: {available}", err=True)
                     raise SystemExit(1)
@@ -414,8 +421,8 @@ def run_outputs(run_id: str, download: str | None, output: str | None, curl: boo
                 click.echo(f"{'NAME':<20} {'TYPE':<10} {'PATH'}")
                 click.echo("-" * 80)
 
-                for out in outputs:
-                    path = out.path or "-"
+                for out in response.outputs:
+                    path = to_relative_path(out.path) or "-"
                     click.echo(f"{out.name:<20} {out.type:<10} {path}")
 
         except APIError as e:
@@ -472,7 +479,7 @@ async def _watch_run(client: ComputeAPIClient, run_id: str, interval: int = 10):
                 if run.status == "succeeded":
                     click.echo("Run completed successfully!")
                     if run.output_path:
-                        click.echo(f"Output: {run.output_path}")
+                        click.echo(f"Output: {to_relative_path(run.output_path)}")
                 elif run.status == "failed":
                     click.echo(f"Run failed: {run.error_message or 'Unknown error'}")
                 else:

{intelliseq_iflow-0.2.7 → intelliseq_iflow-0.2.9}/src/iflow/config.py

@@ -210,6 +210,30 @@ def resolve_gcs_path(path: str) -> str:
     return f"gs://{bucket}/{path}"
 
 
+def to_relative_path(path: str | None) -> str | None:
+    """Convert a full GCS/S3 path to a path relative to project bucket.
+
+    Strips gs://bucket/ or s3://bucket/ prefix, returning just the path.
+    Used for user-facing display where bucket context is implicit.
+
+    Examples:
+        gs://my-bucket/results/file.vcf -> results/file.vcf
+        s3://bucket/data/sample.fastq -> data/sample.fastq
+        results/file.vcf -> results/file.vcf (already relative)
+    """
+    if not path:
+        return None
+    if path.startswith("gs://"):
+        # Format: gs://bucket/path/to/file
+        parts = path[5:].split("/", 1)
+        return parts[1] if len(parts) > 1 else ""
+    if path.startswith("s3://"):
+        # Format: s3://bucket/path/to/file
+        parts = path[5:].split("/", 1)
+        return parts[1] if len(parts) > 1 else ""
+    return path  # Already relative
+
+
 def require_project(project_option: str | None) -> str:
     """Get project ID from option or config, raise if not available."""
     if project_option:

{intelliseq_iflow-0.2.7 → intelliseq_iflow-0.2.9}/src/iflow/curl.py

@@ -27,11 +27,11 @@ def generate_curl(
     Returns:
         Complete curl command string
     """
-    parts = ["curl", "-s"]
+    parts = ["curl -s"]
 
     # Method
     if method != "GET":
-        parts.extend(["-X", method])
+        parts.append(f"-X {method}")
 
     # Add query params to URL
     if params:
@@ -51,13 +51,16 @@ def generate_curl(
     if data and method in ("POST", "PUT", "PATCH"):
         all_headers["Content-Type"] = "application/json"
 
+    # Combine -H flag with argument to prevent line-break issues
     for key, value in all_headers.items():
-        parts.extend(["-H", f"{key}: {value}"])
+        parts.append(f"-H '{key}: {value}'")
 
-    # JSON body
+    # JSON body - combine -d flag with argument
     if data:
-        json_str = json.dumps(data, indent=2)
-        parts.extend(["-d", json_str])
+        json_str = json.dumps(data)
+        # Escape single quotes in JSON and wrap in single quotes
+        json_escaped = json_str.replace("'", "'\\''")
+        parts.append(f"-d '{json_escaped}'")
 
     # URL (quoted)
     parts.append(shlex.quote(url))
@@ -86,11 +89,16 @@ def files_curl(
     data: dict[str, Any] | None = None,
     params: dict[str, str] | None = None,
 ) -> str:
-    """Generate curl for file-service."""
+    """Generate curl for file-service.
+
+    File-service endpoints use /api/v1/files/... with project_id as query param.
+    """
     settings = get_settings()
-    url = f"{settings.file_url}/api/v1/projects/{project_id}{endpoint}"
+    url = f"{settings.file_url}/api/v1{endpoint}"
     headers = {"X-Project-ID": project_id}
-    return generate_curl(method, url, headers, data, params)
+    # Add project_id to query params
+    all_params = {"project_id": project_id, **(params or {})}
+    return generate_curl(method, url, headers, data, all_params)
 
 
 def compute_curl(