structpick 0.1.0__py3-none-any.whl

structpick/__init__.py

@@ -0,0 +1,15 @@
+"""Rank experimental and predicted structures of a protein target for docking."""
+
+from structpick.models import AlphaFoldModel, Ligand, Structure, Target, is_additive
+from structpick.select import Filters, select_structures
+
+__all__ = [
+    "AlphaFoldModel",
+    "Filters",
+    "Ligand",
+    "Structure",
+    "Target",
+    "is_additive",
+    "select_structures",
+]
+__version__ = "0.1.0"

structpick/__main__.py

@@ -0,0 +1,3 @@
+from structpick.cli import main
+
+raise SystemExit(main())

structpick/api.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+import time
+from dataclasses import replace
+from typing import Any
+
+import httpx
+
+from structpick import __version__
+from structpick.models import AlphaFoldModel, Ligand, Structure, Target
+
+PDBE = "https://www.ebi.ac.uk/pdbe/api"
+ALPHAFOLD = "https://alphafold.ebi.ac.uk/api"
+UNIPROT = "https://rest.uniprot.org"
+
+RETRY_STATUS = {429, 500, 502, 503, 504}
+
+
+class TargetNotFoundError(LookupError):
+    pass
+
+
+class Client:
+    """Small wrapper around the UniProt, PDBe and AlphaFold DB REST APIs."""
+
+    def __init__(
+        self,
+        http: httpx.Client | None = None,
+        retries: int = 3,
+        backoff: float = 1.0,
+    ) -> None:
+        self._http = http or httpx.Client(
+            timeout=httpx.Timeout(30.0),
+            headers={"User-Agent": f"structpick/{__version__}"},
+            follow_redirects=True,
+        )
+        self._retries = retries
+        self._backoff = backoff
+
+    def __enter__(self) -> Client:
+        return self
+
+    def __exit__(self, *exc: object) -> None:
+        self.close()
+
+    def close(self) -> None:
+        self._http.close()
+
+    def _get(
+        self,
+        url: str,
+        params: dict[str, str] | None = None,
+        missing: frozenset[int] = frozenset({404}),
+    ) -> Any | None:
+        """GET JSON. Returns None for `missing` statuses; retries rate limits and server errors."""
+        for attempt in range(self._retries + 1):
+            try:
+                response = self._http.get(url, params=params)
+            except httpx.TransportError:
+                if attempt == self._retries:
+                    raise
+            else:
+                if response.status_code in missing:
+                    return None
+                if response.status_code not in RETRY_STATUS or attempt == self._retries:
+                    response.raise_for_status()
+                    return response.json()
+            time.sleep(self._backoff * 2**attempt)
+        raise AssertionError("unreachable")
+
+    def target(self, accession: str) -> Target:
+        data = self._get(
+            f"{UNIPROT}/uniprotkb/{accession}",
+            params={
+                "fields": "accession,protein_name,gene_names,organism_name,length",
+                "format": "json",
+            },
+            # UniProt answers 400 for strings that aren't valid accessions.
+            missing=frozenset({400, 404}),
+        )
+        if data is None:
+            raise TargetNotFoundError(f"UniProt has no entry {accession!r}")
+        description: dict[str, Any] = data.get("proteinDescription", {})
+        submissions: list[dict[str, Any]] = description.get("submissionNames", [])
+        name = (
+            description.get("recommendedName", {}).get("fullName", {}).get("value")
+            or (submissions[0].get("fullName", {}).get("value") if submissions else None)
+            or accession
+        )
+        genes = data.get("genes") or []
+        gene = genes[0].get("geneName", {}).get("value") if genes else None
+        return Target(
+            accession=data["primaryAccession"],
+            name=name,
+            gene=gene,
+            organism=data.get("organism", {}).get("scientificName", ""),
+            length=data.get("sequence", {}).get("length", 0),
+        )
+
+    def structures(self, accession: str) -> list[Structure]:
+        data = self._get(f"{PDBE}/mappings/best_structures/{accession}")
+        if not data:
+            return []
+        rows: list[dict[str, Any]] = data.get(accession) or next(iter(data.values()), [])
+        return [
+            Structure(
+                pdb_id=row["pdb_id"],
+                chain=row["chain_id"],
+                method=row.get("experimental_method", ""),
+                resolution=row.get("resolution"),
+                coverage=float(row.get("coverage", 0.0)),
+                unp_start=row.get("unp_start", 0),
+                unp_end=row.get("unp_end", 0),
+            )
+            for row in rows
+        ]
+
+    def ligands(self, pdb_id: str) -> tuple[Ligand, ...]:
+        data = self._get(f"{PDBE}/pdb/entry/ligand_monomers/{pdb_id}")
+        if not data:
+            return ()
+        return tuple(
+            Ligand(
+                code=row["chem_comp_id"], name=row.get("chem_comp_name", ""), chain=row["chain_id"]
+            )
+            for row in data.get(pdb_id, [])
+        )
+
+    def with_ligands(self, structures: list[Structure]) -> list[Structure]:
+        """Attach ligands, fetching each PDB entry once."""
+        cache: dict[str, tuple[Ligand, ...]] = {}
+        result = []
+        for structure in structures:
+            if structure.pdb_id not in cache:
+                cache[structure.pdb_id] = self.ligands(structure.pdb_id)
+            result.append(replace(structure, ligands=cache[structure.pdb_id]))
+        return result
+
+    def alphafold(self, accession: str) -> AlphaFoldModel | None:
+        data = self._get(f"{ALPHAFOLD}/prediction/{accession}")
+        if not data:
+            return None
+        row = next((r for r in data if r.get("uniprotAccession") == accession), data[0])
+        return AlphaFoldModel(
+            accession=row["uniprotAccession"],
+            version=row.get("latestVersion", 0),
+            mean_plddt=row.get("globalMetricValue", 0.0),
+            fraction_very_high=row.get("fractionPlddtVeryHigh", 0.0),
+            start=row.get("sequenceStart", 0),
+            end=row.get("sequenceEnd", 0),
+            cif_url=row["cifUrl"],
+            pdb_url=row["pdbUrl"],
+        )
+
+    def download(self, url: str) -> bytes:
+        response = self._http.get(url)
+        response.raise_for_status()
+        return response.content
+
+
+def entry_url(pdb_id: str, fmt: str = "cif") -> str:
+    return f"https://files.rcsb.org/download/{pdb_id.upper()}.{fmt}"

structpick/cli.py

@@ -0,0 +1,186 @@
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import sys
+from collections.abc import Sequence
+from dataclasses import asdict, replace
+from pathlib import Path
+from typing import TextIO
+
+import httpx
+
+from structpick import __version__
+from structpick.api import Client, TargetNotFoundError, entry_url
+from structpick.models import AlphaFoldModel, Structure, Target
+from structpick.select import Filters, select_structures
+
+COLUMNS = ["rank", "pdb_id", "chain", "method", "resolution", "coverage", "residues", "ligands"]
+
+
+def _row(rank: int, s: Structure) -> dict[str, str]:
+    return {
+        "rank": str(rank),
+        "pdb_id": s.pdb_id,
+        "chain": s.chain,
+        "method": s.method,
+        "resolution": f"{s.resolution:.2f}" if s.resolution is not None else "",
+        "coverage": f"{s.coverage:.0%}",
+        "residues": f"{s.unp_start}-{s.unp_end}",
+        "ligands": ",".join(sorted({lig.code for lig in s.bound_ligands})),
+    }
+
+
+def _print_table(
+    target: Target, rows: list[dict[str, str]], af: AlphaFoldModel | None, out: TextIO
+) -> None:
+    gene = f" ({target.gene})" if target.gene else ""
+    print(
+        f"{target.accession}{gene}: {target.name} | {target.organism} | {target.length} aa",
+        file=out,
+    )
+    if rows:
+        widths = {c: max(len(c), *(len(r[c]) for r in rows)) for c in COLUMNS}
+        print("  ".join(c.ljust(widths[c]) for c in COLUMNS).rstrip(), file=out)
+        for r in rows:
+            print("  ".join(r[c].ljust(widths[c]) for c in COLUMNS).rstrip(), file=out)
+    else:
+        print("No experimental structure matches the filters.", file=out)
+    if af is not None:
+        print(
+            f"AlphaFold: AF-{af.accession}-F1 v{af.version}, mean pLDDT {af.mean_plddt:.1f}, "
+            f"{af.fraction_very_high:.0%} of residues very high confidence",
+            file=out,
+        )
+
+
+def _filters(args: argparse.Namespace) -> Filters:
+    return Filters(
+        max_resolution=args.max_resolution,
+        min_coverage=args.min_coverage,
+        method=args.method,
+        ligand=args.ligand,
+        require_ligand=args.holo,
+    )
+
+
+def rank(
+    client: Client, accession: str, filters: Filters, top: int | None = None
+) -> list[Structure]:
+    """Filter on the cheap fields first, then look up ligands only for what's left."""
+    ligand_free = replace(filters, ligand=None, require_ligand=False)
+    ranked = select_structures(client.structures(accession), ligand_free)
+    if filters.ligand or filters.require_ligand:
+        ranked = select_structures(client.with_ligands(ranked), filters)
+        return ranked[:top]
+    return client.with_ligands(ranked[:top])
+
+
+def cmd_list(client: Client, args: argparse.Namespace, out: TextIO) -> int:
+    target = client.target(args.accession)
+    ranked = rank(client, target.accession, _filters(args), top=args.top)
+    af = client.alphafold(target.accession)
+    rows = [_row(i, s) for i, s in enumerate(ranked, 1)]
+
+    if args.format == "json":
+        payload = {
+            "target": asdict(target),
+            "structures": [
+                {**asdict(s), "bound_ligands": [lig.code for lig in s.bound_ligands]}
+                for s in ranked
+            ],
+            "alphafold": asdict(af) if af else None,
+        }
+        json.dump(payload, out, indent=2)
+        out.write("\n")
+    elif args.format == "csv":
+        writer = csv.DictWriter(out, fieldnames=COLUMNS, lineterminator="\n")
+        writer.writeheader()
+        writer.writerows(rows)
+    else:
+        _print_table(target, rows, af, out)
+    return 0
+
+
+def cmd_fetch(client: Client, args: argparse.Namespace, out: TextIO) -> int:
+    target = client.target(args.accession)
+    ranked = rank(client, target.accession, _filters(args), top=1)
+    args.output.mkdir(parents=True, exist_ok=True)
+
+    if ranked and not args.alphafold:
+        best = ranked[0]
+        path = args.output / f"{best.pdb_id}.cif"
+        path.write_bytes(client.download(entry_url(best.pdb_id)))
+        print(f"{path}  (PDB {best.pdb_id} chain {best.chain}, {best.method})", file=out)
+        return 0
+
+    af = client.alphafold(target.accession)
+    if af is None:
+        print(f"No structure or AlphaFold model found for {target.accession}.", file=sys.stderr)
+        return 1
+    path = args.output / f"AF-{af.accession}-F1-model_v{af.version}.cif"
+    path.write_bytes(client.download(af.cif_url))
+    print(f"{path}  (AlphaFold, mean pLDDT {af.mean_plddt:.1f})", file=out)
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="structpick",
+        description=(
+            "Rank PDB structures of a UniProt target for docking, with AlphaFold as fallback."
+        ),
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    common = argparse.ArgumentParser(add_help=False)
+    common.add_argument("accession", help="UniProt accession, e.g. P69905")
+    common.add_argument(
+        "--max-resolution", type=float, metavar="Å", help="drop entries worse than this"
+    )
+    common.add_argument("--min-coverage", type=float, default=0.0, metavar="FRACTION",
+                        help="minimum fraction of the UniProt sequence covered (0-1)")  # fmt: skip
+    common.add_argument("--method", help="xray, em, nmr (or the full PDBe method name)")
+    common.add_argument(
+        "--ligand", metavar="CODE", help="only entries with this ligand bound, e.g. HEM"
+    )
+    common.add_argument(
+        "--holo", action="store_true", help="only entries with any non-additive ligand"
+    )
+
+    p_list = sub.add_parser("list", parents=[common], help="show ranked structures")
+    p_list.add_argument("--top", type=int, default=10, help="how many to show (default 10)")
+    p_list.add_argument("--format", choices=["table", "csv", "json"], default="table")
+    p_list.set_defaults(func=cmd_list)
+
+    p_fetch = sub.add_parser("fetch", parents=[common], help="download the best structure as mmCIF")
+    p_fetch.add_argument("-o", "--output", type=Path, default=Path("."), help="output directory")
+    p_fetch.add_argument(
+        "--alphafold", action="store_true", help="download the AlphaFold model instead"
+    )
+    p_fetch.set_defaults(func=cmd_fetch)
+    return parser
+
+
+def main(
+    argv: Sequence[str] | None = None, client: Client | None = None, out: TextIO | None = None
+) -> int:
+    args = build_parser().parse_args(argv)
+    out = out or sys.stdout
+    try:
+        if client is not None:
+            return int(args.func(client, args, out))
+        with Client() as owned:
+            return int(args.func(owned, args, out))
+    except TargetNotFoundError as exc:
+        print(f"structpick: {exc}", file=sys.stderr)
+        return 2
+    except httpx.HTTPError as exc:
+        print(f"structpick: request failed: {exc}", file=sys.stderr)
+        return 3
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

structpick/models.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+# Things that show up in crystal structures but aren't what you'd dock against:
+# solvents, cryoprotectants, buffers, common ions and detergents.
+ADDITIVES = frozenset(
+    {
+        # solvents / cryoprotectants
+        "HOH", "DOD", "GOL", "EDO", "PEG", "PGE", "PG4", "1PE", "P6G", "MPD", "DMS", "IPA",
+        "EOH", "MOH", "ACT", "ACE", "FMT", "BME", "DTT", "TRS", "MES", "EPE", "CIT", "FLC",
+        "TAR", "MLI", "IMD", "BTB", "NHE", "CAPS", "PO4", "SO4", "NO3", "SCN", "AZI",
+        # ions
+        "NA", "K", "LI", "CL", "BR", "IOD", "F", "MG", "CA", "MN", "ZN", "FE", "FE2", "CO",
+        "NI", "CU", "CU1", "CD", "HG", "SR", "BA", "CS", "RB", "NH4", "UNX",
+        # detergents
+        "BOG", "LDA", "SDS", "LMT", "DDM", "OLC",
+    }
+)  # fmt: skip
+
+
+def is_additive(code: str) -> bool:
+    return code.upper() in ADDITIVES
+
+
+@dataclass(frozen=True)
+class Ligand:
+    code: str
+    name: str
+    chain: str
+
+
+@dataclass(frozen=True)
+class Structure:
+    pdb_id: str
+    chain: str
+    method: str
+    resolution: float | None
+    coverage: float
+    unp_start: int
+    unp_end: int
+    ligands: tuple[Ligand, ...] = field(default=())
+
+    @property
+    def bound_ligands(self) -> tuple[Ligand, ...]:
+        """Ligands in this chain that aren't crystallisation additives or ions."""
+        return tuple(
+            lig for lig in self.ligands if lig.chain == self.chain and not is_additive(lig.code)
+        )
+
+
+@dataclass(frozen=True)
+class AlphaFoldModel:
+    accession: str
+    version: int
+    mean_plddt: float
+    fraction_very_high: float
+    start: int
+    end: int
+    cif_url: str
+    pdb_url: str
+
+
+@dataclass(frozen=True)
+class Target:
+    accession: str
+    name: str
+    gene: str | None
+    organism: str
+    length: int

structpick/select.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from collections.abc import Iterable
+from dataclasses import dataclass
+
+from structpick.models import ADDITIVES, Structure, is_additive
+
+__all__ = ["ADDITIVES", "Filters", "is_additive", "rank_key", "select_structures"]
+
+
+METHOD_ALIASES = {
+    "xray": "x-ray diffraction",
+    "em": "electron microscopy",
+    "nmr": "solution nmr",
+}
+
+
+@dataclass(frozen=True)
+class Filters:
+    max_resolution: float | None = None
+    min_coverage: float = 0.0
+    method: str | None = None
+    ligand: str | None = None
+    require_ligand: bool = False
+
+
+def _method_matches(structure: Structure, method: str) -> bool:
+    wanted = METHOD_ALIASES.get(method.lower(), method.lower())
+    return structure.method.lower() == wanted
+
+
+def _keep(structure: Structure, filters: Filters) -> bool:
+    if filters.method and not _method_matches(structure, filters.method):
+        return False
+    if structure.coverage < filters.min_coverage:
+        return False
+    if filters.max_resolution is not None and (
+        structure.resolution is None or structure.resolution > filters.max_resolution
+    ):
+        return False
+    bound = {lig.code.upper() for lig in structure.bound_ligands}
+    if filters.require_ligand and not bound:
+        return False
+    return not (filters.ligand and filters.ligand.upper() not in bound)
+
+
+def rank_key(structure: Structure) -> tuple[bool, float, float, str, str]:
+    """Coverage first (in 10% steps, so 99% and 100% tie), then resolution.
+
+    Entries without a resolution (NMR) go last.
+    """
+    no_resolution = structure.resolution is None
+    resolution = structure.resolution if structure.resolution is not None else 0.0
+    return (
+        no_resolution,
+        -round(structure.coverage, 1),
+        resolution,
+        structure.pdb_id,
+        structure.chain,
+    )
+
+
+def select_structures(
+    structures: Iterable[Structure], filters: Filters | None = None
+) -> list[Structure]:
+    filters = filters or Filters()
+    return sorted((s for s in structures if _keep(s, filters)), key=rank_key)

structpick-0.1.0.dist-info/METADATA

@@ -0,0 +1,132 @@
+Metadata-Version: 2.5
+Name: structpick
+Version: 0.1.0
+Summary: Pick the best protein structure for docking: ranks PDB entries for a UniProt target, flags bound ligands and falls back to AlphaFold.
+Project-URL: Homepage, https://github.com/felipsoliveira/structpick
+Project-URL: Issues, https://github.com/felipsoliveira/structpick/issues
+Author: Luís Felipe de Oliveira
+License-Expression: MIT
+License-File: LICENSE
+Keywords: alphafold,bioinformatics,docking,drug-discovery,pdb,structural-biology,uniprot
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Description-Content-Type: text/markdown
+
+# structpick
+
+[![tests](https://github.com/felipsoliveira/structpick/actions/workflows/tests.yml/badge.svg)](https://github.com/felipsoliveira/structpick/actions/workflows/tests.yml)
+[![PyPI](https://img.shields.io/pypi/v/structpick)](https://pypi.org/project/structpick/)
+[![Python](https://img.shields.io/pypi/pyversions/structpick)](https://pypi.org/project/structpick/)
+
+Pick a protein structure to dock against.
+
+Given a UniProt accession, `structpick` lists the experimental structures from the PDB ranked by sequence coverage and resolution, shows which ones have a real ligand bound (ignoring glycerol, sulfate, ions and other crystallisation leftovers) and reports the AlphaFold model as a fallback. It's the first step of most structure-based drug design projects, and usually it means clicking through a dozen PDB pages.
+
+```console
+$ structpick list Q27743 --holo --max-resolution 2.0 --top 5
+Q27743: L-lactate dehydrogenase | Plasmodium falciparum (isolate CDC / Honduras) | 316 aa
+rank  pdb_id  chain  method             resolution  coverage  residues  ligands
+1     4plz    A      X-ray diffraction  1.05        100%      1-316     NAI,OXM
+2     1t2d    A      X-ray diffraction  1.10        100%      1-316     NAD,OXL
+3     2a94    A      X-ray diffraction  1.50        100%      2-316     AP0
+4     1t24    A      X-ray diffraction  1.70        100%      1-316     NAD,OXQ
+5     1u4o    A      X-ray diffraction  1.70        100%      2-316     NDD
+AlphaFold: AF-Q27743-F1 v6, mean pLDDT 97.4, 98% of residues very high confidence
+```
+
+Looking for a structure of EGFR with erlotinib (`AQ4`) bound:
+
+```console
+$ structpick list P00533 --method xray --ligand AQ4 --top 3
+P00533 (EGFR): Epidermal growth factor receptor | Homo sapiens | 1210 aa
+rank  pdb_id  chain  method             resolution  coverage  residues  ligands
+1     1m17    A      X-ray diffraction  2.60        28%       695-1022  AQ4
+2     4hjo    A      X-ray diffraction  2.75        28%       696-1022  AQ4
+AlphaFold: AF-P00533-F1 v6, mean pLDDT 75.9, 47% of residues very high confidence
+```
+
+## Install
+
+```bash
+pip install structpick
+```
+
+Python 3.10 or newer. The only dependency is [httpx](https://www.python-httpx.org/).
+
+## Usage
+
+```bash
+structpick list <accession> [filters] [--top N] [--format table|csv|json]
+structpick fetch <accession> [filters] [-o DIR] [--alphafold]
+```
+
+| Option | Meaning |
+|---|---|
+| `--max-resolution 2.0` | drop entries worse than 2.0 Å (also drops NMR, which has no resolution) |
+| `--min-coverage 0.8` | keep chains covering at least 80% of the UniProt sequence |
+| `--method xray` | `xray`, `em`, `nmr` or the full PDBe method name |
+| `--ligand HEM` | only chains with this ligand bound |
+| `--holo` | only chains with any ligand that isn't an additive or ion |
+
+`fetch` downloads the best match as mmCIF from RCSB. If nothing matches the filters, or with `--alphafold`, it downloads the AlphaFold model instead.
+
+`--format csv` and `--format json` are meant for scripts and notebooks:
+
+```bash
+structpick list P00533 --holo --format csv > egfr_structures.csv
+```
+
+### From Python
+
+```python
+from structpick import Filters, select_structures
+from structpick.api import Client
+
+with Client() as client:
+    structures = client.with_ligands(client.structures("P00533"))
+    best = select_structures(structures, Filters(max_resolution=2.5, require_ligand=True))
+    for s in best[:3]:
+        print(s.pdb_id, s.chain, s.resolution, [lig.code for lig in s.bound_ligands])
+```
+
+## How ranking works
+
+1. **Coverage**, compared in 10% steps, so a chain covering 99% and one covering 100% count as equal.
+2. **Resolution**, best first. Entries without a resolution (NMR) go last.
+
+Ligands only count if they sit on the same chain and aren't in the [additive list](src/structpick/models.py) (water, glycerol, ethylene glycol, PEG, sulfate, phosphate, common buffers, ions, detergents). Metal ions are on that list too, so check catalytic metals yourself when they matter.
+
+## Data sources
+
+- [UniProt REST API](https://rest.uniprot.org) for the target name, gene and length
+- [PDBe best structures](https://www.ebi.ac.uk/pdbe/api/doc/sifts.html) (SIFTS mappings) for chain coverage, method and resolution
+- [PDBe ligand monomers](https://www.ebi.ac.uk/pdbe/api/doc/pdb.html) for bound ligands
+- [AlphaFold Protein Structure Database](https://alphafold.ebi.ac.uk/api-docs) for predicted models
+
+Requests time out after 30 s and are retried with exponential backoff on 429 and 5xx responses. Ligands are only looked up for the chains left after the other filters, one request per PDB entry.
+
+## Development
+
+```bash
+git clone https://github.com/felipsoliveira/structpick
+cd structpick
+uv sync                   # or: pip install -e . pytest pytest-cov ruff mypy
+uv run pytest             # offline, uses recorded API responses in tests/fixtures
+uv run pytest -m network  # hits the real APIs
+uv run ruff check . && uv run mypy
+```
+
+## License
+
+MIT

structpick-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+structpick/__init__.py,sha256=v9iN15CHLe4zOvCMSxvOSldZfvoLZSvCI_POZ-iB73I,388
+structpick/__main__.py,sha256=wpqwM22i9cQhHCXX4PqAXu3e7-5FzPX07QCemFSrKvQ,58
+structpick/api.py,sha256=CmCHc0mhQSIu5Q8co1TjQ73W0AJ6W59RPbgugxVozUM,5785
+structpick/cli.py,sha256=-Aq7wm8p0WKApYQm6hYL_GSxMCAhDm6_svk7CaoOzps,7012
+structpick/models.py,sha256=ccpE0wbtpyWCL4WK9T00JbclXnv08MBtUD5kRlOx65Q,1825
+structpick/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+structpick/select.py,sha256=RP90VD7aeSQCXUz_mO8MEmZbVItFyQdTIkLc4y7JLgw,2067
+structpick-0.1.0.dist-info/METADATA,sha256=CXGTVhuQl--BikPr33FQUUJlpIyIF54lqx_3SKNGPEA,6083
+structpick-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+structpick-0.1.0.dist-info/entry_points.txt,sha256=nCFdZiYLQ8WFJOqHAXbv-cEKfMI7RHhC5JjCsmuImLU,51
+structpick-0.1.0.dist-info/licenses/LICENSE,sha256=J95RrHtdu6mePrURHCupySJNkJQDz0r6FCNeEMJ1F-U,1081
+structpick-0.1.0.dist-info/RECORD,,

structpick-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

structpick-0.1.0.dist-info/entry_points.txt

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

structpick-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Luís Felipe de Oliveira
+
+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.