dnakit 0.1.0.dev0__py3-none-any.whl

dnakit/download/ncbi.py

@@ -0,0 +1,333 @@
+"""NCBI Datasets data-package downloads."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable, Sequence
+from pathlib import Path
+from typing import Literal
+
+from dnakit.exceptions import ConfigurationError
+from dnakit.references import download_genome as genome
+from dnakit.search._http import build_url, require_text
+from dnakit.search._shared import query_values, quoted_path_values
+from dnakit.search.ncbi import DEFAULT_NCBI_DATASETS_URL
+
+from .files import dataset, resolved_config
+from .models import DatasetDownloadResult, DownloadConfig, DownloadProgress, RemoteFile
+
+_GENOME_INCLUDE = frozenset(
+    {
+        "CDS_FASTA",
+        "GENOME_FASTA",
+        "GENOME_GBFF",
+        "GENOME_GFF",
+        "GENOME_GTF",
+        "NONE",
+        "PROT_FASTA",
+        "RNA_FASTA",
+        "SEQUENCE_REPORT",
+    }
+)
+_GENE_INCLUDE = frozenset(
+    {"FASTA_3P_UTR", "FASTA_5P_UTR", "FASTA_CDS", "FASTA_GENE", "FASTA_PROTEIN", "FASTA_RNA"}
+)
+_VIRUS_INCLUDE = frozenset({"GENOME", "CDS", "PROTEIN", "NONE"})
+_VIRUS_AUX = frozenset({"ANNOTATION", "BIOSAMPLE_REPORT"})
+_VIRUS_ACCESSION = re.compile(r"^[A-Z]{1,6}_?\d{3,}(?:\.\d+)?$", flags=re.IGNORECASE)
+
+
+def _validate_include(values: Sequence[str], allowed: frozenset[str]) -> tuple[str, ...]:
+    resolved = tuple(value.upper() for value in values)
+    if not resolved or any(value not in allowed for value in resolved):
+        raise ConfigurationError(
+            "include contains an unsupported NCBI package file type.",
+            code="INVALID_DOWNLOAD_CONFIG",
+            context={"allowed": sorted(allowed)},
+        )
+    return resolved
+
+
+def _slug(values: Sequence[str]) -> str:
+    joined = "_".join(values[:3])
+    if len(values) > 3:
+        joined += f"_plus_{len(values) - 3}"
+    return re.sub(r"[^A-Za-z0-9_.-]+", "_", joined)
+
+
+def genome_package(
+    accessions: str | Sequence[str],
+    output_dir: str | Path,
+    *,
+    include: Sequence[str] = ("GENOME_FASTA",),
+    chromosomes: Sequence[str] = (),
+    hydrated: Literal["FULLY_HYDRATED", "DATA_REPORT_ONLY"] = "FULLY_HYDRATED",
+    config: DownloadConfig | None = None,
+    progress: Callable[[DownloadProgress], None] | None = None,
+    api_base_url: str = DEFAULT_NCBI_DATASETS_URL,
+) -> DatasetDownloadResult:
+    """Download an NCBI genome ZIP with selected sequences, annotations, and reports."""
+
+    resolved = resolved_config(config)
+    values = query_values(accessions, name="accessions", maximum=100)
+    if any(
+        re.fullmatch(r"GC[AF]_\d+\.\d+", value, flags=re.IGNORECASE) is None for value in values
+    ):
+        raise ConfigurationError(
+            "genome_package requires versioned GCA_/GCF_ accessions.",
+            code="INVALID_ASSEMBLY_ACCESSION",
+        )
+    includes = _validate_include(include, _GENOME_INCLUDE)
+    if hydrated not in {"FULLY_HYDRATED", "DATA_REPORT_ONLY"}:
+        raise ConfigurationError("Unsupported NCBI hydration mode.")
+    chromosome_values = tuple(str(value).strip() for value in chromosomes)
+    if any(not value or len(value) > 128 for value in chromosome_values):
+        raise ConfigurationError("chromosomes contains an invalid value.")
+    url = build_url(
+        api_base_url,
+        f"/genome/accession/{quoted_path_values(values)}/download",
+        (
+            ("include_annotation_type", includes),
+            ("chromosomes", chromosome_values),
+            ("hydrated", hydrated),
+        ),
+    )
+    filename = f"ncbi_genome_{_slug(values)}.zip"
+    headers = {} if resolved.api_key is None else {"api-key": resolved.api_key}
+    return dataset(
+        (RemoteFile(url, filename=filename),),
+        output_dir,
+        kind="ncbi_genome_package",
+        source="NCBI Datasets Genome",
+        metadata={
+            "accessions": values,
+            "include": includes,
+            "chromosomes": chromosome_values,
+            "hydrated": hydrated,
+        },
+        config=resolved,
+        progress=progress,
+        headers=headers,
+    )
+
+
+def annotation(
+    accession: str,
+    output_dir: str | Path,
+    *,
+    formats: Sequence[str] = ("GENOME_GFF", "GENOME_GTF", "GENOME_GBFF", "SEQUENCE_REPORT"),
+    chromosomes: Sequence[str] = (),
+    config: DownloadConfig | None = None,
+    progress: Callable[[DownloadProgress], None] | None = None,
+    api_base_url: str = DEFAULT_NCBI_DATASETS_URL,
+) -> DatasetDownloadResult:
+    """Download an NCBI genome-annotation package (GFF3/GTF/GBFF/reports)."""
+
+    return genome_package(
+        accession,
+        output_dir,
+        include=formats,
+        chromosomes=chromosomes,
+        config=config,
+        progress=progress,
+        api_base_url=api_base_url,
+    )
+
+
+def gene(
+    gene_ids: int | str | Sequence[int | str],
+    output_dir: str | Path,
+    *,
+    include: Sequence[str] = (
+        "FASTA_GENE",
+        "FASTA_RNA",
+        "FASTA_CDS",
+        "FASTA_PROTEIN",
+        "FASTA_5P_UTR",
+        "FASTA_3P_UTR",
+    ),
+    accession_filter: Sequence[str] = (),
+    include_product_report: bool = True,
+    config: DownloadConfig | None = None,
+    progress: Callable[[DownloadProgress], None] | None = None,
+    api_base_url: str = DEFAULT_NCBI_DATASETS_URL,
+) -> DatasetDownloadResult:
+    """Download gene, transcript, CDS, UTR, and protein FASTA from NCBI."""
+
+    resolved = resolved_config(config)
+    values = query_values(gene_ids, name="gene_ids", maximum=100)
+    if any(not value.isdigit() for value in values):
+        raise ConfigurationError("gene requires numeric NCBI GeneIDs.", code="INVALID_QUERY")
+    includes = _validate_include(include, _GENE_INCLUDE)
+    accessions = tuple(str(value).strip() for value in accession_filter)
+    if any(not value or len(value) > 256 for value in accessions):
+        raise ConfigurationError("accession_filter contains an invalid value.")
+    url = build_url(
+        api_base_url,
+        f"/gene/id/{quoted_path_values(values)}/download",
+        (
+            ("include_annotation_type", includes),
+            ("accession_filter", accessions),
+            ("aux_report", "PRODUCT_REPORT" if include_product_report else None),
+            (
+                "tabular_reports",
+                ("DATASET_REPORT", "PRODUCT_REPORT")
+                if include_product_report
+                else ("DATASET_REPORT",),
+            ),
+        ),
+    )
+    headers = {} if resolved.api_key is None else {"api-key": resolved.api_key}
+    return dataset(
+        (RemoteFile(url, filename=f"ncbi_gene_{_slug(values)}.zip"),),
+        output_dir,
+        kind="ncbi_gene_package",
+        source="NCBI Datasets Gene",
+        metadata={"gene_ids": values, "include": includes, "accession_filter": accessions},
+        config=resolved,
+        progress=progress,
+        headers=headers,
+    )
+
+
+def taxonomy(
+    tax_ids: int | str | Sequence[int | str],
+    output_dir: str | Path,
+    *,
+    include_names: bool = True,
+    include_summary: bool = True,
+    config: DownloadConfig | None = None,
+    progress: Callable[[DownloadProgress], None] | None = None,
+    api_base_url: str = DEFAULT_NCBI_DATASETS_URL,
+) -> DatasetDownloadResult:
+    """Download taxonomy JSONL, lineage/names, and optional summary TSV."""
+
+    resolved = resolved_config(config)
+    values = query_values(tax_ids, name="tax_ids", maximum=100)
+    if any(not value.isdigit() for value in values):
+        raise ConfigurationError("taxonomy requires numeric NCBI TaxIDs.", code="INVALID_QUERY")
+    reports: list[str] = []
+    if include_names:
+        reports.append("NAMES_REPORT")
+    if include_summary:
+        reports.append("TAXONOMY_SUMMARY")
+    url = build_url(
+        api_base_url,
+        f"/taxonomy/taxon/{quoted_path_values(values)}/download",
+        (("aux_reports", tuple(reports)),),
+    )
+    headers = {} if resolved.api_key is None else {"api-key": resolved.api_key}
+    return dataset(
+        (RemoteFile(url, filename=f"ncbi_taxonomy_{_slug(values)}.zip"),),
+        output_dir,
+        kind="ncbi_taxonomy_package",
+        source="NCBI Datasets Taxonomy",
+        metadata={"tax_ids": values, "aux_reports": tuple(reports)},
+        config=resolved,
+        progress=progress,
+        headers=headers,
+    )
+
+
+def virus_package(
+    query: str | Sequence[str],
+    output_dir: str | Path,
+    *,
+    by: Literal["auto", "accession", "taxon"] = "auto",
+    include: Sequence[str] = ("GENOME", "CDS", "PROTEIN"),
+    aux_reports: Sequence[str] = ("ANNOTATION", "BIOSAMPLE_REPORT"),
+    refseq_only: bool = False,
+    annotated_only: bool = False,
+    complete_only: bool = False,
+    host: str | None = None,
+    geo_location: str | None = None,
+    released_since: str | None = None,
+    updated_since: str | None = None,
+    config: DownloadConfig | None = None,
+    progress: Callable[[DownloadProgress], None] | None = None,
+    api_base_url: str = DEFAULT_NCBI_DATASETS_URL,
+) -> DatasetDownloadResult:
+    """Download an NCBI Virus genome, CDS, protein, annotation, and metadata ZIP."""
+
+    resolved = resolved_config(config)
+    values = query_values(query, name="query", maximum=100)
+    if by == "auto":
+        flags = tuple(_VIRUS_ACCESSION.fullmatch(value) is not None for value in values)
+        if any(flags) and not all(flags):
+            raise ConfigurationError("Do not mix virus accessions and taxon names.")
+        by = "accession" if all(flags) else "taxon"
+    if by not in {"accession", "taxon"}:
+        raise ConfigurationError("virus_package by must be auto, accession, or taxon.")
+    if by == "taxon" and len(values) != 1:
+        raise ConfigurationError("Virus taxon downloads accept one taxon at a time.")
+    includes = _validate_include(include, _VIRUS_INCLUDE)
+    reports = tuple(value.upper() for value in aux_reports)
+    if any(value not in _VIRUS_AUX for value in reports):
+        raise ConfigurationError(
+            "aux_reports contains an unsupported virus report.",
+            context={"allowed": sorted(_VIRUS_AUX)},
+        )
+    for name, value in (
+        ("refseq_only", refseq_only),
+        ("annotated_only", annotated_only),
+        ("complete_only", complete_only),
+    ):
+        if not isinstance(value, bool):
+            raise ConfigurationError(f"{name} must be boolean.")
+    path_values = values if by == "accession" else (values[0],)
+    url = build_url(
+        api_base_url,
+        f"/virus/{by}/{quoted_path_values(path_values)}/genome/download",
+        (
+            ("include_sequence", includes),
+            ("aux_report", reports),
+            ("refseq_only", refseq_only),
+            ("annotated_only", annotated_only),
+            ("complete_only", complete_only),
+            ("host", None if host is None else require_text(host, "host", max_length=256)),
+            (
+                "geo_location",
+                None
+                if geo_location is None
+                else require_text(geo_location, "geo_location", max_length=256),
+            ),
+            (
+                "released_since",
+                None
+                if released_since is None
+                else require_text(released_since, "released_since", max_length=64),
+            ),
+            (
+                "updated_since",
+                None
+                if updated_since is None
+                else require_text(updated_since, "updated_since", max_length=64),
+            ),
+        ),
+    )
+    headers = {} if resolved.api_key is None else {"api-key": resolved.api_key}
+    return dataset(
+        (RemoteFile(url, filename=f"ncbi_virus_{_slug(values)}.zip"),),
+        output_dir,
+        kind="ncbi_virus_package",
+        source="NCBI Datasets Virus",
+        metadata={
+            "query": values,
+            "by": by,
+            "include": includes,
+            "aux_reports": reports,
+            "refseq_only": refseq_only,
+            "annotated_only": annotated_only,
+            "complete_only": complete_only,
+            "host": host,
+            "geo_location": geo_location,
+            "released_since": released_since,
+            "updated_since": updated_since,
+        },
+        config=resolved,
+        progress=progress,
+        headers=headers,
+    )
+
+
+__all__ = ["annotation", "gene", "genome", "genome_package", "taxonomy", "virus_package"]

dnakit/download/sequence.py

@@ -0,0 +1,133 @@
+"""Persist coordinate sequences returned by Ensembl as auditable FASTA."""
+
+from __future__ import annotations
+
+import hashlib
+import os
+import re
+import tempfile
+from collections.abc import Callable, Sequence
+from pathlib import Path
+
+from dnakit.exceptions import DownloadError
+from dnakit.search import QueryProgress, SearchConfig
+from dnakit.search.ensembl import DEFAULT_ENSEMBL_REST_URL
+from dnakit.search.ensembl import sequence as search_sequence
+
+from .files import _install_staged_files, _write_manifest, resolved_config
+from .models import DatasetDownloadResult, DownloadConfig, DownloadedFile
+
+
+def _fasta_identifier(value: object, fallback: str) -> str:
+    raw = value if isinstance(value, str) and value.strip() else fallback
+    return re.sub(r"[^A-Za-z0-9_.:-]+", "_", str(raw))[:255]
+
+
+def sequence(
+    species: str,
+    region: str | Sequence[str],
+    output_path: str | os.PathLike[str],
+    *,
+    strand: int = 1,
+    upstream: int = 0,
+    downstream: int = 0,
+    mask: str | None = None,
+    config: DownloadConfig | None = None,
+    query_progress: Callable[[QueryProgress], None] | None = None,
+    ensembl_api_base_url: str = DEFAULT_ENSEMBL_REST_URL,
+) -> DatasetDownloadResult:
+    """Fetch one or more 0-based half-open regions and atomically write FASTA."""
+
+    resolved = resolved_config(config)
+    target = Path(output_path).expanduser().resolve()
+    if target.exists() and not target.is_file():
+        raise IsADirectoryError(f"output_path must be a file: {target}")
+    target.parent.mkdir(parents=True, exist_ok=True)
+    manifest = target.with_name(f"{target.name}.manifest.json")
+    if manifest.exists() and not manifest.is_file():
+        raise IsADirectoryError(f"Sequence manifest target must be a file: {manifest}")
+    if not resolved.overwrite and (target.exists() or manifest.exists()):
+        raise FileExistsError("Refusing to overwrite existing FASTA or manifest.")
+    result = search_sequence(
+        species,
+        region,
+        strand=strand,  # type: ignore[arg-type]
+        upstream=upstream,
+        downstream=downstream,
+        mask=mask,  # type: ignore[arg-type]
+        progress=query_progress,
+        config=SearchConfig(
+            timeout=min(float(resolved.timeout), 300.0),
+            max_response_bytes=min(resolved.max_file_bytes, 100_000_000),
+            max_records=resolved.max_files,
+        ),
+        api_base_url=ensembl_api_base_url,
+    )
+    lines: list[str] = []
+    for index, record in enumerate(result.records, start=1):
+        symbols = record.get("seq")
+        if not isinstance(symbols, str) or not symbols:
+            raise DownloadError(
+                "Ensembl sequence response did not contain sequence text.",
+                code="QUERY_RESPONSE_ERROR",
+            )
+        identifier = _fasta_identifier(record.get("id"), f"region_{index}")
+        requested = record.get("requested_region")
+        description = f" requested={requested}" if isinstance(requested, str) else ""
+        lines.append(f">{identifier}{description}")
+        lines.extend(symbols[offset : offset + 80] for offset in range(0, len(symbols), 80))
+    payload = ("\n".join(lines) + "\n").encode("ascii")
+    if len(payload) > resolved.max_file_bytes:
+        raise DownloadError("FASTA output exceeds max_file_bytes.", code="DOWNLOAD_SIZE_LIMIT")
+    md5 = hashlib.md5(payload, usedforsecurity=False).hexdigest()
+    sha256 = hashlib.sha256(payload).hexdigest()
+    downloaded = DownloadedFile(
+        result.request_url,
+        str(target),
+        len(payload),
+        md5,
+        sha256,
+        False,
+    )
+    with tempfile.TemporaryDirectory(prefix=".dnakit-sequence-", dir=str(target.parent)) as raw:
+        stage = Path(raw)
+        staged_target = stage / target.name
+        staged_target.write_bytes(payload)
+        staged_manifest = stage / manifest.name
+        _write_manifest(
+            {
+                "kind": "coordinate_sequence",
+                "source": "Ensembl",
+                "query": result.to_dict(),
+                "file": {
+                    "path": str(target),
+                    "byte_size": len(payload),
+                    "md5": md5,
+                    "sha256": sha256,
+                },
+            },
+            staged_manifest,
+            overwrite=False,
+        )
+        _install_staged_files(
+            (staged_target, staged_manifest),
+            (target, manifest),
+            overwrite=resolved.overwrite,
+        )
+    return DatasetDownloadResult(
+        "coordinate_sequence",
+        "Ensembl",
+        str(target.parent),
+        (downloaded,),
+        str(manifest),
+        result.provenance,
+        metadata={
+            "species": species,
+            "region_count": len(result.records),
+            "input_coordinate_system": "0-based half-open",
+            "strand": strand,
+        },
+    )
+
+
+__all__ = ["sequence"]

dnakit/download/ucsc.py

@@ -0,0 +1,99 @@
+"""Download files selected from the UCSC Genome Browser file catalog."""
+
+from __future__ import annotations
+
+import hashlib
+from collections.abc import Callable
+from pathlib import Path, PurePosixPath
+from urllib.parse import quote, urlsplit
+
+from dnakit.exceptions import ConfigurationError, DownloadError
+from dnakit.search import QueryResult
+from dnakit.search._http import require_https_base
+
+from .files import dataset, resolved_config
+from .models import DatasetDownloadResult, DownloadConfig, DownloadProgress, RemoteFile
+
+DEFAULT_UCSC_DOWNLOAD_URL = "https://hgdownload.soe.ucsc.edu"
+
+
+def _file_url(value: str, base_url: str) -> tuple[str, str]:
+    raw = value.strip()
+    parsed = urlsplit(raw)
+    if parsed.scheme:
+        if parsed.scheme != "https" or not parsed.netloc or parsed.fragment:
+            raise ConfigurationError("UCSC file URL must use HTTPS.", code="INVALID_DOWNLOAD_URL")
+        path = parsed.path
+        url = raw
+    else:
+        relative = raw.lstrip("/")
+        path = "/" + relative
+        url = f"{require_https_base(base_url)}/{quote(relative, safe='/._-')}"
+    parts = PurePosixPath(path).parts
+    if not parts or ".." in parts:
+        raise ConfigurationError("UCSC file path is unsafe.", code="INVALID_DOWNLOAD_URL")
+    basename = PurePosixPath(path).name
+    if not basename:
+        raise ConfigurationError("UCSC file path has no filename.", code="INVALID_DOWNLOAD_URL")
+    digest = hashlib.sha256(raw.encode("utf-8")).hexdigest()[:12]
+    maximum_basename = 240 - len(digest)
+    filename = f"{digest}_{basename[:maximum_basename]}"
+    return url, filename
+
+
+def files(
+    query: QueryResult,
+    output_dir: str | Path,
+    *,
+    config: DownloadConfig | None = None,
+    progress: Callable[[DownloadProgress], None] | None = None,
+    download_base_url: str = DEFAULT_UCSC_DOWNLOAD_URL,
+) -> DatasetDownloadResult:
+    """Download a bounded ``dnakit.search.ucsc_files`` result with local checksums."""
+
+    if (
+        not isinstance(query, QueryResult)
+        or query.provider != "UCSC"
+        or query.query_type != "files"
+    ):
+        raise ConfigurationError("query must be a dnakit.search.ucsc_files() result.")
+    resolved = resolved_config(config)
+    resources: list[RemoteFile] = []
+    expected_total = 0
+    source_paths: dict[str, str] = {}
+    for record in query.records:
+        raw_url = record.get("url")
+        if not isinstance(raw_url, str) or not raw_url.strip():
+            raise DownloadError("UCSC file record has no URL.", code="QUERY_RESPONSE_ERROR")
+        url, filename = _file_url(raw_url, download_base_url)
+        raw_size = record.get("sizeBytes")
+        if isinstance(raw_size, int) and not isinstance(raw_size, bool) and raw_size >= 0:
+            if raw_size > resolved.max_file_bytes:
+                raise DownloadError("UCSC file exceeds max_file_bytes.", code="DOWNLOAD_SIZE_LIMIT")
+            expected_total += raw_size
+        resources.append(RemoteFile(url, filename=filename))
+        source_paths[filename] = raw_url
+    if not resources:
+        raise DownloadError(
+            "UCSC query selected no downloadable files.", code="UCSC_FILES_NOT_FOUND"
+        )
+    if len(resources) > resolved.max_files:
+        raise DownloadError("UCSC files exceed max_files.", code="DOWNLOAD_FILE_LIMIT")
+    if expected_total > resolved.max_total_bytes:
+        raise DownloadError("UCSC files exceed max_total_bytes.", code="DOWNLOAD_TOTAL_SIZE_LIMIT")
+    return dataset(
+        resources,
+        output_dir,
+        kind="ucsc_files",
+        source="UCSC Genome Browser Downloads",
+        metadata={
+            "catalog_url": query.request_url,
+            "expected_total_bytes": expected_total,
+            "source_paths": source_paths,
+        },
+        config=resolved,
+        progress=progress,
+    )
+
+
+__all__ = ["DEFAULT_UCSC_DOWNLOAD_URL", "files"]

dnakit/evaluation/__init__.py

@@ -0,0 +1,81 @@
+"""Transparent, deterministic DNA sequence and dataset evaluation APIs."""
+
+from dnakit.evaluation.collection import (
+    evaluate_diversity,
+    evaluate_redundancy,
+    evaluate_uniqueness,
+)
+from dnakit.evaluation.config import (
+    AmbiguityEvaluationConfig,
+    ComplexityEvaluationConfig,
+    DistributionEvaluationConfig,
+    DiversityEvaluationConfig,
+    EvaluationLimits,
+    FragmentSimilarityConfig,
+    FrechetDistanceConfig,
+    QualityEvaluationConfig,
+    ReferenceSearchConfig,
+    ScorecardConfig,
+    ScoreRule,
+    SNNConfig,
+    SynthesisRiskConfig,
+    UniquenessEvaluationConfig,
+)
+from dnakit.evaluation.distribution import evaluate_distribution_similarity
+from dnakit.evaluation.frechet import evaluate_frechet_distance
+from dnakit.evaluation.generative import evaluate_fragment_similarity, evaluate_snn
+from dnakit.evaluation.reference import (
+    create_reference_library,
+    evaluate_memorization,
+    evaluate_novelty,
+    evaluate_reference_similarity,
+    nearest_reference,
+)
+from dnakit.evaluation.results import EvaluationEntry, EvaluationReport, ReferenceLibrary
+from dnakit.evaluation.scorecard import ScoreInput, evaluate_scorecard
+from dnakit.evaluation.sequence import (
+    evaluate_ambiguity,
+    evaluate_complexity,
+    evaluate_quality,
+    evaluate_validity,
+)
+from dnakit.evaluation.synthesis import evaluate_synthesis_risk
+
+__all__ = [
+    "AmbiguityEvaluationConfig",
+    "ComplexityEvaluationConfig",
+    "DistributionEvaluationConfig",
+    "DiversityEvaluationConfig",
+    "EvaluationEntry",
+    "EvaluationLimits",
+    "EvaluationReport",
+    "FragmentSimilarityConfig",
+    "FrechetDistanceConfig",
+    "QualityEvaluationConfig",
+    "ReferenceLibrary",
+    "ReferenceSearchConfig",
+    "SNNConfig",
+    "ScoreInput",
+    "ScoreRule",
+    "ScorecardConfig",
+    "SynthesisRiskConfig",
+    "UniquenessEvaluationConfig",
+    "create_reference_library",
+    "evaluate_ambiguity",
+    "evaluate_complexity",
+    "evaluate_distribution_similarity",
+    "evaluate_diversity",
+    "evaluate_fragment_similarity",
+    "evaluate_frechet_distance",
+    "evaluate_memorization",
+    "evaluate_novelty",
+    "evaluate_quality",
+    "evaluate_redundancy",
+    "evaluate_reference_similarity",
+    "evaluate_scorecard",
+    "evaluate_snn",
+    "evaluate_synthesis_risk",
+    "evaluate_uniqueness",
+    "evaluate_validity",
+    "nearest_reference",
+]