flybase-cli 0.1.2__py3-none-any.whl

flybase_cli/semantics.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+
+COLUMN_DESCRIPTION_HINTS: dict[str, str] = {
+    "record_id": "Primary row identifier for this table.",
+    "parent_record_id": "Parent record identifier from a nested JSON source row.",
+    "parent_ordinal": "Ordinal position of the direct parent row within a repeated list.",
+    "ordinal": "Ordinal position within a repeated list.",
+    "value": "Scalar value from a repeated JSON list.",
+    "payload_json": "Full raw JSON payload for the source record.",
+    "fbgn_id": "FlyBase gene identifier.",
+    "primary_fbgn": "FlyBase gene identifier alias.",
+    "flybase_fbgn": "FlyBase gene identifier alias.",
+    "fbtr_id": "FlyBase transcript identifier.",
+    "primary_fbtr": "FlyBase transcript identifier alias.",
+    "flybase_fbtr": "FlyBase transcript identifier alias.",
+    "fbpp_id": "FlyBase protein identifier.",
+    "primary_fbpp": "FlyBase protein identifier alias.",
+    "flybase_fbpp": "FlyBase protein identifier alias.",
+    "annotation_id": "Genome annotation identifier.",
+    "feature_id": "Feature identifier from GFF or GTF annotations.",
+    "feature_name": "Feature symbol or display name.",
+    "gene_symbol": "Gene symbol.",
+    "symbol": "Feature symbol.",
+    "seqid": "Sequence or chromosome identifier.",
+    "start": "Genomic start coordinate.",
+    "end": "Genomic end coordinate.",
+    "strand": "Genomic strand.",
+    "summary": "Free-text summary field.",
+}
+
+RELATIONSHIP_GROUPS: dict[str, dict[str, object]] = {
+    "fbgn": {
+        "aliases": ("fbgn_id", "primary_fbgn", "flybase_fbgn"),
+        "kind": "id-alias",
+        "label": "FlyBase fbgn",
+    },
+    "fbtr": {
+        "aliases": ("fbtr_id", "primary_fbtr", "flybase_fbtr", "transcript_id"),
+        "kind": "id-alias",
+        "label": "FlyBase fbtr/transcript",
+    },
+    "fbpp": {
+        "aliases": ("fbpp_id", "primary_fbpp", "flybase_fbpp"),
+        "kind": "id-alias",
+        "label": "FlyBase fbpp",
+    },
+    "publication": {
+        "aliases": ("fbrf", "fbrf_id", "reference_id", "publication_id", "pmid"),
+        "kind": "shared-id",
+        "label": "publication",
+    },
+    "annotation": {
+        "aliases": ("annotation_id", "feature_id"),
+        "kind": "shared-id",
+        "label": "annotation",
+    },
+}
+
+
+def describe_column_name(column_name: str) -> str:
+    hinted = COLUMN_DESCRIPTION_HINTS.get(column_name)
+    if hinted is not None:
+        return hinted
+    lowered = column_name.lower()
+    if lowered.endswith("_json"):
+        return "Raw JSON payload for this nested structure."
+    if lowered.endswith("_id") or lowered.endswith("id"):
+        return "Identifier column."
+    if "summary" in lowered or "description" in lowered:
+        return "Free-text description or summary field."
+    if lowered.endswith("symbol") or lowered == "symbol":
+        return "Symbol or short label."
+    if lowered in {"startposition", "endposition"}:
+        return "Genomic coordinate from a nested JSON location record."
+    return ""
+
+
+def infer_table_tags(table_name: str, source_path: str, columns: list[str]) -> list[str]:
+    name_blob = " ".join([table_name, source_path]).lower()
+    lowered_columns = {column.lower() for column in columns}
+    tags: set[str] = set()
+
+    if any(alias in lowered_columns for alias in RELATIONSHIP_GROUPS["fbgn"]["aliases"]) or {
+        "gene_symbol",
+        "symbol",
+    } & lowered_columns:
+        tags.add("gene")
+    if any(alias in lowered_columns for alias in RELATIONSHIP_GROUPS["fbtr"]["aliases"]):
+        tags.add("transcript")
+    if any(alias in lowered_columns for alias in RELATIONSHIP_GROUPS["fbpp"]["aliases"]):
+        tags.add("protein")
+    if any(alias in lowered_columns for alias in RELATIONSHIP_GROUPS["publication"]["aliases"]):
+        tags.add("publication")
+    if any(alias in lowered_columns for alias in RELATIONSHIP_GROUPS["annotation"]["aliases"]):
+        tags.add("annotation")
+    if {"seqid", "start", "end", "startposition", "endposition"} & lowered_columns:
+        tags.add("coordinates")
+    if "summary" in name_blob or "summary" in lowered_columns:
+        tags.add("summary")
+    if "expression" in name_blob or "rpkm" in name_blob or "scrna" in name_blob:
+        tags.add("expression")
+    if "ortholog" in name_blob or "paralog" in name_blob:
+        tags.add("orthology")
+    if "interaction" in name_blob:
+        tags.add("interaction")
+    if "publication" in name_blob or "reference" in name_blob:
+        tags.add("reference")
+    if "payload_json" in lowered_columns:
+        tags.add("json")
+    if "parent_record_id" in lowered_columns:
+        tags.add("nested")
+
+    return sorted(tags)

flybase_cli/syncing.py

@@ -0,0 +1,254 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from .config import SyncPreset
+from .core import build_manifest, filter_manifest, sync_manifest, write_json
+from .loaders import is_ingestable
+
+
+RELEASE_TOKEN_PATTERNS: tuple[tuple[re.Pattern[str], str], ...] = (
+    (re.compile(r"FB\d{4}_\d{2}", flags=re.IGNORECASE), "FBRELEASE"),
+    (re.compile(r"fb_\d{4}_\d{2}", flags=re.IGNORECASE), "fb_release"),
+)
+
+
+def stable_manifest_key(path: str) -> str:
+    stable = path
+    for pattern, replacement in RELEASE_TOKEN_PATTERNS:
+        stable = pattern.sub(replacement, stable)
+    return stable.lower()
+
+
+def prefer_manifest_entry(entries: list[dict[str, str]]) -> dict[str, str]:
+    return sorted(entries, key=lambda item: item["path"])[0]
+
+
+def group_manifest_by_stable_key(
+    manifest: list[dict[str, str]],
+) -> dict[str, list[dict[str, str]]]:
+    grouped: dict[str, list[dict[str, str]]] = {}
+    for item in manifest:
+        grouped.setdefault(stable_manifest_key(item["path"]), []).append(item)
+    return grouped
+
+
+def merge_manifests(manifests: list[list[dict[str, str]]]) -> list[dict[str, str]]:
+    merged: dict[str, dict[str, str]] = {}
+    for manifest in manifests:
+        for item in manifest:
+            merged[item["path"]] = item
+    return sorted(merged.values(), key=lambda item: item["path"])
+
+
+def filter_ingestable_manifest(manifest: list[dict[str, str]]) -> list[dict[str, str]]:
+    return [item for item in manifest if is_ingestable(Path(item["path"]))]
+
+
+def preset_manifest(preset: SyncPreset, release: str) -> list[dict[str, str]]:
+    manifests: list[list[dict[str, str]]] = []
+    for selection in preset.selections:
+        manifests.append(
+            filter_manifest(
+                build_manifest(selection.prefix, release=release),
+                selection.includes,
+                selection.excludes,
+            )
+        )
+    return merge_manifests(manifests)
+
+
+def full_manifest(
+    *,
+    release: str,
+    prefix: str = "precomputed_files/",
+    include: list[str] | tuple[str, ...] = (),
+    exclude: list[str] | tuple[str, ...] = (),
+    ingestable_only: bool = True,
+) -> list[dict[str, str]]:
+    manifest = filter_manifest(
+        build_manifest(prefix, release=release),
+        include,
+        exclude,
+    )
+    if ingestable_only:
+        manifest = filter_ingestable_manifest(manifest)
+    return manifest
+
+
+def diff_manifests(
+    previous_manifest: list[dict[str, str]],
+    current_manifest: list[dict[str, str]],
+) -> dict[str, object]:
+    previous_by_key = group_manifest_by_stable_key(previous_manifest)
+    current_by_key = group_manifest_by_stable_key(current_manifest)
+    keys = sorted(set(previous_by_key) | set(current_by_key))
+
+    added: list[dict[str, object]] = []
+    removed: list[dict[str, object]] = []
+    updated: list[dict[str, object]] = []
+    unchanged: list[dict[str, object]] = []
+
+    for key in keys:
+        previous_entries = previous_by_key.get(key, [])
+        current_entries = current_by_key.get(key, [])
+        if not previous_entries:
+            added.extend({"stable_key": key, "to": item} for item in current_entries)
+            continue
+        if not current_entries:
+            removed.extend({"stable_key": key, "from": item} for item in previous_entries)
+            continue
+
+        previous_entry = prefer_manifest_entry(previous_entries)
+        current_entry = prefer_manifest_entry(current_entries)
+        if previous_entry["path"] == current_entry["path"] and previous_entry["url"] == current_entry["url"]:
+            unchanged.append({"stable_key": key, "item": current_entry})
+            continue
+        updated.append(
+            {
+                "stable_key": key,
+                "from": previous_entry,
+                "to": current_entry,
+            }
+        )
+
+    return {
+        "added": added,
+        "removed": removed,
+        "updated": updated,
+        "unchanged": unchanged,
+        "added_count": len(added),
+        "removed_count": len(removed),
+        "updated_count": len(updated),
+        "unchanged_count": len(unchanged),
+    }
+
+
+def build_release_diff(
+    *,
+    prefix: str,
+    from_release: str,
+    to_release: str,
+    include: list[str] | tuple[str, ...] = (),
+    exclude: list[str] | tuple[str, ...] = (),
+) -> dict[str, object]:
+    previous_manifest = filter_manifest(
+        build_manifest(prefix, release=from_release),
+        include,
+        exclude,
+    )
+    current_manifest = filter_manifest(
+        build_manifest(prefix, release=to_release),
+        include,
+        exclude,
+    )
+    return {
+        "prefix": prefix,
+        "from_release": from_release,
+        "to_release": to_release,
+        "previous_manifest_count": len(previous_manifest),
+        "current_manifest_count": len(current_manifest),
+        **diff_manifests(previous_manifest, current_manifest),
+    }
+
+
+def build_preset_release_diff(
+    *,
+    preset: SyncPreset,
+    from_release: str,
+    to_release: str,
+) -> dict[str, object]:
+    previous_manifest = preset_manifest(preset, release=from_release)
+    current_manifest = preset_manifest(preset, release=to_release)
+    return {
+        "preset": preset.name,
+        "description": preset.description,
+        "prefixes": list(preset.prefixes),
+        "from_release": from_release,
+        "to_release": to_release,
+        "previous_manifest_count": len(previous_manifest),
+        "current_manifest_count": len(current_manifest),
+        **diff_manifests(previous_manifest, current_manifest),
+    }
+
+
+def incremental_manifest(diff: dict[str, object]) -> list[dict[str, str]]:
+    selected = [item["to"] for item in diff["added"]]
+    selected.extend(item["to"] for item in diff["updated"])
+    return sorted(selected, key=lambda item: item["path"])
+
+
+def sync_incremental_preset(
+    *,
+    preset: SyncPreset,
+    root: Path,
+    db_path: Path,
+    manifest_path: Path,
+    diff_path: Path | None,
+    from_release: str,
+    to_release: str,
+    force: bool = False,
+    no_header: bool = False,
+) -> dict[str, object]:
+    previous_manifest = preset_manifest(preset, release=from_release)
+    current_manifest = preset_manifest(preset, release=to_release)
+    diff = diff_manifests(previous_manifest, current_manifest)
+    selected_manifest = incremental_manifest(diff)
+    if diff_path is not None:
+        write_json(diff_path, diff)
+    summary = sync_manifest(
+        selected_manifest,
+        root=root,
+        db_path=db_path,
+        manifest_path=manifest_path,
+        force=force,
+        no_header=no_header,
+    )
+    return {
+        "preset": preset.name,
+        "description": preset.description,
+        "from_release": from_release,
+        "to_release": to_release,
+        "incremental_file_count": len(selected_manifest),
+        "diff_path": str(diff_path) if diff_path is not None else None,
+        **diff,
+        **summary,
+    }
+
+
+def sync_full_release(
+    *,
+    root: Path,
+    db_path: Path,
+    manifest_path: Path,
+    release: str,
+    prefix: str = "precomputed_files/",
+    include: list[str] | tuple[str, ...] = (),
+    exclude: list[str] | tuple[str, ...] = (),
+    ingestable_only: bool = True,
+    force: bool = False,
+    no_header: bool = False,
+) -> dict[str, object]:
+    manifest = full_manifest(
+        release=release,
+        prefix=prefix,
+        include=include,
+        exclude=exclude,
+        ingestable_only=ingestable_only,
+    )
+    summary = sync_manifest(
+        manifest,
+        root=root,
+        db_path=db_path,
+        manifest_path=manifest_path,
+        force=force,
+        no_header=no_header,
+    )
+    return {
+        "mode": "full-sync",
+        "release": release,
+        "prefix": prefix,
+        "ingestable_only": ingestable_only,
+        **summary,
+    }

flybase_cli/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.2"

flybase_cli-0.1.2.dist-info/METADATA

@@ -0,0 +1,244 @@
+Metadata-Version: 2.4
+Name: flybase-cli
+Version: 0.1.2
+Summary: FlyBase sync/query helper for agents.
+License-Expression: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# FlyBase local sync/query
+
+Use FlyBase bulk files for agent workloads. Live API: helper only.
+
+## Why
+
+- `https://api.flybase.org/api/v1.0/` exists.
+- some endpoints return useful JSON now, eg `domain/FBgn0001250`, `sequence/id/FBgn0001250`.
+- some plausible endpoints return empty body today.
+- bulk bucket + release files: better for repeatable agent queries.
+
+## Current surfaces checked
+
+- release bucket: `https://s3ftp.flybase.org/releases/current/`
+- precomputed files: `https://s3ftp.flybase.org/releases/current/precomputed_files/`
+- Postgres dump: `https://s3ftp.flybase.org/releases/current/psql/FB2026_01.sql.gz`
+- API root: `https://api.flybase.org/api/v1.0/`
+- batch download: `https://flybase.org/batchdownload`
+
+## Layout
+
+- `src/flybase_cli/`: package code
+- `tests/`: stdlib `unittest`
+- `flybase_cli.py`: thin repo-root shim
+- `pyproject.toml`: package metadata / console entrypoint
+
+## CLI
+
+```bash
+python3 flybase_cli.py presets
+
+python3 flybase_cli.py sync gene-core
+
+python3 flybase_cli.py sync gene-core --release FB2026_01
+
+python3 flybase_cli.py sync gene-knowledge --release FB2026_01
+
+python3 flybase_cli.py full-sync --release FB2026_01
+
+python3 flybase_cli.py full-sync \
+  --release FB2026_01 \
+  --include 'best_gene_summary|entity_publication'
+
+python3 flybase_cli.py sync-incremental \
+  gene-knowledge \
+  --from-release FB2025_06 \
+  --release FB2026_01
+
+python3 flybase_cli.py release-diff \
+  --preset gene-knowledge \
+  --from-release FB2025_06 \
+  --to-release FB2026_01
+
+python3 flybase_cli.py genomes --release FB2026_01
+
+python3 flybase_cli.py sync-genome \
+  --release FB2026_01 \
+  --genome dmel_r6.67 \
+  --section fasta \
+  --asset mirna
+
+python3 flybase_cli.py genome-presets
+
+python3 flybase_cli.py sync-genome \
+  --release FB2026_01 \
+  --genome dmel_r6.67 \
+  --preset mirna-fasta
+
+PYTHONPATH=src python3 -m flybase_cli sync gene-expression
+
+python3 flybase_cli.py manifest \
+  --url https://s3ftp.flybase.org/genomes/Drosophila_melanogaster/dmel_r6.67_FB2026_01/fasta/ \
+  --include 'miRNA'
+
+python3 flybase_cli.py sync-url \
+  --url https://s3ftp.flybase.org/genomes/Drosophila_melanogaster/dmel_r6.67_FB2026_01/fasta/ \
+  --include 'miRNA'
+
+python3 flybase_cli.py ingest \
+  data/flybase/precomputed_files/genes/best_gene_summary_fb_2026_01.tsv.gz \
+  data/flybase/precomputed_files/genes/fbgn_fbtr_fbpp_fb_2026_01.tsv.gz \
+  data/flybase/precomputed_files/genes/fbgn_annotation_ID_fb_2026_01.tsv.gz
+
+python3 flybase_cli.py tables --columns
+
+python3 flybase_cli.py describe --sample-values 2
+python3 flybase_cli.py schema-export --sample-values 1
+python3 flybase_cli.py query-plan --sample-values 1 --limit 5
+python3 flybase_cli.py query-run --template-name gene-summary-by-fbgn --param fbgn_id=FBgn0002121
+
+python3 flybase_cli.py fts-build
+
+python3 flybase_cli.py search 'memory formation'
+
+python3 flybase_cli.py pg-load --release FB2026_01
+
+python3 flybase_cli.py sql \
+  "select * from fb_best_gene_summary_fb_2026_01 limit 5"
+
+python3 flybase_cli.py sql \
+  "select s.fbgn_id, s.gene_symbol, a.annotation_id, p.flybase_fbtr, p.flybase_fbpp \
+   from fb_best_gene_summary_fb_2026_01 s \
+   join fb_fbgn_annotation_id_fb_2026_01 a on a.primary_fbgn = s.fbgn_id \
+   left join fb_fbgn_fbtr_fbpp_fb_2026_01 p on p.flybase_fbgn = s.fbgn_id \
+   limit 5"
+
+python3 flybase_cli.py api domain/FBgn0001250
+```
+
+## Sync presets
+
+- `gene-core`: summaries + FBgn/FBtr/FBpp + annotation IDs + SO annotations
+- `gene-expression`: curated/high-throughput/scRNA expression slices
+- `references`: publication/link tables
+- `gene-knowledge`: core gene facts + representative publications + orthology tables
+- `orthology`: ortholog, paralog, and disease-association tables
+- `interactions`: gene- and allele-level interaction tables
+
+## Full sync
+
+- `full-sync` crawls an entire release prefix, default `precomputed_files/`
+- default behavior: download only files the current loaders can ingest into SQLite
+- use `--all-files` if you want non-ingestable release artifacts too
+- use `--include` / `--exclude` to stage a narrower smoke or partial warehouse
+- default manifest path: `data/flybase/manifests/<release>/full-sync.json`
+
+## Discovery
+
+- `genomes --release FB2026_01` lists genome builds linked from that FlyBase release
+- `sync-url` turns a crawlable FlyBase directory URL into a one-step local sync
+- `sync-genome` resolves a release/build pair into the right genome-section URL automatically
+- `genome-presets` lists reusable genome asset sync recipes
+
+## Genome sync
+
+- sections: `fasta`, `gff`, `gtf`, `dna`, `chado-xml`
+- asset shortcuts include `mirna`, `transcript`, `translation`, `gene`, `chromosome`, `cds`, `ncrna`, `gff`, `gtf`
+- presets include `mirna-fasta`, `transcript-fasta`, `translation-fasta`, `gene-fasta`, `chromosome-fasta`, `ncrna-fasta`, `gff-all`, `gtf-all`
+- use `--include`/`--exclude` for narrower file selection on top of the asset preset
+
+## Ingest formats
+
+- delimited: `tsv`, `csv`, gzipped variants
+- sequence: `fasta`, `fa`, `fna`, `faa`, gzipped variants
+- annotation: `gff`, `gff3`, `gtf`, gzipped variants
+- JSON: `json`, `json.gz`
+
+## JSON ingest
+
+- top-level scalar JSON fields become queryable SQLite columns
+- one nested dict level is flattened, eg `gene.symbol` -> `gene_symbol`
+- repeated top-level lists become child tables, eg `symbolSynonyms` -> `<table>_symbolsynonyms`
+- repeated lists nested inside child dict rows become descendant tables, eg `genomeLocations[].exons[]` -> `<table>_genomelocations_exons`
+- full source record remains in `payload_json`
+
+Example:
+
+```bash
+python3 flybase_cli.py sql \
+  "select record_id, symbol, gene_geneId from fb_ncrna_genes_fb_2026_01 limit 5"
+
+python3 flybase_cli.py sql \
+  "select parent_record_id, ordinal, value \
+   from fb_ncrna_genes_fb_2026_01_symbolsynonyms \
+   limit 5"
+
+python3 flybase_cli.py sql \
+  "select parent_record_id, parent_ordinal, ordinal, startPosition, endPosition \
+   from fb_ncrna_genes_fb_2026_01_genomelocations_exons \
+   limit 5"
+```
+
+## Search
+
+- `fts-build` creates a local SQLite FTS5 index from ingested tables
+- `search` queries that index without calling the live FlyBase API
+- record ids prefer stable FlyBase-like columns such as `fbgn_id`, `primary_fbgn`, `flybase_fbtr`
+
+## Metadata
+
+- `describe` summarizes ingested tables with row counts, source paths, semantic tags, columns, and representative non-empty values
+- `schema-export` writes the same metadata to a deterministic JSON artifact beside the SQLite DB, eg `FB2026_01.schema.json`
+- `schema-export` also includes inferred `relationships` for nested child tables and common FlyBase ID joins
+- `schema-export` also emits `semantic_summary` for table/entity tag coverage
+- `schema-export` also emits ready-to-run `query_templates`
+- `query-plan` prints starter SQL without the larger schema payload
+- `query-plan` now includes named biological templates such as `gene-summary-by-fbgn`, `transcript-protein-links`, `publications-for-gene`, and coordinate lookups when matching tables exist
+- `query-run` selects one template and executes it with parameter values
+- useful first step before writing ad hoc SQL or building agent query plans
+
+Example:
+
+```bash
+python3 flybase_cli.py schema-export \
+  --db data/flybase/FB2026_01.sqlite \
+  --sample-values 1
+
+python3 flybase_cli.py query-plan \
+  --db data/flybase/FB2026_01.sqlite \
+  --sample-values 1 \
+  --limit 5
+
+python3 flybase_cli.py query-run \
+  --db data/flybase/FB2026_01.sqlite \
+  --template-name gene-summary-by-fbgn \
+  --param fbgn_id=FBgn0002121
+```
+
+## Notes
+
+- nested JSON child tables keep lineage columns like `parent_record_id`, `parent_ordinal`, `ordinal`.
+- many FlyBase files start with `##` metadata lines; loader skips those.
+- `sync` writes a preset manifest under `data/flybase/manifests/<release>/`.
+- `full-sync` is the broadest offline path for release bulk data without going through the full Postgres dump.
+- `sync --release FB2026_01` defaults to `data/flybase/FB2026_01.sqlite` to avoid cross-release mixing.
+- `sync-incremental` uses stable manifest keys so release-renamed files still land in `updated` instead of noisy add/remove pairs.
+- `release-diff` compares releases either by raw prefix or by curated multi-prefix preset.
+- `manifest --url` lets you crawl non-`releases/` FlyBase directories such as genome FASTA/GFF trees.
+- `sync-url` is the shortest path for genome assets once you know the directory URL.
+- `sync-genome` is the shortest path when you know the FlyBase release + genome build label.
+- `sync-genome --preset ...` is the preferred path for common genome asset pulls.
+- some FlyBase `.gff.gz` assets are tar-wrapped gzip archives; loader handles that transparently.
+- `sql` and `query-run` shape results as record-oriented JSON with summary metadata for agent chaining.
+- `pg-load` stages the full Postgres import script for `releases/<release>/psql/<release>.sql.gz`.
+- `pg-load --execute` runs the staged script when `createdb` and `psql` are installed locally.
+- SQLite keeps setup minimal; switch to DuckDB/Postgres if you want bigger joins/faster scans.
+- if you only need a few IDs, FlyBase Batch Download may be simpler than syncing files.
+- use `--no-header` for files whose first non-comment row is data, not column names.
+
+## Tests
+
+```bash
+python3 -m unittest discover -s tests
+```

flybase_cli-0.1.2.dist-info/RECORD

@@ -0,0 +1,18 @@
+flybase_cli/__init__.py,sha256=lEw53vLD-DrNuj5MFPyP9jpSSwFtyNOEhQ0hM5TPJjc,90
+flybase_cli/__main__.py,sha256=PSQ4rpL0dG6f-qH4N7H-gD9igQkdHzH4yVZDcW8lfZo,80
+flybase_cli/cli.py,sha256=05xJ2O9WQD3fNAlZDzdNxAeAH1ZXdbPJexbo3ArvJHE,25338
+flybase_cli/config.py,sha256=9arWRL_7Hw3mWjKjn_nR7j7j9EGnJKzytyyy0wAtFRI,7620
+flybase_cli/core.py,sha256=ID2p3ZHfEXh2twuEiOFOT7QBuZzJv4ln-w9oTL2DNdo,21681
+flybase_cli/loaders.py,sha256=8ll0lJ3dHMRhRX3oCjE8_XRSP1-wcxzdf_4ckhElVvc,18833
+flybase_cli/postgres.py,sha256=5TVLQj3kZwdCboG_oq1tbKdSAKhhSm4726YJLiDpxlI,2731
+flybase_cli/querying.py,sha256=x9R-R6XitCYkVJpPHtwhdrOYXLP2uTUbkS3iKUcTRK4,4816
+flybase_cli/schema.py,sha256=1-40-ep1cEKoDWw7-9nA_-euIWRR_9c4E9hHcNl9Yf8,24055
+flybase_cli/semantics.py,sha256=SpixB9nPNYBSWRgm6WMcXBkrYSbKxFo-rX4hw2NRBiQ,4649
+flybase_cli/syncing.py,sha256=Qa7lGtKd-O6jrnNS3OPcbHHYHRr8CvHm7G4P32lVZbQ,7783
+flybase_cli/version.py,sha256=YvuYzWnKtqBb-IqG8HAu-nhIYAsgj9Vmc_b9o7vO-js,22
+flybase_cli-0.1.2.dist-info/licenses/LICENSE,sha256=pOm_AKDa_IHzuMyjTQlSC46C0WZiYTDhQXkmlkSk6cI,1080
+flybase_cli-0.1.2.dist-info/METADATA,sha256=6TnyXJI8WMpCezR1ngYrE0L3AhaOJ1ezlHhTvO6Lso4,9577
+flybase_cli-0.1.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+flybase_cli-0.1.2.dist-info/entry_points.txt,sha256=UL7hpwro7lPQv5gu3MNehvdDcLfy2zoPqBM81rQK6Tg,53
+flybase_cli-0.1.2.dist-info/top_level.txt,sha256=QbB-Gk-A6obyDd9fkFs2Njv6zB9k7OWTBLtKW-xsP7Q,12
+flybase_cli-0.1.2.dist-info/RECORD,,

flybase_cli-0.1.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

flybase_cli-0.1.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+flybase-cli = flybase_cli.cli:main

flybase_cli-0.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Gustavo Madeira Santana
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

flybase_cli-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+flybase_cli