NEWS

apbCatalogR 0.99.4

Names follow apb-catalog's vocabulary: the catalog is apb-catalog as a whole, abundance_alpha and the others are its sets, spelled "catalog" throughout. catalogues() is sets(), with a set column instead of catalogue; catalogue_table(catalogue) is catalog_table(set_name); rule_coverage(catalogue) is rule_coverage(set_name).
Catalog$new(software, software_version, set_name, enforce) replaces Catalog$new(software, version, catalog, enforce): the version is a real software version such as "2.2.0", and a version label such as 2.x stays version. DataCatalog$new(result, ..., enforce) is unchanged.
catalog_table() and fields() call the slot slot, not location, and have a version column after source: the version label of the entry's id, for a vendor entry of every version the label of the row's version pattern, * for an app's or an annotation's entry. fields() of a DataCatalog composing several sets keeps catalog_table()'s column order.
rule_coverage() has the columns software, version, software_version_pattern, level, slot, table, name, key, kind, one qualifier.<name> column per qualifier of the set, producer, requirement, needs and verdict: column is name, location is slot, and the qualifiers string and the origin column give way to the qualifier.<name> columns, as in catalog_table().
Bundle format 5: the tables are in data/, not catalogues/; the manifest lists sets; catalog.csv names who writes a field in a source column, not software. Bundles of format 4 are passed over. The test bundle's cases name set and, for Catalog, software_version.
The README says how AI coding agents were used, where the code comes from, under which licence it can be redistributed, and that the maintainer is responsible for it.
Messages say "set": "unknown set", "no set named", "the set reviews no entries for …", "the sets … set no requirements"; in Catalog$new() and rule_coverage(), a software_version or set_name that is not one character string is an error naming that argument.

apbCatalogR 0.99.3

rhdf5 is suggested without a minimum version. 0.99.2 asked for 2.57.5, which Bioconductor 3.23 does not have, so its dependencies could not be installed there; reading a .h5ad result works with rhdf5 2.56.

apbCatalogR 0.99.2

Catalog$new(), rule_coverage(), read_parsed_levels(), update_catalog() and every key lookup check their arguments: a software, version, set, key or path that is not one character string, or a path that does not exist, is an error that says so.
The vignette says why apbCatalogR is on Bioconductor.
apbCatalogR no longer imports dplyr, tidyr and rlang: catalogue lookups use base R again, now with lapply(), vapply(), Map(), Filter(), Find() and Reduce() instead of for loops, and are about 20 times faster than in 0.99.1. Every answer is unchanged.
A .duckdb or .h5ad result reads exactly as its Parquet result: DuckDB's integer columns and layers are integer, not double; an .h5ad result's varm tables have the column types their schema declares, text where anndata stored categories; varm tables no longer carry an empty apb attribute. The test bundle holds every synthetic result also as .duckdb and, for a one-level result, as .h5ad, and a test reads each as its Parquet result.
Reading a .h5ad result needs the rhdf5 package, with which anndataR reads HDF5; apbCatalogR suggests it and names it when it is missing.
?read_parsed_levels describes the layout of each format it reads. Level, LevelNames, Slot and Columns, the objects a catalog's levels hold, are in the help index with their methods $get(), $name(), $keys(), [[ and [.

apbCatalogR 0.99.1

update_catalog(path) installs a bundle archive from a local file, such as the one apb-catalog's make bundle writes; the package no longer downloads anything.
The Functional Genomics Center Zurich is listed as funder.
Reading .h5ad and Parquet or DuckDB results ends in one shared step that names the rows and builds the AnnData; results are read as before.

apbCatalogR 0.99.0

First version: apb-catalog's API in R on the apb-catalog bundle: the R6 classes Catalog and DataCatalog, catalogues(), rule_coverage(), catalogue_table() and the conditions UnresolvedField and MissingRequiredField.
Needs R 4.6.0 or later, the R of Bioconductor 3.24; CI checks on R 4.6.
Reading a .duckdb result no longer keeps a duckdb home under ~/.duckdb.
CITATION.cff and .zenodo.json describe the package to GitHub and Zenodo; citation("apbCatalogR") cites its Zenodo DOI, 10.5281/zenodo.23928865.
The README and the vignette open with a figure of who does what: quantification software, apb2, the APB result and catalog, the apb-catalog API and Bioconductor applications; tools/draw_actors.py draws it.
A hex sticker, man/figures/logo.png, heads the README: a card-catalogue drawer with one card pulled up, showing an AnnData matrix.
read_parsed_levels() reads an APB Parquet result into ParsedLevels, one anndataR AnnData per level. It also reads apb2's .h5ad and .duckdb results into the same ParsedLevels; Parquet needs the suggested arrow package and DuckDB the suggested duckdb and DBI packages; .h5ad needs only anndataR 1.2.2 or later, the first to read the text columns apb2 writes.
Lookups ask by key: each set lists its keys in the bundle's keys.csv, each a kind with the qualifier values it fixes, such as "normalized_intensity" (kind intensity, normalization run_setting); further qualifiers, such as unit, narrow a lookup, and one the key fixes is an error. The abundance set has its normalization qualifier again; asking "intensity" where the normalization is unknown is unknown. q_value in var is the q-value across the experiment (was global_q_value); Sage's is "quantification_q_value". catalogue_table() and fields() have key and kind columns, rule_coverage() a key column.
update_catalog() downloads the bundle of an apb-catalog release; catalog_version() reports the bundle in use.
The bundle holds only the catalogue tables; the synthetic results and expected answers ship as a separate test bundle in inst/extdata/test-bundle/.
Bundle format 2: the catalogue sets are six CSV tables (entries, entry_qualifiers, vocabulary, keys, requirements, producers) described by datapackage.json; a vendor catalogue reviews every rule level the bundle's rule_levels.csv lists, and every qualifier lists unknown as a value. Bundles of format 1 are passed over.
Entries name the software version patterns they were reviewed for, not apb2's rule files, and the bundle carries no rules: rule_levels.csv gives the levels apb2 converts for each software version. apb2's own columns (ProForma_*, apb_Decoy, the protein-assignment columns) are each software's entries in the apb set. catalogue_table() and fields() name software_version_pattern and have no rule column; rule_coverage() has software_version_pattern and neither rule nor inputs.
Bundle format 3: entries name software versions by their labels (1.8–1.9, 2.x) in a version column, and versions.csv (software, version, version pattern) replaces rule_levels.csv; a version's levels are the levels its entries name. Bundles of format 2 are passed over. Answers are unchanged; rule_coverage() lists a version's levels in the order its entries first name them.
Bundle format 4: requirement levels are required, recommended and optional (were MUST, SHOULD and MAY); enforce takes "required" or "recommended"; rule_coverage() gives pass to a level missing only optional fields, which it still lists. keys.csv names each key's kind and PSI-MS terms, and key_qualifiers.csv the qualifier values it fixes, one row each. sets.csv, kinds.csv, qualifiers.csv and qualifier_values.csv replace vocabulary.csv: a kind is no longer a qualifier, so an entry, a key and a request each carry one kind beside their qualifiers, as do the resolutions of UnresolvedField and MissingRequiredField. Bundles of format 3 are passed over.
Entry ids name where a field lives, built as CPE names are: <source>/<version>/<level>/<attribute>/<key>/<column>, such as DIA-NN/2.x/peptidoform_ion/layers/PEP/-; * as version is every version of the source, and a trailing * in the column matches obs columns by prefix. entries.csv keeps set, entry_id, kind, basis and evidence_url; one id with two kinds is two rows, and entry_qualifiers.csv joins on entry_id and kind. A prefix entry bound to a result's column takes that column's id. An app's or annotation convention's entry may name level *, every level: it answers on each, taking that level in its reference and id, and catalogue_table() gives it one row with level *. Answers are unchanged; catalogue_table() and fields() show the new entry_id values.
DataCatalog$new(result, ...) composes the named catalogue sets with apb, which is always in; a key routes to the sets that define it, and two sets naming different fields for one key on one level is an error. Its levels give anndataR's slots looked up as cf_xarray does: cat$levels$protein$layers[["maxlfq"]] reads a key, else the level's own layer of that name, else an error; X, var[[...]], obs[[...]], obs_names, var_names; $keys() lists keys only.
var[c(...)] and obs[c(...)] read every column the names name as a data frame, as cf_xarray's ds.cf[["name"]]: both contaminant flags where the vendor and apb-fasta each set one, every prolfquapp group column; [[ still signals UnresolvedField there. A varm column is named table/column.
keys() lists only the keys a field the level holds answers: an app's keys, such as apb-fasta's, appear once it has run, so every key listed reads; asking for one before still signals UnresolvedField naming what to run.
Catalog$new() has levels too, with the same slots holding names: catalog$levels$peptidoform_ion$layers[["intensity"]] is "Precursor_Quantity", and [ returns a character vector.
A level's slots have $get(key, ...), which returns NULL where [[ signals an error, and $name(key, ...), the name of the field $get() reads ("PEP", or table/column for a varm column); both take the qualifiers a key leaves open, such as unit = "minute". On a Catalog's levels $get() returns the name.
A prefix makes a lookup exact, since a vendor may name a column as a key is named: a set's prefix asks that set alone, so var[["c:q_value"]] is the confidence set's q-value or an error, never Sage's own q_value column; "v:q_value" asks the level's own field alone, never the catalog. sets.csv gives each set its prefix, catalogues() lists it in a prefix column, and v is reserved. A plain name is read as before.
Lookups go through levels only: Catalog and DataCatalog have no lookup methods of their own, and a slot's $keys() takes no qualifiers.
The vignette shows a level's slots beside anndataR's, one lookup across MaxQuant, Spectronaut and DIA-NN, a protein level, and composed sets with a qualifier.
Snapshots are not ported: DataCatalog$snapshot(), $resolve(), attach_snapshot() and ResolutionSnapshot have no R counterpart.
Catalog structure review, apb-catalog's catalog version 0.32: catalog.csv and terms.csv replace entries.csv, entry_qualifiers.csv, keys.csv, key_qualifiers.csv and requirements.csv; each row pairs its qualifier with its value. Sets are named by producer and carry _alpha: apb_alpha holds only what apb2 convert writes, apb_fasta_alpha (prefix fasta) apb-fasta's peptide verification and obs_annotation_alpha (prefix annot) the SDRF and prolfquapp group and subject. Abundance keys follow (intensity_norm_settings, intensity_ms1, …). A request for a key answers with that key's entries; a kind is always known.
DataCatalog$new() composes only the sets named; apb is no longer always in. With no set named every name is the level's own, and $description signals "no catalogue set named". A named set that can answer nothing on the result, because its app has not run or the result records no sample annotation, is an error at init saying what to run.
enforce is checked once, when Catalog$new() or DataCatalog$new() opens; lookups no longer enforce. One MissingRequiredField lists every missing field in missing, each as its resolution and requirement row, one message line per field; under "required" the missing recommended fields give one warning, under "recommended" they signal too. enforce on sets without requirements is an error.
apb-catalog 0.33: apb_fasta_alpha splits into fasta_peptides_alpha (prefix fpep), what apb-fasta verify-peptides writes, and fasta_proteins_alpha (prefix fprot), what apb-fasta merge-annotations writes on the protein level; each holds only the keys a consumer reads. DataCatalog$answering_sets(result) lists the sets a result opens, without an error.