From d039d2507d3fc84fc9b64b2b8e9c63e2e74dfaf0 Mon Sep 17 00:00:00 2001 From: Jason Stajich Date: Sat, 3 Oct 2026 12:55:16 -0700 Subject: [PATCH 1/3] docs+config: README rewrite; NCBI e-mail from env or config file, no default - README: goals, workflow diagrams, supported lineages, curation process with links, layout, quickstart (verified on GCF_001638985.1), usage, validation and limits, authors, citation. - NCBI identity: $MATPREDICT_NCBI_EMAIL / $MATPREDICT_NCBI_API_KEY, else the [ncbi] table of ~/.config/matpredict/config.toml ($MATPREDICT_CONFIG, $XDG_CONFIG_HOME). No default address; one warning when unset. Requests send tool=MATPredict. - HTTP cache key leaves out email/api_key/tool; pre-change entries (full URL with the old default e-mail) are found and copied forward, so the existing cache stays valid (checked on 7 of 8 sampled taxids). - pyproject version 0.6.0; CHANGELOG entries for 0.6.0 and Unreleased. 998 tests pass (11 new). Co-Authored-By: Claude Opus 5.5 --- CHANGELOG.md | 21 ++ README.md | 377 ++++++++++++++++++++++++++++- pyproject.toml | 2 +- src/MATPredict/config.py | 54 ++++- src/MATPredict/db/http_cache.py | 48 +++- src/MATPredict/db/ncbi_client.py | 8 +- src/MATPredict/db/taxonomy.py | 5 +- tests/db/test_http_cache.py | 38 +++ tests/test_config_ncbi_identity.py | 65 +++++ 9 files changed, 601 insertions(+), 17 deletions(-) create mode 100644 tests/test_config_ncbi_identity.py diff --git a/CHANGELOG.md b/CHANGELOG.md index bab62516..c5b1e210 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,27 @@ All notable changes to MATPredict. Versions follow [semantic versioning](https:/ release tags may carry a clade suffix naming the lineage whose infrastructure that release completed. +## [Unreleased] + +### Changed +- No default NCBI e-mail. The address comes from `$MATPREDICT_NCBI_EMAIL` or the + `[ncbi]` table of `~/.config/matpredict/config.toml` (`$MATPREDICT_CONFIG`, + `$XDG_CONFIG_HOME`). Without one, requests carry no e-mail and one warning is + logged. Requests now send `tool=MATPredict`. +- The NCBI response cache key leaves out `email`, `api_key` and `tool`. Entries + cached under the old full-URL key are still found and copied forward. +- README rewritten: goals, workflow, curation process, quickstart, usage, + validation, citation. + +## [0.6.0] — 2026-10-03 — `v0.6.0` + +Post-#9 work merged as PR #10: confidence and tier rules, the V3 polish cap, +the flank-carried rule, `not_searched` routing, the MAT-gene gate, the P1 +paralog class, deterministic classifier builds, scope-only families, +`idiomorph_class`, the regression check, new curated records, and held-out +validation (LCG 536/621, Jena 61/64, Zygo 23/23). See the `v0.6.0` tag message +and `analysis/INDEX.md`. + ## [0.5.0] — 2026-09-20 — `v0.5.0-mucoromycota` Mucoromycota detection becomes usable end to end: idiomorph calling works, the diff --git a/README.md b/README.md index a613a57b..d6e80089 100644 --- a/README.md +++ b/README.md @@ -1,10 +1,375 @@ -# MATPredict: prediction of MAT loci in fungi +# MATPredict -Framework: -Develop curated set of model MAT locus representation for differnet taxonomic groups. +Find and type the mating-type (MAT) loci of fungi in genome assemblies. -Use translated searches to identify key loci and flanking genes. Classify MAT type by typical naming scheme for the group. +MATPredict searches a genome assembly with a curated reference database of MAT +loci. It reports where each locus is, which genes it carries, and which +idiomorph or mating type it is (for example Plus/Minus, MAT1-1/MAT1-2, HD/PR +alleles). Every reference record traces to a publication or a validated +deposit, and every call reports the evidence behind it. -Extract the locus region, genes, and provide these as a standardized report along with figures and tables. +Current release: [`v0.6.0`](https://github.com/stajichlab/MATPredict/releases/tag/v0.6.0). +Changes: [CHANGELOG.md](CHANGELOG.md). -Visualize synteny of the genome regions across sets of species. +## Contents + +- [Project goals](#project-goals) +- [Workflow](#workflow) +- [Supported lineages](#supported-lineages) +- [Curation process](#curation-process) +- [Repository layout](#repository-layout) +- [Quickstart](#quickstart) +- [Usage](#usage) +- [Validation and known limits](#validation-and-known-limits) +- [Authors](#authors) +- [Citation](#citation) +- [License](#license) + +## Project goals + +1. **Curated reference loci.** Develop a curated set of model MAT loci for + different taxonomic groups, one record per strain and idiomorph, with + provenance for every gene. +2. **Detection.** Use translated searches to find the key MAT genes and their + flanking genes in new genome assemblies, annotated or not. +3. **Typing.** Classify each locus by the mating-type naming scheme of its group + (for example Plus/Minus, MAT1-1/MAT1-2, HD/PR alleles), and report when the + evidence is not enough to decide. +4. **Standard reports.** Extract the locus region and its genes, and report them + in a standard format with figures and tables. Report uncalled genomes with a + reason, and two idiomorphs in one genome as a flag for review. +5. **Synteny.** Visualize the synteny of MAT regions across sets of species. +6. **Scale.** Run on thousands of genomes (for example the full BFD fungal + genome collection) on a SLURM cluster. + +## Workflow + +``` + genome assembly (FASTA) [+ proteins] [+ NCBI taxid] + │ + ▼ + ┌──────────────────────────────────────────────────────────────────────┐ + │ 1. ROUTE taxid lineage ──► curated families in db// │ + │ order.yml. No match ──► phylum fallback, or │ + │ "not_searched". --phylum forces one phylum. │ + ├──────────────────────────────────────────────────────────────────────┤ + │ 2. SEARCH tblastn (genome) / diamond (proteome) with the │ + │ reference proteins: core MAT genes + flanking genes │ + ├──────────────────────────────────────────────────────────────────────┤ + │ 3. CLUSTER hits ──► candidate loci per contig (lineage gap rules) │ + ├──────────────────────────────────────────────────────────────────────┤ + │ 4. POLISH exonerate / miniprot gene models on a sliced window │ + │ (at most 6 loci per family) │ + ├──────────────────────────────────────────────────────────────────────┤ + │ 5. GATE modelled-gene bar, fraction floor, MAT-gene gate, │ + │ flank-carried rule, paralog class, CAAX check │ + ├──────────────────────────────────────────────────────────────────────┤ + │ 6. TYPE idiomorph from gene content, or profile-HMM classifier │ + │ (Mucoromycota sexP/sexM); margin and confidence tier │ + └──────────────────────────────────────────────────────────────────────┘ + │ + ▼ + detection_report.yaml detected_loci.gff3 [detected_loci.fasta] + (calls, evidence, withheld loci, uncalled reason, two-idiomorph flag) +``` + +The reference database feeds steps 1, 2 and 6: + +``` + literature / GenBank deposit + │ propose (PMID/DOI + source text required) + ▼ + db/candidates/ ──► automated validation ──► curator sign-off ──► db/// + (accession resolves, (accept or locus.gbk, locus.gff3, + translation matches, reject with proteins.faa, + taxonomy current) a reason) metadata.yaml + │ + classifiers, regression check ◄─┘ +``` + +## Supported lineages + +The curated families are defined in each phylum's `order.yml`. + +| Phylum | Families (`locus_name`) | Records | Definition | +|---|---|---|---| +| Ascomycota | MAT, PM, mat1, mat2, mat3, MATsc, MATyl, MTL, MATtub | 57 | [db/Ascomycota/order.yml](db/Ascomycota/order.yml) | +| Basidiomycota | HD, PR, MAT, Aalpha, Abeta, Balpha, Bbeta, aLocus, bLocus, rustHD, redPR, redHD, wallMAT | 73 | [db/Basidiomycota/order.yml](db/Basidiomycota/order.yml) | +| Mucoromycota | MAT (sexP / sexM, with an idiomorph classifier) | 20 | [db/Mucoromycota/order.yml](db/Mucoromycota/order.yml) | + +Other phyla (for example Mortierellomycota, Kickxellomycota, Chytridiomycota) +have no curated family. By default their genomes are reported as +`not_searched`. Use `--exhaustive` to search them with every family. + +## Curation process + +Each reference record is a folder `db////` with four +files. The record id is `___`. + +| File | Content | +|---|---| +| `metadata.yaml` | Taxonomy, organism, strain, mating type, locus coordinates, genes, evidence (tier, PMID/DOI, source text), validation result, curation history. Schema: [db/_schema/metadata.schema.yaml](db/_schema/metadata.schema.yaml) | +| `locus.gbk` | The locus as GenBank | +| `locus.gff3` | Gene features of the locus | +| `proteins.faa` | Reference proteins, tagged with gene name and role (`core_MAT`, `flanking_conserved`, `flanking_variable`) | + +Rules: + +1. **Evidence.** Tier 1: a published and experimentally validated locus. Tier 2: + genome-derived coordinates, admitted only with extra checks (domain evidence, + alignment to curated orthologs, or a gene tree) and a record of how the + locus was derived. A source never comes from inference alone. +2. **Proposal.** A candidate record goes to [db/candidates/](db/candidates/) with + a resolvable PMID/DOI or accession and the exact source text. +3. **Automated validation.** The accession must resolve, the translation must + match the cited protein, and the taxonomy must be current. +4. **Curator sign-off.** Only the curator moves a record to `accepted`. Rejected + candidates are kept with a reason. +5. **Regression check.** A change to a record, classifier or rule runs the + regression panel before sign-off. See [docs/regression-check.md](docs/regression-check.md). + +Related files: + +| Path | Purpose | +|---|---| +| [db/_schema/](db/_schema/) | JSON schemas for `metadata.yaml` and `order.yml`; DuckDB schema | +| [db/Mucoromycota/classifiers/](db/Mucoromycota/classifiers/) | Idiomorph classifier: HMMs, build manifest, paralog negatives | +| [db/suppress.txt](db/suppress.txt) | Genomes that must not be searched (for example amplicon-only deposits) | +| [db/taxon_overrides.tsv](db/taxon_overrides.tsv) | Genomes whose deposited name is likely wrong (used in held-out scoring only) | +| [db/assembly_zygosity.yml](db/assembly_zygosity.yml) | Lineages where an assembly can collapse a heterozygous locus | +| [ANNOTATION_ERRORS_FIXED_REPORT.md](ANNOTATION_ERRORS_FIXED_REPORT.md) | Errors found in deposits, annotations and literature, and what was done | +| [analysis/](analysis/) | One report per study, the curator's [decisions](analysis/decisions.md), [open questions](analysis/open-questions.md) and an [index](analysis/INDEX.md) | +| [docs/publication-notable-findings/](docs/publication-notable-findings/) | Findings with citeable evidence (new loci, homothallism candidates) | +| [docs/holdout-benchmark.md](docs/holdout-benchmark.md) | How held-out recall is measured | + +## Repository layout + +| Path | Content | +|---|---| +| [src/MATPredict/](src/MATPredict/) | The Python package and the `matpredict` CLI | +| [src/MATPredict/detect/](src/MATPredict/detect/) | Detection pipeline (routing, search, polish, gates, classifier, reports) | +| [src/MATPredict/db/](src/MATPredict/db/) | Database curation, validation, taxonomy, drawing | +| [db/](db/) | The curated reference database | +| [scripts/](scripts/) | SLURM runners, regression check, classifier build, record tools | +| [tests/](tests/) | pytest suite | +| [testset/](testset/) | Ground-truth coordinates and the regression panel list | +| [analysis/](analysis/) | Study reports and the decision log | +| [docs/](docs/) | Design notes, handoffs, benchmark and regression documentation | + +## Quickstart + +### Install + +MATPredict uses [pixi](https://pixi.sh) for its environment. The environment +holds Python, BLAST+, DIAMOND, miniprot, exonerate, Augustus, pyhmmer, MAFFT and +the drawing tools. Linux (x86-64) only. + +```bash +git clone https://github.com/stajichlab/MATPredict.git +cd MATPredict +pixi install +pixi run matpredict --help +``` + +### Run one genome + +This example uses *Phycomyces blakesleeanus* NRRL 1555 (NCBI taxid 4837). + +```bash +# 1. Download the assembly from NCBI +curl -L -o phybl.zip \ + "https://api.ncbi.nlm.nih.gov/datasets/v2/genome/accession/GCF_001638985.1/download?include_annotation_type=GENOME_FASTA" +unzip -q phybl.zip + +# 2. Detect MAT loci (run from the repository root, so db/ is found). +# Set your e-mail for NCBI first (see Configuration). +export MATPREDICT_NCBI_EMAIL=you@example.org +pixi run matpredict detect \ + --genome ncbi_dataset/data/GCF_001638985.1/GCF_001638985.1_Phybl2_genomic.fna \ + --taxid 4837 \ + --out-dir phybl_out +``` + +The run takes about 1.5 minutes on one CPU. `phybl_out/detection_report.yaml` +reports one locus: + +``` +Mucoromycota:MAT Minus high mat_locus NW_017265134.1:3978283-3991589 +genes: tptA, sexM, rnhA, algA +``` + +This genome is the source of a curated record +(`4837_nrrl1555_MAT_Minus`), so the example shows that the tool works. It is +not an independent test. + +## Usage + +### `matpredict detect` + +``` +matpredict detect --genome GENOME [--proteins PROTEINS] [--taxid TAXID] + --out-dir OUT_DIR [options] +``` + +| Option | Description | +|---|---| +| `--genome` | Genome assembly, FASTA (uncompressed) | +| `--proteins` | Optional proteome FASTA. Enables the DIAMOND fast path | +| `--taxid` | NCBI taxid. Selects the families for the lineage and the genetic code | +| `--phylum {Ascomycota,Basidiomycota,Mucoromycota}` | Search one phylum's families and skip taxid routing | +| `--exhaustive` | Search every family when no curated family covers the genome | +| `--genetic-code N` / `--genetic-code-map FILE` | Translation table, for one genome or per genome in a batch | +| `--max-polished-clusters-per-family N` | Polish cap (default 6; 0 = no cap) | +| `--min-hits N` | Distinct genes a cluster needs before polishing (default 2) | +| `--min-identity PCT` | Best-hit identity a cluster needs before polishing (default: none) | +| `--no-require-core-role` | Allow polishing of clusters without a core MAT gene hit | +| `--exclude-records IDS` | Withhold curated records (comma-separated) for leave-one-out tests | +| `--evidence-diagnostics FILE` | Write per-hit evidence as JSON lines | +| `--emit-cds-fasta` | Add CDS features with translations to the GFF3, and write `detected_loci.fasta` (full sequence of every contig with a call; can be large) | + +**Outputs** (in `--out-dir`): + +| File | Content | +|---|---| +| `detection_report.yaml` | Routing mode, genetic code, detected loci (family, contig, coordinates, idiomorph, confidence, `locus_class`, genes found and missing, classifier scores and margin, gene evidence), withheld loci with the reason, zygosity and two-idiomorph flags, families not detected | +| `detected_loci.gff3` | One gene feature per found or missing gene at each locus | +| `detected_loci.fasta` | Only with `--emit-cds-fasta` | + +**Routing modes** (`routing_mode` in the report): `lineage` (taxid matched a +family scope), `phylum_fallback`, `explicit_phylum` (`--phylum`), +`exhaustive`, `not_searched`. + +### `matpredict detect` helper commands + +| Command | Purpose | +|---|---| +| `matpredict detect rollout-summary --reports-dir DIR --out FILE` | Combine the reports of a batch into one summary | +| `matpredict detect suppress-filter --list FILE` | Remove suppressed genomes from an `ASMID...` list | +| `matpredict detect audit-scope` | Check every record's taxid against its family's `taxonomic_scope` | +| `matpredict detect benchmark` | Leave-one-out sensitivity/specificity benchmark | + +### Batch runs on SLURM + +| Script | Purpose | +|---|---| +| [scripts/run_clade_panel.slurm](scripts/run_clade_panel.slurm) | Run every BFD genome of one clade (`RANK=ORDER CLADE=Mucorales`). Per-genome timeout `GENOME_TIMEOUT` (default 3600 s) | +| [scripts/submit_binned_panel.py](scripts/submit_binned_panel.py) | Split a panel into genome-size bins with matching time limits | +| [scripts/run_detection_batch.slurm](scripts/run_detection_batch.slurm) | Generic batch runner | +| [scripts/run_regression_panel.sh](scripts/run_regression_panel.sh), [scripts/regression_check.py](scripts/regression_check.py) | Regression check: baseline and candidate on a fixed panel, then a diff | + +Run a batch from a frozen git worktree on shared storage, not from a tree you +are editing. Set `SRC` and `MATPREDICT_DB_ROOT` to that worktree, so the code +and the database come from the same commit. + +### `matpredict curate-db` + +| Command | Purpose | +|---|---| +| `propose --phylum P --record-file F` | Add a candidate record to `db/candidates/` | +| `validate --phylum P --record-id ID` | Run automated validation on a candidate | +| `accept --phylum P --order-or-family O --record-id ID` | Move a validated candidate into `db///` (curator only) | +| `reject --phylum P --record-id ID --reason TEXT` | Reject a candidate and keep the reason | +| `build-gff` / `backfill-gff` | Write `locus.gff3` from the record | +| `draw-locus` / `draw-synteny` | Draw one locus, or synteny across records (pyGenomeViz, clinker) | +| `build-duckdb [--out FILE]` | Build the DuckDB query cache from the record files | +| `release` | Stamp a database release on all records | + +### Configuration + +MATPredict looks up NCBI taxonomy (for `--taxid` routing and the genetic code) +through NCBI E-utilities. NCBI asks every caller to send an e-mail address. +MATPredict has no default address. Set yours once, in one of two ways: + +1. **Config file** (recommended). Create `~/.config/matpredict/config.toml`: + + ```toml + [ncbi] + email = "you@example.org" + # api_key = "your-ncbi-api-key" # optional: higher request rate + ``` + + MATPredict reads `$MATPREDICT_CONFIG` instead when it is set, or + `$XDG_CONFIG_HOME/matpredict/config.toml` when `XDG_CONFIG_HOME` is set. + +2. **Environment variables**, for example in `~/.bashrc` or a SLURM script: + + ```bash + export MATPREDICT_NCBI_EMAIL=you@example.org + export MATPREDICT_NCBI_API_KEY=your-ncbi-api-key # optional + ``` + +An environment variable wins over the config file. With no address set, the +tool still runs, sends no e-mail, and logs one warning. + +| Variable | Default | Purpose | +|---|---|---| +| `MATPREDICT_NCBI_EMAIL` | none | E-mail sent to NCBI E-utilities | +| `MATPREDICT_NCBI_API_KEY` | none | NCBI API key | +| `MATPREDICT_CONFIG` | `~/.config/matpredict/config.toml` | Config file path | +| `MATPREDICT_DB_ROOT` | `./db` | Reference database to use | +| `MATPREDICT_CACHE_DIR` | `./.matpredict_cache` | Cache for NCBI responses. The e-mail and API key are not part of the cache key, so users with different settings share one cache | + +### Tests + +```bash +pixi run -e test pytest -q +``` + +## Validation and known limits + +Measured results (details in [analysis/INDEX.md](analysis/INDEX.md)): + +| Test | Result | +|---|---| +| Zygomycete ground-truth set (23 genomes) | 23/23 loci and idiomorphs | +| Held-out LCG Mucoromycotina genomes (never used in curation) | 536/621 called | +| Held-out Jena Mucoromycotina genomes | 61/64 called | +| Idiomorph typing validation | 0/540 typed wrong | +| Pezizomycotina hold-out, order radius | 7/7 | +| Basidiomycota, 3,270 BFD genomes | Agaricomycotina 83.0%, Ustilaginomycotina 95.6%, Pucciniomycotina 13.2% called | + +Known limits (open items in [analysis/open-questions.md](analysis/open-questions.md)): + +- Only three phyla have curated families. +- Ascomycota outside the curated orders has had no full-scale run. A genome + far from every reference often fails the evidence bar, so an uncalled genome + is weak evidence that the genome has no MAT locus. +- Fragmented assemblies can split a locus or lose its flanking genes. +- In Mucoromycota, *Absidia* flanking genes are often off-scaffold, and the + gene order of the Lichtheimiaceae is not yet known. +- Basidiomycota pheromone-receptor calls that depend only on the CAAX motif are + marked unverified. +- A two-idiomorph result is a flag for review. It can come from homothallism, + a mixed culture or a duplication. + +## Authors + +- Jason E. Stajich — University of California, Riverside + ([jason.stajich@ucr.edu](mailto:jason.stajich@ucr.edu), + ORCID [0000-0002-7591-0020](https://orcid.org/0000-0002-7591-0020)) + +## Citation + +No paper describes MATPredict yet. Cite the software and the release you used. +The citation metadata is in [CITATION.cff](CITATION.cff); GitHub shows it under +"Cite this repository". + +> Stajich JE. MATPredict: MAT locus identification in Fungi. Version 0.6.0. +> https://github.com/stajichlab/MATPredict + +```bibtex +@software{matpredict, + author = {Stajich, Jason E.}, + title = {MATPredict: MAT locus identification in Fungi}, + version = {0.6.0}, + url = {https://github.com/stajichlab/MATPredict}, + year = {2026} +} +``` + +Please also cite the publications behind the reference records you rely on. +Each record's `metadata.yaml` lists its source (PMID/DOI or accession). + +## License + +MATPredict is released under the MIT License. See [LICENSE](LICENSE). diff --git a/pyproject.toml b/pyproject.toml index 54279952..c5d0ad3a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "MATPredict" -version = "0.5.0" +version = "0.6.0" description = "Fungal MAT locus annotator/classifier" authors = [{name = "Jason Stajich", email = "jason.stajich@ucr.edu"}] requires-python = ">=3.11" diff --git a/src/MATPredict/config.py b/src/MATPredict/config.py index 15bc6a16..99ae4e69 100644 --- a/src/MATPredict/config.py +++ b/src/MATPredict/config.py @@ -1,17 +1,66 @@ """Runtime configuration for MATPredict's db subcommands.""" from __future__ import annotations +import logging import os +import tomllib from dataclasses import dataclass from pathlib import Path +log = logging.getLogger(__name__) + +#: Config file read when $MATPREDICT_CONFIG is not set. +DEFAULT_CONFIG_PATH = Path("~/.config/matpredict/config.toml") + +_warned_no_email = False + + +def config_path() -> Path: + """$MATPREDICT_CONFIG, else $XDG_CONFIG_HOME/matpredict/config.toml, else + ~/.config/matpredict/config.toml.""" + explicit = os.environ.get("MATPREDICT_CONFIG") + if explicit: + return Path(explicit).expanduser() + xdg = os.environ.get("XDG_CONFIG_HOME") + if xdg: + return Path(xdg) / "matpredict" / "config.toml" + return DEFAULT_CONFIG_PATH.expanduser() + + +def _read_config_file() -> dict: + path = config_path() + if not path.is_file(): + return {} + with open(path, "rb") as fh: + return tomllib.load(fh) + + +def ncbi_identity() -> tuple[str | None, str | None]: + """(email, api_key) sent to NCBI E-utilities. + + Each value comes from the environment ($MATPREDICT_NCBI_EMAIL, + $MATPREDICT_NCBI_API_KEY) or, when that is unset, from the `[ncbi]` table of + the config file (`email`, `api_key`). There is no default: with no e-mail, + requests carry none and one warning is logged per process. + """ + global _warned_no_email + ncbi = (_read_config_file().get("ncbi") or {}) + email = os.environ.get("MATPREDICT_NCBI_EMAIL") or ncbi.get("email") or None + api_key = os.environ.get("MATPREDICT_NCBI_API_KEY") or ncbi.get("api_key") or None + if email is None and not _warned_no_email: + log.warning("no NCBI e-mail configured; set MATPREDICT_NCBI_EMAIL or add " + "[ncbi] email = \"...\" to %s (NCBI asks E-utilities users to " + "identify themselves)", config_path()) + _warned_no_email = True + return email, api_key + @dataclass(frozen=True) class MatpredictConfig: """Resolved configuration for a matpredict invocation.""" db_root: Path - ncbi_email: str + ncbi_email: str | None ncbi_api_key: str | None cache_dir: Path @@ -19,7 +68,6 @@ class MatpredictConfig: def from_env(cls, repo_root: Path) -> "MatpredictConfig": """Build config from the repo layout plus environment overrides.""" db_root = Path(os.environ.get("MATPREDICT_DB_ROOT", repo_root / "db")) - ncbi_email = os.environ.get("MATPREDICT_NCBI_EMAIL", "jason.stajich@ucr.edu") - ncbi_api_key = os.environ.get("MATPREDICT_NCBI_API_KEY") + ncbi_email, ncbi_api_key = ncbi_identity() cache_dir = Path(os.environ.get("MATPREDICT_CACHE_DIR", repo_root / ".matpredict_cache")) return cls(db_root=db_root, ncbi_email=ncbi_email, ncbi_api_key=ncbi_api_key, cache_dir=cache_dir) diff --git a/src/MATPredict/db/http_cache.py b/src/MATPredict/db/http_cache.py index 9177520f..5b692c20 100644 --- a/src/MATPredict/db/http_cache.py +++ b/src/MATPredict/db/http_cache.py @@ -7,6 +7,29 @@ from pathlib import Path from typing import Callable +#: Query parameters that identify the caller, not the request. They are left out +#: of the cache key, so the cache is shared whatever e-mail or API key is set. +IDENTITY_PARAMS = ("email", "api_key", "tool") + +#: Until 2026-10-03 the cache key was the full URL, and every NCBI URL ended with +#: this fixed default e-mail. A miss on the new key retries the old key once and +#: copies the entry forward, so caches built before then stay valid. The +#: address is used only to find old cache files; it is never sent to NCBI. +_LEGACY_EMAIL_SUFFIX = "&email=jason.stajich@ucr.edu" + + +def cache_key(url: str) -> str: + """`url` without the caller-identity query parameters (`IDENTITY_PARAMS`). + + Plain string edit, no re-encoding: every other byte of the URL is kept, so the + key of a URL with no identity parameters is the URL itself (as before 2026-10-03). + """ + base, sep, query = url.partition("?") + if not sep: + return url + kept = [item for item in query.split("&") if item.split("=", 1)[0] not in IDENTITY_PARAMS] + return f"{base}?{'&'.join(kept)}" if kept else base + @dataclass class CachedFetcher: @@ -15,10 +38,20 @@ class CachedFetcher: cache_dir: Path transport: Callable[[str], str] - def _cache_path(self, url: str) -> Path: - digest = hashlib.sha256(url.encode("utf-8")).hexdigest() + def _raw_path(self, key: str) -> Path: + digest = hashlib.sha256(key.encode("utf-8")).hexdigest() return self.cache_dir / f"{digest}.txt" + def _cache_path(self, url: str) -> Path: + return self._raw_path(cache_key(url)) + + def _legacy_path(self, url: str) -> Path | None: + """The pre-2026-10-03 cache file of an NCBI URL (see `_LEGACY_EMAIL_SUFFIX`).""" + key = cache_key(url) + if "eutils.ncbi.nlm.nih.gov" not in key: + return None + return self._raw_path(key + _LEGACY_EMAIL_SUFFIX) + def get(self, url: str) -> str: self.cache_dir.mkdir(parents=True, exist_ok=True) path = self._cache_path(url) @@ -26,11 +59,20 @@ def get(self, url: str) -> str: # a writer could see a truncated file and return '' as the answer. if path.exists() and path.stat().st_size > 0: return path.read_text() + legacy = self._legacy_path(url) + if legacy is not None and legacy.exists() and legacy.stat().st_size > 0: + body = legacy.read_text() + self._write(path, body) + return body body = self.transport(url) # Write to a unique temporary name, then rename into place: a rename # is atomic within a filesystem, so a concurrent reader (many detect # processes share one cache) sees nothing or the whole response. + self._write(path, body) + return body + + @staticmethod + def _write(path: Path, body: str) -> None: tmp = path.with_name(f".{path.name}.{os.getpid()}.tmp") tmp.write_text(body) os.replace(tmp, path) - return body diff --git a/src/MATPredict/db/ncbi_client.py b/src/MATPredict/db/ncbi_client.py index 4426c1d6..c224990b 100644 --- a/src/MATPredict/db/ncbi_client.py +++ b/src/MATPredict/db/ncbi_client.py @@ -58,13 +58,17 @@ class AccessionStatus: class NcbiClient: """Thin wrapper around NCBI E-utilities, backed by an injected CachedFetcher.""" - email: str + email: str | None api_key: str | None fetcher: CachedFetcher def _url(self, path: str, params: str) -> str: + """E-utilities URL. NCBI asks callers to send `tool` and `email`; the e-mail + is sent only when one is configured (see `MATPredict.config.ncbi_identity`). + The cache key leaves these out (`http_cache.IDENTITY_PARAMS`).""" + email_param = f"&email={self.email}" if self.email else "" key_param = f"&api_key={self.api_key}" if self.api_key else "" - return f"{_EUTILS_BASE}/{path}?{params}&email={self.email}{key_param}" + return f"{_EUTILS_BASE}/{path}?{params}&tool=MATPredict{email_param}{key_param}" def resolve_accession(self, accession: str) -> AccessionStatus: """Look up an accession's live/suppressed status and current version via esummary.""" diff --git a/src/MATPredict/db/taxonomy.py b/src/MATPredict/db/taxonomy.py index ffa4e00c..e04f670a 100644 --- a/src/MATPredict/db/taxonomy.py +++ b/src/MATPredict/db/taxonomy.py @@ -86,9 +86,10 @@ def _get_default_ncbi_client(): from MATPredict.db.http_cache import CachedFetcher from MATPredict.db.ncbi_client import NcbiClient + from MATPredict.config import ncbi_identity + cache_dir = Path(os.environ.get("MATPREDICT_CACHE_DIR", Path.cwd() / ".matpredict_cache")) - email = os.environ.get("MATPREDICT_NCBI_EMAIL", "jason.stajich@ucr.edu") - api_key = os.environ.get("MATPREDICT_NCBI_API_KEY") + email, api_key = ncbi_identity() fetcher = CachedFetcher(cache_dir=cache_dir, transport=_default_transport) _default_ncbi_client = NcbiClient(email=email, api_key=api_key, fetcher=fetcher) return _default_ncbi_client diff --git a/tests/db/test_http_cache.py b/tests/db/test_http_cache.py index ae3a4242..ac3e1a27 100644 --- a/tests/db/test_http_cache.py +++ b/tests/db/test_http_cache.py @@ -41,3 +41,41 @@ def test_a_write_leaves_no_temporary_file(tmp_path): fetcher = CachedFetcher(cache_dir=tmp_path, transport=lambda u: "body") fetcher.get("https://example.org/a") assert [p.name for p in tmp_path.iterdir()] == [fetcher._cache_path("https://example.org/a").name] + + +def test_the_cache_key_ignores_the_caller_identity(tmp_path): + """E-mail, API key and tool name identify the caller, not the request, so + one cache serves every user's configuration.""" + calls = [] + fetcher = CachedFetcher(cache_dir=tmp_path, transport=lambda u: calls.append(u) or "body") + base = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?db=taxonomy&id=4837&retmode=xml" + fetcher.get(base + "&tool=MATPredict&email=a@example.org") + fetcher.get(base + "&tool=MATPredict&email=b@example.org&api_key=XYZ") + fetcher.get(base + "&tool=MATPredict") + assert len(calls) == 1 + + +def test_cache_key_keeps_every_other_byte(): + from MATPredict.db.http_cache import cache_key + assert cache_key("https://x.org/a?db=n&id=A,B:1&email=e@x&strand=2") == "https://x.org/a?db=n&id=A,B:1&strand=2" + assert cache_key("https://x.org/a") == "https://x.org/a" + assert cache_key("https://x.org/a?email=e") == "https://x.org/a" + + +def test_an_old_cache_entry_is_found_and_copied_forward(tmp_path): + """Caches written before 2026-10-03 are keyed on the full URL, which ended + with the fixed default e-mail. They must still answer, with no request.""" + import hashlib + base = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?db=taxonomy&id=4837&retmode=xml" + old = tmp_path / (hashlib.sha256((base + "&email=jason.stajich@ucr.edu").encode()).hexdigest() + ".txt") + old.write_text("cached body") + calls = [] + fetcher = CachedFetcher(cache_dir=tmp_path, transport=lambda u: calls.append(u) or "fresh") + assert fetcher.get(base + "&tool=MATPredict&email=someone@example.org") == "cached body" + assert calls == [] + assert fetcher._cache_path(base).read_text() == "cached body" + + +def test_the_old_key_is_not_tried_for_other_hosts(tmp_path): + fetcher = CachedFetcher(cache_dir=tmp_path, transport=lambda u: "x") + assert fetcher._legacy_path("https://rest.uniprot.org/uniprotkb/P12345.fasta") is None diff --git a/tests/test_config_ncbi_identity.py b/tests/test_config_ncbi_identity.py new file mode 100644 index 00000000..6a714944 --- /dev/null +++ b/tests/test_config_ncbi_identity.py @@ -0,0 +1,65 @@ +"""NCBI identity: environment first, then the config file, and no default.""" +import logging + +import pytest + +import MATPredict.config as config +from MATPredict.db.http_cache import CachedFetcher +from MATPredict.db.ncbi_client import NcbiClient + + +@pytest.fixture(autouse=True) +def _clean_env(monkeypatch, tmp_path): + for v in ("MATPREDICT_NCBI_EMAIL", "MATPREDICT_NCBI_API_KEY", "MATPREDICT_CONFIG", "XDG_CONFIG_HOME"): + monkeypatch.delenv(v, raising=False) + monkeypatch.setenv("HOME", str(tmp_path / "home")) + monkeypatch.setattr(config, "_warned_no_email", False) + + +def test_no_default_email(caplog): + with caplog.at_level(logging.WARNING): + assert config.ncbi_identity() == (None, None) + assert "no NCBI e-mail configured" in caplog.text + + +def test_the_config_file_supplies_email_and_key(monkeypatch, tmp_path): + f = tmp_path / "c.toml" + f.write_text('[ncbi]\nemail = "file@example.org"\napi_key = "K1"\n') + monkeypatch.setenv("MATPREDICT_CONFIG", str(f)) + assert config.ncbi_identity() == ("file@example.org", "K1") + + +def test_the_default_config_path_is_under_home(tmp_path): + p = tmp_path / "home" / ".config" / "matpredict" / "config.toml" + p.parent.mkdir(parents=True) + p.write_text('[ncbi]\nemail = "home@example.org"\n') + assert config.ncbi_identity() == ("home@example.org", None) + + +def test_xdg_config_home_is_honoured(monkeypatch, tmp_path): + p = tmp_path / "xdg" / "matpredict" / "config.toml" + p.parent.mkdir(parents=True) + p.write_text('[ncbi]\nemail = "xdg@example.org"\n') + monkeypatch.setenv("XDG_CONFIG_HOME", str(tmp_path / "xdg")) + assert config.ncbi_identity()[0] == "xdg@example.org" + + +def test_the_environment_wins_over_the_file(monkeypatch, tmp_path): + f = tmp_path / "c.toml" + f.write_text('[ncbi]\nemail = "file@example.org"\napi_key = "K1"\n') + monkeypatch.setenv("MATPREDICT_CONFIG", str(f)) + monkeypatch.setenv("MATPREDICT_NCBI_EMAIL", "env@example.org") + assert config.ncbi_identity() == ("env@example.org", "K1") + + +def test_a_request_without_email_carries_none(tmp_path): + seen = [] + client = NcbiClient(email=None, api_key=None, + fetcher=CachedFetcher(cache_dir=tmp_path, transport=lambda u: seen.append(u) or "")) + client.fetcher.get(client._url("efetch.fcgi", "db=taxonomy&id=4837&retmode=xml")) + assert "email=" not in seen[0] and "tool=MATPredict" in seen[0] + + +def test_a_configured_email_is_sent(): + client = NcbiClient(email="me@example.org", api_key=None, fetcher=None) + assert "&email=me@example.org" in client._url("efetch.fcgi", "db=taxonomy&id=1") From cb3ccd55b0086fd4f595362b361fbea716fbcfd6 Mon Sep 17 00:00:00 2001 From: Jason Stajich Date: Sat, 3 Oct 2026 13:16:36 -0700 Subject: [PATCH 2/3] config: warn about a missing NCBI e-mail at the first request, not at start-up The CLI builds a config to list the --phylum choices, so the warning printed for --help and --version. NcbiClient now warns once, when it builds a URL without an e-mail. Co-Authored-By: Claude Opus 5.5 --- src/MATPredict/config.py | 14 ++------------ src/MATPredict/db/ncbi_client.py | 11 +++++++++++ tests/test_config_ncbi_identity.py | 15 ++++++++++++--- 3 files changed, 25 insertions(+), 15 deletions(-) diff --git a/src/MATPredict/config.py b/src/MATPredict/config.py index 99ae4e69..c910e1ac 100644 --- a/src/MATPredict/config.py +++ b/src/MATPredict/config.py @@ -1,19 +1,14 @@ """Runtime configuration for MATPredict's db subcommands.""" from __future__ import annotations -import logging import os import tomllib from dataclasses import dataclass from pathlib import Path -log = logging.getLogger(__name__) - #: Config file read when $MATPREDICT_CONFIG is not set. DEFAULT_CONFIG_PATH = Path("~/.config/matpredict/config.toml") -_warned_no_email = False - def config_path() -> Path: """$MATPREDICT_CONFIG, else $XDG_CONFIG_HOME/matpredict/config.toml, else @@ -41,17 +36,12 @@ def ncbi_identity() -> tuple[str | None, str | None]: Each value comes from the environment ($MATPREDICT_NCBI_EMAIL, $MATPREDICT_NCBI_API_KEY) or, when that is unset, from the `[ncbi]` table of the config file (`email`, `api_key`). There is no default: with no e-mail, - requests carry none and one warning is logged per process. + requests carry none, and `NcbiClient` logs one warning per process at the + first request (not at start-up, so `--help` and offline runs stay quiet). """ - global _warned_no_email ncbi = (_read_config_file().get("ncbi") or {}) email = os.environ.get("MATPREDICT_NCBI_EMAIL") or ncbi.get("email") or None api_key = os.environ.get("MATPREDICT_NCBI_API_KEY") or ncbi.get("api_key") or None - if email is None and not _warned_no_email: - log.warning("no NCBI e-mail configured; set MATPREDICT_NCBI_EMAIL or add " - "[ncbi] email = \"...\" to %s (NCBI asks E-utilities users to " - "identify themselves)", config_path()) - _warned_no_email = True return email, api_key diff --git a/src/MATPredict/db/ncbi_client.py b/src/MATPredict/db/ncbi_client.py index c224990b..a41fea2a 100644 --- a/src/MATPredict/db/ncbi_client.py +++ b/src/MATPredict/db/ncbi_client.py @@ -2,6 +2,7 @@ from __future__ import annotations import json +import logging import xml.etree.ElementTree as ET from dataclasses import dataclass from io import StringIO @@ -12,6 +13,9 @@ _EUTILS_BASE = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils" +log = logging.getLogger(__name__) +_warned_no_email = False + @dataclass(frozen=True) class CdsStructure: @@ -66,6 +70,13 @@ def _url(self, path: str, params: str) -> str: """E-utilities URL. NCBI asks callers to send `tool` and `email`; the e-mail is sent only when one is configured (see `MATPredict.config.ncbi_identity`). The cache key leaves these out (`http_cache.IDENTITY_PARAMS`).""" + global _warned_no_email + if not self.email and not _warned_no_email: + from MATPredict.config import config_path + log.warning("no NCBI e-mail configured; set MATPREDICT_NCBI_EMAIL or add " + "[ncbi] email = \"...\" to %s (NCBI asks E-utilities users to " + "identify themselves)", config_path()) + _warned_no_email = True email_param = f"&email={self.email}" if self.email else "" key_param = f"&api_key={self.api_key}" if self.api_key else "" return f"{_EUTILS_BASE}/{path}?{params}&tool=MATPredict{email_param}{key_param}" diff --git a/tests/test_config_ncbi_identity.py b/tests/test_config_ncbi_identity.py index 6a714944..479179c5 100644 --- a/tests/test_config_ncbi_identity.py +++ b/tests/test_config_ncbi_identity.py @@ -13,13 +13,22 @@ def _clean_env(monkeypatch, tmp_path): for v in ("MATPREDICT_NCBI_EMAIL", "MATPREDICT_NCBI_API_KEY", "MATPREDICT_CONFIG", "XDG_CONFIG_HOME"): monkeypatch.delenv(v, raising=False) monkeypatch.setenv("HOME", str(tmp_path / "home")) - monkeypatch.setattr(config, "_warned_no_email", False) + import MATPredict.db.ncbi_client as nc + monkeypatch.setattr(nc, "_warned_no_email", False) -def test_no_default_email(caplog): +def test_no_default_email_and_no_warning_at_lookup(caplog): with caplog.at_level(logging.WARNING): assert config.ncbi_identity() == (None, None) - assert "no NCBI e-mail configured" in caplog.text + assert caplog.text == "" + + +def test_the_first_request_without_email_warns_once(caplog): + client = NcbiClient(email=None, api_key=None, fetcher=None) + with caplog.at_level(logging.WARNING): + client._url("efetch.fcgi", "db=taxonomy&id=1") + client._url("efetch.fcgi", "db=taxonomy&id=2") + assert caplog.text.count("no NCBI e-mail configured") == 1 def test_the_config_file_supplies_email_and_key(monkeypatch, tmp_path): From 1871c28608b770346521d93ca57a40fa6fc142f4 Mon Sep 17 00:00:00 2001 From: Jason Stajich Date: Sat, 3 Oct 2026 13:16:57 -0700 Subject: [PATCH 3/3] build: commit pixi.lock; conda environment.yml; Dockerfile and GHCR release workflow - pixi.lock tracked (was git-ignored) so images and environments are reproducible. - environment.yml exported from pixi.toml for conda/mamba users. - Dockerfile: pixi 0.71.3 build stage installs the locked environment; Ubuntu 24.04 runtime carries the env, src/ and db/; ENTRYPOINT matpredict. - .github/workflows/docker.yml: PRs build + smoke-test (tools on PATH, pyhmmer and MATPredict import, --version, detect --help); v* tags, published releases and workflow_dispatch also push ghcr.io/stajichlab/matpredict (:version, :major.minor, :latest, :sha). - README: Docker, Apptainer and conda install sections. Locked install checked locally: all tools present, matpredict --version 0.6.0. Co-Authored-By: Claude Opus 5.5 --- .dockerignore | 11 + .github/workflows/docker.yml | 83 + .gitignore | 1 - CHANGELOG.md | 10 + Dockerfile | 34 + README.md | 31 + environment.yml | 22 + pixi.lock | 3659 ++++++++++++++++++++++++++++++++++ 8 files changed, 3850 insertions(+), 1 deletion(-) create mode 100644 .dockerignore create mode 100644 .github/workflows/docker.yml create mode 100644 Dockerfile create mode 100644 environment.yml create mode 100644 pixi.lock diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 00000000..548f50cd --- /dev/null +++ b/.dockerignore @@ -0,0 +1,11 @@ +# Only pixi.toml, pixi.lock, pyproject.toml, README.md, src/ and db/ go into the image. +* +!pixi.toml +!pixi.lock +!pyproject.toml +!README.md +!src/ +!db/ +**/__pycache__ +db/*.duckdb +db/candidates/ diff --git a/.github/workflows/docker.yml b/.github/workflows/docker.yml new file mode 100644 index 00000000..c6843032 --- /dev/null +++ b/.github/workflows/docker.yml @@ -0,0 +1,83 @@ +name: docker + +# Release images: ghcr.io/stajichlab/matpredict: and :latest. +# A v* tag or a published release builds and pushes; a pull request that touches +# the image inputs builds and smoke-tests without pushing; workflow_dispatch +# builds and pushes on demand. +on: + push: + tags: ["v*"] + release: + types: [published] + workflow_dispatch: + pull_request: + paths: + - Dockerfile + - .dockerignore + - pixi.toml + - pixi.lock + - pyproject.toml + - .github/workflows/docker.yml + +permissions: + contents: read + packages: write + +env: + IMAGE: ghcr.io/${{ github.repository_owner }}/matpredict + +jobs: + image: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - name: Image tags + id: meta + uses: docker/metadata-action@v5 + with: + images: ${{ env.IMAGE }} + tags: | + type=semver,pattern={{version}} + type=semver,pattern={{major}}.{{minor}} + type=raw,value=latest,enable=${{ startsWith(github.ref, 'refs/tags/v') || github.event_name == 'release' }} + type=ref,event=pr + type=sha,format=short + + - uses: docker/setup-buildx-action@v3 + + - name: Build (load locally for the smoke test) + uses: docker/build-push-action@v6 + with: + context: . + load: true + tags: matpredict:test + build-args: VERSION=${{ steps.meta.outputs.version }} + cache-from: type=gha + cache-to: type=gha,mode=max + + - name: Smoke test + run: | + docker run --rm matpredict:test --version + docker run --rm matpredict:test detect --help > /dev/null + docker run --rm --entrypoint /bin/bash matpredict:test /shell-hook.sh \ + bash -c 'for t in tblastn diamond miniprot exonerate mafft augustus taxonkit; do command -v $t > /dev/null || { echo "missing $t"; exit 1; }; done; python -c "import pyhmmer, MATPredict"' + + - name: Log in to GHCR + if: github.event_name != 'pull_request' + uses: docker/login-action@v3 + with: + registry: ghcr.io + username: ${{ github.actor }} + password: ${{ secrets.GITHUB_TOKEN }} + + - name: Push + if: github.event_name != 'pull_request' + uses: docker/build-push-action@v6 + with: + context: . + push: true + tags: ${{ steps.meta.outputs.tags }} + labels: ${{ steps.meta.outputs.labels }} + build-args: VERSION=${{ steps.meta.outputs.version }} + cache-from: type=gha diff --git a/.gitignore b/.gitignore index b7fce45d..bdbffcf7 100644 --- a/.gitignore +++ b/.gitignore @@ -3,7 +3,6 @@ .matpredict_cache/ __pycache__/ *.pyc -pixi.lock .pytest_cache/ .pixi/ db/*.duckdb diff --git a/CHANGELOG.md b/CHANGELOG.md index c5b1e210..5ae0f820 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -16,6 +16,16 @@ release completed. - README rewritten: goals, workflow, curation process, quickstart, usage, validation, citation. +### Added +- `pixi.lock` is now committed, so environments and images are reproducible. +- `environment.yml` for conda/mamba users (exported from `pixi.toml`). +- `Dockerfile` (pixi build stage, Ubuntu 24.04 runtime with the environment, + the package and `db/`). +- `.github/workflows/docker.yml`: builds and smoke-tests the image on pull + requests that touch the image inputs; on a `v*` tag, a published release or a + manual run it also pushes `ghcr.io/stajichlab/matpredict:` and + `:latest`. + ## [0.6.0] — 2026-10-03 — `v0.6.0` Post-#9 work merged as PR #10: confidence and tier rules, the V3 polish cap, diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..f25080e8 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,34 @@ +# MATPredict container image. +# Build stage: solve nothing, install the locked pixi environment (pixi.lock). +# Runtime stage: the environment, the package source and the curated database. +# +# docker build -t matpredict . +# docker run --rm -v "$PWD":/data -e MATPREDICT_NCBI_EMAIL=you@example.org \ +# matpredict detect --genome /data/genome.fna --taxid 4837 --out-dir /data/out + +FROM ghcr.io/prefix-dev/pixi:0.71.3-noble AS build +WORKDIR /app +COPY pixi.toml pixi.lock pyproject.toml README.md ./ +COPY src ./src +RUN pixi install --locked -e default \ + && pixi shell-hook -e default -s bash > /shell-hook.sh \ + && echo 'exec "$@"' >> /shell-hook.sh + +FROM ubuntu:24.04 AS runtime +ARG VERSION=dev +LABEL org.opencontainers.image.title="MATPredict" \ + org.opencontainers.image.description="Find and type fungal mating-type (MAT) loci in genome assemblies" \ + org.opencontainers.image.source="https://github.com/stajichlab/MATPredict" \ + org.opencontainers.image.version="${VERSION}" +# The environment keeps its build path (/app/.pixi/envs/default): conda +# packages and the editable MATPredict install record absolute paths. +COPY --from=build /app/.pixi/envs/default /app/.pixi/envs/default +COPY --from=build /shell-hook.sh /shell-hook.sh +COPY --from=build /app/src /app/src +COPY pyproject.toml README.md /app/ +COPY db /app/db +ENV MATPREDICT_DB_ROOT=/app/db \ + MATPREDICT_CACHE_DIR=/data/.matpredict_cache +WORKDIR /data +ENTRYPOINT ["/bin/bash", "/shell-hook.sh", "matpredict"] +CMD ["--help"] diff --git a/README.md b/README.md index d6e80089..03d7a5f2 100644 --- a/README.md +++ b/README.md @@ -171,6 +171,37 @@ pixi install pixi run matpredict --help ``` +### Other ways to install + +**Docker.** Each release publishes an image to the GitHub Container Registry. +The image holds the environment, the package and the curated database. + +```bash +docker pull ghcr.io/stajichlab/matpredict:latest # or a release version, : +docker run --rm -v "$PWD":/data -e MATPREDICT_NCBI_EMAIL=you@example.org \ + ghcr.io/stajichlab/matpredict:latest \ + detect --genome /data/genome.fna --taxid 4837 --out-dir /data/out +``` + +On an HPC system without Docker, use Apptainer/Singularity: + +```bash +apptainer pull matpredict.sif docker://ghcr.io/stajichlab/matpredict:latest +apptainer run matpredict.sif detect --genome genome.fna --taxid 4837 --out-dir out +``` + +**Conda / mamba.** [environment.yml](environment.yml) lists the same packages +as `pixi.toml` (exported with `pixi workspace export conda-environment`). Run +from the repository root, because it installs MATPredict from the checkout: + +```bash +mamba env create -f environment.yml +mamba activate matpredict +matpredict --help +``` + +The exact versions used for releases are in [pixi.lock](pixi.lock). + ### Run one genome This example uses *Phycomyces blakesleeanus* NRRL 1555 (NCBI taxid 4837). diff --git a/environment.yml b/environment.yml new file mode 100644 index 00000000..336da24e --- /dev/null +++ b/environment.yml @@ -0,0 +1,22 @@ +name: matpredict +channels: +- conda-forge +- bioconda +- nodefaults +dependencies: +- python >=3.11 +- pip * +- taxonkit * +- diamond * +- blast * +- miniprot * +- exonerate * +- augustus * +- clinker-py >=0.0.32,<0.0.33 +- pygenomeviz >=1.7.0,<2 +- pyhmmer >=0.12.3,<0.13 +- mafft >=7.526,<8 +- pip +- pip: + - -e . + diff --git a/pixi.lock b/pixi.lock new file mode 100644 index 00000000..735d1584 --- /dev/null +++ b/pixi.lock @@ -0,0 +1,3659 @@ +version: 7 +platforms: +- name: linux-64 + virtual-packages: + - __unix=0=0 + - __linux=4.18 + - __glibc=2.28 + - __archspec=0=x86_64 +environments: + default: + channels: + - url: https://conda.anaconda.org/conda-forge/ + - url: https://conda.anaconda.org/bioconda/ + indexes: + - https://pypi.org/simple + packages: + linux-64: + - conda: https://conda.anaconda.org/bioconda/linux-64/augustus-3.5.0-pl5321h5653ebf_10.conda + - conda: https://conda.anaconda.org/bioconda/linux-64/bamtools-2.5.3-he132191_0.tar.bz2 + - conda: https://conda.anaconda.org/bioconda/linux-64/blast-2.17.0-hb02a186_1.conda + - conda: https://conda.anaconda.org/bioconda/linux-64/cdbtools-0.99-h077b44d_12.tar.bz2 + - conda: https://conda.anaconda.org/bioconda/linux-64/diamond-2.2.8-he361c42_0.conda + - conda: https://conda.anaconda.org/bioconda/linux-64/entrez-direct-26.0-h1079eea_0.conda + - conda: https://conda.anaconda.org/bioconda/linux-64/exonerate-2.4.0-hf34a1b8_9.tar.bz2 + - conda: https://conda.anaconda.org/bioconda/linux-64/htslib-1.24-ha79157c_0.conda + - conda: https://conda.anaconda.org/bioconda/linux-64/miniprot-0.18-h577a1d6_0.tar.bz2 + - conda: https://conda.anaconda.org/bioconda/linux-64/ncbi-vdb-3.4.1-hd63eeec_0.conda + - conda: https://conda.anaconda.org/bioconda/linux-64/perl-io-compress-2.216-pl5321h503566f_0.conda + - conda: https://conda.anaconda.org/bioconda/linux-64/perl-json-xs-4.04-pl5321h9948957_0.conda + - conda: https://conda.anaconda.org/bioconda/linux-64/perl-list-moreutils-xs-0.430-pl5321h7b50bb2_5.tar.bz2 + - conda: https://conda.anaconda.org/bioconda/linux-64/pyhmmer-0.12.3-py313hd978853_0.conda + - conda: https://conda.anaconda.org/bioconda/linux-64/samtools-1.24-h9dcdb79_1.conda + - conda: https://conda.anaconda.org/bioconda/linux-64/taxonkit-0.20.0-h9ee0642_1.conda + - conda: https://conda.anaconda.org/bioconda/linux-64/ucsc-fatotwobit-482-hdc0a859_0.tar.bz2 + - conda: https://conda.anaconda.org/bioconda/linux-64/ucsc-twobitinfo-482-hdc0a859_0.tar.bz2 + - conda: https://conda.anaconda.org/bioconda/noarch/clinker-py-0.0.32-pyhdfd78af_0.conda + - conda: https://conda.anaconda.org/bioconda/noarch/gffutils-0.14-pyh106432d_0.conda + - conda: https://conda.anaconda.org/bioconda/noarch/perl-archive-tar-3.12-pl5321hdfd78af_0.conda + - conda: https://conda.anaconda.org/bioconda/noarch/perl-io-zlib-1.15-pl5321hdfd78af_1.tar.bz2 + - conda: https://conda.anaconda.org/bioconda/noarch/perl-json-4.11-pl5321hdfd78af_0.conda + - conda: https://conda.anaconda.org/bioconda/noarch/perl-list-moreutils-0.430-pl5321hdfd78af_0.tar.bz2 + - conda: https://conda.anaconda.org/bioconda/noarch/perl-parallel-forkmanager-2.04-pl5321hdfd78af_0.conda + - conda: https://conda.anaconda.org/bioconda/noarch/perl-types-serialiser-1.01-pl5321hdfd78af_0.tar.bz2 + - conda: https://conda.anaconda.org/bioconda/noarch/perl-yaml-1.30-pl5321hdfd78af_0.tar.bz2 + - conda: https://conda.anaconda.org/bioconda/noarch/pyfaidx-0.9.0.4-pyhdfd78af_0.conda + - conda: https://conda.anaconda.org/bioconda/noarch/pyvcf3-1.0.3-pyhdfd78af_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/biopython-1.88-py313h995f894_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/boost-cpp-1.85.0-h3c6214e_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-1.2.0-h505cf86_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-bin-1.2.0-h9908984_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_10.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.8-hebe6cf0_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/contourpy-1.4.0-py313h2551ef2_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/curl-8.21.0-hcf29cc6_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/fonttools-4.66.1-py313h6cd9899_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/freetype-2.14.3-ha770c72_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gawk-5.4.1-h0a3468a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/glib-2.90.0-h5e3c387_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/glib-tools-2.90.0-h3d503d9_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gmp-6.3.0-hfd2156b_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gsl-2.8-h3cd6761_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-75.1-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/jsoncpp-1.9.6-hf42df4d_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.3-h7cc23a3_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/kiwisolver-1.5.1-py313h2551ef2_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.22.2-hbc21106_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/lcms2-2.19.1-h9073bf1_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.46.1-default_hbd61a6d_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/lerc-4.2.0-hdb68285_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libamd-3.3.3-h456b2da_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libasprintf-0.25.1-h0e23cf9_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.11.0-11_h4a7cf45_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-1.85.0-h0ccab89_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-devel-1.85.0-h00ab1b0_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-headers-1.85.0-ha770c72_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlicommon-1.2.0-h39a168f_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlidec-1.2.0-ha411449_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlienc-1.2.0-h018ffa1_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libbtf-2.3.2-hf02c80a_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcamd-3.3.3-hf02c80a_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.11.0-11_h0358290_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libccolamd-3.3.4-hf02c80a_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcholmod-5.3.1-h9cf07ce_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcolamd-3.3.4-hf02c80a_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.21.0-hcf29cc6_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcxsparse-4.4.1-hf02c80a_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libdeflate-1.25-hd45a770_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20250104-pl5321h373387f_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-h280c20c_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.8.5-hd2095e1_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.7.0-h81df57d_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype-2.14.3-ha770c72_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype6-2.14.3-h5e6c136_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-16.2.0-ha9f2e26_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-16.2.0-h69a702a_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgettextpo-0.25.1-h0e23cf9_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-16.2.0-h69a702a_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-16.2.0-h6b99dfc_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.90.0-h569388d_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-16.2.0-he0feb66_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h0cb94f2_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libidn2-2.3.8-hfac485b_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libjpeg-turbo-3.2.0-hb03c661_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libklu-2.3.5-h95ff59c_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.11.0-11_h47877c9_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libldl-3.3.2-hf02c80a_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.3-hb03c661_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-devel-5.8.3-hb03c661_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb03c661_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.68.1-h74cf4be_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.34-pthreads_hf13c14d_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenssl-static-3.6.4-h7cc23a3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libparu-1.0.0-hc6afc67_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libpng-1.6.59-h922cc85_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libpython-3.13.15-hdc7f604_103_cp313.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/librbio-4.3.4-hf02c80a_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libspex-3.2.3-h9226d62_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libspqr-4.3.4-h23b7119_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.4-h0737f62_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.1-h6154650_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-16.2.0-h934c35e_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-16.2.0-hdf11a46_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsuitesparseconfig-7.10.1-h901830b_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.7.2-hcc2c06a_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libumfpack-6.3.5-h873dde6_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libunistring-0.9.10-h7f98852_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.4-hcfc3c73_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libwebp-base-1.6.0-hd42ef1d_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcb-1.17.0-hb83e432_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.38-h280c20c_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/lp_solve-5.5.2.11-hd590300_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/mafft-7.526-h4bc722e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-base-3.10.9-py313h683a580_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/metis-5.1.0-h86e3903_1008.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/mpfr-4.2.2-ha2cb11d_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/mysql-connector-c-6.1.11-h659d440_1008.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.5.3-py313hb5f73ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openjpeg-2.5.4-heb1ab33_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.4-h781a0a9_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre-8.45-h9c3ff4c_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.47-h8b3dc9c_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-5.32.1-10_h7cc23a3_perl5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-class-method-modifiers-2.13-pl5321ha770c72_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-compress-raw-bzip2-2.214-pl5321hda65f42_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-compress-raw-zlib-2.214-pl5321h4dac143_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-dbi-1.651-pl5321hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-encode-3.24-pl5321hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-inc-latest-0.500-pl5321ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-module-build-0.4234-pl5321ha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-moo-2.005004-pl5321ha770c72_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-pathtools-3.75-pl5321hb9d3cd8_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-role-tiny-2.002004-pl5321ha770c72_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-scalar-list-utils-1.70-pl5321hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-storable-3.15-pl5321hb9d3cd8_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-sub-quote-2.006006-pl5321ha770c72_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-test-fatal-0.016-pl5321ha770c72_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-try-tiny-0.31-pl5321ha770c72_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/pillow-12.3.0-py313h3b26573_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/psutil-7.2.2-py313hd42f317_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pthread-stubs-0.4-h7cc23a3_1004.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.13.15-hf47f18c_103_cp313.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/qhull-2020.2-h434a139_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-hd6e31c0_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.18.1-py313he2a5f1a_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/simplejson-4.2.0-py313h995f894_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/sqlite-3.53.4-h6e79ffa_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/suitesparse-7.10.1-h5b2951e_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tar-1.35-h3b78370_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h1df4ec4_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/wget-1.25.0-h653f8fd_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxau-1.0.12-h7cc23a3_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdmcp-1.1.5-h7cc23a3_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xz-5.8.3-ha02ee65_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xz-gpl-tools-5.8.3-ha02ee65_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xz-tools-5.8.3-hb03c661_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zlib-1.3.2-h25fd6f3_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zlib-ng-2.3.3-hce19668_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_7.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/argcomplete-3.7.2-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/argh-0.31.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.7.22-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cycler-0.12.1-pyhcf101f3_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/disjoint-set-0.8.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-9.0.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/munkres-1.1.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.3-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/perl-app-cpanminus-1.7048-pl5321hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/perl-carp-1.50-pl5321hd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/perl-common-sense-3.75-pl5321hd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/perl-constant-1.33-pl5321hd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/perl-exporter-5.74-pl5321hd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/perl-exporter-tiny-1.002002-pl5321hd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/perl-extutils-makemaker-7.70-pl5321hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/perl-file-path-2.18-pl5321hd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/perl-file-temp-0.2304-pl5321hd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/perl-file-which-1.24-pl5321hd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/perl-parent-0.243-pl5321hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-26.2.1-pyh145f28c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pygenomeviz-1.7.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pyparsing-3.3.3-pyh5ded981_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.13-9_cp313.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-84.0.0-pyh332efcf_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-4.1.0-pyhcf101f3_0.conda + - pypi: ./ + - pypi: https://files.pythonhosted.org/packages/0b/a7/71ac2cff56fec219ed242bb11b8efb69fcc4bec75db06fb7bfe35de520e6/certifi-2026.7.22-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/4b/85/41d27f234b82e47c167a5f6c0f62501dc0c640585ff4aba79e08a390336a/charset_normalizer-3.5.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl + - pypi: https://files.pythonhosted.org/packages/57/d7/fe978efc2ae50abe48eb7464668ea99f53c010c60aeebb7b35ad27f23661/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl + - pypi: https://files.pythonhosted.org/packages/58/a2/bb081bab032533a855d44de1d56f8e8426114ff1ba5d1f07a438a0a654f8/idna-3.20-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/69/90/f63fb5873511e014207a475e2bb4e8b2e570d655b00ac19a9a0ca0a385ee/jsonschema-4.26.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/70/21/61dd2876bbaa69cf77d7b5c620e52e8b25faae7096f4d2e4a812b52095d7/duckdb-1.5.6-cp313-cp313-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl + - pypi: https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl + - pypi: https://files.pythonhosted.org/packages/92/9d/c4e665119135114480843e7ab388fa94d8480650450e6f8e26b70d323a4c/urllib3-2.8.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl + test: + channels: + - url: https://conda.anaconda.org/conda-forge/ + - url: https://conda.anaconda.org/bioconda/ + indexes: + - https://pypi.org/simple + packages: + linux-64: + - conda: https://conda.anaconda.org/bioconda/linux-64/augustus-3.5.0-pl5321h5653ebf_10.conda + - conda: https://conda.anaconda.org/bioconda/linux-64/bamtools-2.5.3-he132191_0.tar.bz2 + - conda: https://conda.anaconda.org/bioconda/linux-64/blast-2.17.0-hb02a186_1.conda + - conda: https://conda.anaconda.org/bioconda/linux-64/cdbtools-0.99-h077b44d_12.tar.bz2 + - conda: https://conda.anaconda.org/bioconda/linux-64/diamond-2.2.8-he361c42_0.conda + - conda: https://conda.anaconda.org/bioconda/linux-64/entrez-direct-26.0-h1079eea_0.conda + - conda: https://conda.anaconda.org/bioconda/linux-64/exonerate-2.4.0-hf34a1b8_9.tar.bz2 + - conda: https://conda.anaconda.org/bioconda/linux-64/htslib-1.24-ha79157c_0.conda + - conda: https://conda.anaconda.org/bioconda/linux-64/miniprot-0.18-h577a1d6_0.tar.bz2 + - conda: https://conda.anaconda.org/bioconda/linux-64/ncbi-vdb-3.4.1-hd63eeec_0.conda + - conda: https://conda.anaconda.org/bioconda/linux-64/perl-io-compress-2.216-pl5321h503566f_0.conda + - conda: https://conda.anaconda.org/bioconda/linux-64/perl-json-xs-4.04-pl5321h9948957_0.conda + - conda: https://conda.anaconda.org/bioconda/linux-64/perl-list-moreutils-xs-0.430-pl5321h7b50bb2_5.tar.bz2 + - conda: https://conda.anaconda.org/bioconda/linux-64/pyhmmer-0.12.3-py313hd978853_0.conda + - conda: https://conda.anaconda.org/bioconda/linux-64/samtools-1.24-h9dcdb79_1.conda + - conda: https://conda.anaconda.org/bioconda/linux-64/taxonkit-0.20.0-h9ee0642_1.conda + - conda: https://conda.anaconda.org/bioconda/linux-64/ucsc-fatotwobit-482-hdc0a859_0.tar.bz2 + - conda: https://conda.anaconda.org/bioconda/linux-64/ucsc-twobitinfo-482-hdc0a859_0.tar.bz2 + - conda: https://conda.anaconda.org/bioconda/noarch/clinker-py-0.0.32-pyhdfd78af_0.conda + - conda: https://conda.anaconda.org/bioconda/noarch/gffutils-0.14-pyh106432d_0.conda + - conda: https://conda.anaconda.org/bioconda/noarch/perl-archive-tar-3.12-pl5321hdfd78af_0.conda + - conda: https://conda.anaconda.org/bioconda/noarch/perl-io-zlib-1.15-pl5321hdfd78af_1.tar.bz2 + - conda: https://conda.anaconda.org/bioconda/noarch/perl-json-4.11-pl5321hdfd78af_0.conda + - conda: https://conda.anaconda.org/bioconda/noarch/perl-list-moreutils-0.430-pl5321hdfd78af_0.tar.bz2 + - conda: https://conda.anaconda.org/bioconda/noarch/perl-parallel-forkmanager-2.04-pl5321hdfd78af_0.conda + - conda: https://conda.anaconda.org/bioconda/noarch/perl-types-serialiser-1.01-pl5321hdfd78af_0.tar.bz2 + - conda: https://conda.anaconda.org/bioconda/noarch/perl-yaml-1.30-pl5321hdfd78af_0.tar.bz2 + - conda: https://conda.anaconda.org/bioconda/noarch/pyfaidx-0.9.0.4-pyhdfd78af_0.conda + - conda: https://conda.anaconda.org/bioconda/noarch/pyvcf3-1.0.3-pyhdfd78af_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/biopython-1.88-py313h995f894_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/boost-cpp-1.85.0-h3c6214e_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-1.2.0-h505cf86_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-bin-1.2.0-h9908984_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_10.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.8-hebe6cf0_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/contourpy-1.4.0-py313h2551ef2_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/curl-8.21.0-hcf29cc6_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/fonttools-4.66.1-py313h6cd9899_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/freetype-2.14.3-ha770c72_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gawk-5.4.1-h0a3468a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/glib-2.90.0-h5e3c387_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/glib-tools-2.90.0-h3d503d9_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gmp-6.3.0-hfd2156b_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gsl-2.8-h3cd6761_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-75.1-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/jsoncpp-1.9.6-hf42df4d_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.3-h7cc23a3_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/kiwisolver-1.5.1-py313h2551ef2_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.22.2-hbc21106_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/lcms2-2.19.1-h9073bf1_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.46.1-default_hbd61a6d_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/lerc-4.2.0-hdb68285_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libamd-3.3.3-h456b2da_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libasprintf-0.25.1-h0e23cf9_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.11.0-11_h4a7cf45_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-1.85.0-h0ccab89_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-devel-1.85.0-h00ab1b0_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-headers-1.85.0-ha770c72_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlicommon-1.2.0-h39a168f_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlidec-1.2.0-ha411449_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlienc-1.2.0-h018ffa1_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libbtf-2.3.2-hf02c80a_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcamd-3.3.3-hf02c80a_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.11.0-11_h0358290_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libccolamd-3.3.4-hf02c80a_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcholmod-5.3.1-h9cf07ce_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcolamd-3.3.4-hf02c80a_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.21.0-hcf29cc6_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcxsparse-4.4.1-hf02c80a_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libdeflate-1.25-hd45a770_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20250104-pl5321h373387f_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-h280c20c_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.8.5-hd2095e1_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.7.0-h81df57d_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype-2.14.3-ha770c72_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype6-2.14.3-h5e6c136_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-16.2.0-ha9f2e26_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-16.2.0-h69a702a_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgettextpo-0.25.1-h0e23cf9_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-16.2.0-h69a702a_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-16.2.0-h6b99dfc_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.90.0-h569388d_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-16.2.0-he0feb66_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h0cb94f2_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libidn2-2.3.8-hfac485b_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libjpeg-turbo-3.2.0-hb03c661_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libklu-2.3.5-h95ff59c_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.11.0-11_h47877c9_openblas.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libldl-3.3.2-hf02c80a_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.3-hb03c661_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-devel-5.8.3-hb03c661_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb03c661_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.68.1-h74cf4be_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.34-pthreads_hf13c14d_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopenssl-static-3.6.4-h7cc23a3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libparu-1.0.0-hc6afc67_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libpng-1.6.59-h922cc85_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libpython-3.13.15-hdc7f604_103_cp313.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/librbio-4.3.4-hf02c80a_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libspex-3.2.3-h9226d62_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libspqr-4.3.4-h23b7119_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.4-h0737f62_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.1-h6154650_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-16.2.0-h934c35e_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-16.2.0-hdf11a46_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsuitesparseconfig-7.10.1-h901830b_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.7.2-hcc2c06a_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libumfpack-6.3.5-h873dde6_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libunistring-0.9.10-h7f98852_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.4-hcfc3c73_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libwebp-base-1.6.0-hd42ef1d_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcb-1.17.0-hb83e432_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.38-h280c20c_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/lp_solve-5.5.2.11-hd590300_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/mafft-7.526-h4bc722e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-base-3.10.9-py313h683a580_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/metis-5.1.0-h86e3903_1008.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/mpfr-4.2.2-ha2cb11d_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/mysql-connector-c-6.1.11-h659d440_1008.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.5.3-py313hb5f73ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openjpeg-2.5.4-heb1ab33_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.4-h781a0a9_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre-8.45-h9c3ff4c_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.47-h8b3dc9c_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-5.32.1-10_h7cc23a3_perl5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-class-method-modifiers-2.13-pl5321ha770c72_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-compress-raw-bzip2-2.214-pl5321hda65f42_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-compress-raw-zlib-2.214-pl5321h4dac143_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-dbi-1.651-pl5321hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-encode-3.24-pl5321hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-inc-latest-0.500-pl5321ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-module-build-0.4234-pl5321ha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-moo-2.005004-pl5321ha770c72_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-pathtools-3.75-pl5321hb9d3cd8_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-role-tiny-2.002004-pl5321ha770c72_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-scalar-list-utils-1.70-pl5321hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-storable-3.15-pl5321hb9d3cd8_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-sub-quote-2.006006-pl5321ha770c72_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-test-fatal-0.016-pl5321ha770c72_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/perl-try-tiny-0.31-pl5321ha770c72_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/pillow-12.3.0-py313h3b26573_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/psutil-7.2.2-py313hd42f317_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pthread-stubs-0.4-h7cc23a3_1004.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.13.15-hf47f18c_103_cp313.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/qhull-2020.2-h434a139_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-hd6e31c0_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.18.1-py313he2a5f1a_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/simplejson-4.2.0-py313h995f894_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/sqlite-3.53.4-h6e79ffa_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/suitesparse-7.10.1-h5b2951e_7100101.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tar-1.35-h3b78370_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h1df4ec4_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/wget-1.25.0-h653f8fd_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxau-1.0.12-h7cc23a3_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdmcp-1.1.5-h7cc23a3_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xz-5.8.3-ha02ee65_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xz-gpl-tools-5.8.3-ha02ee65_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xz-tools-5.8.3-hb03c661_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zlib-1.3.2-h25fd6f3_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zlib-ng-2.3.3-hce19668_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_7.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/argcomplete-3.7.2-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/argh-0.31.3-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.7.22-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cycler-0.12.1-pyhcf101f3_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/disjoint-set-0.8.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-9.0.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/munkres-1.1.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.3-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/perl-app-cpanminus-1.7048-pl5321hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/perl-carp-1.50-pl5321hd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/perl-common-sense-3.75-pl5321hd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/perl-constant-1.33-pl5321hd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/perl-exporter-5.74-pl5321hd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/perl-exporter-tiny-1.002002-pl5321hd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/perl-extutils-makemaker-7.70-pl5321hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/perl-file-path-2.18-pl5321hd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/perl-file-temp-0.2304-pl5321hd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/perl-file-which-1.24-pl5321hd8ed1ab_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/perl-parent-0.243-pl5321hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pip-26.2.1-pyh145f28c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pygenomeviz-1.7.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.21.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pyparsing-3.3.3-pyh5ded981_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.13-9_cp313.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-84.0.0-pyh332efcf_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-4.1.0-pyhcf101f3_0.conda + - pypi: ./ + - pypi: https://files.pythonhosted.org/packages/0b/a7/71ac2cff56fec219ed242bb11b8efb69fcc4bec75db06fb7bfe35de520e6/certifi-2026.7.22-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/4b/85/41d27f234b82e47c167a5f6c0f62501dc0c640585ff4aba79e08a390336a/charset_normalizer-3.5.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl + - pypi: https://files.pythonhosted.org/packages/57/d7/fe978efc2ae50abe48eb7464668ea99f53c010c60aeebb7b35ad27f23661/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl + - pypi: https://files.pythonhosted.org/packages/58/a2/bb081bab032533a855d44de1d56f8e8426114ff1ba5d1f07a438a0a654f8/idna-3.20-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/69/90/f63fb5873511e014207a475e2bb4e8b2e570d655b00ac19a9a0ca0a385ee/jsonschema-4.26.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/70/21/61dd2876bbaa69cf77d7b5c620e52e8b25faae7096f4d2e4a812b52095d7/duckdb-1.5.6-cp313-cp313-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl + - pypi: https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl + - pypi: https://files.pythonhosted.org/packages/92/9d/c4e665119135114480843e7ab388fa94d8480650450e6f8e26b70d323a4c/urllib3-2.8.0-py3-none-any.whl + - pypi: https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl +packages: +- conda: https://conda.anaconda.org/bioconda/linux-64/augustus-3.5.0-pl5321h5653ebf_10.conda + sha256: 4a4b4795f253bc2dc3e948143d6511e94ace2da7a06feb46ba84cb89b90b17f3 + md5: 8259e19b21c88f026885df48cff25306 + depends: + - __glibc >=2.17,<3.0.a0 + - bamtools >=2.5.3,<3.0a0 + - biopython + - boost-cpp + - cdbtools + - diamond + - gsl >=2.8 + - gsl >=2.8,<2.9.0a0 + - htslib >=1.24,<1.25.0a0 + - libamd >=3.3.3,<4.0a0 + - libblas >=3.9.0,<4.0a0 + - libbtf >=2.3.2,<3.0a0 + - libcamd >=3.3.3,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + - libccolamd >=3.3.4,<4.0a0 + - libcholmod >=5.3.1,<6.0a0 + - libcolamd >=3.3.4,<4.0a0 + - libcxsparse >=4.4.1,<5.0a0 + - libgcc >=14 + - libklu >=2.3.5,<3.0a0 + - libldl >=3.3.2,<4.0a0 + - libparu >=1.0.0,<2.0a0 + - librbio >=4.3.4,<5.0a0 + - libspex >=3.2.3,<4.0a0 + - libspqr >=4.3.4,<5.0a0 + - libsqlite >=3.53.4,<4.0a0 + - libstdcxx >=14 + - libsuitesparseconfig >=7.10.1,<8.0a0 + - libumfpack >=6.3.5,<7.0a0 + - libzlib >=1.3.2,<2.0a0 + - lp_solve + - perl >=5.32.1,<5.33.0a0 *_perl5 + - perl-app-cpanminus + - perl-dbi + - perl-file-which + - perl-module-build 0.4234.* + - perl-parallel-forkmanager + - perl-scalar-list-utils + - perl-yaml + - samtools >=1.24,<2.0a0 + - sqlite + - suitesparse >=7.10.1,<8.0a0 + - tar + - ucsc-fatotwobit + - ucsc-twobitinfo + license: Artistic License + license_family: Other + run_exports: + weak: + - augustus >=3.5.0,<4.0a0 + size: 27187849 + timestamp: 1787052423939 +- conda: https://conda.anaconda.org/bioconda/linux-64/bamtools-2.5.3-he132191_0.tar.bz2 + sha256: 18d0c7e69cc6c775184ca7034d8e2f8b6de4a516c3de74792391882ef1bdcd0d + md5: e3302f3cd140ded877f39abe612bed08 + depends: + - jsoncpp >=1.9.6,<1.9.7.0a0 + - libgcc >=13 + - libstdcxx >=13 + - libzlib >=1.3.1,<2.0a0 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - bamtools >=2.5.3,<3.0a0 + size: 783519 + timestamp: 1747609084710 +- conda: https://conda.anaconda.org/bioconda/linux-64/blast-2.17.0-hb02a186_1.conda + sha256: d506d022ca8ab1346dc816cbcbe3e798d7f104714e14dea1d750db9dec47c205 + md5: 8e5e0c669b39ab1c7c46aea1fda0a495 + depends: + - __glibc >=2.17,<3.0.a0 + - _openmp_mutex >=4.5 + - bzip2 >=1.0.8,<2.0a0 + - curl + - entrez-direct >=26.0,<27.0a0 + - libgcc >=14 + - libgomp + - libsqlite >=3.53.4,<4.0a0 + - libstdcxx >=14 + - libzlib >=1.3.2,<2.0a0 + - ncbi-vdb >=3.4.1,<4.0a0 + - perl + - perl-archive-tar + - perl-json + - perl-list-moreutils + license: NCBI-PD + run_exports: + weak: + - blast >=2.17.0,<2.18.0a0 + size: 160245811 + timestamp: 1787404664731 +- conda: https://conda.anaconda.org/bioconda/linux-64/cdbtools-0.99-h077b44d_12.tar.bz2 + sha256: b70324c9af58110d40b8ed9b5210fe7829cadd59ffef66cf01fa818cc9476fa6 + md5: 6b938da47db28f06ca9258f92d80e7cb + depends: + - libgcc >=13 + - libstdcxx >=13 + - libzlib >=1.3.1,<2.0a0 + license: Public Domain + purls: [] + run_exports: + weak: + - cdbtools >=0.99,<0.100.0a0 + size: 80142 + timestamp: 1744771014271 +- conda: https://conda.anaconda.org/bioconda/linux-64/diamond-2.2.8-he361c42_0.conda + sha256: 2fc36bd54c6f3d0910c37dadcd4eb5b242d522ce1cf331f66a19942b18a70744 + md5: 312008ad0c1e6e05c4e8b9cc6dbd1765 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libsqlite >=3.53.4,<4.0a0 + - libstdcxx >=14 + - libzlib >=1.3.2,<2.0a0 + license: GPL-3.0-or-later + license_family: GPL3 + run_exports: + weak: + - diamond >=2.2.8,<3.0a0 + size: 3390953 + timestamp: 1789907382970 +- conda: https://conda.anaconda.org/bioconda/linux-64/entrez-direct-26.0-h1079eea_0.conda + sha256: 611734d6067084d12a4f5e2a3376ff1a47737d7e563d53677e7ee7d9e6472640 + md5: eb37fd2fbf2bc8192c550999a3bbc5c3 + depends: + - __glibc >=2.17,<3.0.a0 + - wget + license: Public Domain + purls: [] + run_exports: + weak: + - entrez-direct >=26.0,<27.0a0 + size: 16111403 + timestamp: 1785702946517 +- conda: https://conda.anaconda.org/bioconda/linux-64/exonerate-2.4.0-hf34a1b8_9.tar.bz2 + sha256: bd335b369b08d36cc15556fcecb1d498bc28b7a94d9343d4b4b6194851d10c82 + md5: 30b43aa02f2ecfd42f96b2398cdc2914 + depends: + - glib + - libgcc >=12 + - libglib >=2.84.2,<3.0a0 + - pcre >=8.45,<9.0a0 + license: GPL-3.0-or-later + license_family: GPL3 + purls: [] + run_exports: + weak: + - exonerate >=2.4.0,<3.0a0 + size: 1865614 + timestamp: 1751936938866 +- conda: https://conda.anaconda.org/bioconda/linux-64/htslib-1.24-ha79157c_0.conda + sha256: 97e0f0b8700f56b1ade3034f81070ede705fce3ef9a1b5f15e79e3eb9997ac17 + md5: 232775112c6fea38e9e7c25d2a58d7d2 + depends: + - __glibc >=2.17,<3.0.a0 + - bzip2 >=1.0.8,<2.0a0 + - libcurl >=8.21.0,<9.0a0 + - libdeflate >=1.25,<1.27.0a0 + - libgcc >=14 + - liblzma >=5.8.3,<6.0a0 + - libzlib >=1.3.2,<2.0a0 + - openssl >=3.5.7,<4.0a0 + license: MIT + license_family: MIT + run_exports: + weak: + - htslib >=1.24,<1.25.0a0 + size: 1166222 + timestamp: 1783611817902 +- conda: https://conda.anaconda.org/bioconda/linux-64/miniprot-0.18-h577a1d6_0.tar.bz2 + sha256: a7785a0db01773819ba1c3b897d2987a5ec18f4c80165096c87d924c7e4e845b + md5: e60a264d0b4ba975ac1fb1c8e66753a3 + depends: + - libgcc >=13 + - libzlib >=1.3.1,<2.0a0 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - miniprot >=0.18,<0.19.0a0 + size: 70915 + timestamp: 1752254293809 +- conda: https://conda.anaconda.org/bioconda/linux-64/ncbi-vdb-3.4.1-hd63eeec_0.conda + sha256: 1c876e74214ef7269de12286e1b9b370e3167c0825d215de3b81bf46f3956072 + md5: 70de9f284c305131b458cf69676f1b2f + depends: + - libgcc >=14 + - libstdcxx >=14 + license: Public Domain + purls: [] + run_exports: + weak: + - ncbi-vdb >=3.4.1,<4.0a0 + size: 9227191 + timestamp: 1774474370894 +- conda: https://conda.anaconda.org/bioconda/linux-64/perl-io-compress-2.216-pl5321h503566f_0.conda + sha256: 5241c33cf55ba0cbfc0ccab96b4a31123761db00310eab4fedd7a95226c4fca7 + md5: 0784cb3c120f934a5fe61961c8238330 + depends: + - libgcc >=13 + - libstdcxx >=13 + - perl >=5.32.1,<5.33.0a0 *_perl5 + - perl-compress-raw-bzip2 >=2.214 + - perl-compress-raw-zlib >=2.214 + - perl-encode + - perl-scalar-list-utils + license: Perl_5 + purls: [] + run_exports: + weak: + - perl-io-compress >=2.216,<3.0a0 + size: 87231 + timestamp: 1769815108308 +- conda: https://conda.anaconda.org/bioconda/linux-64/perl-json-xs-4.04-pl5321h9948957_0.conda + sha256: f16cf35917a5d75fb55cfc69d8651dc72ff4e06370142b447a4864f5de7d97c6 + md5: 7916b2e794393b3389535ba750f489da + depends: + - libgcc >=13 + - libstdcxx >=13 + - perl >=5.32.1,<5.33.0a0 *_perl5 + - perl-common-sense + - perl-types-serialiser + license: GPL-1.0-or-later OR Artistic-1.0-Perl + purls: [] + run_exports: + weak: + - perl-json-xs >=4.4,<5.0a0 + size: 70770 + timestamp: 1757352008878 +- conda: https://conda.anaconda.org/bioconda/linux-64/perl-list-moreutils-xs-0.430-pl5321h7b50bb2_5.tar.bz2 + sha256: fe2d360770fe5b856ee1e625eac6b07cea386c64b0866e323c6535eb62b9ceee + md5: 9192770eb08524038c3fcf24e915b10c + depends: + - libgcc >=13 + - perl >=5.32.1,<5.33.0a0 *_perl5 + license: apache_2_0 + purls: [] + run_exports: + weak: + - perl-list-moreutils-xs >=0.430,<0.431.0a0 + size: 51506 + timestamp: 1741776389435 +- conda: https://conda.anaconda.org/bioconda/linux-64/pyhmmer-0.12.3-py313hd978853_0.conda + sha256: 4661a18a1ebbff62149b3d34745cb0d7256f8f0ea88b9cb053327b9d15c15279 + md5: 6801577284f982bbffb66805b9c4acc5 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - psutil >=6.0,<8.0 + - python >=3.13,<3.14.0a0 + - python_abi 3.13.* *_cp313 + license: MIT + license_family: MIT + purls: + - pkg:pypi/pyhmmer?source=hash-mapping + run_exports: + weak: + - pyhmmer >=0.12.3,<0.13.0a0 + size: 3147561 + timestamp: 1787165555672 +- conda: https://conda.anaconda.org/bioconda/linux-64/samtools-1.24-h9dcdb79_1.conda + sha256: 18fd604932d0fc197dcfdd54d67e7c54770a2d8eca819e03074556ed9cd3422e + md5: 9cbf5a1cbce4f7d997a4e3e2a27343f1 + depends: + - __glibc >=2.17,<3.0.a0 + - htslib >=1.24,<1.25.0a0 + - libgcc >=14 + - libzlib >=1.3.2,<2.0a0 + - ncurses >=6.6,<7.0a0 + license: MIT + run_exports: + weak: + - samtools >=1.24,<2.0a0 + size: 504278 + timestamp: 1784062341168 +- conda: https://conda.anaconda.org/bioconda/linux-64/taxonkit-0.20.0-h9ee0642_1.conda + sha256: 30e9ba14e337b2685deb4e90abc2b4a9e752b0ea68bc9c23feb5c9e345696cac + md5: 852e72e10b02594fa72db6184c3c1c60 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - taxonkit >=0.20.0,<0.21.0a0 + size: 3859321 + timestamp: 1766200430366 +- conda: https://conda.anaconda.org/bioconda/linux-64/ucsc-fatotwobit-482-hdc0a859_0.tar.bz2 + sha256: 49a3812350d8bcde5993e1620e36921e7419fb98db8b160e186fff16a4bfdaf9 + md5: bfac086f1764d2aedfb35540a9009cdf + depends: + - bzip2 >=1.0.8,<2.0a0 + - libgcc >=13 + - liblzma >=5.8.1,<6.0a0 + - libopenssl-static + - libpng >=1.6.49,<1.7.0a0 + - libuuid >=2.38.1,<3.0a0 + - libzlib >=1.3.1,<2.0a0 + - mysql-connector-c >=6.1.11,<6.1.12.0a0 + license: Varies; see https://genome.ucsc.edu/license + purls: [] + run_exports: + weak: + - ucsc-fatotwobit >=482 + size: 383232 + timestamp: 1750330214400 +- conda: https://conda.anaconda.org/bioconda/linux-64/ucsc-twobitinfo-482-hdc0a859_0.tar.bz2 + sha256: 113321fb70d6cd6b75c04dbd0925cb7a2f4aabfd138d0206af82f899412a1bb6 + md5: 91466585cc720548e4e4c105686fecb8 + depends: + - bzip2 >=1.0.8,<2.0a0 + - libgcc >=13 + - liblzma >=5.8.1,<6.0a0 + - libopenssl-static + - libpng >=1.6.49,<1.7.0a0 + - libuuid >=2.38.1,<3.0a0 + - libzlib >=1.3.1,<2.0a0 + - mysql-connector-c >=6.1.11,<6.1.12.0a0 + license: Varies; see https://genome.ucsc.edu/license + purls: [] + run_exports: + weak: + - ucsc-twobitinfo >=482 + size: 378240 + timestamp: 1750330740699 +- conda: https://conda.anaconda.org/bioconda/noarch/clinker-py-0.0.32-pyhdfd78af_0.conda + sha256: 92b74c32f8e1b84aafcd1c3a3adc6c98e814afd214c1142f1a2a0cadb40bd933 + md5: a20fdf221b377ab0810c566cacacc1a9 + depends: + - biopython >=1.78 + - disjoint-set >=0.7.1 + - gffutils + - numpy >=1.13.3 + - python >=3.6 + - scipy >=1.3.3 + license: MIT + license_family: MIT + purls: + - pkg:pypi/clinker?source=hash-mapping + run_exports: + weak: + - clinker-py >=0.0.32,<0.1.0a0 + size: 123883 + timestamp: 1766380830078 +- conda: https://conda.anaconda.org/bioconda/noarch/gffutils-0.14-pyh106432d_0.conda + sha256: 20da3b97ab5f911165b6bf75e000242ca93eda8ec7179a0c4b37970095dca033 + md5: 3db71e9215083c11e953c9231a227570 + depends: + - argcomplete >=1.9.4 + - argh >=0.26.2 + - pyfaidx >=0.5.5.2 + - python + - simplejson + license: MIT + license_family: MIT + purls: + - pkg:pypi/gffutils?source=hash-mapping + run_exports: + weak: + - gffutils >=0.14,<0.15.0a0 + size: 1093791 + timestamp: 1774978439423 +- conda: https://conda.anaconda.org/bioconda/noarch/perl-archive-tar-3.12-pl5321hdfd78af_0.conda + sha256: fb56a9489a87fc238fc70da7a2329495204eec30f7a5f5af1014a6fb22b528f4 + md5: 4ee2727440bf9b0b055c1f17a72701f6 + depends: + - perl >=5.32.1,<6.0a0 *_perl5 + - perl-io-compress + - perl-io-zlib + - perl-pathtools + license: Perl_5 + purls: [] + run_exports: + weak: + - perl-archive-tar >=3.12,<4.0a0 + size: 38811 + timestamp: 1780439474451 +- conda: https://conda.anaconda.org/bioconda/noarch/perl-io-zlib-1.15-pl5321hdfd78af_1.tar.bz2 + sha256: 771a44b338cac68a22893897450222b886e24bbb291b014897d561f2ba3b588f + md5: db92645dabe9467115729e4479841b5d + depends: + - perl >=5.32.1,<6.0a0 *_perl5 + license: GPL-1.0-or-later OR Artistic-1.0-Perl + purls: [] + run_exports: + weak: + - perl-io-zlib >=1.15,<2.0a0 + size: 12760 + timestamp: 1752069858135 +- conda: https://conda.anaconda.org/bioconda/noarch/perl-json-4.11-pl5321hdfd78af_0.conda + sha256: 1c1649f491c76f4ae2984b547701df91c8abfda2e3b7b44e0c007f5e78a87c08 + md5: 56411755d21870a9ec16c76fd7b66dba + depends: + - perl >=5.32.1,<6.0a0 *_perl5 + - perl-json-xs + license: GPL-1.0-or-later OR Artistic-1.0-Perl + purls: [] + run_exports: + weak: + - perl-json >=4.11,<5.0a0 + size: 52845 + timestamp: 1774152885168 +- conda: https://conda.anaconda.org/bioconda/noarch/perl-list-moreutils-0.430-pl5321hdfd78af_0.tar.bz2 + sha256: 2190cc8430bb218ea80f5fc5e2bf75e4e20a27fb83e8c3cb789a18c32854a56c + md5: 7f04c79d216d0f8e7b6d5a51de4aafa0 + depends: + - perl >=5.32.1,<6.0a0 *_perl5 + - perl-exporter-tiny + - perl-list-moreutils-xs >=0.430 + license: apache_2_0 + purls: [] + run_exports: {} + size: 32468 + timestamp: 1644871004171 +- conda: https://conda.anaconda.org/bioconda/noarch/perl-parallel-forkmanager-2.04-pl5321hdfd78af_0.conda + sha256: d71f83a9d415beb11e4f9832122236cd13686393f6336863ebc8a46d5e3e315f + md5: c0d5b1238870d70b3af64854901d7f62 + depends: + - perl >=5.32.1,<6.0a0 *_perl5 + - perl-carp + - perl-file-path + - perl-file-temp + - perl-moo + - perl-storable + license: perl_5 + purls: [] + run_exports: + weak: + - perl-parallel-forkmanager >=2.4,<3.0a0 + size: 24120 + timestamp: 1756574734791 +- conda: https://conda.anaconda.org/bioconda/noarch/perl-types-serialiser-1.01-pl5321hdfd78af_0.tar.bz2 + sha256: 20f61217b16235d0161ad6fa0a234585afcc04ec5a6142c65b5867e26216dfe3 + md5: cfc65753e827bbef80c00eaa395f6ae7 + depends: + - perl >=5.32.1,<6.0a0 *_perl5 + - perl-common-sense + license: perl_5 + purls: [] + run_exports: {} + size: 13136 + timestamp: 1644512391683 +- conda: https://conda.anaconda.org/bioconda/noarch/perl-yaml-1.30-pl5321hdfd78af_0.tar.bz2 + noarch: true + sha256: 6813626ecc8859b4f16de20f35c9bfdfbdf0a60d7da33494bca6c0c34511a76e + md5: da9ef80f4c4c2374d7f4ec7af6d96b6a + depends: + - perl >=5.32.1,<6.0a0 *_perl5 + license: perl_5 + purls: [] + run_exports: {} + size: 43572 + timestamp: 1644444148032 +- conda: https://conda.anaconda.org/bioconda/noarch/pyfaidx-0.9.0.4-pyhdfd78af_0.conda + sha256: d90a12928b785905f1004579fbc81979458adac45951df32dc1adb9cfe5bff89 + md5: 75ed54b24e699257e168b130aef5f71c + depends: + - biopython + - importlib-metadata + - packaging + - python >=3.7 + - pyvcf3 + - setuptools + - six + license: BSD + license_family: BSD + purls: + - pkg:pypi/pyfaidx?source=hash-mapping + run_exports: + weak: + - pyfaidx >=0.9.0.4,<1.0a0 + size: 36680 + timestamp: 1773947691710 +- conda: https://conda.anaconda.org/bioconda/noarch/pyvcf3-1.0.3-pyhdfd78af_0.tar.bz2 + sha256: 5283bca618cea395f5aabdc40a9a136c0203c247e16935a2b250e84670e1dccb + md5: 2471bf4fad9f15602ad24164adf1a22a + depends: + - python 3.* + license: MIT + purls: + - pkg:pypi/pyvcf3?source=hash-mapping + run_exports: {} + size: 979534 + timestamp: 1650931704574 +- conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda + build_number: 20 + sha256: 1dd3fffd892081df9726d7eb7e0dea6198962ba775bd88842135a4ddb4deb3c9 + md5: a9f577daf3de00bca7c3c76c0ecbd1de + depends: + - __glibc >=2.17,<3.0.a0 + - libgomp >=7.5.0 + constrains: + - openmp_impl <0.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + strong: + - _openmp_mutex >=4.5 + size: 28948 + timestamp: 1770939786096 +- conda: https://conda.anaconda.org/conda-forge/linux-64/biopython-1.88-py313h995f894_1.conda + sha256: ee6e3d7a629298c24bc7caa87429a46f71b426f73665e8863e025c648cb96a11 + md5: 02e3baf98d68e473812a7d930e58a2cf + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - numpy + - python >=3.13,<3.14.0a0 + - python_abi 3.13.* *_cp313 + license: LicenseRef-Biopython + purls: + - pkg:pypi/biopython?source=compressed-mapping + run_exports: {} + size: 3323630 + timestamp: 1789126317234 +- conda: https://conda.anaconda.org/conda-forge/linux-64/boost-cpp-1.85.0-h3c6214e_4.conda + sha256: dec1f52d8869b94a9cb2b4d9a727a00ae2c54e7b5a66a51d3d9f1c33159ebb45 + md5: cc4533eabf5caa8b4fbb56418d1617a9 + depends: + - bzip2 >=1.0.8,<2.0a0 + - icu >=75.1,<76.0a0 + - libboost-devel 1.85.0 h00ab1b0_4 + - libzlib >=1.3.1,<2.0a0 + - xz >=5.2.6,<6.0a0 + - zstd >=1.5.6,<1.6.0a0 + license: BSL-1.0 + purls: [] + run_exports: {} + size: 18122 + timestamp: 1722289881184 +- conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-1.2.0-h505cf86_4.conda + sha256: 61b78574f002390b6a7fc79834fc344beaab09550068a51100eea5a485dac741 + md5: 746aa619a1bcaf4da541101179d7c60e + depends: + - __glibc >=2.17,<3.0.a0 + - brotli-bin 1.2.0 h9908984_4 + - libbrotlidec 1.2.0 ha411449_4 + - libbrotlienc 1.2.0 h018ffa1_4 + - libgcc >=15 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - libbrotlicommon >=1.2.0,<1.3.0a0 + - libbrotlienc >=1.2.0,<1.3.0a0 + - libbrotlidec >=1.2.0,<1.3.0a0 + size: 20679 + timestamp: 1788480401508 +- conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-bin-1.2.0-h9908984_4.conda + sha256: ce7db81d5fd4b222ee1a27c52ccf7af44faaf88283017103a8e288f9c372b973 + md5: c48c09444f3736800ea0b9550c365baf + depends: + - __glibc >=2.17,<3.0.a0 + - libbrotlidec 1.2.0 ha411449_4 + - libbrotlienc 1.2.0 h018ffa1_4 + - libgcc >=15 + license: MIT + license_family: MIT + purls: [] + run_exports: {} + size: 21601 + timestamp: 1788480392621 +- conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_10.conda + sha256: 1a0d382c515ebf55f8ee1f38c8b81bc95af5c2acc42ad53b66bc5df932032f96 + md5: e675fabcf81499adc7edf58124fb1e01 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: bzip2-1.0.6 + license_family: BSD + purls: [] + run_exports: + weak: + - bzip2 >=1.0.8,<2.0a0 + size: 257808 + timestamp: 1785906269155 +- conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.8-hebe6cf0_2.conda + sha256: 9c37cc233238adf366ea75b0e845662a5be07ceadf62e458183516369340274b + md5: 3ad2b403be8fc5612b9159e2ce621f69 + depends: + - libgcc >=15 + - __glibc >=2.17,<3.0.a0 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - c-ares >=1.34.8,<2.0a0 + size: 228700 + timestamp: 1787169971173 +- conda: https://conda.anaconda.org/conda-forge/linux-64/contourpy-1.4.0-py313h2551ef2_1.conda + sha256: 078f4a0f83ee7d0f88c110e15f9f94ff4080dc925711d1d22b52779c2e48cf87 + md5: 1883f23b947ffaa13f9511ea817fc4e6 + depends: + - numpy >=2.0 + - python + - __glibc >=2.17,<3.0.a0 + - libstdcxx >=15 + - libgcc >=15 + - python_abi 3.13.* *_cp313 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/contourpy?source=compressed-mapping + run_exports: {} + size: 329540 + timestamp: 1789746824998 +- conda: https://conda.anaconda.org/conda-forge/linux-64/curl-8.21.0-hcf29cc6_1.conda + sha256: 8eb4ebeae7230110569da734e2420aee84f6977850bae4af94dc7f0b382f9d89 + md5: 58609be98a9725cd359a1c63ff329628 + depends: + - __glibc >=2.17,<3.0.a0 + - krb5 >=1.22.2,<1.23.0a0 + - libcurl 8.21.0 hcf29cc6_1 + - libgcc >=14 + - libssh2 >=1.11.1,<2.0a0 + - libzlib >=1.3.2,<2.0a0 + - openssl >=3.5.7,<4.0a0 + - zstd >=1.5.7,<1.6.0a0 + license: curl + license_family: MIT + purls: [] + run_exports: {} + size: 194657 + timestamp: 1782802525727 +- conda: https://conda.anaconda.org/conda-forge/linux-64/fonttools-4.66.1-py313h6cd9899_0.conda + sha256: af48e493a3f6f2e54c19e58607a26e9b3e0cca4c4aab45e2ba161f906069f9ac + md5: bc5e99327ffd810f4e3574315ed2d954 + depends: + - __glibc >=2.17,<3.0.a0 + - brotli + - libgcc >=15 + - munkres + - python >=3.13,<3.14.0a0 + - python_abi 3.13.* *_cp313 + license: MIT + license_family: MIT + purls: + - pkg:pypi/fonttools?source=compressed-mapping + run_exports: {} + size: 3183109 + timestamp: 1790702941759 +- conda: https://conda.anaconda.org/conda-forge/linux-64/freetype-2.14.3-ha770c72_2.conda + sha256: 612a8e0c1a6ecae23da54d81ef395f6ebb5c8e4468ec2611593ebce75876a4e0 + md5: 2d0ea23b23603e07ca47f23f949f67b6 + depends: + - libfreetype 2.14.3 ha770c72_2 + - libfreetype6 2.14.3 h5e6c136_2 + license: GPL-2.0-only OR FTL + purls: [] + run_exports: + weak: + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + size: 175239 + timestamp: 1786641011029 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gawk-5.4.1-h0a3468a_0.conda + sha256: 0ae20399bc13d1097237cf29653c1f2dd68e37f08b47a9b3cab76f97556a6bfa + md5: 64fd8d804a6aaef55d6d6c562446d72b + depends: + - gmp + - mpfr + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - gmp >=6.3.0,<7.0a0 + - readline >=8.3,<9.0a0 + - libasprintf >=0.25.1,<1.0a0 + - libgettextpo >=0.25.1,<1.0a0 + - mpfr >=4.2.2,<5.0a0 + license: GPL-3.0-or-later + license_family: GPL + purls: [] + run_exports: {} + size: 1522511 + timestamp: 1783686211415 +- conda: https://conda.anaconda.org/conda-forge/linux-64/glib-2.90.0-h5e3c387_0.conda + sha256: 4d3ddb32831bbd89d4c1b5282930f70a1bf0e1210c772d2df4c13b3eb12f577f + md5: 783f9086aaff57b304816dc67181e3f7 + depends: + - python * + - packaging + - libglib ==2.90.0 h569388d_0 + - glib-tools ==2.90.0 h3d503d9_0 + license: LGPL-2.1-or-later + purls: [] + run_exports: + weak: + - libglib >=2.90.0,<3.0a0 + size: 85802 + timestamp: 1789478025196 +- conda: https://conda.anaconda.org/conda-forge/linux-64/glib-tools-2.90.0-h3d503d9_0.conda + sha256: a31c2244c6743a85941ac1d19a77ce2cc871afa171b0ad9aaac309af532d0677 + md5: d4adaebf8a2c9040ada6549c52a6b8d8 + depends: + - libglib ==2.90.0 h569388d_0 + - libffi + - libgcc >=15 + - __glibc >=2.17,<3.0.a0 + license: LGPL-2.1-or-later + purls: [] + run_exports: {} + size: 237225 + timestamp: 1789478025196 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gmp-6.3.0-hfd2156b_3.conda + sha256: f36c336efc874f346a53a9011f67e997f9faac505562cc18c13b6d399cfe61c7 + md5: 576e32739f323438bf69ab006c21be7b + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libstdcxx >=14 + license: GPL-2.0-or-later OR LGPL-3.0-or-later + purls: [] + run_exports: + weak: + - gmp >=6.3.0,<7.0a0 + size: 493498 + timestamp: 1786629164954 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gsl-2.8-h3cd6761_2.conda + sha256: 433d1b1570afa09f469fa5cfb633a2d860fe270639ffa6ba7a354088ab5aba23 + md5: 5071d6d2577a3d5989b1767fbd0a4d56 + depends: + - __glibc >=2.17,<3.0.a0 + - libblas >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + - libgcc >=15 + license: GPL-3.0-or-later + license_family: GPL + purls: [] + run_exports: + weak: + - gsl >=2.8,<2.9.0a0 + size: 2466796 + timestamp: 1789041589598 +- conda: https://conda.anaconda.org/conda-forge/linux-64/icu-75.1-he02047a_0.conda + sha256: 71e750d509f5fa3421087ba88ef9a7b9be11c53174af3aa4d06aff4c18b38e8e + md5: 8b189310083baabfb622af68fd9d3ae3 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - icu >=75.1,<76.0a0 + size: 12129203 + timestamp: 1720853576813 +- conda: https://conda.anaconda.org/conda-forge/linux-64/jsoncpp-1.9.6-hf42df4d_1.conda + sha256: ed4b1878be103deb2e4c6d0eea3c9bdddfd7fc3178383927dce7578fb1063520 + md5: 7bdc5e2cc11cb0a0f795bdad9732b0f2 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 + license: LicenseRef-Public-Domain OR MIT + purls: [] + run_exports: + weak: + - jsoncpp >=1.9.6,<1.9.7.0a0 + size: 169093 + timestamp: 1733780223643 +- conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.3-h7cc23a3_1.conda + sha256: dd053c96dcb0dcfd59422aefea9d2fe937a190167f34fba7893ec1e10a7e8963 + md5: ba55d1b89fd7775e67de8291029b4059 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + license: LGPL-2.1-or-later + purls: [] + run_exports: + weak: + - keyutils >=1.6.3,<2.0a0 + size: 135295 + timestamp: 1786739238128 +- conda: https://conda.anaconda.org/conda-forge/linux-64/kiwisolver-1.5.1-py313h2551ef2_3.conda + sha256: bb5beb208c8379eee9b3ce620684ac44ae73597ae0dab500c12f18e63e3c1020 + md5: 45c8698dd577ba504513001219cfd0fd + depends: + - python + - libstdcxx >=15 + - libgcc >=15 + - __glibc >=2.17,<3.0.a0 + - python_abi 3.13.* *_cp313 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/kiwisolver?source=compressed-mapping + run_exports: {} + size: 75111 + timestamp: 1790082004004 +- conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.22.2-hbc21106_2.conda + sha256: 2a5c38c85e63df84c4e69ee71439841ce570d259ae3060627bb9a49a938d66f4 + md5: 53318d715316929a574f83591308b1f8 + depends: + - __glibc >=2.17,<3.0.a0 + - keyutils >=1.6.3,<2.0a0 + - libedit >=3.1.20250104,<3.2.0a0 + - libedit >=3.1.20250104,<4.0a0 + - libgcc >=15 + - libstdcxx >=15 + - openssl >=3.5.7,<4.0a0 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - krb5 >=1.22.2,<1.23.0a0 + size: 1394333 + timestamp: 1786762112514 +- conda: https://conda.anaconda.org/conda-forge/linux-64/lcms2-2.19.1-h9073bf1_3.conda + sha256: 03e675b9adaf235aab880e4133c72f4830e87bc7da2df59d6194771612239b22 + md5: 596464faa06e0b656b35416188ef9bba + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - libjpeg-turbo >=3.2.0,<4.0a0 + - libtiff >=4.7.2,<4.8.0a0 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - lcms2 >=2.19.1,<3.0a0 + size: 254292 + timestamp: 1789051947923 +- conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.46.1-default_hbd61a6d_102.conda + sha256: 27d83f1188cd19bcb7754a078b3fa7f4cfb8527f8eb2fde54dd01fc529d1adec + md5: 449500f2c089da11c40f5c21312e3e07 + depends: + - __glibc >=2.17,<3.0.a0 + - zstd >=1.5.7,<1.6.0a0 + constrains: + - binutils_impl_linux-64 2.46.1 + license: GPL-3.0-only + license_family: GPL + purls: [] + run_exports: {} + size: 745303 + timestamp: 1784214507189 +- conda: https://conda.anaconda.org/conda-forge/linux-64/lerc-4.2.0-hdb68285_0.conda + sha256: bf9fdebf55d8bc99d83531cdffda00703f4dc5f93a1a956768c147362c72feda + md5: fb9d356b1a57d6d54768be7ebd5fce09 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libstdcxx >=14 + license: Apache-2.0 + license_family: Apache + purls: [] + run_exports: + weak: + - lerc >=4.2.0,<5.0a0 + size: 271158 + timestamp: 1785036167977 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libamd-3.3.3-h456b2da_7100101.conda + sha256: 5fc32a5497c9919ffde729a604b0acfa97c403ce5b2b27b28ca261cf0c4643aa + md5: a067596d679bcde85375143e7c374738 + depends: + - __glibc >=2.17,<3.0.a0 + - libgfortran5 >=13.3.0 + - libgfortran + - libgcc >=13 + - libsuitesparseconfig >=7.10.1,<8.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - libamd >=3.3.3,<4.0a0 + size: 48250 + timestamp: 1741963824815 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libasprintf-0.25.1-h0e23cf9_2.conda + sha256: cd1acde49a1915b7a62a9678bdf42557f083d63f08d4ccc5cd9834553be96eb1 + md5: 708966b4a89392fe7b7d348f41501ffc + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - libstdcxx >=15 + license: LGPL-2.1-or-later + purls: [] + run_exports: + weak: + - libasprintf >=0.25.1,<1.0a0 + size: 53449 + timestamp: 1790117307288 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.11.0-11_h4a7cf45_openblas.conda + build_number: 11 + sha256: d942e0c820d60a613a6f786d074f0820fb6343e3f1ccfb110b1d98b44fb75968 + md5: b8cce1486f3c62f33291d6318c193d0d + depends: + - libopenblas >=0.3.34,<0.3.35.0a0 + - libopenblas >=0.3.34,<1.0a0 + constrains: + - blas 2.311 openblas + - libcblas 3.11.0 11*_openblas + - liblapack 3.11.0 11*_openblas + - liblapacke 3.11.0 11*_openblas + - mkl <2027 + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - libblas >=3.11.0,<4.0a0 + size: 18246 + timestamp: 1789061062982 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-1.85.0-h0ccab89_4.conda + sha256: dc19dfc636c363871763384219269ce6a027fcf3831f17e018caeecb2ffbb20a + md5: 4da1690badd566fc1041f91cd5655727 + depends: + - __glibc >=2.17,<3.0.a0 + - bzip2 >=1.0.8,<2.0a0 + - icu >=75.1,<76.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - libzlib >=1.3.1,<2.0a0 + - xz >=5.2.6,<6.0a0 + - zstd >=1.5.6,<1.6.0a0 + constrains: + - boost-cpp =1.85.0 + license: BSL-1.0 + purls: [] + run_exports: {} + size: 2869710 + timestamp: 1722289756758 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-devel-1.85.0-h00ab1b0_4.conda + sha256: 04ec5a59e87d75cf6f8b539493f7f71c0cca3f50976251895f51da45e39cddf7 + md5: ded76b8670cb505006c891c4d45844a5 + depends: + - libboost 1.85.0 h0ccab89_4 + - libboost-headers 1.85.0 ha770c72_4 + constrains: + - boost-cpp =1.85.0 + license: BSL-1.0 + purls: [] + run_exports: + weak: + - libboost >=1.85.0,<1.86.0a0 + size: 40881 + timestamp: 1722289871820 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libboost-headers-1.85.0-ha770c72_4.conda + sha256: 55aa2ac604bd7ed76fae0c93698d37aae455ca2fb229ff9aa45e085ff7ad48ec + md5: 00e4848983222729ccb7c69f1039f4b9 + constrains: + - boost-cpp =1.85.0 + license: BSL-1.0 + purls: [] + run_exports: {} + size: 13961521 + timestamp: 1722289776587 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlicommon-1.2.0-h39a168f_4.conda + sha256: c4e9854c585f3ee1785f651287ecdf8c28f30a2ea1b159a513005f8a0f6453a3 + md5: df210655e30a05e3b069c91b7aaddd2d + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - libbrotlicommon >=1.2.0,<1.3.0a0 + size: 80561 + timestamp: 1788480364653 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlidec-1.2.0-ha411449_4.conda + sha256: d5ed24da3e583a92227fe77280978b7933f07a39a2b60156c5ad95e5c76733fa + md5: 0cfd601eb03cca403dcc248844787486 + depends: + - __glibc >=2.17,<3.0.a0 + - libbrotlicommon 1.2.0 h39a168f_4 + - libgcc >=15 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - libbrotlidec >=1.2.0,<1.3.0a0 + size: 34739 + timestamp: 1788480374261 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlienc-1.2.0-h018ffa1_4.conda + sha256: b9f3cb510337655485c2e79ce5f7dd468991b19ad29723ffa1175a0aed1b69ae + md5: 4136f6e4ef4835cc7df39a707cbd511c + depends: + - __glibc >=2.17,<3.0.a0 + - libbrotlicommon 1.2.0 h39a168f_4 + - libgcc >=15 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - libbrotlienc >=1.2.0,<1.3.0a0 + size: 298134 + timestamp: 1788480383223 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libbtf-2.3.2-hf02c80a_7100101.conda + sha256: fe36f414f48ab87251f02aeef1fcbb6f3929322316842dada0f8142db2710264 + md5: 6f4aec52002defbdf3e24eb79e56a209 + depends: + - libgcc >=13 + - __glibc >=2.17,<3.0.a0 + - libsuitesparseconfig >=7.10.1,<8.0a0 + license: LGPL-2.1-or-later + purls: [] + run_exports: + weak: + - libbtf >=2.3.2,<3.0a0 + size: 26913 + timestamp: 1741963824815 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcamd-3.3.3-hf02c80a_7100101.conda + sha256: 16e9ae4e173a8606b0b8be118dbdcf4e03c9dd9777eea6bf9dff4397133d0d06 + md5: 1c9d1532caadece8adc2d14c6d4fc726 + depends: + - libgcc >=13 + - __glibc >=2.17,<3.0.a0 + - libsuitesparseconfig >=7.10.1,<8.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - libcamd >=3.3.3,<4.0a0 + size: 44119 + timestamp: 1741963824815 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.11.0-11_h0358290_openblas.conda + build_number: 11 + sha256: f7d1bbdea61cf94ba219d17b2cb571a29830f8025385af799bff5a7ad1ef45e6 + md5: 73a248c30811075059b5aeda766c2624 + depends: + - libblas 3.11.0 11_h4a7cf45_openblas + constrains: + - blas 2.311 openblas + - liblapack 3.11.0 11*_openblas + - liblapacke 3.11.0 11*_openblas + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - libcblas >=3.11.0,<4.0a0 + size: 18196 + timestamp: 1789061068819 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libccolamd-3.3.4-hf02c80a_7100101.conda + sha256: cc90aa5e0ad1f7ae9a29d9a42aacd7f7f02aba0bf5467513bfda7e6b18a4cbc8 + md5: e5107e02dc4c2f9f41eef72d72c23517 + depends: + - libgcc >=13 + - __glibc >=2.17,<3.0.a0 + - libsuitesparseconfig >=7.10.1,<8.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - libccolamd >=3.3.4,<4.0a0 + size: 41578 + timestamp: 1741963824815 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcholmod-5.3.1-h9cf07ce_7100101.conda + sha256: 69540315b4b8de93b383243334151ed19e98968baaa59440ba645a3bff68d765 + md5: f51e24ce110ae24c92074736a308e47e + depends: + - libgcc >=13 + - libstdcxx >=13 + - libgcc >=13 + - __glibc >=2.17,<3.0.a0 + - _openmp_mutex >=4.5 + - liblapack >=3.9.0,<4.0a0 + - libcolamd >=3.3.4,<4.0a0 + - libamd >=3.3.3,<4.0a0 + - libsuitesparseconfig >=7.10.1,<8.0a0 + - libccolamd >=3.3.4,<4.0a0 + - libblas >=3.9.0,<4.0a0 + - libcamd >=3.3.3,<4.0a0 + license: LGPL-2.1-or-later AND GPL-2.0-or-later AND Apache-2.0 + purls: [] + run_exports: + weak: + - libcholmod >=5.3.1,<6.0a0 + size: 990886 + timestamp: 1741963824815 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcolamd-3.3.4-hf02c80a_7100101.conda + sha256: 00d1b976b914f0c20ae6f81f4e4713fa87717542eba8757b9a3c9e8abcc29858 + md5: 56d4c5542887e8955f21f8546ad75d9d + depends: + - libgcc >=13 + - __glibc >=2.17,<3.0.a0 + - libsuitesparseconfig >=7.10.1,<8.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - libcolamd >=3.3.4,<4.0a0 + size: 33160 + timestamp: 1741963824815 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.21.0-hcf29cc6_1.conda + sha256: 7d243f45a48f62cb8e3b871dd336137fe0fb90094a191756fb553508837f6338 + md5: 2c1e55d695b11525c760b486ac0be517 + depends: + - __glibc >=2.17,<3.0.a0 + - krb5 >=1.22.2,<1.23.0a0 + - libgcc >=14 + - libnghttp2 >=1.68.1,<2.0a0 + - libssh2 >=1.11.1,<2.0a0 + - libzlib >=1.3.2,<2.0a0 + - openssl >=3.5.7,<4.0a0 + - zstd >=1.5.7,<1.6.0a0 + license: curl + license_family: MIT + purls: [] + run_exports: + weak: + - libcurl >=8.21.0,<9.0a0 + size: 478914 + timestamp: 1782802520033 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcxsparse-4.4.1-hf02c80a_7100101.conda + sha256: ab40fc8a4662f550d053576a56db896247bc81eb291eff3811f24c231829e3dd + md5: 917931d508582ef891bbac172294d9fb + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - _openmp_mutex >=4.5 + - libsuitesparseconfig >=7.10.1,<8.0a0 + license: LGPL-2.1-or-later + purls: [] + run_exports: + weak: + - libcxsparse >=4.4.1,<5.0a0 + size: 113979 + timestamp: 1741963824815 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libdeflate-1.25-hd45a770_1.conda + sha256: 82e134c8a08b1eed9a2ed8ab578b89aa1730dcde3dea8dd87645ed0637878e54 + md5: 40f9b31aa9cf007789867df0decd0492 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - libdeflate >=1.25,<1.26.0a0 + size: 73710 + timestamp: 1785908694612 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20250104-pl5321h373387f_1.conda + sha256: 6473eb8caf2aae830f37caa93db9b26dddf7ac84b63229e8bf7fc0e5c3ab95b0 + md5: 50708d3b951d0f8e2d7f2df5b5edc040 + depends: + - ncurses + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + - ncurses >=6.6,<7.0a0 + license: BSD-2-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - libedit >=3.1.20250104,<3.2.0a0 + size: 135098 + timestamp: 1786616658086 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-h280c20c_3.conda + sha256: e4418f68d01a6307c4431b585c71b584f40189877364e542ee87deb777f5e85b + md5: 7bc31538d6e3fb349e897353969237ec + depends: + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + license: BSD-2-Clause OR GPL-2.0-or-later + license_family: GPL + purls: [] + run_exports: + weak: + - libev >=4.33,<4.34.0a0 + size: 43220 + timestamp: 1785917328200 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.8.5-hd2095e1_0.conda + sha256: 6de73033a7c5f712c9c5a54124e4581e025691029835e5bceaf10a333a7e7bc0 + md5: 72cfd2b95b0540247220b42f58a148d7 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + constrains: + - expat 2.8.5.* + license: MIT + license_family: MIT + purls: [] + run_exports: {} + size: 77893 + timestamp: 1790346247149 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.7.0-h81df57d_1.conda + sha256: c8c7583ef063bc3c430f1d48298e5ad24f796a35c22ed5b14183325825a61106 + md5: 6525a0b06aa4fd390795f0740636a9dd + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - libffi >=3.7.0,<3.8.0a0 + size: 68004 + timestamp: 1787753412298 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype-2.14.3-ha770c72_2.conda + sha256: fb12ecb46c30d18d928c0e8fc346ab13b5f6fc8a9cacae4f2f4bb188782586f5 + md5: f8054e759d0ddddaf34a5c8fedc900a1 + depends: + - libfreetype6 >=2.14.3 + license: GPL-2.0-only OR FTL + purls: [] + run_exports: {} + size: 8407 + timestamp: 1786641007099 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype6-2.14.3-h5e6c136_2.conda + sha256: ec607dd5445dd17ff6bf8b7fe6832e5504c226dd91d3aaea7ba83569808b0ce4 + md5: b72a266a9317036fd0464cb98b027cd0 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - libpng >=1.6.58,<1.7.0a0 + - libzlib >=1.3.2,<2.0a0 + constrains: + - freetype >=2.14.3 + license: GPL-2.0-only OR FTL + purls: [] + run_exports: {} + size: 387671 + timestamp: 1786641006460 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-16.2.0-ha9f2e26_7.conda + sha256: e031634c3a928f9594eba868bc46ef5230d6571a364a0c63215b06c4563bfcea + md5: 735629b400b70eeab21a2ba8f5b1c2ce + depends: + - __glibc >=2.17,<3.0.a0 + - _openmp_mutex >=4.5 + constrains: + - libgcc-ng ==16.2.0=*_7 + - libgomp 16.2.0 he0feb66_7 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + purls: [] + run_exports: {} + size: 1058444 + timestamp: 1790303109576 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-16.2.0-h69a702a_7.conda + sha256: 03b54d7008de080a17cc2174b0e4acd6d06e1c981b2eb19846f46d8f59966034 + md5: 2005515ac9340f816fb2ac7e83afe553 + depends: + - libgcc 16.2.0 ha9f2e26_7 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + purls: [] + run_exports: + strong: + - libgcc + size: 28616 + timestamp: 1790303114248 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgettextpo-0.25.1-h0e23cf9_2.conda + sha256: 58bbdb3ee8ab85fff94435bcf4a335fd5e7b61d4d84f15d9afc8b4207d522ea3 + md5: de2346aa9d78288e6924b01a2db091c1 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - libiconv >=1.18,<2.0a0 + license: GPL-3.0-or-later + license_family: GPL + purls: [] + run_exports: + weak: + - libgettextpo >=0.25.1,<1.0a0 + size: 186971 + timestamp: 1790117313607 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-16.2.0-h69a702a_7.conda + sha256: 9682ae4dd11487e10b904b3cb3ab6379cad25233d45fdfdf90d54349df244494 + md5: 3a8d285f5f22138ef826ad54cf267e73 + depends: + - libgfortran5 16.2.0 h6b99dfc_7 + constrains: + - libgfortran-ng ==16.2.0=*_7 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + purls: [] + run_exports: {} + size: 28571 + timestamp: 1790303139904 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-16.2.0-h6b99dfc_7.conda + sha256: 04dbab12c925b92977bb835dd2f5eda413607afa79f95a554e5a04b07a380322 + md5: 7719ed7be38ad8c492c4bd5cc2bce0c4 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=16.2.0 + constrains: + - libgfortran 16.2.0 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + purls: [] + run_exports: {} + size: 2528180 + timestamp: 1790303122004 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.90.0-h569388d_0.conda + sha256: 9e688e046550415c030c3d08ed9a3fd13a51d7bc56295283b858b6c3070bb9f8 + md5: c85e9539551f1fd21104e518d940c244 + depends: + - libgcc >=15 + - __glibc >=2.17,<3.0.a0 + - libiconv >=1.18,<2.0a0 + - pcre2 >=10.47,<10.48.0a0 + - libffi >=3.7.0,<3.8.0a0 + - libzlib >=1.3.2,<2.0a0 + constrains: + - glib >2.66 + license: LGPL-2.1-or-later + purls: [] + run_exports: + weak: + - libglib >=2.90.0,<3.0a0 + size: 4819130 + timestamp: 1789478025196 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-16.2.0-he0feb66_7.conda + sha256: 92a0bb350c7be6a4eedcb4e111c60aefd176018e6b1c009a6e025dbe9bbcd758 + md5: d904c7ddd95e026254b4b80808ee9e12 + depends: + - __glibc >=2.17,<3.0.a0 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + purls: [] + run_exports: + strong: + - _openmp_mutex >=4.5 + size: 640566 + timestamp: 1790303046034 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h0cb94f2_3.conda + sha256: f943117edb9cd4d9c61cc972eee5a34291dc55ea7a6e9e38da104995841cbcb6 + md5: f92233bf33e24a25668bb2119e2c51f9 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + license: LGPL-2.1-only + purls: [] + run_exports: + weak: + - libiconv >=1.18,<2.0a0 + size: 789471 + timestamp: 1787033836207 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libidn2-2.3.8-hfac485b_1.conda + sha256: cc38c900b9a20fe75e61cbb594e749c57a06d96510722f5ddfa309682062b065 + md5: 842a81de672ddcf476337c8bde3cad33 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libunistring >=0,<1.0a0 + license: LGPL-2.0-only + license_family: LGPL + purls: [] + run_exports: + weak: + - libidn2 >=2,<3.0a0 + size: 139036 + timestamp: 1760385590993 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libjpeg-turbo-3.2.0-hb03c661_1.conda + sha256: bba8538e6538ed58a8479b332337b96986561f975d06cfa2039a016c2d246ee4 + md5: 898d1c9793eaa52efc4727bd84d2e39a + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + constrains: + - jpeg <0.0.0a + license: IJG AND BSD-3-Clause AND Zlib + purls: [] + run_exports: + weak: + - libjpeg-turbo >=3.2.0,<4.0a0 + size: 650434 + timestamp: 1785896381946 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libklu-2.3.5-h95ff59c_7100101.conda + sha256: 6b4d462642c240dc3671af74f7705b23f34eea0f71e0d9dbcf14b4ed008311ff + md5: efaa5e7dc6989363585fbb591480b256 + depends: + - libgcc >=13 + - __glibc >=2.17,<3.0.a0 + - _openmp_mutex >=4.5 + - metis >=5.1.0,<5.1.1.0a0 + - libcamd >=3.3.3,<4.0a0 + - liblapack >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + - libsuitesparseconfig >=7.10.1,<8.0a0 + - libcolamd >=3.3.4,<4.0a0 + - libamd >=3.3.3,<4.0a0 + - libcholmod >=5.3.1,<6.0a0 + - libblas >=3.9.0,<4.0a0 + - libbtf >=2.3.2,<3.0a0 + - libccolamd >=3.3.4,<4.0a0 + license: LGPL-2.1-or-later + purls: [] + run_exports: + weak: + - libklu >=2.3.5,<3.0a0 + size: 131775 + timestamp: 1741963824816 +- conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.11.0-11_h47877c9_openblas.conda + build_number: 11 + sha256: 1ad3f43c9319ef398a8ef45989f4903a06e3965b51e77fc669a4c894168a8411 + md5: 5622a13917855ce4b953b9e655cf9262 + depends: + - libblas 3.11.0 11_h4a7cf45_openblas + constrains: + - blas 2.311 openblas + - libcblas 3.11.0 11*_openblas + - liblapacke 3.11.0 11*_openblas + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - liblapack >=3.11.0,<3.12.0a0 + size: 18227 + timestamp: 1789061073957 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libldl-3.3.2-hf02c80a_7100101.conda + sha256: 590232cd302047023ab31b80458833a71b10aeabee7474304dc65db322b5cd70 + md5: 19b71122fea7f6b1c4815f385b2da419 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libsuitesparseconfig >=7.10.1,<8.0a0 + license: LGPL-2.1-or-later + purls: [] + run_exports: + weak: + - libldl >=3.3.2,<4.0a0 + size: 23391 + timestamp: 1741963824815 +- conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.3-hb03c661_1.conda + sha256: 9787df8c22a59c9a70d3e5a10db9ad663485e75e9ccc3f09bd092cb7b95e0dab + md5: 1390b7c5ac0b1d8e447bc5efa6d3c8c2 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + constrains: + - xz 5.8.3.* + license: 0BSD + purls: [] + run_exports: + weak: + - liblzma >=5.8.3,<6.0a0 + size: 112995 + timestamp: 1786348617826 +- conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-devel-5.8.3-hb03c661_1.conda + sha256: adef6e8b60afb684110b06b5310977c6836e1c923ce3ec199f45c0f000b42f20 + md5: 6d83d6a332c19424e9e66b69b180ec11 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - liblzma 5.8.3 hb03c661_1 + license: 0BSD + purls: [] + run_exports: + weak: + - liblzma >=5.8.3,<6.0a0 + size: 491970 + timestamp: 1786348627135 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb03c661_2.conda + sha256: 46820b4a835e175940ae20bec00fdddaff804cda27a1408ab1b95e77a2196437 + md5: fcfed1dc5053eb1901b66e7b1fc32588 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: BSD-2-Clause + license_family: BSD + purls: [] + run_exports: {} + size: 92759 + timestamp: 1786650399772 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.68.1-h74cf4be_1.conda + sha256: 11a2f54a6f391e25738bce0023e6ef499600147bbcf21c1fa69d2e251b03cc6a + md5: 75d211f04ac87506f1f43420712a69fe + depends: + - __glibc >=2.17,<3.0.a0 + - c-ares >=1.34.8,<2.0a0 + - libev >=4.33,<4.34.0a0 + - libev >=4.33,<5.0a0 + - libgcc >=15 + - libstdcxx >=15 + - libzlib >=1.3.2,<2.0a0 + - openssl >=3.5.7,<4.0a0 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - libnghttp2 >=1.68.1,<2.0a0 + size: 649974 + timestamp: 1787177490105 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenblas-0.3.34-pthreads_hf13c14d_2.conda + sha256: 69a722751e14eab2eb3bfdcb9acb1187afbd962b0c49b48d829341e0f6787f60 + md5: 7e19fcd73d7f0997d3cb3326d2586a86 + depends: + - libgfortran5 >=15.3.0 + - libgfortran + - libgcc >=15 + - __glibc >=2.17,<3.0.a0 + constrains: + - openblas >=0.3.34,<0.3.35.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - libopenblas >=0.3.34,<1.0a0 + size: 6845411 + timestamp: 1789141490688 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopenssl-static-3.6.4-h7cc23a3_0.conda + sha256: 332bc0cbf22ce800dbff2498217941f387bfd1f8040439e575f23f1a81febfdb + md5: 76030dff3efd7612926e51ee06a3060b + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - openssl 3.6.4 h781a0a9_0 + license: Apache-2.0 + license_family: Apache + purls: [] + run_exports: {} + size: 2868999 + timestamp: 1787698792926 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libparu-1.0.0-hc6afc67_7100101.conda + sha256: 50144e87b95d1309d2043aa5bf02035b948b1ae9ec6ec44ee97b7aec1cccd70a + md5: fd1d3e26c1b12c70f7449369ae3d9c1a + depends: + - libgcc >=13 + - libstdcxx >=13 + - libgcc >=13 + - __glibc >=2.17,<3.0.a0 + - _openmp_mutex >=4.5 + - libsuitesparseconfig >=7.10.1,<8.0a0 + - libblas >=3.9.0,<4.0a0 + - libumfpack >=6.3.5,<7.0a0 + license: GPL-3.0-or-later + license_family: GPL + purls: [] + run_exports: + weak: + - libparu >=1.0.0,<2.0a0 + size: 89738 + timestamp: 1741963824815 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libpng-1.6.59-h922cc85_0.conda + sha256: c7381be8ef713501f6cd2f5ad473e401f2edeaec3c46788296b8dbf0de165e15 + md5: 8c9caf742a485ac688ffa88bbadbf0be + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - libzlib >=1.3.2,<2.0a0 + license: zlib-acknowledgement + purls: [] + run_exports: + weak: + - libpng >=1.6.59,<1.7.0a0 + size: 316872 + timestamp: 1790805159503 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libpython-3.13.15-hdc7f604_103_cp313.conda + build_number: 103 + sha256: a25db25aad6cbf53e523e1f310713f31372932d5db655f1f2d62a204c7cdf1d7 + md5: e64cd43bbd07afafbc458138e979c851 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - libstdcxx >=15 + license: Python-2.0 + purls: [] + run_exports: {} + size: 9711017 + timestamp: 1788387797958 +- conda: https://conda.anaconda.org/conda-forge/linux-64/librbio-4.3.4-hf02c80a_7100101.conda + sha256: c502b4203cc0d38f49005994b5c80c89660bcd40ff170c529cda90827ec6b1f4 + md5: 4b3a3d711d1c1f76f7f440e51458f512 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libsuitesparseconfig >=7.10.1,<8.0a0 + license: GPL-2.0-or-later + license_family: GPL + purls: [] + run_exports: + weak: + - librbio >=4.3.4,<5.0a0 + size: 46633 + timestamp: 1741963824815 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libspex-3.2.3-h9226d62_7100101.conda + sha256: 24dffff614943c547ba094f8eb03b412a18cc4654663202f1aab9158bfa875ba + md5: 63323b258079a75133ccecbb0902614d + depends: + - libgcc >=13 + - __glibc >=2.17,<3.0.a0 + - _openmp_mutex >=4.5 + - libamd >=3.3.3,<4.0a0 + - libcolamd >=3.3.4,<4.0a0 + - libsuitesparseconfig >=7.10.1,<8.0a0 + - gmp >=6.3.0,<7.0a0 + - mpfr >=4.2.1,<5.0a0 + license: LGPL-2.0-or-later + license_family: LGPL + purls: [] + run_exports: + weak: + - libspex >=3.2.3,<4.0a0 + size: 79220 + timestamp: 1741963824815 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libspqr-4.3.4-h23b7119_7100101.conda + sha256: 52851575496122f9088c9f5a4283da7fbb277d9a877b5ce60a939554df542f3c + md5: c1ee33a71065c1f0efd9c8174d5f18b0 + depends: + - libgcc >=13 + - libstdcxx >=13 + - libgcc >=13 + - __glibc >=2.17,<3.0.a0 + - libcholmod >=5.3.1,<6.0a0 + - libblas >=3.9.0,<4.0a0 + - liblapack >=3.9.0,<4.0a0 + - libsuitesparseconfig >=7.10.1,<8.0a0 + license: GPL-2.0-or-later + license_family: GPL + purls: [] + run_exports: + weak: + - libspqr >=4.3.4,<5.0a0 + size: 203419 + timestamp: 1741963824816 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.53.4-h0737f62_1.conda + sha256: 35c05bd0adfaf6fcac01fc3a42214e4e2a44e32f7ce2c77ddae419522c3c328d + md5: 17b328272d5caa0994678529be5b86ab + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - libzlib >=1.3.2,<2.0a0 + license: blessing + purls: [] + run_exports: + weak: + - libsqlite >=3.53.4,<4.0a0 + size: 968893 + timestamp: 1787051134858 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.1-h6154650_1.conda + sha256: 7e463000fa1cba3f3a6597b776f6ab301d425a96e3bc20d0d9d76a3b9f237aa3 + md5: 5c526561e1d2a2e071941174eae84557 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libzlib >=1.3.2,<2.0a0 + - openssl >=3.5.7,<4.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - libssh2 >=1.11.1,<2.0a0 + size: 306045 + timestamp: 1786713107897 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-16.2.0-h934c35e_7.conda + sha256: fa7018298629fc429971fffd6ecba3d27a7b02e4e890d6a93ea01ffebe8cb745 + md5: 9b6707e0caca917fa6ea9ee473f37a5d + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc 16.2.0 ha9f2e26_7 + constrains: + - libstdcxx-ng ==16.2.0=*_7 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + purls: [] + run_exports: {} + size: 6615436 + timestamp: 1790303132935 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-16.2.0-hdf11a46_7.conda + sha256: 337f481db36cc357884f05f404ccd1b3a7e0fc1ee48ec5c884e4281d213bc863 + md5: 25a23bde5e26d548374f3e02b4669670 + depends: + - libstdcxx 16.2.0 h934c35e_7 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + purls: [] + run_exports: + strong: + - libstdcxx + size: 28665 + timestamp: 1790303164510 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libsuitesparseconfig-7.10.1-h901830b_7100101.conda + sha256: d8f32a0b0ee17fbace7af4bd34ad554cc855b9c18e0aeccf8395e1478c161f37 + md5: 57ae1dd979da7aa88a9b38bfa2e1d6b2 + depends: + - libgcc >=13 + - __glibc >=2.17,<3.0.a0 + - libgfortran5 >=13.3.0 + - libgfortran + - libgcc >=13 + - _openmp_mutex >=4.5 + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - libsuitesparseconfig >=7.10.1,<8.0a0 + size: 42708 + timestamp: 1741963824815 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.7.2-hcc2c06a_1.conda + sha256: 10e125da82ca93e09191e66e5a94d566b2cf8d4024e2a0db3a9114297447e0d9 + md5: 0907d876f460ebc941ae590338b6102f + depends: + - __glibc >=2.17,<3.0.a0 + - lerc >=4.2.0,<5.0a0 + - libdeflate >=1.25,<1.26.0a0 + - libgcc >=15 + - libjpeg-turbo >=3.2.0,<4.0a0 + - liblzma >=5.8.3,<6.0a0 + - libstdcxx >=15 + - libwebp-base >=1.6.0,<2.0a0 + - libzlib >=1.3.2,<2.0a0 + - zstd >=1.5.7,<1.6.0a0 + license: HPND + purls: [] + run_exports: + weak: + - libtiff >=4.7.2,<4.8.0a0 + size: 459753 + timestamp: 1787755584172 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libumfpack-6.3.5-h873dde6_7100101.conda + sha256: 9a2c0049210c0223084c29b39404ad6da6538e7a4d1ed74ee8423212998fd686 + md5: 9626fc7667bc6c901c7a0a4004938c71 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libsuitesparseconfig >=7.10.1,<8.0a0 + - libcholmod >=5.3.1,<6.0a0 + - libblas >=3.9.0,<4.0a0 + - libamd >=3.3.3,<4.0a0 + license: GPL-2.0-or-later + license_family: GPL + purls: [] + run_exports: + weak: + - libumfpack >=6.3.5,<7.0a0 + size: 404065 + timestamp: 1741963824815 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libunistring-0.9.10-h7f98852_0.tar.bz2 + sha256: e88c45505921db29c08df3439ddb7f771bbff35f95e7d3103bf365d5d6ce2a6d + md5: 7245a044b4a1980ed83196176b78b73a + depends: + - libgcc-ng >=9.3.0 + license: GPL-3.0-only OR LGPL-3.0-only + purls: [] + run_exports: + weak: + - libunistring >=0,<1.0a0 + size: 1433436 + timestamp: 1626955018689 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.4-hcfc3c73_0.conda + sha256: f34b8d1de9a2bf62476d8608057d9b8a918d97444236dc53a47128f2fae79041 + md5: 54a948337e66706380ff24d6b5fde63f + depends: + - libgcc >=15 + - __glibc >=2.17,<3.0.a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - libuuid >=2.42.4,<3.0a0 + size: 34442 + timestamp: 1790121449161 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libwebp-base-1.6.0-hd42ef1d_1.conda + sha256: 8415001414f488c85b72b9d8cc2071dfb3981a47bc3c8eb56ef91a57d12eae7f + md5: 9332b53d0ea93c5d39e33be03a0c611a + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + constrains: + - libwebp 1.6.0 + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - libwebp-base >=1.6.0,<2.0a0 + size: 428430 + timestamp: 1785954557217 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libxcb-1.17.0-hb83e432_2.conda + sha256: 7b49e6fd2a584b7f072943e6adf4149677af5121246975278804782d37752837 + md5: 61f0ffba9161cbb3a77722869b21e4bb + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - pthread-stubs + - xorg-libxau >=1.0.12,<2.0a0 + - xorg-libxdmcp >=1.1.5,<2.0a0 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - libxcb >=1.17.0,<2.0a0 + size: 395120 + timestamp: 1787885788278 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.38-h280c20c_0.conda + sha256: f7e9292dd219a6435bbb1223da9586c3e70d66d169c5a92f08db3f2127df04e9 + md5: f7a7ff5a6ab331e037abd34f379a631d + depends: + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + license: LGPL-2.1-or-later + purls: [] + run_exports: + weak: + - libxcrypt >=4.4.38 + size: 101957 + timestamp: 1785887123445 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_3.conda + sha256: eb8a0db0aa570124f7d2a93d7c7f596e3390df5e047818d873baad32985fc736 + md5: 0de0122d9570a8ab637c6b73db268389 + depends: + - __glibc >=2.17,<3.0.a0 + constrains: + - zlib 1.3.2 *_3 + license: Zlib + license_family: Other + purls: [] + run_exports: + weak: + - libzlib >=1.3.2,<2.0a0 + size: 63713 + timestamp: 1785362952714 +- conda: https://conda.anaconda.org/conda-forge/linux-64/lp_solve-5.5.2.11-hd590300_0.conda + sha256: 3c28e1494834f77cbd23467fdac0f701cb9a0c17a4251e79e83f0946e788abf9 + md5: c9ca19b1a4b4f1038b23fb8b5918929c + depends: + - libgcc-ng >=12 + license: LGPL-2.1-only + purls: [] + run_exports: {} + size: 410024 + timestamp: 1697545354266 +- conda: https://conda.anaconda.org/conda-forge/linux-64/mafft-7.526-h4bc722e_0.conda + sha256: e307b4d817c5f1d1173896d8d54b1b11761b0fc7889bf618ff59dd6407b11d36 + md5: cf3b2acf649bc31e576ed43a2fa4aaa3 + depends: + - __glibc >=2.17 + - __glibc >=2.17,<3.0.a0 + - gawk + - libgcc-ng >=12 + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - mafft >=7.526,<8.0a0 + size: 2610460 + timestamp: 1720680384725 +- conda: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-base-3.10.9-py313h683a580_0.conda + sha256: ae0233aa03da84e0964a4c214faaa9d0735575714529a7f2ebe96bc712c276bf + md5: 4265d85b1d706caba7ac1d73b5f43dee + depends: + - __glibc >=2.17,<3.0.a0 + - contourpy >=1.0.1 + - cycler >=0.10 + - fonttools >=4.22.0 + - freetype + - kiwisolver >=1.3.1 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libgcc >=14 + - libstdcxx >=14 + - numpy >=1.23 + - numpy >=1.23,<3 + - packaging >=20.0 + - pillow >=8 + - pyparsing >=2.3.1 + - python >=3.13,<3.14.0a0 + - python-dateutil >=2.7 + - python_abi 3.13.* *_cp313 + - qhull >=2020.2,<2020.3.0a0 + - tk >=8.6.13,<8.7.0a0 + license: PSF-2.0 + license_family: PSF + purls: + - pkg:pypi/matplotlib?source=hash-mapping + run_exports: {} + size: 8303180 + timestamp: 1777000576435 +- conda: https://conda.anaconda.org/conda-forge/linux-64/metis-5.1.0-h86e3903_1008.conda + sha256: c845827efbac5eaf722260493dbf06a520c89bf0d59c46605af72cb47c3f75e9 + md5: bd71f3eb5f383d32032e344784d928f6 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - libstdcxx >=15 + license: Apache-2.0 + license_family: APACHE + purls: [] + run_exports: + weak: + - metis >=5.1.0,<5.1.1.0a0 + size: 3956091 + timestamp: 1790635774330 +- conda: https://conda.anaconda.org/conda-forge/linux-64/mpfr-4.2.2-ha2cb11d_1.conda + sha256: 0be79ef2ee536e0c5d3ddb4a52bbae9f26d08560623299f33db2f4c4a17c525a + md5: 7dcc10f6c0bc3596d5519a710a84dfd4 + depends: + - __glibc >=2.17,<3.0.a0 + - gmp >=6.3.0,<7.0a0 + - libgcc >=15 + license: LGPL-3.0-only + license_family: LGPL + purls: [] + run_exports: + weak: + - mpfr >=4.2.2,<5.0a0 + size: 730409 + timestamp: 1787236218159 +- conda: https://conda.anaconda.org/conda-forge/linux-64/mysql-connector-c-6.1.11-h659d440_1008.conda + sha256: 0d796529e90bf6f511fd7199acfb5cc788e04d853e1afd48aa6bad33a6e49008 + md5: 149e0b89cbbe09397f1147cb3736bcbe + depends: + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - openssl >=3.1.3,<4.0a0 + license: GPL-2.0-only + license_family: GPL + purls: [] + run_exports: + weak: + - mysql-connector-c >=6.1.11,<6.1.12.0a0 + size: 1268505 + timestamp: 1697651492989 +- conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_1.conda + sha256: 5d46557214ed184381dafe835b7c94a474a1c3b307a08a250b1ea4779b44ffb3 + md5: ee6c0cd80a60961a1f48aa3e0b91f986 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: X11 AND BSD-3-Clause + purls: [] + run_exports: + weak: + - ncurses >=6.6,<7.0a0 + size: 911196 + timestamp: 1786355078102 +- conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.5.3-py313hb5f73ae_0.conda + sha256: 7093b2633416f91147ed92583b7af6454d9349805601c5bbac8cef2d31f955c6 + md5: efea38e4c681d5c33aade39330bea01c + depends: + - python + - libgcc >=15 + - __glibc >=2.17,<3.0.a0 + - libstdcxx >=15 + - liblapack >=3.9.0,<4.0a0 + - python_abi 3.13.* *_cp313 + - libcblas >=3.9.0,<4.0a0 + - libblas >=3.9.0,<4.0a0 + constrains: + - numpy-base <0a0 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/numpy?source=hash-mapping + run_exports: + weak: + - numpy >=1.25,<3 + size: 9327632 + timestamp: 1788731990928 +- conda: https://conda.anaconda.org/conda-forge/linux-64/openjpeg-2.5.4-heb1ab33_2.conda + sha256: 131688a88bea8da92fe418c4558c5073435e2848911bc4c836c3a9dd5994b4aa + md5: a3f3ac7a68d01c198e276dbb99e62032 + depends: + - libgcc >=15 + - __glibc >=2.17,<3.0.a0 + - libstdcxx >=15 + - libtiff >=4.7.2,<4.8.0a0 + - libzlib >=1.3.2,<2.0a0 + - libpng >=1.6.58,<1.7.0a0 + license: BSD-2-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - openjpeg >=2.5.4,<3.0a0 + size: 391242 + timestamp: 1788425045145 +- conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.4-h781a0a9_0.conda + sha256: 4747b2d6a8336f52343bceb8a1ebf41a9e6e665b9d2e3f989972de53a310599e + md5: 16e3034a330cc625f2c685edec60cf4e + depends: + - __glibc >=2.17,<3.0.a0 + - ca-certificates + - libgcc >=15 + license: Apache-2.0 + license_family: Apache + purls: [] + run_exports: + weak: + - openssl >=3.6.4,<4.0a0 + size: 3202955 + timestamp: 1787698780103 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pcre-8.45-h9c3ff4c_0.tar.bz2 + sha256: 8f35c244b1631a4f31fb1d66ab6e1d9bfac0ca9b679deced1112c7225b3ad138 + md5: c05d1820a6d34ff07aaaab7a9b7eddaa + depends: + - libgcc-ng >=9.3.0 + - libstdcxx-ng >=9.3.0 + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - pcre >=8.45,<9.0a0 + size: 259377 + timestamp: 1623788789327 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.47-h8b3dc9c_1.conda + sha256: 9ebb10a4eb3be51ae67d85c679f5a7a50cb040ed25c783e6331a225ea09991d4 + md5: 06f6113cf1ff4a54b65f87ead132a5f1 + depends: + - __glibc >=2.17,<3.0.a0 + - bzip2 >=1.0.8,<2.0a0 + - libgcc >=15 + - libzlib >=1.3.2,<2.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - pcre2 >=10.47,<10.48.0a0 + size: 1218833 + timestamp: 1787294571916 +- conda: https://conda.anaconda.org/conda-forge/linux-64/perl-5.32.1-10_h7cc23a3_perl5.conda + build_number: 10 + sha256: 6ab2c89273347c20144c20691f98c3721e930af38e801ec16c737d2e24406010 + md5: dfa988f7a513f0f441ba36d128b5d327 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - libxcrypt >=4.4.38 + license: GPL-1.0-or-later OR Artistic-1.0-Perl + purls: [] + run_exports: + weak: + - perl >=5.32.1,<5.33.0a0 *_perl5 + noarch: + - perl >=5.32.1,<6.0a0 *_perl5 + - __unix + size: 13478478 + timestamp: 1790377730194 +- conda: https://conda.anaconda.org/conda-forge/linux-64/perl-class-method-modifiers-2.13-pl5321ha770c72_0.tar.bz2 + sha256: bed763551ecf5e47249f4596b642f6279d64ee6e1c73998236456829c29ea6c2 + md5: 7b7ec3dd22b056c2d5ea53f9033c26b8 + depends: + - perl >=5.32.1,<5.33.0a0 *_perl5 + - perl-test-fatal 0.016.* + license: GPL-1.0-or-later OR Artistic-1.0-Perl + purls: [] + run_exports: + weak: + - perl-class-method-modifiers =2.13 + size: 22098 + timestamp: 1666342663240 +- conda: https://conda.anaconda.org/conda-forge/linux-64/perl-compress-raw-bzip2-2.214-pl5321hda65f42_0.conda + sha256: 2cbd3fcb7028415654057ab3142cee1e5cc4cf9bdd0e590f072e8ecd29cb6382 + md5: 1ec33b9f74a71c17cc5579e35027832a + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - perl >=5.32.1,<5.33.0a0 *_perl5 + license: GPL-1.0-or-later OR Artistic-1.0-Perl + license_family: OTHER + purls: [] + run_exports: {} + size: 55733 + timestamp: 1761332551110 +- conda: https://conda.anaconda.org/conda-forge/linux-64/perl-compress-raw-zlib-2.214-pl5321h4dac143_0.conda + sha256: 4fd3a11f8dbd2c9d1a1c5547e344ad20412a3f0d36967502d9764e1b2734dd47 + md5: 943e7033e6f709adf0d89a3af51ab81b + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - perl >=5.32.1,<5.33.0a0 *_perl5 + license: GPL-1.0-or-later OR Artistic-1.0-Perl + license_family: OTHER + purls: [] + run_exports: {} + size: 81114 + timestamp: 1761332700914 +- conda: https://conda.anaconda.org/conda-forge/linux-64/perl-dbi-1.651-pl5321hb03c661_0.conda + sha256: cfd1fb4b1c56b6ac1b97b5039a4dfc39015d0294e9191ee4cec90ffffe238707 + md5: f8255e8683b5f4f0de3d223bff7c8ef6 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - perl >=5.32.1,<5.33.0a0 *_perl5 + license: GPL-1.0-or-later OR Artistic-1.0-Perl + license_family: OTHER + purls: [] + run_exports: {} + size: 604067 + timestamp: 1784040732388 +- conda: https://conda.anaconda.org/conda-forge/linux-64/perl-encode-3.24-pl5321hb03c661_0.conda + sha256: c83d8de38ce43ca15af05f76bc933ff76894aef84baed47300e463dae0c11857 + md5: 35776d4c5766e9d98754d1e7530c2961 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - perl >=5.32.1,<5.33.0a0 *_perl5 + - perl-exporter + - perl-parent + - perl-storable + license: GPL-1.0-or-later OR Artistic-1.0-Perl + purls: [] + run_exports: {} + size: 1725053 + timestamp: 1780396038421 +- conda: https://conda.anaconda.org/conda-forge/linux-64/perl-inc-latest-0.500-pl5321ha770c72_0.conda + sha256: ff6b6ffffd6ecbed19a00ee41bb54c283d171f3feff7f45e840441551b5ab876 + md5: 0879971f134628d37bc4b13581113134 + depends: + - perl >=5.32.1,<5.33.0a0 *_perl5 + license: Apache-2.0 + license_family: APACHE + purls: [] + run_exports: + weak: + - perl-inc-latest =0.500 + size: 16039 + timestamp: 1669240163980 +- conda: https://conda.anaconda.org/conda-forge/linux-64/perl-module-build-0.4234-pl5321ha770c72_1.conda + sha256: 40bc64172a969e87ade758320049c86c6a0d83cf8aeaa69ad218fa463ac6cb5b + md5: 358d42e9f08dd917b649089526e2ae1f + depends: + - perl >=5.32.1,<5.33.0a0 *_perl5 + - perl-inc-latest 0.500.* + license: GPL-1.0-or-later OR Artistic-1.0-Perl + purls: [] + run_exports: + weak: + - perl-module-build =0.4234 + size: 137087 + timestamp: 1738241035046 +- conda: https://conda.anaconda.org/conda-forge/linux-64/perl-moo-2.005004-pl5321ha770c72_0.tar.bz2 + sha256: e82a11e50392c965e88db4cba4d23ed0be5c4917319385ea23d32d9484246227 + md5: 3499fef1ed2c74f253b1f032f22deb51 + depends: + - perl >=5.32.1,<5.33.0a0 *_perl5 + - perl-class-method-modifiers 2.13.* + - perl-role-tiny 2.002004.* + - perl-sub-quote 2.006006.* + license: GPL-1.0-or-later OR Artistic-1.0-Perl + purls: [] + run_exports: + weak: + - perl-moo =2.005004 + size: 47669 + timestamp: 1666344231925 +- conda: https://conda.anaconda.org/conda-forge/linux-64/perl-pathtools-3.75-pl5321hb9d3cd8_2.conda + sha256: a80bc265aa749ae03fdd6d5f2098312ea6f43cc193ea7aba0e6e4304d84ce8c0 + md5: 03d88c89dfac8a26adcdeff242f94007 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - perl >=5.32.1,<5.33.0a0 *_perl5 + - perl-carp + license: GPL-1.0-or-later OR Artistic-1.0-Perl + license_family: OTHER + purls: [] + run_exports: {} + size: 50681 + timestamp: 1741783312134 +- conda: https://conda.anaconda.org/conda-forge/linux-64/perl-role-tiny-2.002004-pl5321ha770c72_0.tar.bz2 + sha256: 7895ed40c44c08ee3ddbb48a3ee70e1eda32a6c529b632af98663e7603adda08 + md5: 83b5b630aeddca09e26fded9af4f3ce5 + depends: + - perl >=5.32.1,<5.33.0a0 *_perl5 + license: GPL-1.0-or-later OR Artistic-1.0-Perl + purls: [] + run_exports: + weak: + - perl-role-tiny =2.002004 + size: 23283 + timestamp: 1666339833893 +- conda: https://conda.anaconda.org/conda-forge/linux-64/perl-scalar-list-utils-1.70-pl5321hb03c661_0.conda + sha256: 00678b34a57df53fa31585ff1579f42a6dfc8b1b059fd1b386c6e89573959a9f + md5: 046486011bf7674e3c2f2a1513ac4f3d + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - perl >=5.32.1,<5.33.0a0 *_perl5 + license: GPL-1.0-or-later OR Artistic-1.0-Perl + license_family: OTHER + purls: [] + run_exports: {} + size: 51958 + timestamp: 1753965684679 +- conda: https://conda.anaconda.org/conda-forge/linux-64/perl-storable-3.15-pl5321hb9d3cd8_2.conda + sha256: 25beba40154a394189d0ff2afd31683d79c9106d47e77e12d20900d053dffaf6 + md5: 212f63a5c7c753ecf0a74c349b9270c5 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - perl >=5.32.1,<5.33.0a0 *_perl5 + license: GPL-1.0-or-later OR Artistic-1.0-Perl + license_family: OTHER + purls: [] + run_exports: {} + size: 71475 + timestamp: 1741353849888 +- conda: https://conda.anaconda.org/conda-forge/linux-64/perl-sub-quote-2.006006-pl5321ha770c72_0.tar.bz2 + sha256: 4200429318a1a2d9276c4095bb63e29d655fc98208341b6db0752788d3016587 + md5: 3d58e92f33b2382c10ac7eccd883a42f + depends: + - perl >=5.32.1,<5.33.0a0 *_perl5 + - perl-test-fatal 0.016.* + license: GPL-1.0-or-later OR Artistic-1.0-Perl + purls: [] + run_exports: + weak: + - perl-sub-quote =2.006006 + size: 26698 + timestamp: 1666342630627 +- conda: https://conda.anaconda.org/conda-forge/linux-64/perl-test-fatal-0.016-pl5321ha770c72_0.tar.bz2 + sha256: d5420f90b3bca641cdad0c5674b356a060bf1587e82d3828f382a466bdaba6d1 + md5: 5c397b1fd3095004f4ff149af1c0dd3c + depends: + - perl >=5.32.1,<5.33.0a0 *_perl5 + - perl-try-tiny 0.31.* + license: GPL-1.0-or-later OR Artistic-1.0-Perl + purls: [] + run_exports: + weak: + - perl-test-fatal =0.016 + size: 19528 + timestamp: 1666339958976 +- conda: https://conda.anaconda.org/conda-forge/linux-64/perl-try-tiny-0.31-pl5321ha770c72_0.tar.bz2 + sha256: 7e74c95eb085b095a258a22ee2f30192d79f23a58cbbcb8ca2b14f4fe0a8c406 + md5: cc23b14ed56bf51d84832d98ebd156af + depends: + - perl >=5.32.1,<5.33.0a0 *_perl5 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - perl-try-tiny =0.31 + size: 17704 + timestamp: 1659695570098 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pillow-12.3.0-py313h3b26573_4.conda + sha256: 26d0fec97210b130c5d4299a0d648e78a7386be1cc90ae25618fa4b838f1627a + md5: 6739325f3022c709753d26fff83ae20e + depends: + - python + - libgcc >=15 + - __glibc >=2.17,<3.0.a0 + - python_abi 3.13.* *_cp313 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libwebp-base >=1.6.0,<2.0a0 + - libtiff >=4.7.2,<4.8.0a0 + - tk >=8.6.13,<8.7.0a0 + - zlib-ng >=2.3.3,<2.4.0a0 + - openjpeg >=2.5.4,<3.0a0 + - lcms2 >=2.19.1,<3.0a0 + - libxcb >=1.17.0,<2.0a0 + - libjpeg-turbo >=3.2.0,<4.0a0 + license: HPND + purls: + - pkg:pypi/pillow?source=compressed-mapping + run_exports: {} + size: 1072896 + timestamp: 1789122647267 +- conda: https://conda.anaconda.org/conda-forge/linux-64/psutil-7.2.2-py313hd42f317_3.conda + sha256: a7cffeba6c7957cc47f1f28576f39bd04aceb42ab962d5d8c91c3f60fedd304f + md5: 0bc97f7c2f4a6993798c004fd557e3a1 + depends: + - python + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - python_abi 3.13.* *_cp313 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/psutil?source=compressed-mapping + run_exports: {} + size: 228778 + timestamp: 1789682033076 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pthread-stubs-0.4-h7cc23a3_1004.conda + sha256: 4a44fd00ea73b79ca2c89b0727b9ccf61c506ead71e67a9abfa4c590042b5a4a + md5: bb66b610707b811e3c65181a6431e7a8 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + license: MIT + license_family: MIT + purls: [] + run_exports: {} + size: 9630 + timestamp: 1788381877753 +- conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.13.15-hf47f18c_103_cp313.conda + build_number: 103 + sha256: cc18ba39af0d591ac012c1334ac98aa59ec7be389719b4cd80cc0a58a53019de + md5: 641613f2d89da811bc29fa4cde88ef20 + depends: + - __glibc >=2.17,<3.0.a0 + - bzip2 >=1.0.8,<2.0a0 + - ld_impl_linux-64 >=2.36.1 + - libexpat >=2.8.1,<3.0a0 + - libffi >=3.7.0,<3.8.0a0 + - libgcc >=15 + - liblzma >=5.8.3,<6.0a0 + - libmpdec >=4.0.0,<5.0a0 + - libpython 3.13.15 hdc7f604_103_cp313 + - libsqlite >=3.53.4,<4.0a0 + - libuuid >=2.42.3,<3.0a0 + - libzlib >=1.3.2,<2.0a0 + - ncurses >=6.6,<7.0a0 + - openssl >=3.5.8,<4.0a0 + - python_abi 3.13.* *_cp313 + - readline >=8.3,<9.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + license: Python-2.0 + purls: [] + run_exports: + weak: + - python_abi 3.13.* *_cp313 + noarch: + - python + size: 24369771 + timestamp: 1788387840141 + python_site_packages_path: lib/python3.13/site-packages +- conda: https://conda.anaconda.org/conda-forge/linux-64/qhull-2020.2-h434a139_5.conda + sha256: 776363493bad83308ba30bcb88c2552632581b143e8ee25b1982c8c743e73abc + md5: 353823361b1d27eb3960efb076dfcaf6 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 + license: LicenseRef-Qhull + purls: [] + run_exports: + weak: + - qhull >=2020.2,<2020.3.0a0 + size: 552937 + timestamp: 1720813982144 +- conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-hd6e31c0_1.conda + sha256: 01b3fe073a66e321970d09e04b388708f8cbdca5cdfbfcb7c9eeb470ad10383d + md5: 69c01c781e7c8190bbdaf79e3848c5ca + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - ncurses >=6.6,<7.0a0 + license: GPL-3.0-only + license_family: GPL + purls: [] + run_exports: + weak: + - readline >=8.3,<9.0a0 + size: 348899 + timestamp: 1787033801506 +- conda: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.18.1-py313he2a5f1a_1.conda + sha256: 6012c3cb1052fa46c44ed380c04db6edd1f7cd91379ca830c7faf2e344eb0456 + md5: 70c6a7ea500089cf1543378c69f94fac + depends: + - __glibc >=2.17,<3.0.a0 + - libblas >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + - libgcc >=15 + - libgfortran + - libgfortran5 >=15.3.0 + - liblapack >=3.9.0,<4.0a0 + - libstdcxx >=15 + - numpy <2.8 + - numpy >=1.25,<3 + - numpy >=2.0.0 + - python >=3.13,<3.14.0a0 + - python_abi 3.13.* *_cp313 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/scipy?source=compressed-mapping + run_exports: {} + size: 17249511 + timestamp: 1790022620230 +- conda: https://conda.anaconda.org/conda-forge/linux-64/simplejson-4.2.0-py313h995f894_0.conda + sha256: d70057d692f394b275eaeec67e6d22f9f8bc57de3280acc771dee59a0f057c45 + md5: 5318271d58c7cbe5a512321fea791616 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - python >=3.13,<3.14.0a0 + - python_abi 3.13.* *_cp313 + license: MIT + license_family: MIT + purls: + - pkg:pypi/simplejson?source=compressed-mapping + run_exports: {} + size: 176618 + timestamp: 1791026086751 +- conda: https://conda.anaconda.org/conda-forge/linux-64/sqlite-3.53.4-h6e79ffa_1.conda + sha256: 45babc48aef7a468175a609848d56242e43c043a5c2a4d595c220cfc31488028 + md5: 237875bda674b2da7ca68765ffb22645 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - libsqlite 3.53.4 h0737f62_1 + - libzlib >=1.3.2,<2.0a0 + - ncurses >=6.6,<7.0a0 + - readline >=8.3,<9.0a0 + license: blessing + purls: [] + run_exports: + weak: + - libsqlite >=3.53.4,<4.0a0 + size: 205639 + timestamp: 1787051140325 +- conda: https://conda.anaconda.org/conda-forge/linux-64/suitesparse-7.10.1-h5b2951e_7100101.conda + sha256: 7c1c5bd2ba8385202ac3cb4c9c7f9bb87a2e677e977afd72c910314c014b28be + md5: e927e0f248a498050443dab8bb1203a9 + depends: + - libsuitesparseconfig ==7.10.1 h901830b_7100101 + - libamd ==3.3.3 h456b2da_7100101 + - libbtf ==2.3.2 hf02c80a_7100101 + - libcamd ==3.3.3 hf02c80a_7100101 + - libccolamd ==3.3.4 hf02c80a_7100101 + - libcolamd ==3.3.4 hf02c80a_7100101 + - libcholmod ==5.3.1 h9cf07ce_7100101 + - libcxsparse ==4.4.1 hf02c80a_7100101 + - libldl ==3.3.2 hf02c80a_7100101 + - libklu ==2.3.5 h95ff59c_7100101 + - libumfpack ==6.3.5 h873dde6_7100101 + - libparu ==1.0.0 hc6afc67_7100101 + - librbio ==4.3.4 hf02c80a_7100101 + - libspex ==3.2.3 h9226d62_7100101 + - libspqr ==4.3.4 h23b7119_7100101 + license: LGPL-2.1-or-later AND BSD-3-Clause AND GPL-2.0-or-later AND Apache-2.0 + purls: [] + run_exports: + weak: + - libsuitesparseconfig >=7.10.1,<8.0a0 + - libamd >=3.3.3,<4.0a0 + - libbtf >=2.3.2,<3.0a0 + - libcamd >=3.3.3,<4.0a0 + - libccolamd >=3.3.4,<4.0a0 + - libcolamd >=3.3.4,<4.0a0 + - libcholmod >=5.3.1,<6.0a0 + - libcxsparse >=4.4.1,<5.0a0 + - libldl >=3.3.2,<4.0a0 + - libklu >=2.3.5,<3.0a0 + - libumfpack >=6.3.5,<7.0a0 + - libparu >=1.0.0,<2.0a0 + - librbio >=4.3.4,<5.0a0 + - libspex >=3.2.3,<4.0a0 + - libspqr >=4.3.4,<5.0a0 + - suitesparse >=7.10.1,<8.0a0 + size: 12135 + timestamp: 1741963824816 +- conda: https://conda.anaconda.org/conda-forge/linux-64/tar-1.35-h3b78370_0.conda + sha256: eab162cadb948c91c14f18b6f30a7c270d682e820c4f2fdb0030c9fc99b3fa49 + md5: 8e037804a92c84cb901bdd83a8e5ff46 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libiconv >=1.18,<2.0a0 + license: GPL-3.0-or-later + license_family: GPL + purls: [] + run_exports: {} + size: 778622 + timestamp: 1753467956747 +- conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h1df4ec4_4.conda + build_number: 104 + sha256: a1a241d172c1ccab067ba245206dd048bc3c2d1b84504b53c9468e99adfc16a1 + md5: 676a2f9b1c4fcf57b70aa5c65f6c60d0 + depends: + - libgcc >=15 + - __glibc >=2.17,<3.0.a0 + - libzlib >=1.3.2,<2.0a0 + constrains: + - xorg-libx11 >=1.8.13,<2.0a0 + license: TCL + purls: [] + run_exports: + weak: + - tk >=8.6.13,<8.7.0a0 + size: 3566806 + timestamp: 1787272857910 +- conda: https://conda.anaconda.org/conda-forge/linux-64/wget-1.25.0-h653f8fd_1.conda + sha256: 66a5a05e0e44fd7a57e24d77665d5d6672646a7b316575b2f679108966d9124e + md5: 3b97a15e7345c7f6c51bb57bffad7c93 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libidn2 >=2,<3.0a0 + - libunistring >=0,<1.0a0 + - libzlib >=1.3.1,<2.0a0 + - openssl >=3.5.5,<4.0a0 + - pcre2 >=10.47,<10.48.0a0 + - zlib + license: GPL-3.0-or-later + license_family: GPL + purls: [] + run_exports: {} + size: 746336 + timestamp: 1772232737502 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxau-1.0.12-h7cc23a3_2.conda + sha256: 3ec065b94554dc48a4ca582a960a5484bc166b26e83ce0954653e08d17e8bd53 + md5: da33efee1a93603d92e06d4a2b68def6 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - xorg-libxau >=1.0.12,<2.0a0 + size: 18793 + timestamp: 1788960512381 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdmcp-1.1.5-h7cc23a3_2.conda + sha256: 8a095df9bc1d2e50f2504ce8858a047ae29ea634aad6cc0b43298c63361da6d9 + md5: eabfc45786244de252090cf8d55128a8 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + license: MIT + license_family: MIT + purls: [] + run_exports: + weak: + - xorg-libxdmcp >=1.1.5,<2.0a0 + size: 22606 + timestamp: 1789676943335 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xz-5.8.3-ha02ee65_1.conda + sha256: 547b2392d8f7b76efd4a0970946f6da2a1136ad5fe3dc936af81e02eb7181076 + md5: 36a079606b3aaf9d726211825f182452 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - liblzma 5.8.3 hb03c661_1 + - liblzma-devel 5.8.3 hb03c661_1 + - xz-gpl-tools 5.8.3 ha02ee65_1 + - xz-tools 5.8.3 hb03c661_1 + license: 0BSD AND LGPL-2.1-or-later AND GPL-2.0-or-later + purls: [] + run_exports: + weak: + - liblzma >=5.8.3,<6.0a0 + size: 23610 + timestamp: 1786348658246 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xz-gpl-tools-5.8.3-ha02ee65_1.conda + sha256: ed6dbec5e4f0f71e7ac629b90dc4c9fba38d194cc88eab891c29e461b408977a + md5: 137db930adb0b3c5407485e0e1a50cfa + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - liblzma 5.8.3 hb03c661_1 + constrains: + - xz 5.8.3.* + license: 0BSD AND LGPL-2.1-or-later AND GPL-2.0-or-later + purls: [] + run_exports: + weak: + - liblzma >=5.8.3,<6.0a0 + size: 40118 + timestamp: 1786348648882 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xz-tools-5.8.3-hb03c661_1.conda + sha256: c74fa3eddd3ea648456517948f85068d8a07acad7752fd83c7e95b6cebb7114a + md5: 10d693a2db6e8339e4eebcb3a3dae88d + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - liblzma 5.8.3 hb03c661_1 + constrains: + - xz 5.8.3.* + license: 0BSD AND LGPL-2.1-or-later + purls: [] + run_exports: {} + size: 96459 + timestamp: 1786348637686 +- conda: https://conda.anaconda.org/conda-forge/linux-64/zlib-1.3.2-h25fd6f3_3.conda + sha256: 16080a1c7724f7d25727cdc23c7658e0cec2db52448c1dc0c33467ee2c6e1c62 + md5: 6acb86426229f96f93e5468d1df3a5e8 + depends: + - __glibc >=2.17,<3.0.a0 + - libzlib 1.3.2 h25fd6f3_3 + license: Zlib + license_family: Other + purls: [] + run_exports: + weak: + - libzlib >=1.3.2,<2.0a0 + size: 96132 + timestamp: 1785362957588 +- conda: https://conda.anaconda.org/conda-forge/linux-64/zlib-ng-2.3.3-hce19668_1.conda + sha256: 8b786bb4380fa69a718b08a400040b865bc9207eda337e0a1955717c3c3a9403 + md5: 1726acec19beeed1c764385cd8622405 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - libstdcxx >=15 + license: Zlib + license_family: Other + purls: [] + run_exports: + weak: + - zlib-ng >=2.3.3,<2.4.0a0 + size: 123959 + timestamp: 1786736890973 +- conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_7.conda + sha256: 47d682b9f6d6ec9eb1a6e6c3e75ea6273e899e78fb7fc59f81d39745009fbc60 + md5: aa459086047c0e5e27023ab19f8cb86a + depends: + - __glibc >=2.17,<3.0.a0 + - libzlib >=1.3.2,<2.0a0 + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: + weak: + - zstd >=1.5.7,<1.6.0a0 + size: 601301 + timestamp: 1786599621503 +- conda: https://conda.anaconda.org/conda-forge/noarch/argcomplete-3.7.2-pyhcf101f3_0.conda + sha256: 7a0e771e709b1620a914ba8a9590433c4a9fd84779d137216ac29ca50e959a1f + md5: 5185c9f9742daeffae5daae93c802bf7 + depends: + - python >=3.10 + - python + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/argcomplete?source=hash-mapping + run_exports: {} + size: 47150 + timestamp: 1786180543999 +- conda: https://conda.anaconda.org/conda-forge/noarch/argh-0.31.3-pyhd8ed1ab_1.conda + sha256: 77461522043a7eb5a42ae87071382816487bc07823cf2ba5a7aa5b00eb6cb81f + md5: 8076e887c023ab1229e72aed02c9b33f + depends: + - python >=3.9 + license: LGPL-3.0-or-later + license_family: LGPL + purls: + - pkg:pypi/argh?source=hash-mapping + run_exports: {} + size: 44983 + timestamp: 1736349335944 +- conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.7.22-hbd8a1cb_0.conda + sha256: 0a0544cf95f64394fe4959286f5c71f5444ad58feb0602e53becb27448d24da6 + md5: 0f51e2391ade309db462a55611263e9c + depends: + - __unix + license: ISC + purls: [] + run_exports: {} + size: 131780 + timestamp: 1784754889428 +- conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda + sha256: ab29d57dc70786c1269633ba3dff20288b81664d3ff8d21af995742e2bb03287 + md5: 962b9857ee8e7018c22f2776ffa0b2d7 + depends: + - python >=3.9 + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/colorama?source=hash-mapping + run_exports: {} + size: 27011 + timestamp: 1733218222191 +- conda: https://conda.anaconda.org/conda-forge/noarch/cycler-0.12.1-pyhcf101f3_2.conda + sha256: bb47aec5338695ff8efbddbc669064a3b10fe34ad881fb8ad5d64fbfa6910ed1 + md5: 4c2a8fef270f6c69591889b93f9f55c1 + depends: + - python >=3.10 + - python + license: BSD-3-Clause + license_family: BSD + purls: + - pkg:pypi/cycler?source=hash-mapping + run_exports: {} + size: 14778 + timestamp: 1764466758386 +- conda: https://conda.anaconda.org/conda-forge/noarch/disjoint-set-0.8.0-pyhd8ed1ab_0.conda + sha256: 798c520001a253b92d09b0fe9bb0f168c4ffa47eab452a29be82058e64e290c7 + md5: 149b386baf11814ab07646244d72fa08 + depends: + - python >=3.7 + license: MIT + license_family: MIT + purls: + - pkg:pypi/disjoint-set?source=hash-mapping + run_exports: {} + size: 11482 + timestamp: 1710363488655 +- conda: https://conda.anaconda.org/conda-forge/noarch/exceptiongroup-1.3.1-pyhd8ed1ab_0.conda + sha256: ee6cf346d017d954255bbcbdb424cddea4d14e4ed7e9813e429db1d795d01144 + md5: 8e662bd460bda79b1ea39194e3c4c9ab + depends: + - python >=3.10 + - typing_extensions >=4.6.0 + license: MIT and PSF-2.0 + purls: + - pkg:pypi/exceptiongroup?source=hash-mapping + run_exports: {} + size: 21333 + timestamp: 1763918099466 +- conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-9.0.1-pyhcf101f3_0.conda + sha256: 95a074a7d3f58b3494c068d4789c364dcb591c56b70ca6b12f149a540f9aeea4 + md5: 77ec68e0aa61c3fff9ecbf840f93d64e + depends: + - python >=3.10 + - zipp >=3.20 + - python + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/importlib-metadata?source=compressed-mapping + run_exports: {} + size: 34920 + timestamp: 1787943971257 +- conda: https://conda.anaconda.org/conda-forge/noarch/iniconfig-2.3.0-pyhd8ed1ab_0.conda + sha256: e1a9e3b1c8fe62dc3932a616c284b5d8cbe3124bbfbedcf4ce5c828cb166ee19 + md5: 9614359868482abba1bd15ce465e3c42 + depends: + - python >=3.10 + license: MIT + license_family: MIT + purls: + - pkg:pypi/iniconfig?source=hash-mapping + run_exports: {} + size: 13387 + timestamp: 1760831448842 +- conda: https://conda.anaconda.org/conda-forge/noarch/munkres-1.1.4-pyhd8ed1ab_1.conda + sha256: d09c47c2cf456de5c09fa66d2c3c5035aa1fa228a1983a433c47b876aa16ce90 + md5: 37293a85a0f4f77bbd9cf7aaefc62609 + depends: + - python >=3.9 + license: Apache-2.0 + license_family: Apache + purls: + - pkg:pypi/munkres?source=hash-mapping + run_exports: {} + size: 15851 + timestamp: 1749895533014 +- conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.3-pyhc364b38_0.conda + sha256: c432626b16768b8dab228bfb706f7060c2d462a21c516d240f68f2f902b5a044 + md5: 936687ed80f295a1f5dbcf8bd34c252c + depends: + - python >=3.9 + - python + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/packaging?source=hash-mapping + run_exports: {} + size: 116363 + timestamp: 1785888127370 +- conda: https://conda.anaconda.org/conda-forge/noarch/perl-app-cpanminus-1.7048-pl5321hd8ed1ab_0.conda + sha256: 20850458e691b12fc4da209e204fc4c4d1abe93311913929dc536b9b3857b681 + md5: adb8fae79589a7bb03aa9ad976e3bd92 + depends: + - perl >=5.32.1,<6.0a0 *_perl5 + - __unix + license: GPL-1.0-or-later OR Artistic-1.0-Perl + purls: [] + run_exports: {} + size: 229935 + timestamp: 1730267467434 +- conda: https://conda.anaconda.org/conda-forge/noarch/perl-carp-1.50-pl5321hd8ed1ab_0.tar.bz2 + sha256: 1981e31113e1e77a2cdc13db657c636f047cd3be2a64d9a0bffac03c5427c1bd + md5: bdddc03e28019b902da71b722f2288d7 + depends: + - perl >=5.32.1,<6.0a0 *_perl5 + - perl-exporter + - perl-extutils-makemaker + - __unix + license: GPL-1.0-or-later OR Artistic-1.0-Perl + license_family: OTHER + purls: [] + run_exports: {} + size: 22257 + timestamp: 1636653208008 +- conda: https://conda.anaconda.org/conda-forge/noarch/perl-common-sense-3.75-pl5321hd8ed1ab_0.tar.bz2 + sha256: 38ef218e9b9d55b9fbdce6b31cf81bcf6f1b16f21b8e7cb9279b41399522a320 + md5: ef70dc77e8b10bbb62f5e843b401ef0e + depends: + - perl >=5.32.1,<6.0a0 *_perl5 + - __unix + license: GPL-1.0-or-later OR Artistic-1.0-Perl + license_family: OTHER + purls: [] + run_exports: {} + size: 20291 + timestamp: 1660429950685 +- conda: https://conda.anaconda.org/conda-forge/noarch/perl-constant-1.33-pl5321hd8ed1ab_0.tar.bz2 + sha256: cfd5ef9af8de221292f7059d1ff88ff10f1340fc4dbbd0dc81ce2275bf76651d + md5: 7f9fc9cfa08a3fe36ffcff820c65c3ac + depends: + - perl >=5.32.1,<6.0a0 *_perl5 + - __unix + license: GPL-1.0-or-later OR Artistic-1.0-Perl + license_family: OTHER + purls: [] + run_exports: {} + size: 15711 + timestamp: 1636645107290 +- conda: https://conda.anaconda.org/conda-forge/noarch/perl-exporter-5.74-pl5321hd8ed1ab_0.tar.bz2 + sha256: 42271d0b79043a10a89044acb5febea50046b745dd2fc37e02943bc3bc75bf8e + md5: fd2eac4e35f8c970870a3961c1df3e29 + depends: + - perl >=5.32.1,<6.0a0 *_perl5 + - __unix + license: GPL-1.0-or-later OR Artistic-1.0-Perl + license_family: OTHER + purls: [] + run_exports: {} + size: 19071 + timestamp: 1636696009075 +- conda: https://conda.anaconda.org/conda-forge/noarch/perl-exporter-tiny-1.002002-pl5321hd8ed1ab_0.tar.bz2 + sha256: abdf86828a12a389d0feb0d70501b267842557bae11820e266526aeb6ab2bebe + md5: 48d709826875be1f2c108d3d1d8efec7 + depends: + - perl >=5.32.1,<6.0a0 *_perl5 + - __unix + license: GPL-1.0-or-later OR Artistic-1.0-Perl + license_family: OTHER + purls: [] + run_exports: {} + size: 28592 + timestamp: 1660341479867 +- conda: https://conda.anaconda.org/conda-forge/noarch/perl-extutils-makemaker-7.70-pl5321hd8ed1ab_0.conda + sha256: 1d3f342ca74cf2948c3edcfe0d3367b1db0fc64bb163393a2e025336dec3a40c + md5: ec3e57ed34f7765bfc7054a05868ce5d + depends: + - perl >=5.32.1,<6.0a0 *_perl5 + - __unix + license: GPL-1.0-or-later OR Artistic-1.0-Perl + license_family: OTHER + purls: [] + run_exports: {} + size: 157323 + timestamp: 1679847836884 +- conda: https://conda.anaconda.org/conda-forge/noarch/perl-file-path-2.18-pl5321hd8ed1ab_0.tar.bz2 + sha256: ac7a0e0c36ec199709c8523132ded35efb84941a1a476b271fd25362dfbf5339 + md5: e13e456f61b8261ba074c0aa93086afe + depends: + - perl >=5.32.1,<6.0a0 *_perl5 + - perl-exporter + - __unix + license: GPL-1.0-or-later OR Artistic-1.0-Perl + license_family: OTHER + purls: [] + run_exports: {} + size: 22382 + timestamp: 1636696260633 +- conda: https://conda.anaconda.org/conda-forge/noarch/perl-file-temp-0.2304-pl5321hd8ed1ab_0.tar.bz2 + sha256: 91f9fe152b38441386053876198d0c9437e7b4b5fa7da1e5db48b9e1b21fdae9 + md5: 0a039c4fc36748942287ee10d0431515 + depends: + - perl >=5.32.1,<6.0a0 *_perl5 + - perl-carp + - perl-constant + - perl-exporter + - perl-file-path + - perl-parent + - __unix + license: GPL-1.0-or-later OR Artistic-1.0-Perl + license_family: OTHER + purls: [] + run_exports: {} + size: 31509 + timestamp: 1636696164992 +- conda: https://conda.anaconda.org/conda-forge/noarch/perl-file-which-1.24-pl5321hd8ed1ab_0.tar.bz2 + sha256: 901e9c4177b6bdb23600446fd64a105a437112e63bc23a6163f669bc5098c502 + md5: 94e5b2c9d56ef7c4c70ddf51ac38ae3d + depends: + - perl >=5.32.1,<6.0a0 *_perl5 + - __unix + license: GPL-1.0-or-later OR Artistic-1.0-Perl + license_family: OTHER + purls: [] + run_exports: {} + size: 17329 + timestamp: 1636695979827 +- conda: https://conda.anaconda.org/conda-forge/noarch/perl-parent-0.243-pl5321hd8ed1ab_0.conda + sha256: ec57d9e56ba86d840d5a9e65c665365fb6a290851cd13e6719628f3295eabf34 + md5: 314caa3b72d65f8078d426c6721dcacc + depends: + - perl >=5.32.1,<6.0a0 *_perl5 + - __unix + license: GPL-1.0-or-later OR Artistic-1.0-Perl + license_family: OTHER + purls: [] + run_exports: {} + size: 13933 + timestamp: 1733429736293 +- conda: https://conda.anaconda.org/conda-forge/noarch/pip-26.2.1-pyh145f28c_0.conda + sha256: 0f7021cfb3ff454c91a5e28e1f5060906a52c6d1cde3f879a7d03ac33c28b1c3 + md5: 573cb3ed111004230ed3de650653cd4d + depends: + - python >=3.13.0a0 + license: MIT + license_family: MIT + purls: + - pkg:pypi/pip?source=hash-mapping + run_exports: {} + size: 1198163 + timestamp: 1785914482439 +- conda: https://conda.anaconda.org/conda-forge/noarch/pluggy-1.6.0-pyhf9edf01_1.conda + sha256: e14aafa63efa0528ca99ba568eaf506eb55a0371d12e6250aaaa61718d2eb62e + md5: d7585b6550ad04c8c5e21097ada2888e + depends: + - python >=3.9 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/pluggy?source=hash-mapping + run_exports: {} + size: 25877 + timestamp: 1764896838868 +- conda: https://conda.anaconda.org/conda-forge/noarch/pygenomeviz-1.7.0-pyhd8ed1ab_0.conda + sha256: 82d7c8baf4f7a0cb4c466664df10037efe4111c98114cb77454c27fda163774f + md5: 22ee3f3befa9196f3255ebf3cfb33f46 + depends: + - biopython >=1.80 + - matplotlib-base >=3.6.3 + - numpy >=1.21 + - python >=3.10 + constrains: + - streamlit >=1.32.0 + license: MIT + license_family: MIT + purls: + - pkg:pypi/pygenomeviz?source=hash-mapping + run_exports: {} + size: 1629848 + timestamp: 1781338565444 +- conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.21.0-pyhcf101f3_0.conda + sha256: f5f015ff1bc3e1b7fc08eee096b1865234189ae0b82bebdb86a5369116e42fa0 + md5: 2882dee445dfa45b0c5afce3ffb7730a + depends: + - python >=3.10 + - python + license: BSD-2-Clause + license_family: BSD + purls: + - pkg:pypi/pygments?source=compressed-mapping + run_exports: {} + size: 959376 + timestamp: 1786995678795 +- conda: https://conda.anaconda.org/conda-forge/noarch/pyparsing-3.3.3-pyh5ded981_0.conda + sha256: dc10d64d4b9a1310083b2f563416ab45560ee2a04fd6baab40f223f2b1ab37bc + md5: 8bf43ae1312e9b966063459e04c20fa7 + depends: + - python >=3.11 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/pyparsing?source=compressed-mapping + run_exports: {} + size: 114046 + timestamp: 1790063282695 +- conda: https://conda.anaconda.org/conda-forge/noarch/pytest-9.1.1-pyhc364b38_2.conda + sha256: 430051d80765207a7d782b2b188230ba1489d35c6e75fd9903f76cb9fda4af16 + md5: 64c98a12c4e23eb238bf66bbecafdf3c + depends: + - colorama + - pygments >=2.7.2 + - python >=3.10 + - iniconfig >=1.0.1 + - packaging >=22 + - pluggy >=1.5,<2 + - tomli >=1 + - exceptiongroup >=1 + - python + constrains: + - pytest-faulthandler >=2 + license: MIT + license_family: MIT + purls: + - pkg:pypi/pytest?source=hash-mapping + run_exports: {} + size: 306724 + timestamp: 1782127176429 +- conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda + sha256: d6a17ece93bbd5139e02d2bd7dbfa80bee1a4261dced63f65f679121686bf664 + md5: 5b8d21249ff20967101ffa321cab24e8 + depends: + - python >=3.9 + - six >=1.5 + - python + license: Apache-2.0 + license_family: APACHE + purls: + - pkg:pypi/python-dateutil?source=hash-mapping + run_exports: {} + size: 233310 + timestamp: 1751104122689 +- conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.13-9_cp313.conda + build_number: 9 + sha256: 9dc0cb6a20ebc7e9bcd8c6868f2bec083c114b0ba20b7118405c036533d5c522 + md5: c5abc97af551bc12d71305852392f75c + constrains: + - python 3.13.* *_cp313 + license: BSD-3-Clause + license_family: BSD + purls: [] + run_exports: {} + size: 6769 + timestamp: 1788302828005 +- conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-84.0.0-pyh332efcf_0.conda + sha256: 9e200ee5f9ff19a4d94e4b51c4856d53dec849f91032f345cf0c6bc3d51a7183 + md5: 62ac906f1cd582c6c264c95625cb9d6f + depends: + - python >=3.10 + license: MIT + license_family: MIT + purls: + - pkg:pypi/setuptools?source=compressed-mapping + run_exports: {} + size: 524488 + timestamp: 1786282924579 +- conda: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda + sha256: 458227f759d5e3fcec5d9b7acce54e10c9e1f4f4b7ec978f3bfd54ce4ee9853d + md5: 3339e3b65d58accf4ca4fb8748ab16b3 + depends: + - python >=3.9 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/six?source=hash-mapping + run_exports: {} + size: 18455 + timestamp: 1753199211006 +- conda: https://conda.anaconda.org/conda-forge/noarch/tomli-2.4.1-pyhcf101f3_0.conda + sha256: 91cafdb64268e43e0e10d30bd1bef5af392e69f00edd34dfaf909f69ab2da6bd + md5: b5325cf06a000c5b14970462ff5e4d58 + depends: + - python >=3.10 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/tomli?source=hash-mapping + run_exports: {} + size: 21561 + timestamp: 1774492402955 +- conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.16.0-pyhcf101f3_0.conda + sha256: 2d888f90af0686044882c74193ec80a90ec1943145d94a7b1b048958acda1848 + md5: c70ad746c22219b9700931707482992c + depends: + - python >=3.10 + - python + license: PSF-2.0 + license_family: PSF + purls: + - pkg:pypi/typing-extensions?source=hash-mapping + run_exports: {} + size: 52631 + timestamp: 1783002732887 +- conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026c-h151e31d_0.conda + sha256: b928c30ddcb0e3f544c6eade8352737e6e610e263276b90232db6a578ef899d8 + md5: fcb489df604d100968b737f2cb6076c6 + license: LicenseRef-Public-Domain + purls: [] + run_exports: {} + size: 118849 + timestamp: 1784250406640 +- conda: https://conda.anaconda.org/conda-forge/noarch/zipp-4.1.0-pyhcf101f3_0.conda + sha256: 210bd31c22bb88f5e2a167df24c95bb5f152b2ada7502f9b8c49d1f5366db423 + md5: ba3dcdc8584155c97c648ae9c044b7a3 + depends: + - python >=3.10 + - python + license: MIT + license_family: MIT + purls: + - pkg:pypi/zipp?source=hash-mapping + run_exports: {} + size: 24190 + timestamp: 1779159948016 +- pypi: ./ + name: matpredict + requires_dist: + - pyyaml>=6.0 + - jsonschema>=4.21 + - duckdb>=1.0 + - biopython>=1.83 + - requests>=2.31 + - pyhmmer>=0.12 + - pygenomeviz>=1.7.0,<2 ; extra == 'viz' + - clinker>=0.0.32,<0.0.33 ; extra == 'viz' + requires_python: '>=3.11' +- pypi: https://files.pythonhosted.org/packages/0b/a7/71ac2cff56fec219ed242bb11b8efb69fcc4bec75db06fb7bfe35de520e6/certifi-2026.7.22-py3-none-any.whl + name: certifi + version: 2026.7.22 + sha256: 62f22742b58a1a33014a2b6b706588a8d7e2a88ae7bd1a6ebe8c992928483775 + requires_python: '>=3.7' +- pypi: https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl + name: referencing + version: 0.37.0 + sha256: 381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231 + requires_dist: + - attrs>=22.2.0 + - rpds-py>=0.7.0 + - typing-extensions>=4.4.0 ; python_full_version < '3.13' + requires_python: '>=3.10' +- pypi: https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl + name: jsonschema-specifications + version: 2025.9.1 + sha256: 98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe + requires_dist: + - referencing>=0.31.0 + requires_python: '>=3.9' +- pypi: https://files.pythonhosted.org/packages/4b/85/41d27f234b82e47c167a5f6c0f62501dc0c640585ff4aba79e08a390336a/charset_normalizer-3.5.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl + name: charset-normalizer + version: 3.5.2 + sha256: 7218e8f32b0956cfcd048fd42d9d5779809745ca1d86113ca56f66e7ae1549c4 + requires_python: '>=3.7' +- pypi: https://files.pythonhosted.org/packages/57/d7/fe978efc2ae50abe48eb7464668ea99f53c010c60aeebb7b35ad27f23661/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl + name: rpds-py + version: 2026.6.3 + sha256: acac386b453c2516111b50985d60ce46e7fadb5ea71ae7b25f4c946935bf27cf + requires_python: '>=3.11' +- pypi: https://files.pythonhosted.org/packages/58/a2/bb081bab032533a855d44de1d56f8e8426114ff1ba5d1f07a438a0a654f8/idna-3.20-py3-none-any.whl + name: idna + version: '3.20' + sha256: ab7ae7122974553370f0bdb919e1a960b2cd1bc1ef0276416d896db81c14582c + requires_dist: + - ruff>=0.16.0 ; extra == 'all' + - mypy>=1.11.2 ; extra == 'all' + - ty>=0.0.37 ; extra == 'all' + - pytest>=8.3.2 ; extra == 'all' + - hypothesis>=6.141.1 ; extra == 'all' + - coverage>=7.10.0 ; extra == 'all' + requires_python: '>=3.9' +- pypi: https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl + name: attrs + version: 26.1.0 + sha256: c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309 + requires_python: '>=3.9' +- pypi: https://files.pythonhosted.org/packages/69/90/f63fb5873511e014207a475e2bb4e8b2e570d655b00ac19a9a0ca0a385ee/jsonschema-4.26.0-py3-none-any.whl + name: jsonschema + version: 4.26.0 + sha256: d489f15263b8d200f8387e64b4c3a75f06629559fb73deb8fdfb525f2dab50ce + requires_dist: + - attrs>=22.2.0 + - jsonschema-specifications>=2023.3.6 + - referencing>=0.28.4 + - rpds-py>=0.25.0 + - fqdn ; extra == 'format' + - idna ; extra == 'format' + - isoduration ; extra == 'format' + - jsonpointer>1.13 ; extra == 'format' + - rfc3339-validator ; extra == 'format' + - rfc3987 ; extra == 'format' + - uri-template ; extra == 'format' + - webcolors>=1.11 ; extra == 'format' + - fqdn ; extra == 'format-nongpl' + - idna ; extra == 'format-nongpl' + - isoduration ; extra == 'format-nongpl' + - jsonpointer>1.13 ; extra == 'format-nongpl' + - rfc3339-validator ; extra == 'format-nongpl' + - rfc3986-validator>0.1.0 ; extra == 'format-nongpl' + - rfc3987-syntax>=1.1.0 ; extra == 'format-nongpl' + - uri-template ; extra == 'format-nongpl' + - webcolors>=24.6.0 ; extra == 'format-nongpl' + requires_python: '>=3.10' +- pypi: https://files.pythonhosted.org/packages/70/21/61dd2876bbaa69cf77d7b5c620e52e8b25faae7096f4d2e4a812b52095d7/duckdb-1.5.6-cp313-cp313-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl + name: duckdb + version: 1.5.6 + sha256: 644f54ce99b3b61844bc9a3fe80e0aecb1ea4084b1fffc4396d1569db6111679 + requires_dist: + - ipython ; extra == 'all' + - fsspec ; extra == 'all' + - numpy ; extra == 'all' + - pandas ; extra == 'all' + - pyarrow ; extra == 'all' + - adbc-driver-manager ; extra == 'all' + requires_python: '>=3.10.0' +- pypi: https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl + name: pyyaml + version: 6.0.3 + sha256: 0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6 + requires_python: '>=3.8' +- pypi: https://files.pythonhosted.org/packages/92/9d/c4e665119135114480843e7ab388fa94d8480650450e6f8e26b70d323a4c/urllib3-2.8.0-py3-none-any.whl + name: urllib3 + version: 2.8.0 + sha256: 0cf3cae568d36aa9576b28dfb35f11328f1cb974ca7647d9475ebb86c75ac6e3 + requires_dist: + - brotli>=1.2.0 ; platform_python_implementation == 'CPython' and extra == 'brotli' + - brotlicffi>=1.2.0.0 ; platform_python_implementation != 'CPython' and extra == 'brotli' + - h2>=4,<5 ; extra == 'h2' + - pysocks>=1.5.6,!=1.5.7,<2.0 ; extra == 'socks' + - backports-zstd>=1.0.0 ; python_full_version < '3.14' and extra == 'zstd' + requires_python: '>=3.10' +- pypi: https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl + name: requests + version: 2.34.2 + sha256: 2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0 + requires_dist: + - charset-normalizer>=2,<4 + - idna>=2.5,<4 + - urllib3>=1.26,<3 + - certifi>=2023.5.7 + - pysocks>=1.5.6,!=1.5.7 ; extra == 'socks' + - chardet>=3.0.2,<8 ; extra == 'use-chardet-on-py3' + requires_python: '>=3.10'