Skip to content

Releases

taxify 0.8.0

Choose a tag to compare

@gcol33 gcol33 released this 17 Nov 10:54

Breaking changes

  • Every source-specific add_*() function prefixes its attached columns with
    its source key, including columns selected with cols = "all". An existing
    prefix is kept once. Common names use common_, preserving common_name.
    Grouped values use the same prefix and append group codes for multiple groups;
    the grouping key remains a filter and reshape key. enrichment_cols() now
    reports both source column and attached output names. Selection accepts
    the source name, full output name, or output name without its prefix.
    The internal join engines use one prefix argument, replacing col_prefix
    and out_prefix.
  • The overlapping growth_form, litter_size, longevity_yr, and
    seed_mass_mg outputs now carry their respective source prefixes. COMBINE
    outputs use combine_, combine_reported_, and combine_imputed_ for the
    coalesced, reported, and imputed doors. Euro+Med distribution exposes
    euromed_status; alien first records expose
    alien_first_records_year, alien_first_records_source, and
    alien_first_records_reference.
  • Removed gift_traits(). Use enrichment_cols("gift").
  • Removed children(). Use downstream(taxon, downto = ) for descendants
    beneath a genus, family, or higher taxon.
  • Made taxify_load_register() internal and removed taxify_build_register().
    Use lookup_genus() and taxify_register_coverage() to query the register,
    taxify_download("register") to download it, or taxifydb::build_register()
    to build it from source.
  • Made score_candidates(), normalize_epithets(),
    normalize_syntaxon_name(), and backbone_code() internal.
  • Merged taxify_download_enrichment() into
    taxify_download(name, kind = c("backbone", "enrichment"), ...).
    The first argument is the asset name; kind selects its catalogue.
    Version and content-ID downloads, named path returns, the register alias,
    and backbone source-build delegation remain available. force = TRUE
    refreshes an installed version. install_backbones() installs the default set.

Bug fixes

  • Abbreviated-genus matching no longer stops with "missing value where
    TRUE/FALSE needed" on backbones whose genus field is empty on some rows
    (ITIS leaves it empty on many species rows; "x bicknellii" hit it). Such a
    row takes its genus from the first word of its name, so "P. bicknellii" now
    reaches Panicum bicknellii on ITIS (#98).

taxify 0.7.1

Choose a tag to compare

@gcol33 gcol33 released this 02 Nov 11:24

Data directory

  • taxify removes outdated data on its own. Each session records when it first reads a backbone or enrichment build, and when the package is loaded, every outdated build that has not been read or downloaded for getOption("taxify.max_unused_days") days (default 90) is deleted, with the files of interrupted downloads and any directory this leaves empty. A build is outdated when it is stored in the format used before 0.7.0 or a newer build of it has been published. The current build of a backbone or enrichment stays however long it is unused, and so does a pinned build. options(taxify.max_unused_days = Inf) keeps every build.
  • taxify_clean(unused_days = ) applies the same rule on demand.

Submitted to CRAN on 2026-11-02.

taxify 0.7.0

Choose a tag to compare

@gcol33 gcol33 released this 26 Oct 22:13

Data directory

  • Backbones and enrichments are downloaded in the storage format of vectra
    0.14.0, which taxify now requires, and take about a quarter of the space:
    the nineteen taxon and two syntaxon backbones together 2.1 GB instead of
    8.3 GB, the first-run set (COL, GBIF, ITIS) 1.1 GB instead of 3.8 GB, WFO
    120 MB instead of 785 MB. The data are unchanged; each store was re-encoded
    from the published one and compared with it column by column. A backbone or
    enrichment already installed is replaced by its new copy at the next
    version check, unless it was pinned by taxify_restore(). taxify reads its catalogue from inst/manifest_v3.json;
    releases before 0.7.0 keep reading the earlier stores through
    inst/manifest.json.
  • A backbone is installed only when asked for. install_backbones() and
    taxify_download() install as before; any other function that needs a
    backbone not on disk (a first taxify() call on a new setup, a browse verb
    naming a backbone) asks before downloading in an interactive session and
    stops with an error naming the install_backbones() call otherwise.
    options(taxify.auto_download = TRUE) or the environment variable
    TAXIFY_AUTO_DOWNLOAD restores downloading on first use for scripts and
    pipelines.
  • A refreshed enrichment replaces the build it supersedes, as backbones
    already did; options(taxify.keep_enrichment_versions = TRUE) keeps the old
    build. A lockfile pin is restored from the published copy of that build.
  • taxify_clean() frees disk space: by default it removes builds taxify no
    longer reads and files left by an interrupted download, keeping the active
    build of every asset; it also removes named backbones or enrichments, or the
    whole data directory with "all".
  • Every download clears what an interrupted one left in the same directory
    (curl's partial .curltmp file was never removed and could reach the size
    of the backbone).

Vegetation units (syntaxa)

  • Two syntaxon backbones match vegetation-unit names the way the others match
    taxon names: evc, the EuroVegChecklist (Mucina et al. 2016, current
    version from FloraVeg.EU: 150 classes, 381 orders, 1,310 alliances and
    their synonyms), and vegcz, the national classification of the Czech
    Republic (Chytrý 2007-2013, from Pladias: classes, alliances and 496
    associations). Name one in taxify(backbone = ); the default chain stays
    with taxon names, and the two kinds are not combined in one call (#96).
  • A syntaxon result carries the accepted unit's class, order, alliance
    and association in place of family, genus and epithet, so a name at
    any rank rolls up. A Czech association reaches its EuroVegChecklist
    alliance through vegcz (which places it under its alliance) and then
    evc.
  • Names are read under the phytosociological code: the author citation
    ((Neuhäusl 1959) Oberd. et al. 1967), annotations (nom. inval. (5a)),
    a database code in front (TDA - Arrhenatherion elatioris), rank-labelled
    lists (all. X, ord. Y) and code-page mojibake are parsed off, and the rank
    is read from the suffix. parse_name(x, code = "syntaxon") returns the
    parse.
  • A unit written without its epithets (Cynosurion for Cynosurion
    cristati
    ) resolves with the new match_type = "short_name" when its stems
    name one unit; otherwise it stays unmatched with the candidates in
    accepted_ids. Fuzzy matching of a syntaxon keeps its rank and the plant
    names it is built from, so Vaccinio-Piceion is not matched to the
    different alliance Vaccinio-Pinion.
  • The backbone registry records each backbone's nomenclature code
    (backbone_code(), the code column of list_backbones()), and the name
    cleaner, normalization key and stages a backbone runs are read from that
    code.
  • A fuzzy syntaxon match whose first word is misspelt carries the accepted
    unit's class, order, alliance and association, as every other match
    does (#97).
  • A syntaxon whose suffix gives its rank no longer fuzzy-matches a name that
    carries no rank suffix: Deschampsietum caespitosae is not matched to
    Deschampsiosum cespitosae (#97).

Accepted-ID columns

  • n_ids and accepted_ids are in every taxify() result: 1 and the
    accepted_id for a name with one accepted ID, NA for an unmatched row.
    Two results now always rbind(), and x$n_ids > 1 is FALSE rather than
    logical(0) on a list without homonyms. Printing still leaves the two
    columns out when no row has more than one ID (#92).

Requesting GBIF data

  • gbif_request(keys = c("taxon", "pick", "all")) replaces strict.
    taxify_ids() gives each ID a role: pick, same_name (another record
    of the same name, such as GBIF's doubtful Pinus sylvestris homonyms) or
    other_taxon (the accepted taxon of a synonym record under another author,
    a different species). The default "taxon" requests the first two and
    names the keys of other taxa it leaves out; previously every key was
    requested, so Absinthium vulgare returned two species under one name.
    "pick" is the old strict = TRUE, "all" the old default (#93).
  • A default-chain result follows the taxon each row picked: a crosswalked
    row takes its pick's GBIF key, a row without one is re-matched against GBIF
    by its accepted_name rather than its input name. With the GBIF backbone
    installed, GBIF's further records of the picked name and the occurrence
    counts of crosswalked keys are read from it, so the same list requests the
    same keys through backbone = "gbif" and through the default chain, and
    the size estimate covers every key. The taxa attribute gains
    key_source (backbone / crosswalk / rematch) and requested (#93).

Picking between homonyms

  • Publication year orders same-name homonyms only when every candidate at
    that level has a year; a dated record beside an undated one no longer wins
    for being dated. A recombination is dated by its own publication, not its
    basionym's (ICN Art. 53.1): Rhus hirta (L.) Sudw. (1892) now loses to
    Rhus hirta Harv. ex Engl. (1883) (#91).
  • taxify() results and taxify_ids() carry pick_basis, what decided the
    pick over a name's other accepted IDs (status, priority,
    occurrences, validity, fuzzy, authorship, basionym, or id when
    only the lowest taxon ID separated them, which settles nothing) (#91).
  • add_wfo_info() and add_col_info() return the publication reference as
    name_published_in, the name add_gbif_info() uses; it reads the
    unified column taxifydb now writes for every backbone (gcol33/taxifydb#60).

Documentation

  • The README and every article were rewritten. Get started is now
    vignette("taxify") (the old quickstart URL redirects), and the articles
    are grouped into workflows and background. New articles cover exploring the
    backbone (synonyms(), children(), upstream(), ...) and matching
    vegetation units. The per-source detail of every published dataset moved to
    The backbones and datasets.
  • The output shown in the README and the articles comes from running their
    code against the installed backbones (data-raw/precompute_vignettes.R
    knits vignettes/*.Rmd.orig), so it no longer drifts from what the
    functions return.
  • citation("taxify") now reads inst/CITATION, with the CRAN DOI, and
    cite() takes the package's own entry from it.
  • scripts/benchmark-scale.R times lists of 1,000 to 100,000 names; the
    memory and WorldFlora benchmark scripts, which called taxify() with an
    argument it no longer has, run again, and all three results were measured
    for the articles that quote them.

New features and speed

  • list_backbones() gains a title column with each backbone's full name.
  • Exact matching of 100,000 WFO names takes 14 s instead of 61 s, measured
    with scripts/benchmark-scale.R before and after the change: choosing the pick of each name
    scanned the whole candidate table once per name.

Bug fixes

  • add_data(), the cross-backbone recovery of the add_<source>()
    functions and inspect(backbones = TRUE) no longer repeat the
    taxify_multiple_ids warning for names they match internally (the joined
    table's names, a dataset's names); the warning still names the inputs of
    the taxify() call itself.
  • taxify(kingdom = ) now moves a name used in two kingdoms to its record in
    the requested kingdom instead of leaving it unmatched: Prunella with
    kingdom = "plants" matched the bird genus, dropped it, and returned
    nothing, although COL also accepts the plant genus. The row's pick_basis
    is "kingdom".
  • cite() and the "Sources:" line under a printed result name only the
    backbones that matched a row, not every backbone of the fallback chain, and
    the line no longer prints NA for a backbone without a version.
  • add_col_info(), add_wfo_info(), add_gbif_info() and
    add_hybrid_info() no longer register themselves as published datasets,
    which made cite() list an empty entry ("COL (2025). col_info.") and
    taxify_lock() record a dataset taxify_restore() could never find. Their
    columns come from a backbone the result already cites.
  • add_data() records the joined table under taxify_meta$user_data
    instead of among the published datasets, so cite() no longer lists it and
    taxify_restore() no longer reports it as missing.
  • inspect(backbones = TRUE) matches in the order of the default fallback
    chain, so its labels are the ones taxify() gives.
  • A subset of an inspect() report is a plain data frame; it printed as an
    empty report.
  • gbif_request(dry_run = TRUE) prints the keys alone instead of the key
    table and the match metadata attached to them.

Submitted to CRAN: https://cran.r-project.org/package=taxify

v0.6.0

Choose a tag to compare

@gcol33 gcol33 released this 22 Sep 20:56

Genus register kingdoms

  • The genus register (genus_register.vtr, which fills kingdom_group, taxon_group and life_form) is rebuilt: its kingdom is read from accepted genus records before synonyms, a spelling shared by genera in two kingdoms resolves to the genus with more accepted species, a genus's ranks all come from one of the genera sharing its spelling, and GBIF's own kingdom column is read. Genera without a kingdom fall from 44,024 to 2,978 of 502,381, and 5,767 change kingdom. Olea europaea read kingdom_group = "animalia" (the register had picked the sea slug Olea), and Aa, Abelia and Acaena read as animals from synonym records; Panthera and Pteropus carried a moth's and a stick insect's family.
  • The register's new multi_kingdom column marks the 5,026 genera whose spelling accepted records place in more than one kingdom. For those, a matched row's kingdom_group is the kingdom of the record it matched, read from the backbone's kingdom column, and taxon_group / life_form are NA where that kingdom differs from the register's.
  • A backbone scoped to one kingdom (WFO, Euro+Med, LCVP, WCVP, Species Fungorum, MDD, AviList, ReptileDB, FishBase) always sets a matched row's kingdom_group to that kingdom.
  • taxify_register_coverage() reports the release each backbone was indexed from; the previous coverage table had none for 17 of 19 backbones.

Euro+Med distribution status

  • add_euromed_distribution() attaches the status Euro+Med PlantBase states for a taxon in each Euro+Med area: euromed_status is native, naturalised, introduced, casual, cultivated, doubtful or extinct, and euromed_status_detail keeps the term as Euro+Med words it (endemic, introduced: uncertain degree of naturalisation). The citing references of each record are in euromed_status_source (resolve with cite(x$euromed_status_source, source = "euromed_distribution")), and cols = "all" adds the taxon's Euro+Med UUID as taxon_id, the taxon_id of the euromed backbone. region takes ISO 3166-1 alpha-2 country codes or Euro+Med area codes. A report Euro+Med marks as made in error is not carried, and a former presence is extinct (issue #90).
  • euromed_areas() lists the areas with the ISO code of those that are exactly one country. A combined area (Italy with San Marino and Vatican City, Ireland with Northern Ireland) has none; its countries are read from the level-2 areas (Au(A) Austria, Au(L) Liechtenstein).
  • The status is harvested per accepted taxon from the europlusmed.org portal taxon pages, served from the CyberTaxonomy CDM which has no bulk export, by crawl_euromed_portal.py in taxifydb.

Requesting GBIF data for a name list

  • gbif_request() takes a species list, matches it against the GBIF backbone
    and requests occurrence data for every accepted taxon key the matches resolve
    to. GBIF serves records by taxon key rather than by name, and a name it files
    under several keys (a homonym, or a name held once as accepted and again as a
    doubtful record) needs all of them: of the four species in the new vignette,
    Quercus robur has three keys and Pinus sylvestris six. strict = TRUE
    narrows the request to the key taxify() reported, and reports how many
    keys and records that leaves behind. It is off by default.
  • taxify_ids() gains a gbif_key column: the legacy GBIF taxon key(s) of each accepted ID, which are what GBIF serves occurrence records for. On the gbif backbone it is the ID itself; on a COL XR build that carries a GBIF crosswalk it is the |-delimited set of GBIF keys for the same name, several where GBIF files it under more than one. gbif_request() reads it, so a default-chain result whose names are on COL XR is requested without a second match pass over the GBIF backbone; only names on a backbone with no crosswalk, on a COL XR build that predates it, or that resolve to several accepted taxa (COL XR files a homonym's synonyms under other species) are still re-matched against GBIF. taxon_id and accepted_id stay COL XR's.
  • method = "download" (default) submits one asynchronous GBIF download
    covering every key as a single taxonKey IN (...) predicate, so the list
    returns as one dataset under one citable DOI. It needs a GBIF account in
    GBIF_USER / GBIF_PWD / GBIF_EMAIL, and says which are missing before
    contacting GBIF. method = "search" sends unauthenticated searches and
    returns the records directly, with a taxon_key_requested column tracing
    each row to the key that asked for it.
  • Before a request is sent, the expected size is reported from the backbone's
    own occurrence counts, and dry_run = TRUE returns the keys while contacting
    nothing. An ID that is not a GBIF integer key is refused rather than sent,
    which is what happens against the bundled example database.
  • A result from the default backbone chain works without being re-matched by
    hand. The chain starts at COL XR, whose alphanumeric IDs GBIF does not serve
    records for, so gbif_request() re-matches every row without a GBIF key
    against the GBIF backbone and keeps the rows that already had one. A mixed
    result, where the one name only GBIF carries landed on gbif, keeps all of
    its names rather than dropping the others.
  • rgbif moves into Suggests. Resolving names and reading off their keys stays
    offline and does not need it; only the request itself does.
  • gbif_fetch() waits for a submitted download, retrieves it, imports it and
    attaches the queried names, so the records come back in one call instead of a
    wait/get/import loop. A split request is fetched the same way: every download
    is waited for and the frames stacked on the union of their columns, since
    GBIF returns only the fields a record carries.
  • gbif_backmatch() links the returned occurrence records back to the names
    they were requested for. Joining on taxonKey alone loses records without
    saying so: GBIF returns a key's descendants too, and a record identified
    below species level carries its own key, so a request for Pinus nigra
    returns rows whose taxonKey is its subspecies and which carry the
    requested key only in speciesKey. On a 300-record sample of that request
    a taxonKey join matches 250; gbif_backmatch() matches 300.
  • A list too long for one GBIF query is split automatically. GBIF caps a
    download query at 12,000 characters, which a taxonKey predicate reaches at
    about 1,187 keys (10 characters per key plus 125 of envelope, measured
    against occ_download_prep()), so a few hundred names can exceed it once
    their homonyms are counted. gbif_request() chunks at 1,000 keys and
    submits through rgbif's occ_download_queue(), which respects GBIF's limit
    of three concurrent downloads. Each chunk gets its own DOI and cite()
    reports all of them.
  • cite() reports a GBIF download's DOI beside the backbone citations. The
    download key travels from gbif_request() through gbif_backmatch() onto
    the records, and the DOI is read from GBIF at citation time, since GBIF
    issues it only once the download has finished preparing. A download still
    running is reported as having no DOI yet, and an unreachable GBIF leaves
    the backbone citations intact rather than failing. file = writes the
    download as a BibTeX @misc entry too.
  • New vignette, vignette("gbif-requests"), which also covers installing
    rgbif and storing GBIF credentials.

Names with several accepted IDs

  • taxify() output replaces is_ambiguous and ambiguous_targets with
    n_ids and accepted_ids: how many distinct accepted taxa the backbone
    files the matched name under, and all of those IDs (|-joined, the one in
    accepted_id first). The old flag fired only when candidates tied in the top
    priority tier, so a name GBIF holds both as an accepted record and as a
    doubtful or duplicate one came back with one ID and is_ambiguous = FALSE.
    n_ids counts every record of the name. In a fuzzy match only names at the
    pick's distance count: a farther neighbour is a worse reading of the input,
    not another taxon it names.
  • taxify() warns once per call when any name resolves to more than one
    accepted ID, naming the count and a few examples. The warning has class
    taxify_multiple_ids; switch it off with
    options(taxify.warn_multiple_ids = FALSE). The verbs built on taxify()
    (reconcile(), synonyms(), upstream(), ...) do not repeat it.
    summary() shows the count as a multiple ids line.
  • taxify_ids() lists every accepted ID of each matched name, one row per
    (name, ID), with accepted name, authorship, rank, status, family, the GBIF
    occurrence count and which ID taxify() picked. It replaces
    taxify_candidates(), which only expanded tied homonyms.
  • n_ids and accepted_ids appear in taxify() output only when some name
    resolves to more than one accepted ID, which is also when the
    taxify_multiple_ids warning fires (unless switched off). Otherwise accepted_id says all there
    is to say and the two columns are left out. taxify_ids() and reconcile()
    work either way (reconcile() always carries n_ids). Results from two
    calls can then differ in columns: combine them with dplyr::bind_rows(),
    which fills the missing columns with NA, rather than base rbind().
  • On the GBIF backbone the pick now reads occurrence records: among the
    records that keep a name as their own concept (accepted, doubtful,
    unplaced), a key with any GBIF occurrence records beats a key with none,
    before taxonomic status is consulted. A synonym record never wins on
    records, since its accepted ID is another species and a download by it
    returns that species' data; its key stays listed in accepted_ids and
    taxify_ids(). Between keys that both have records, or both have none,
    status decides as before, and the count only breaks a tie status, rank and
    epithet leave.
    Checked against the l...
Read more

v0.5.6

Choose a tag to compare

@gcol33 gcol33 released this 21 Sep 22:31

What's Changed

  • add_wcvp() (and every grouped door over an authorship-bearing source)
    returns the range of the taxon a name was matched to, as the matching
    backbone circumscribes it: its own concept plus every name the backbone
    places inside it, each picked by author. Another name's autonym and a
    species' range filed under one of its subspecies no longer leak in.
  • Cross-backbone recovery in grouped doors also runs for names whose own
    concept the source does not hold under that name, and for each part of the
    matched taxon that found nothing under its own name. An alternative is taken
    only if it lies inside the matched taxon: a broader rank, or a taxon the
    matched backbone accepts separately, is refused.
  • Those refusals are reported rather than silent: the recovery message and
    summary() count them, and the enrichment's taxify_meta entry lists them
    as refused (queried name, refused name, reason, offering backbones, groups
    it would have filled).
  • add_wcvp(): where parts of a taxon disagree on a region, native wins
    over introduced, and introduced over extinct.
  • Faster grouped enrichment: add_wcvp(region = "all") over 10,000 names
    through GBIF 53 s -> 22 s; add_griis(country = "all") through WFO
    29.6 s -> 3.7 s, output unchanged.
  • enrichment_authorship_col() exported (internal) for taxifydb; every
    backbone manifest entry records source_date (#88).

Install: install.packages("taxify", repos = c("https://gcol33.r-universe.dev", "https://cloud.r-project.org"))

Full history: https://github.com/gcol33/taxify/blob/main/NEWS.md

v0.5.5

Choose a tag to compare

@gcol33 gcol33 released this 17 Sep 20:01

What's Changed

  • Fourteen fixes in the core matching path and its side paths (#56-#70), plus
    a query-batch-size cap on add_trait() that silently emptied sources past
    it (#55).
  • A name a backbone holds without placing it no longer reads as accepted; it
    carries its own status in a new taxonomic_status column and resolves
    through its basionym link where the build carries one (#81). A homonym
    collision warning during enrichment joins now distinguishes a genuine tie
    from a concept none of the candidates share any authorship with (#87).
  • Breaking: add_alien_first_records() takes location = in place of
    country =, so islands recorded as their own regions no longer backdate
    their country's first record.
  • New exports: taxify_pin(), normalize_kingdom_group(),
    backbone_fixed_kingdom(), basionym_placement().
  • Requires vectra (>= 0.12.4), released to CRAN 2026-09-16.

Full history: https://github.com/gcol33/taxify/blob/main/NEWS.md

CRAN: https://cran.r-project.org/package=taxify

taxify 0.5.4

Choose a tag to compare

@gcol33 gcol33 released this 15 Sep 12:50
  • Breaking: add_alien_first_records() joins on the source's own locations and takes
    location = in place of country =. FirstRecords records islands and
    other parts of a country as regions of their own ("282 non-overlapping
    regions (countries and sub-national regions such as islands)", Seebens et
    al. 2017), so its United States of America excludes Hawaii and Alaska and its
    Spain excludes the Canary and Balearic Islands. The enrichment used to credit
    each of those to its country and keep the earliest year, which in v4.0 dated
    665 of the source's species x country first records from an island's earlier year (337 of them from
    Hawaii, by a median of 25 years) and gave 3,541 country records to species
    the source records only on an island. A country is still keyed on its ISO
    3166-1 alpha-2 code (location = "AT"); a sub-national location is keyed on
    its name (location = "Hawaii"), listed by
    enrichment_groups("alien_first_records"). Every row carries
    country_code for an explicit roll-up to countries.

  • dispersal_syndrome reads BROT 2.0 (gcol33/taxifydb#57). BROT writes
    dispersal mode as vector letters, most important first, and no pattern
    matched a letter, so BROT supplied nothing; the slot now maps the first
    letter through the legend of the BROT 2.0 data paper (Tavsanoglu & Pausas
    2018). G ("autochory, by Gravity (=unassisted dispersal)") reads as
    gravity, the class Baseflor, AusTraits and LEDA fill from barochory.

  • dispersal_syndrome leaves a term that names no mechanism unplaced, so a
    source that does name one fills the species. Autochory is the self-dispersal
    umbrella in LEDA and AusTraits, not ballistic; LEDA's blastochor was read as
    gravity, herpochor (a diaspore crawling on hygroscopic awns) as ballistic,
    and bythisochor (non-floating seeds carried along the bottom of running
    water) as gravity; AusTraits' undefined ("Dispersal mechanism unknown")
    was read as unspecialized. All are now NA; a co-listed vector still wins
    (autochory, myrmecochory is ant). GIFT's unspecialized keeps its class.
    Each source note carries the definitions and the shared-species calibration.

  • LEDA is read as taxifydb's corrected reader builds it (gcol33/taxifydb#57).
    leda_seed_mass_mg calibrates at 1.00 against Kew SID, GIFT and BIEN and
    now feeds seed_mass; ssd_g_cm3 is g/cm3 as built, so wood_density no
    longer divides it by 1000 and carries a caution (most records are air-dry
    densities, 1.14x GWDD on 37 shared species). add_leda() attaches
    clonal_growth_organ and floating_capacity_1week_pct in place of the
    empty clonal_growth and buoyancy.

  • add_bien() and add_ecoflora() document the unit of every curated numeric
    column. The rebuilt assets write BIEN leaf dry mass in mg (BIEN records g)
    and Ecoflora typical maximum and minimum height in mm (Ecoflora records cm).

  • taxify requires vectra (>= 0.12.4), which ties each .vtri index to the
    store it was built for and drops stale indexes when a .vtr is rewritten.

taxify 0.5.3

Choose a tag to compare

@gcol33 gcol33 released this 15 Sep 12:50

Five fixes in the core matching path, all of them cases where a result depended
on something other than the name being matched: how often it was submitted,
which backbone happened to answer a neighbouring name, or which build was
loaded earlier in the session.

  • Several queries may now resolve to the same backbone row (#56). Fuzzy
    matching kept only the closest query per target and returned match_type = "none" for the rest, to stop two different species collapsing onto one row.
    But two inputs sharing a target is the normal shape of a dirty checklist: a
    repeated misspelling, or two spellings of one name. The rejected input came
    back as if the backbone held nothing near it, and which input was rejected
    depended on how the batch was ordered. Every query within threshold now
    matches its best target and carries its own fuzzy_dist.

  • The loaded backbone and its compact fuzzy copy are keyed on the build, not
    on the file's basename (#57). Both were memoized under .blk_<basename>, so
    a taxify_restore(install = TRUE), a mid-session update and a data-dir
    switch -- all of which swap builds under one basename -- left the rest of the
    session matching against the replaced build while the metadata reported the
    new one. clear_backbone_memo() now owns that state and runs wherever a
    backbone path is invalidated, so the loaded copy cannot outlive the path that
    resolved it.

  • The authorship tiebreak writes accepted_authorship (#58). Resolving a
    homonym by the author the query carried rewrote accepted_name but left the
    author of the candidate it had just rejected, so name and author named two
    different taxa.

  • Abbreviated-genus resolution reads the genus context off the whole query
    (#59). "Q. petraea" is disambiguated by a genus written out in full
    elsewhere in the batch, but each backbone in a fallback chain sees only the
    names still unmatched -- so a genus an earlier backbone had already answered
    was invisible to the later ones, and mode = "fallback" disagreed with
    mode = "agreement" on the same query.

  • Three smaller inconsistencies in the core path (#60). clean_one(), an
    unreachable and drifted copy of clean_names(), is deleted and names_df is
    now required, so clean_names() is the single cleaner. An NA input gets
    match_type = "none" like "", which is what the documented vocabulary says
    (match_type is never NA). And summary() prints each backbone's own
    version next to it, rather than labelling a whole chain with the first
    matched row's build.

Five fixes in the side paths around matching: joining custom data, pinning and
locking a build, the less common enrichment joins, and empty input.

  • add_data() joins on the accepted taxon, not a bare accepted_id (#61).
    Backend ids are integers in most backbones and carry no namespace, so a name
    matched by ITIS could join onto an unrelated taxon GBIF happened to number the
    same, with no warning. The id is now qualified by the backbone that issued it,
    and rows matched by different backbones on the two sides join through
    accepted_name, which is what the synonym promise in the documentation needs.

  • A pinned version downloads that version (#62). taxify_download(version = )
    and taxify_download_enrichment(version = ) fetched the current release and
    labelled it with the requested version, marked pinned, so the next session
    never corrected it. The URL is now derived from the release tag
    (<name>-<version>/<name>.vtr, enrichment-<version>/<name>.vtr), and a
    version that was never published is an error.

  • taxify_lock() pins the builds a result was produced from (#63). Version and
    content id are recorded when an enrichment is joined, not read from whatever
    is installed when the lock is written, so a refresh or restore in between no
    longer changes the pin. Sources that contributed no value are left out, as
    cite() already did, and add_trait() sources carry their version instead
    of NA. taxify_restore() reports a row as "unverified" when the lock
    holds a content id and the install has none, rather than "ok" on matching
    version labels.

  • Four enrichment join paths now follow the main one (#64). A mixed-grain
    source (genus_fallback) fills from the genus row only after cross-backbone
    recovery has looked for the species, so species resolution wins.
    groups = "all" reads the groups of the installed build before the manifest,
    so a pinned or restored build no longer gets columns for groups it lacks.
    Grouped add_data() errors on conflicting values within a group, like the
    flat join, and uses the shared group fill. The emergency grouped path keeps
    the NA group, so add_common_names(lang = NA) returns names there too.

  • Empty input returns an empty result (#65). comm2sci(output = "result") with
    no match, and add_trait() or any add_*() door on a zero-row result,
    errored or warned once per source. They now return the full output schema at
    zero rows, built by one constructor.

Five fixes in the verbs around taxify(): browsing the backbone, inspecting a
list, and the lookups between names, ids and common names.

  • No more indistinguishable duplicate rows (#66). comm2sci(output = "result")
    returned one identical row per language a vernacular was stored in, because
    it deduplicated on a key that included lang and then dropped lang; it now
    has one row per (query, scientific name). synonyms() repeated every synonym
    once per copy of a repeated input name; each distinct name is now reported
    once.

  • inspect() no longer flags valid names or input (#67). The register check
    read the genus as the raw, case-sensitive first word, so "quercus robur"
    and "cf. Quercus robur" came back unknown / unresolved; the genus is now
    taken from the cleaned name and looked up case-insensitively, as taxify()
    does. A mistyped region code ("GRE" for Greece, which is GRC) was kept as
    a region, and inspect() then flagged every plant with WCVP data as
    geographic. region = now drops a code the WGSRPD crosswalk does not list,
    with a warning, as it already did for an unrecognised name; inspect()
    reports the geographic check under not checked. region and coords are
    no longer resolved when nothing reads them (a character vector inspected
    without matching), which could download the region boundaries.

  • Four input shapes in the secondary verbs (#68). lookup_genus(NA) returned
    every register row filled with NA; it returns NULL. id2name() matched a
    numeric id through as.character(), which writes 1e+05, so a round GBIF
    key or TSN read from a CSV found nothing; numeric ids are now written out in
    full, and a fractional one is an error. class2tree()'s $phylo tip labels
    read Quercus_robur where $tip_labels read Quercus robur; the phylo
    now carries the names, and only the Newick string uses _. taxify_long()
    stopped with "No suffixed columns found" on single-group input that carried a
    companion column such as <trait>_sources, and matched base names as regular
    expressions in one of its two checks; one literal predicate now decides both.

  • children() and downstream() are one query (#69). children() is
    downstream() with the parent restricted to a genus or family, so the two no
    longer disagree: under rank = "any" / downto = "any" neither returns the
    parent itself. Both take kingdom =, as taxify() does, for a name used in
    more than one kingdom: on COL or GBIF, children("Morus") returned mulberries
    and gannets together, and downstream() chose the parent's rank by a vote
    across the homonyms. Without kingdom, a result that mixes kingdoms now
    warns. Both return the same columns, adding kingdom_group, and children()
    gains parent.

  • The sibling verbs forward matching arguments the same way (#70). synonyms(),
    upstream(), sci2comm(), comm2sci(), reconcile(), lowest_common()
    and class2tree() pass named arguments in ... on to taxify(), so
    fuzzy = FALSE, fuzzy_threshold, kingdom or region reach the matcher
    from each of them; synonyms(), upstream() and sci2comm() no longer set
    fuzzy = TRUE regardless. resolve = now means one thing: run the input
    through taxify() first, as in sci2comm(). comm2sci()'s argument, which
    instead changed the return type, is renamed output = c("lookup", "result").

  • The eight genus-keyed doors reach every genus their source covers (#77).
    add_blanchard(), add_cefas_btrait(), add_disperse(),
    add_freshwater_insects_conus(), add_fungal_traits(), add_fungalroot(),
    add_noddb() and add_ramond() read assets rebuilt by taxifydb 0.1.23.
    Their cross-backbone name expansion had keyed rows under subgenus renderings
    and species, which no genus can match, and had pulled in genus homonyms from
    the other nomenclature code. For fungalroot, fungal_traits and noddb the
    expanded names also never reached the genus column the door joins on.

  • list_enrichments() reports every column an enrichment attaches (#76).
    The manifest's trait_cols had fallen behind 40 of the assets, missing the
    _min / _max / _n spread columns, FishBase's and SeaLifeBase's lw_*
    length-weight columns, bet's substrate and arthropod_traits'
    taxon_order. They are now taken from each asset's schema, and the manifest
    sync keeps them that way.

  • normalize_kingdom_group() and backbone_fixed_kingdom() are exported as
    low-level building blocks, for taxifydb's kingdom check on enrichment name
    expansion.

  • GIFT is no longer a suggested package. add_gift() has read the bundled
    .vtr since GIFT was built into an enrichment, and the enrichments vignette
    no longer describes the earlier on-demand API route.

  • A backbone upgrade patches through xdelta3 when the data directory contains a
    space (#79). download_backbone() ...

Read more

taxify 0.5.2

Choose a tag to compare

@gcol33 gcol33 released this 04 Sep 08:04

A follow-up audit for the shape behind #55: a failure returned as a plausible
answer, with the only notice gated on verbose.

The cause behind #55 does not recur

Every other session cache is keyed on a backbone name or a file basename, both
bounded by construction; taxifydb has no environment caches at all. A scale
sweep over taxify(), add_trait(), add_gift(), add_wcvp(),
add_common_names(), add_classification(), add_iucn(), inspect() and
reconcile() at 5 / 100 / 800 / 2400 names confirms every count now grows with
the batch.

The shape, though, was in three more places

  • region = / coords = now warn when the constraint could not be applied.
    With no range data for the declared region, region_range_sets() returned
    NULL and the fuzzy filter passed its candidates through unconstrained, so a
    match the region would have excluded could win. This is the one that could
    change which taxon a name resolved to.

  • inspect() names the checks it could not run, in the report header under
    not checked. An anomaly-only report has no other way to separate a check
    that ran clean from one that never ran: both contribute no rows, and the
    report then prints "nothing stood out". The genus-recognition check without
    the register, and both range checks without the WCVP range data, were skipped
    that way. The skipped set travels on the result, so a saved report carries it.

  • Cross-backbone name recovery names a backbone it could not resolve
    against
    , instead of silently contributing no alternatives for it. That pass
    runs over the whole gap set at once, which is where a size-dependent failure
    like #55 would next hide.

Deliberately left alone

Verified as not the same shape: the xdelta3 patch fallback and the
point-in-polygon engine fallback (both compute the same answer another way),
the "already present (pinned)" notices (successes), add_combine()'s degrade to
reported-only (documented, with per-cell _src provenance), and the authorship
tiebreak (the row stays flagged ambiguous).

taxify 0.5.1

Choose a tag to compare

@gcol33 gcol33 released this 04 Sep 07:31

Fixed

add_trait() no longer returns NA for every source past a batch size (#55).

The per-name-set memos behind hybrid-parent resolution and cross-backbone name
recovery were keyed on the query set itself, held as a variable in the session
environment. R caps the name of a variable in an environment at 10000 bytes, and
reading past that cap raises rather than missing -- so once a batch resolved
enough names, the cache read took the whole join down with it and every source
came back all-NA.

Because the cap is on total bytes, the batch size that tripped it moved with how
many names the backbone resolved and how long they were. That is why a large
call could come back with one source populated and the rest empty, and read as a
coverage result rather than a failure.

Both memos now use a session store that carries keys of any length.

Reporting

  • A trait source that cannot be joined is named in a warning whether or not
    verbose = TRUE. Such a source leaves an all-NA column, which reads exactly
    like the source genuinely holding nothing for those taxa, so silence there
    turns a failure into a coverage statement.

  • add_trait(verbose = TRUE) reports what each source supplied against the
    number of names the backbone resolved:

    add_trait('dispersal_syndrome'): gift 152, austraits 40, leda 281, baseflor 336, brot 0 (of 2400 resolved names).
    

Thanks to @gcol33 for the report and the reproducible test case.