raxtik-etl 0.1.0.dev0__py3-none-any.whl

raxtik_etl/__init__.py

@@ -0,0 +1,6 @@
+"""raxtik-etl: Versioned, reproducible FAERS data platform for high-performance analytics."""
+
+from raxtik_etl.sdk import FAERS
+
+__version__ = "0.1.0.dev0"
+__all__ = ["FAERS", "__version__"]

raxtik_etl/cli.py

@@ -0,0 +1,298 @@
+"""Typer CLI interface for raxtik-etl pipeline commands."""
+
+from pathlib import Path
+from typing import List, Optional
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+from raxtik_etl.distribution.huggingface import DEFAULT_HF_REPO
+from raxtik_etl.longitudinal import (
+    build_merged_longitudinal_package,
+    get_longitudinal_summary_report,
+)
+from raxtik_etl.packaging.builder import PACKAGE_OUTPUT_DIR, build_quarterly_package
+from raxtik_etl.sdk import FAERS
+
+app = typer.Typer(
+    name="raxtik-etl",
+    help="Enterprise-grade FAERS adverse event data platform & packaging CLI.",
+    add_completion=False,
+)
+console = Console()
+CACHE_DIR = Path("data/raw/archives_cache")
+
+
+def parse_quarter_range(start_quarter: str, end_quarter: str) -> List[str]:
+    """Generates an inclusive list of quarterly releases between start and end (e.g. '2004Q1' to '2006Q4')."""
+    start_clean = start_quarter.strip().upper()
+    end_clean = end_quarter.strip().upper()
+
+    start_y, start_q = int(start_clean[:4]), int(start_clean[-1])
+    end_y, end_q = int(end_clean[:4]), int(end_clean[-1])
+
+    quarters: List[str] = []
+    y, q = start_y, start_q
+    while (y < end_y) or (y == end_y and q <= end_q):
+        quarters.append(f"{y}Q{q}")
+        q += 1
+        if q > 4:
+            q = 1
+            y += 1
+    return quarters
+
+
+@app.command("build-package")
+def build_package_cmd(
+    source: str = typer.Option(
+        "faers", "--source", "-s", help="Source connector name (e.g. faers)"
+    ),
+    release: str = typer.Option(
+        "2004Q1", "--release", "-r", help="Quarter release identifier (e.g. 2004Q1)"
+    ),
+    zip_path: Optional[Path] = typer.Option(
+        None, "--zip-path", "-z", help="Path to source archive/zip file"
+    ),
+    output_dir: Optional[Path] = typer.Option(
+        None, "--output-dir", "-o", help="Output package directory"
+    ),
+):
+    """Build a standalone, self-describing Safety DuckDB and Parquet package."""
+    release_clean = release.upper()
+    archive_file = zip_path or (CACHE_DIR / f"{release_clean.lower()}_ascii.zip")
+
+    if not archive_file.exists():
+        console.print(f"[bold red]Source archive not found at {archive_file}.[/bold red]")
+        raise typer.Exit(code=1)
+
+    res = build_quarterly_package(
+        release=release_clean,
+        zip_path=archive_file,
+        source_name=source,
+        output_dir=output_dir,
+    )
+    console.print(
+        Panel(
+            f"Release: [bold]{res['release']}[/bold]\nSignature: {res['signature_id']}\nDuckDB: {res['duckdb_path']}\nParquet: {res['parquet_dir']}",
+            title="Package Generated Successfully",
+            style="green",
+        )
+    )
+
+
+@app.command("build-cohort")
+def build_cohort_cmd(
+    start: str = typer.Option("2004Q1", "--start", help="Starting quarter release (e.g. 2004Q1)"),
+    end: str = typer.Option("2006Q4", "--end", help="Ending quarter release (e.g. 2006Q4)"),
+    source: str = typer.Option("faers", "--source", "-s", help="Source connector name"),
+    output_dir: Optional[Path] = typer.Option(
+        None, "--output-dir", "-o", help="Output directory for packages"
+    ),
+):
+    """Batch build standalone packages for every quarter in the specified range."""
+    quarters = parse_quarter_range(start, end)
+    console.print(
+        f"[bold cyan]Building {len(quarters)} quarterly packages ({quarters[0]} to {quarters[-1]})...[/bold cyan]"
+    )
+
+    for q in quarters:
+        archive_file = CACHE_DIR / f"{q.lower()}_ascii.zip"
+        if not archive_file.exists():
+            console.print(f"[bold red]Archive not found for {q}: {archive_file}[/bold red]")
+            raise typer.Exit(code=1)
+        build_quarterly_package(
+            release=q,
+            zip_path=archive_file,
+            source_name=source,
+            output_dir=output_dir,
+        )
+
+    console.print(f"[bold green]✓ Successfully built all {len(quarters)} packages.[/bold green]")
+
+
+@app.command("merge-cohort")
+def merge_cohort_cmd(
+    start: str = typer.Option("2004Q1", "--start", help="Starting quarter release (e.g. 2004Q1)"),
+    end: str = typer.Option("2006Q4", "--end", help="Ending quarter release (e.g. 2006Q4)"),
+    package_dir: Optional[Path] = typer.Option(
+        None, "--package-dir", "-p", help="Directory containing quarterly packages"
+    ),
+    output_name: Optional[str] = typer.Option(
+        None,
+        "--output-name",
+        "-n",
+        help="Merged output name (defaults to faers_{start}_{end}_merged)",
+    ),
+    output_dir: Optional[Path] = typer.Option(
+        None, "--output-dir", "-o", help="Destination folder for merged package"
+    ),
+):
+    """Merge quarterly packages into a consolidated longitudinal dataset with cross-quarter deduplication."""
+    quarters = parse_quarter_range(start, end)
+    resolved_output_name = output_name or f"faers_{start}_{end}_merged".lower()
+    res = build_merged_longitudinal_package(
+        releases=quarters,
+        package_dir=package_dir,
+        output_name=resolved_output_name,
+        output_dir=output_dir,
+    )
+    console.print(
+        Panel(
+            f"Merged Database: [bold]{res['output_duckdb']}[/bold]\n"
+            f"Merged Parquet: [bold]{res['output_parquet']}[/bold]\n"
+            f"Total Submissions: [cyan]{res['metrics'].get('total_raw_submissions')}[/cyan]\n"
+            f"Deduplicated Unique Cases: [green]{res['metrics'].get('total_unique_cases')}[/green]\n"
+            f"Cross-Quarter Cases: [yellow]{res['metrics'].get('cases_spanning_multiple_quarters')}[/yellow]\n"
+            f"Duplicates Removed: [magenta]{res['metrics'].get('deduplicated_duplicate_reports_removed')} ({res['metrics'].get('deduplication_reduction_pct')})[/magenta]",
+            title="Longitudinal Cohort Merged & Deduplicated",
+            style="green",
+        )
+    )
+
+
+@app.command("inspect-package")
+def inspect_package_cmd(
+    release: str = typer.Option(
+        "2004Q1", "--release", "-r", help="Quarter release identifier to inspect"
+    ),
+    package_dir: Optional[Path] = typer.Option(
+        None, "--package-dir", "-p", help="Directory containing package files"
+    ),
+):
+    """Inspect and display metadata and data quality report for a compiled package."""
+    try:
+        with FAERS(release=release, package_dir=package_dir) as faers:
+            faers.print_summary()
+    except Exception as e:
+        console.print(f"[bold red]Failed to inspect package:[/bold red] {e}")
+        raise typer.Exit(code=1)
+
+
+@app.command("inspect-cohort")
+def inspect_cohort_cmd(
+    cohort: Optional[str] = typer.Option(
+        None,
+        "--cohort",
+        "-c",
+        help="Cohort name or identifier (e.g. 'faers_2004_2006_merged' or '2004_2006')",
+    ),
+    db_path: Optional[Path] = typer.Option(
+        None,
+        "--db-path",
+        "-d",
+        help="Direct path to merged DuckDB package file",
+    ),
+    package_dir: Optional[Path] = typer.Option(
+        None,
+        "--package-dir",
+        "-p",
+        help="Directory containing packages (defaults to data/packages or RAXTIK_PACKAGE_DIR)",
+    ),
+):
+    """Inspect and display metrics for a merged longitudinal cohort package."""
+    base_dir = package_dir or PACKAGE_OUTPUT_DIR
+    target_path: Optional[Path] = None
+
+    if db_path is not None:
+        target_path = db_path
+    elif cohort is not None:
+        filename = cohort if cohort.endswith(".duckdb") else f"{cohort}.duckdb"
+        if not filename.startswith("faers_") and not filename.startswith("/"):
+            filename = f"faers_{filename}"
+        candidate = base_dir / filename
+        if not candidate.exists() and not filename.endswith("_merged.duckdb"):
+            merged_candidate = base_dir / filename.replace(".duckdb", "_merged.duckdb")
+            if merged_candidate.exists():
+                candidate = merged_candidate
+        target_path = candidate
+    else:
+        # Default fallback: check for existing merged package
+        default_2004_2006 = base_dir / "faers_2004_2006_merged.duckdb"
+        if default_2004_2006.exists():
+            target_path = default_2004_2006
+        else:
+            merged_files = sorted(base_dir.glob("*merged*.duckdb"))
+            target_path = merged_files[0] if merged_files else default_2004_2006
+
+    if not target_path.exists():
+        console.print(f"[bold red]Database not found at {target_path}[/bold red]")
+        raise typer.Exit(code=1)
+    report_table = get_longitudinal_summary_report(target_path)
+    console.print(report_table)
+
+
+@app.command("hf-download")
+def hf_download_cmd(
+    release: str = typer.Option(
+        "2004Q1",
+        "--release",
+        "-r",
+        help="Release identifier (e.g. 2004Q1 or faers_2004_2006_merged)",
+    ),
+    repo_id: str = typer.Option(
+        DEFAULT_HF_REPO,
+        "--repo-id",
+        help="Hugging Face dataset repository (defaults to RAXTIK_HF_REPO)",
+    ),
+    dest_dir: Path = typer.Option(
+        Path("data/packages"), "--dest-dir", "-d", help="Destination folder"
+    ),
+    force: bool = typer.Option(False, "--force", "-f", help="Overwrite existing local files"),
+):
+    """Download a compiled FAERS package from Hugging Face Hub (zero auth required)."""
+    from raxtik_etl.distribution.huggingface import download_package_from_hf
+
+    try:
+        download_package_from_hf(
+            release_or_name=release,
+            dest_dir=dest_dir,
+            repo_id=repo_id,
+            force=force,
+        )
+    except Exception as e:
+        console.print(f"[bold red]Download failed:[/bold red] {e}")
+        raise typer.Exit(code=1)
+
+
+@app.command("hf-upload")
+def hf_upload_cmd(
+    release: str = typer.Option(
+        "2004Q1",
+        "--release",
+        "-r",
+        help="Release identifier (e.g. 2004Q1 or faers_2004_2006_merged)",
+    ),
+    repo_id: str = typer.Option(
+        DEFAULT_HF_REPO,
+        "--repo-id",
+        help="Hugging Face dataset repository (defaults to RAXTIK_HF_REPO)",
+    ),
+    package_dir: Path = typer.Option(
+        Path("data/packages"), "--package-dir", "-p", help="Directory containing packages"
+    ),
+    token: Optional[str] = typer.Option(
+        None, "--token", "-t", help="Hugging Face write access token (defaults to HF_TOKEN env var)"
+    ),
+    parquet: bool = typer.Option(
+        True, "--parquet/--no-parquet", help="Whether to include Parquet shards"
+    ),
+):
+    """Upload a compiled FAERS package to Hugging Face Hub (requires write token)."""
+    from raxtik_etl.distribution.huggingface import upload_package_to_hf
+
+    try:
+        upload_package_to_hf(
+            release_or_name=release,
+            package_dir=package_dir,
+            repo_id=repo_id,
+            token=token,
+            include_parquet=parquet,
+        )
+    except Exception as e:
+        console.print(f"[bold red]Upload failed:[/bold red] {e}")
+        raise typer.Exit(code=1)
+
+
+if __name__ == "__main__":
+    app()

raxtik_etl/config.py

@@ -0,0 +1,30 @@
+"""Global configuration and directory paths for raxtik-etl."""
+
+import os
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
+
+# Base data directories
+DATA_DIR = Path(os.getenv("RAXTIK_DATA_DIR", PROJECT_ROOT / "data"))
+RAW_DATA_DIR = DATA_DIR / "raw"
+INTERMEDIATE_DATA_DIR = DATA_DIR / "intermediate"
+OUTPUT_DATA_DIR = DATA_DIR / "output"
+
+# DuckDB intermediate database
+DEFAULT_DUCKDB_PATH = INTERMEDIATE_DATA_DIR / "faers.duckdb"
+
+# Exporter output paths
+DEFAULT_SQLITE_PATH = OUTPUT_DATA_DIR / "faers_seed.sqlite"
+DEFAULT_PARQUET_DIR = OUTPUT_DATA_DIR / "parquet"
+
+# FAERS configuration
+FAERS_TABLE_TYPES = ["demo", "drug", "reac", "outc", "indi"]
+FAERS_BASE_URL = "https://fis.fda.gov/content/Exports"
+
+
+def ensure_directories():
+    """Ensure that standard data directories exist."""
+    RAW_DATA_DIR.mkdir(parents=True, exist_ok=True)
+    INTERMEDIATE_DATA_DIR.mkdir(parents=True, exist_ok=True)
+    OUTPUT_DATA_DIR.mkdir(parents=True, exist_ok=True)

raxtik_etl/distribution/__init__.py

@@ -0,0 +1,13 @@
+"""Remote distribution subsystem for FAERS packages (Hugging Face Hub integration)."""
+
+from raxtik_etl.distribution.huggingface import (
+    DEFAULT_HF_REPO,
+    download_package_from_hf,
+    upload_package_to_hf,
+)
+
+__all__ = [
+    "DEFAULT_HF_REPO",
+    "download_package_from_hf",
+    "upload_package_to_hf",
+]

raxtik_etl/distribution/huggingface.py

@@ -0,0 +1,210 @@
+"""Hugging Face Hub distribution module for downloading and uploading compiled packages.
+
+Designed with zero-auth public downloads:
+- Downloads can use direct streaming HTTP via requests (no Hugging Face login required).
+- Uploads require `huggingface_hub` (in dev dependencies) and a valid write token.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+from pathlib import Path
+from typing import Optional
+
+import requests
+from rich.console import Console
+from tqdm import tqdm
+
+console = Console()
+
+DEFAULT_HF_REPO = os.getenv("RAXTIK_HF_REPO", "raxtik-org/faers-safety-database")
+
+
+def download_package_from_hf(
+    release_or_name: str,
+    dest_dir: Path | str = "data/packages",
+    repo_id: str = DEFAULT_HF_REPO,
+    force: bool = False,
+) -> Path:
+    """
+    Downloads a compiled .duckdb safety package from Hugging Face Hub.
+
+    Publicly accessible without any authentication token or Hugging Face account.
+
+    Args:
+        release_or_name: e.g. '2004Q1' or 'faers_2004_2006_merged'
+        dest_dir: Destination folder (defaults to data/packages)
+        repo_id: Hugging Face dataset repository id
+        force: Whether to overwrite existing local file
+
+    Returns:
+        Path to downloaded DuckDB package.
+    """
+    target_dir = Path(dest_dir)
+    target_dir.mkdir(parents=True, exist_ok=True)
+
+    rel_upper = release_or_name.strip()
+    if not rel_upper.startswith("faers_"):
+        filename = f"faers_{rel_upper.upper()}.duckdb"
+    else:
+        filename = f"{rel_upper}.duckdb"
+
+    match = re.search(r"(\d{4})Q[1-4]", rel_upper)
+    subfolder = match.group(1) if match else ("merged" if "merged" in rel_upper.lower() else "")
+    rel_path = f"{subfolder}/{filename}" if subfolder else filename
+
+    dest_file = target_dir / filename
+    if dest_file.exists() and not force:
+        console.print(f"[bold green]Package already present locally:[/bold green] {dest_file}")
+        return dest_file
+
+    # Try huggingface_hub if available
+    try:
+        from huggingface_hub import hf_hub_download  # type: ignore
+
+        console.print(
+            f"[bold cyan]Downloading {filename} from Hugging Face Hub ({repo_id})...[/bold cyan]"
+        )
+        try:
+            downloaded_path = hf_hub_download(
+                repo_id=repo_id,
+                filename=rel_path,
+                repo_type="dataset",
+                local_dir=str(target_dir),
+            )
+        except Exception:
+            # Fall back to root path if not in year subfolder
+            downloaded_path = hf_hub_download(
+                repo_id=repo_id,
+                filename=filename,
+                repo_type="dataset",
+                local_dir=str(target_dir),
+            )
+        return Path(downloaded_path)
+    except ImportError:
+        # Fallback to direct HTTP download via requests (no huggingface_hub needed)
+        url = f"https://huggingface.co/datasets/{repo_id}/resolve/main/{rel_path}"
+        console.print(
+            f"[bold cyan]Downloading {filename} via public direct stream from {url}...[/bold cyan]"
+        )
+
+        response = requests.get(url, stream=True, timeout=120)
+        if response.status_code != 200:
+            # Try root URL fallback
+            fallback_url = f"https://huggingface.co/datasets/{repo_id}/resolve/main/{filename}"
+            response = requests.get(fallback_url, stream=True, timeout=120)
+            if response.status_code != 200:
+                raise RuntimeError(
+                    f"Failed to download package '{filename}' from Hugging Face Hub at {url} (HTTP {response.status_code})."
+                )
+
+        total_size = int(response.headers.get("content-length", 0))
+        with (
+            open(dest_file, "wb") as f,
+            tqdm(
+                desc=filename,
+                total=total_size if total_size > 0 else None,
+                unit="iB",
+                unit_scale=True,
+                unit_divisor=1024,
+            ) as bar,
+        ):
+            for chunk in response.iter_content(chunk_size=1024 * 1024):
+                if chunk:
+                    size = f.write(chunk)
+                    bar.update(size)
+
+        console.print(f"[bold green]✓ Download complete:[/bold green] {dest_file}")
+        return dest_file
+
+
+def upload_package_to_hf(
+    release_or_name: str,
+    package_dir: Path | str = "data/packages",
+    repo_id: str = DEFAULT_HF_REPO,
+    token: Optional[str] = None,
+    include_parquet: bool = True,
+) -> None:
+    """
+    Uploads a compiled .duckdb package and optional Parquet shards to Hugging Face Hub.
+
+    Organizes releases cleanly into year subfolders (e.g. 2004/faers_2004Q1.duckdb, merged/...).
+
+    Requires `huggingface_hub` (available via `pip install 'raxtik-etl[dev]'`) and
+    a Hugging Face write token (via argument or HF_TOKEN env var).
+
+    Args:
+        release_or_name: e.g. '2004Q1' or 'faers_2004_2006_merged'
+        package_dir: Directory containing compiled packages
+        repo_id: Destination Hugging Face dataset repository id
+        token: Hugging Face user write access token
+        include_parquet: Whether to also upload the corresponding .parquet folder
+    """
+    try:
+        from huggingface_hub import HfApi  # type: ignore
+    except ImportError:
+        raise ImportError(
+            "Uploading requires 'huggingface_hub'. Please install it using: pip install 'raxtik-etl[dev]'"
+        )
+
+    auth_token = token or os.environ.get("HF_TOKEN") or os.environ.get("HUGGINGFACE_HUB_TOKEN")
+    if not auth_token:
+        raise ValueError(
+            "Hugging Face write token is required to upload packages. "
+            "Pass token=... or set the HF_TOKEN environment variable."
+        )
+
+    pkg_dir = Path(package_dir)
+    rel_clean = release_or_name.strip()
+    if not rel_clean.startswith("faers_"):
+        duckdb_name = f"faers_{rel_clean.upper()}.duckdb"
+        parquet_dir_name = f"faers_{rel_clean.upper()}.parquet"
+    else:
+        duckdb_name = f"{rel_clean}.duckdb"
+        parquet_dir_name = f"{rel_clean}.parquet"
+
+    # Route into year subfolder (e.g. 2004/...) or merged/...
+    match = re.search(r"(\d{4})Q[1-4]", rel_clean.upper())
+    if match:
+        subfolder = match.group(1)
+    elif "merged" in rel_clean.lower():
+        subfolder = "merged"
+    else:
+        subfolder = ""
+
+    path_in_repo_duckdb = f"{subfolder}/{duckdb_name}" if subfolder else duckdb_name
+    path_in_repo_parquet = f"{subfolder}/{parquet_dir_name}" if subfolder else parquet_dir_name
+
+    duckdb_file = pkg_dir / duckdb_name
+    parquet_dir = pkg_dir / parquet_dir_name
+
+    if not duckdb_file.exists():
+        raise FileNotFoundError(f"Package database not found at {duckdb_file}")
+
+    api = HfApi(token=auth_token)
+
+    # 1. Upload DuckDB file
+    console.print(
+        f"[bold cyan]Uploading {duckdb_name} -> {path_in_repo_duckdb} ({duckdb_file.stat().st_size / (1024 * 1024):.2f} MB)...[/bold cyan]"
+    )
+    api.upload_file(
+        path_or_fileobj=duckdb_file.as_posix(),
+        path_in_repo=path_in_repo_duckdb,
+        repo_id=repo_id,
+        repo_type="dataset",
+    )
+    console.print(f"[bold green]✓ Uploaded {path_in_repo_duckdb} successfully.[/bold green]")
+
+    # 2. Optionally upload Parquet shards
+    if include_parquet and parquet_dir.exists():
+        console.print(
+            f"[bold cyan]Uploading Parquet shards from {parquet_dir_name} -> {path_in_repo_parquet}...[/bold cyan]"
+        )
+        api.upload_folder(
+            folder_path=parquet_dir.as_posix(),
+            path_in_repo=path_in_repo_parquet,
+            repo_id=repo_id,
+            repo_type="dataset",
+        )
+        console.print(f"[bold green]✓ Uploaded {path_in_repo_parquet} successfully.[/bold green]")

raxtik_etl/exporters/__init__.py

@@ -0,0 +1,6 @@
+"""Seed exporters for SQLite and Parquet artifacts."""
+
+from raxtik_etl.exporters.parquet_exporter import export_parquet
+from raxtik_etl.exporters.sqlite_exporter import export_sqlite
+
+__all__ = ["export_sqlite", "export_parquet"]

raxtik_etl/exporters/parquet_exporter.py

@@ -0,0 +1,77 @@
+"""Parquet Seed Exporter for analytical workloads."""
+
+from pathlib import Path
+from typing import Dict, List, Optional
+
+import duckdb
+from rich.console import Console
+
+from raxtik_etl.config import DEFAULT_DUCKDB_PATH, DEFAULT_PARQUET_DIR
+
+console = Console()
+
+SEED_TABLES = [
+    "drug_reaction_stats",
+    "drug_demographics",
+    "drug_indications",
+    "drug_routes",
+    "drug_outcomes",
+]
+
+
+def export_parquet(
+    db_path: Optional[Path | str] = None,
+    parquet_dir: Optional[Path | str] = None,
+    dataset_schema: str = "faers_raw",
+    tables: Optional[List[str]] = None,
+    verbose: bool = True,
+) -> Path:
+    """
+    Export transformed tables from DuckDB into compressed Parquet files.
+
+    Args:
+        db_path: Source DuckDB database path.
+        parquet_dir: Target directory for Parquet files.
+        dataset_schema: Schema where tables are located.
+        tables: List of tables to export (defaults to SEED_TABLES).
+        verbose: Log export progress.
+
+    Returns:
+        Path to output directory containing Parquet files.
+    """
+    src_path = Path(db_path) if db_path else DEFAULT_DUCKDB_PATH
+    dest_dir = Path(parquet_dir) if parquet_dir else DEFAULT_PARQUET_DIR
+
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    export_tables = tables or SEED_TABLES
+
+    duck_con = duckdb.connect(str(src_path), read_only=True)
+
+    exported: Dict[str, Path] = {}
+    for table_name in export_tables:
+        out_file = dest_dir / f"{table_name}.parquet"
+        success = False
+        for query_target in [f"{dataset_schema}.{table_name}", f"{table_name}"]:
+            try:
+                duck_con.execute(
+                    f"COPY {query_target} TO '{out_file.as_posix()}' (FORMAT PARQUET, COMPRESSION ZSTD)"
+                )
+                exported[table_name] = out_file
+                success = True
+                if verbose:
+                    console.print(f"[green]✓[/green] Exported [bold]{out_file.name}[/bold]")
+                break
+            except Exception:
+                continue
+
+        if not success and verbose:
+            console.print(f"[yellow]⚠[/yellow] Skipping {table_name}: not found in DuckDB.")
+
+    duck_con.close()
+
+    if verbose:
+        console.print(
+            f"[bold green]✓ Successfully generated Parquet seed files at:[/bold green] {dest_dir}"
+        )
+
+    return dest_dir