opik 1.9.39__py3-none-any.whl → 1.9.86__py3-none-any.whl

opik/cli/imports/__init__.py

@@ -0,0 +1,439 @@
+"""Import command for Opik CLI."""
+
+import sys
+from pathlib import Path
+from typing import Dict, Optional
+
+import click
+from rich.console import Console
+
+import opik
+
+from .dataset import import_datasets_from_directory
+from .experiment import import_experiments_from_directory
+from .project import import_projects_from_directory
+from .prompt import import_prompts_from_directory
+from .utils import print_import_summary, debug_print
+
+console = Console()
+
+IMPORT_CONTEXT_SETTINGS = {"help_option_names": ["-h", "--help"]}
+
+
+def _import_by_type(
+    import_type: str,
+    path: str,
+    workspace: str,
+    dry_run: bool,
+    name_pattern: Optional[str],
+    debug: bool,
+    recreate_experiments: bool = False,
+    api_key: Optional[str] = None,
+) -> None:
+    """
+    Import data by type (dataset, project, experiment) with pattern matching.
+
+    Args:
+        import_type: Type of data to import ("dataset", "project", "experiment")
+        path: Base directory containing the exported data
+        workspace: Target workspace name
+        dry_run: Whether to show what would be imported without importing
+        name_pattern: Optional string pattern to filter items by name (case-insensitive substring matching)
+        debug: Enable debug output
+        recreate_experiments: Whether to recreate experiments after importing
+    """
+    try:
+        debug_print(f"DEBUG: Starting {import_type} import from {path}", debug)
+
+        # Initialize Opik client
+        if api_key:
+            client = opik.Opik(api_key=api_key, workspace=workspace)
+        else:
+            client = opik.Opik(workspace=workspace)
+
+        # Determine source directory based on import type
+        base_path = Path(path)
+
+        if import_type == "dataset":
+            source_dir = base_path / "datasets"
+        elif import_type == "project":
+            source_dir = base_path / "projects"
+        elif import_type == "experiment":
+            source_dir = base_path / "experiments"
+        elif import_type == "prompt":
+            source_dir = base_path / "prompts"
+        else:
+            console.print(f"[red]Unknown import type: {import_type}[/red]")
+            return
+
+        if not source_dir.exists():
+            console.print(f"[red]Source directory {source_dir} does not exist[/red]")
+            sys.exit(1)
+
+        debug_print(f"Source directory: {source_dir}", debug)
+
+        stats: Dict[str, int] = {}
+
+        if import_type == "dataset":
+            stats = import_datasets_from_directory(
+                client, source_dir, dry_run, name_pattern, debug
+            )
+        elif import_type == "project":
+            stats = import_projects_from_directory(
+                client, source_dir, dry_run, name_pattern, debug, recreate_experiments
+            )
+        elif import_type == "experiment":
+            stats = import_experiments_from_directory(
+                client, source_dir, dry_run, name_pattern, debug
+            )
+        elif import_type == "prompt":
+            stats = import_prompts_from_directory(
+                client, source_dir, dry_run, name_pattern, debug
+            )
+
+        # Display summary
+        print_import_summary(stats)
+
+        # Also show a simple message for backward compatibility
+        # Map import_type to the key used in stats dictionary
+        type_key_map = {
+            "dataset": "datasets",
+            "prompt": "prompts",
+            "project": "projects",
+            "experiment": "experiments",
+        }
+        stats_key = type_key_map.get(import_type, import_type + "s")
+        imported_count = stats.get(stats_key, 0)
+        errors = stats.get(stats_key + "_errors", 0)
+
+        if dry_run:
+            console.print(
+                f"[blue]Dry run complete: Would import {imported_count} {import_type}s[/blue]"
+            )
+        else:
+            if errors > 0:
+                console.print(
+                    f"[yellow]Import completed with {errors} error(s) while importing {import_type}s[/yellow]"
+                )
+            elif imported_count == 0:
+                console.print(f"[yellow]No {import_type}s were imported[/yellow]")
+            else:
+                console.print(
+                    f"[green]Successfully imported {imported_count} {import_type}s[/green]"
+                )
+
+    except Exception as e:
+        console.print(f"[red]Error importing {import_type}s: {e}[/red]")
+        sys.exit(1)
+
+
+@click.group(name="import", context_settings=IMPORT_CONTEXT_SETTINGS)
+@click.argument("workspace", type=str)
+@click.option(
+    "--api-key",
+    type=str,
+    help="Opik API key. If not provided, will use OPIK_API_KEY environment variable or configuration.",
+)
+@click.pass_context
+def import_group(ctx: click.Context, workspace: str, api_key: Optional[str]) -> None:
+    """Import data to Opik workspace.
+
+    This command allows you to import previously exported data back into an Opik workspace.
+    Supported data types include projects, datasets, experiments, and prompts.
+
+    \b
+    General Usage:
+        opik import WORKSPACE TYPE NAME [OPTIONS]
+
+    \b
+    Data Types:
+        project     Import projects from path/projects/ (default: opik_exports)
+        dataset     Import datasets from path/datasets/ (default: opik_exports)
+        experiment  Import experiments from path/experiments/ (default: opik_exports)
+        prompt      Import prompts from path/prompts/ (default: opik_exports)
+
+    \b
+    Common Options:
+        --path, -p  Directory containing exported data (default: opik_exports)
+        --dry-run   Preview what would be imported without actually importing
+        --debug     Show detailed information about the import process
+
+    \b
+    Examples:
+        # Preview an experiment that would be imported
+        opik import my-workspace experiment "my-experiment" --dry-run
+
+        # Import a specific project
+        opik import my-workspace project "my-project"
+
+        # Import a specific dataset
+        opik import my-workspace dataset "my-dataset"
+
+        # Import from a custom path
+        opik import my-workspace project "my-project" --path ./custom-exports/
+    """
+    ctx.ensure_object(dict)
+    ctx.obj["workspace"] = workspace
+    # Use API key from this command or from parent context
+    ctx.obj["api_key"] = api_key or (
+        ctx.parent.obj.get("api_key") if ctx.parent and ctx.parent.obj else None
+    )
+
+
+# Set subcommand metavar to ITEM instead of COMMAND
+import_group.subcommand_metavar = "ITEM [ARGS]..."
+
+
+def format_commands(
+    self: click.Group, ctx: click.Context, formatter: click.HelpFormatter
+) -> None:
+    """Override to change 'Commands' heading to 'Items'."""
+    commands = []
+    for subcommand in self.list_commands(ctx):
+        cmd = self.get_command(ctx, subcommand)
+        if cmd is None or cmd.hidden:
+            continue
+        commands.append((subcommand, cmd))
+
+    if len(commands):
+        limit = formatter.width - 6 - max(len(cmd[0]) for cmd in commands)
+        rows = []
+        for subcommand, cmd in commands:
+            help = cmd.get_short_help_str(limit)
+            rows.append((subcommand, help))
+
+        if rows:
+            with formatter.section("Items"):
+                formatter.write_dl(rows)
+
+
+# Override format_commands method
+setattr(
+    import_group,
+    "format_commands",
+    format_commands.__get__(import_group, type(import_group)),
+)
+
+
+@import_group.command(name="dataset")
+@click.argument("name", type=str)
+@click.option(
+    "--path",
+    "-p",
+    type=click.Path(file_okay=False, dir_okay=True, readable=True),
+    default="opik_exports",
+    help="Directory containing exported data. Defaults to opik_exports.",
+)
+@click.option(
+    "--dry-run",
+    is_flag=True,
+    help="Show what would be imported without actually importing. Use this to preview datasets before importing.",
+)
+@click.option(
+    "--debug",
+    is_flag=True,
+    help="Enable debug output to show detailed information about the import process.",
+)
+@click.pass_context
+def import_dataset(
+    ctx: click.Context,
+    name: str,
+    path: str,
+    dry_run: bool,
+    debug: bool,
+) -> None:
+    """Import datasets from workspace/datasets directory.
+
+    This command imports datasets matching the specified name from the path/datasets/ directory.
+    The name is matched using case-insensitive substring matching.
+
+    \b
+    Examples:
+    \b
+        # Preview a dataset that would be imported
+        opik import my-workspace dataset "my-dataset" --dry-run
+    \b
+        # Import a specific dataset
+        opik import my-workspace dataset "my-dataset"
+    \b
+        # Import datasets containing "training" in the name
+        opik import my-workspace dataset "training"
+    \b
+        # Import from a custom path
+        opik import my-workspace dataset "my-dataset" --path ./custom-exports/
+    """
+    workspace = ctx.obj["workspace"]
+    api_key = ctx.obj.get("api_key") if ctx.obj else None
+    _import_by_type("dataset", path, workspace, dry_run, name, debug, api_key=api_key)
+
+
+@import_group.command(name="project")
+@click.argument("name", type=str)
+@click.option(
+    "--path",
+    "-p",
+    type=click.Path(file_okay=False, dir_okay=True, readable=True),
+    default="opik_exports",
+    help="Directory containing exported data. Defaults to opik_exports.",
+)
+@click.option(
+    "--dry-run",
+    is_flag=True,
+    help="Show what would be imported without actually importing. Use this to preview projects before importing.",
+)
+@click.option(
+    "--debug",
+    is_flag=True,
+    help="Enable debug output to show detailed information about the import process.",
+)
+@click.pass_context
+def import_project(
+    ctx: click.Context,
+    name: str,
+    path: str,
+    dry_run: bool,
+    debug: bool,
+) -> None:
+    """Import projects from workspace/projects directory.
+
+    This command imports projects matching the specified name from the path/projects/ directory.
+    The name is matched using case-insensitive substring matching.
+
+    \b
+    Examples:
+    \b
+        # Preview a project that would be imported
+        opik import my-workspace project "my-project" --dry-run
+    \b
+        # Import a specific project
+        opik import my-workspace project "my-project"
+    \b
+        # Import projects containing "test" in the name
+        opik import my-workspace project "test"
+    \b
+        # Import projects with debug output
+        opik import my-workspace project "my-project" --debug
+    \b
+        # Import from a custom path
+        opik import my-workspace project "my-project" --path ./custom-exports/
+    """
+    workspace = ctx.obj["workspace"]
+    api_key = ctx.obj.get("api_key") if ctx.obj else None
+    _import_by_type(
+        "project",
+        path,
+        workspace,
+        dry_run,
+        name,
+        debug,
+        True,  # Always recreate experiments when importing projects
+        api_key=api_key,
+    )
+
+
+@import_group.command(name="experiment")
+@click.argument("name", type=str)
+@click.option(
+    "--path",
+    "-p",
+    type=click.Path(file_okay=False, dir_okay=True, readable=True),
+    default="opik_exports",
+    help="Directory containing exported data. Defaults to opik_exports.",
+)
+@click.option(
+    "--dry-run",
+    is_flag=True,
+    help="Show what would be imported without actually importing.",
+)
+@click.option(
+    "--debug",
+    is_flag=True,
+    help="Enable debug output to show detailed information about the import process.",
+)
+@click.pass_context
+def import_experiment(
+    ctx: click.Context,
+    name: str,
+    path: str,
+    dry_run: bool,
+    debug: bool,
+) -> None:
+    """Import experiments from workspace/experiments directory.
+
+    This command imports experiments matching the specified name from the path/experiments/ directory.
+    The name is matched using case-insensitive substring matching.
+
+    \b
+    Examples:
+    \b
+        # Preview an experiment that would be imported
+        opik import my-workspace experiment "my-experiment" --dry-run
+    \b
+        # Import a specific experiment
+        opik import my-workspace experiment "my-experiment"
+    \b
+        # Import from a custom path
+        opik import my-workspace experiment "my-experiment" --path ./custom-exports/
+    """
+    workspace = ctx.obj["workspace"]
+    api_key = ctx.obj.get("api_key") if ctx.obj else None
+    # Always recreate experiments when importing
+    _import_by_type(
+        "experiment",
+        path,
+        workspace,
+        dry_run,
+        name,
+        debug,
+        True,
+        api_key=api_key,
+    )
+
+
+@import_group.command(name="prompt")
+@click.argument("name", type=str)
+@click.option(
+    "--path",
+    "-p",
+    type=click.Path(file_okay=False, dir_okay=True, readable=True),
+    default="opik_exports",
+    help="Directory containing exported data. Defaults to opik_exports.",
+)
+@click.option(
+    "--dry-run",
+    is_flag=True,
+    help="Show what would be imported without actually importing.",
+)
+@click.option(
+    "--debug",
+    is_flag=True,
+    help="Enable debug output to show detailed information about the import process.",
+)
+@click.pass_context
+def import_prompt(
+    ctx: click.Context,
+    name: str,
+    path: str,
+    dry_run: bool,
+    debug: bool,
+) -> None:
+    """Import prompts from workspace/prompts directory.
+
+    This command imports prompts matching the specified name from the path/prompts/ directory.
+    The name is matched using case-insensitive substring matching.
+
+    \b
+    Examples:
+    \b
+        # Preview a prompt that would be imported
+        opik import my-workspace prompt "my-prompt" --dry-run
+    \b
+        # Import a specific prompt
+        opik import my-workspace prompt "my-prompt"
+    \b
+        # Import from a custom path
+        opik import my-workspace prompt "my-prompt" --path ./custom-exports/
+    """
+    workspace = ctx.obj["workspace"]
+    api_key = ctx.obj.get("api_key") if ctx.obj else None
+    _import_by_type("prompt", path, workspace, dry_run, name, debug, api_key=api_key)

opik/cli/imports/dataset.py

@@ -0,0 +1,143 @@
+"""Dataset import functionality."""
+
+import json
+from pathlib import Path
+from typing import Dict, Optional
+
+import opik
+from rich.console import Console
+
+from .utils import matches_name_pattern
+
+console = Console()
+
+
+def import_datasets_from_directory(
+    client: opik.Opik,
+    source_dir: Path,
+    dry_run: bool,
+    name_pattern: Optional[str],
+    debug: bool,
+) -> Dict[str, int]:
+    """Import datasets from a directory.
+
+    Returns:
+        Dictionary with keys: 'datasets', 'datasets_skipped', 'datasets_errors'
+    """
+    try:
+        dataset_files = list(source_dir.glob("dataset_*.json"))
+
+        if not dataset_files:
+            console.print("[yellow]No dataset files found in the directory[/yellow]")
+            return {"datasets": 0, "datasets_skipped": 0, "datasets_errors": 0}
+
+        imported_count = 0
+        skipped_count = 0
+        error_count = 0
+        for dataset_file in dataset_files:
+            try:
+                with open(dataset_file, "r", encoding="utf-8") as f:
+                    dataset_data = json.load(f)
+
+                # Handle two export formats:
+                # 1. {"name": "...", "items": [...]} - from export_single_dataset
+                # 2. {"dataset": {"name": "...", "id": "..."}, "items": [...]} - from export_experiment_datasets
+                dataset_name = dataset_data.get("name") or (
+                    dataset_data.get("dataset", {}).get("name")
+                    if dataset_data.get("dataset")
+                    else None
+                )
+
+                # Check if name is missing or empty
+                if not dataset_name or (
+                    isinstance(dataset_name, str) and not dataset_name.strip()
+                ):
+                    console.print(
+                        f"[red]Error: Dataset file {dataset_file.name} is missing or has an empty name field[/red]"
+                    )
+                    error_count += 1
+                    continue
+
+                # Strip whitespace from name
+                dataset_name = dataset_name.strip()
+
+                # Filter by name pattern if specified
+                if name_pattern and not matches_name_pattern(
+                    dataset_name, name_pattern
+                ):
+                    if debug:
+                        console.print(
+                            f"[blue]Skipping dataset {dataset_name} (doesn't match pattern)[/blue]"
+                        )
+                    skipped_count += 1
+                    continue
+
+                if dry_run:
+                    console.print(f"[blue]Would import dataset: {dataset_name}[/blue]")
+                    imported_count += 1
+                    continue
+
+                if debug:
+                    console.print(f"[blue]Importing dataset: {dataset_name}[/blue]")
+
+                # Get or create dataset (handles case where dataset already exists)
+                try:
+                    dataset = client.get_dataset(dataset_name)
+                    if debug:
+                        console.print(
+                            f"[blue]Dataset '{dataset_name}' already exists, using existing dataset[/blue]"
+                        )
+                except Exception:
+                    # Dataset doesn't exist, create it
+                    dataset = client.create_dataset(name=dataset_name)
+                    if debug:
+                        console.print(
+                            f"[blue]Created new dataset: {dataset_name}[/blue]"
+                        )
+
+                # Import dataset items
+                items = dataset_data.get("items", [])
+                if items:
+                    # Remove 'id' field from items before inserting (IDs are auto-generated)
+                    items_to_insert = []
+                    for item in items:
+                        if isinstance(item, dict):
+                            # Create a copy without the 'id' field
+                            item_copy = {k: v for k, v in item.items() if k != "id"}
+                            items_to_insert.append(item_copy)
+                        else:
+                            items_to_insert.append(item)
+
+                    if items_to_insert:
+                        dataset.insert(items_to_insert)
+                        if debug:
+                            console.print(
+                                f"[blue]Inserted {len(items_to_insert)} items into dataset '{dataset_name}'[/blue]"
+                            )
+                    else:
+                        console.print(
+                            f"[yellow]Warning: No items to insert for dataset '{dataset_name}' (all items were empty after removing 'id' field)[/yellow]"
+                        )
+
+                imported_count += 1
+                if debug:
+                    console.print(
+                        f"[green]Imported dataset: {dataset_name} with {len(items)} items[/green]"
+                    )
+
+            except Exception as e:
+                console.print(
+                    f"[red]Error importing dataset from {dataset_file.name}: {e}[/red]"
+                )
+                error_count += 1
+                continue
+
+        return {
+            "datasets": imported_count,
+            "datasets_skipped": skipped_count,
+            "datasets_errors": error_count,
+        }
+
+    except Exception as e:
+        console.print(f"[red]Error importing datasets: {e}[/red]")
+        return {"datasets": 0, "datasets_skipped": 0, "datasets_errors": 1}