orthonym 1.0.0__tar.gz

orthonym-1.0.0/.github/workflows/ci.yml

@@ -0,0 +1,85 @@
+name: CI
+
+# Lightweight public CI: install the package, confirm it imports and names a
+# handful of molecules correctly, and run advisory linting. Does not depend on
+# the internal benchmark baselines or the large corpora — a contributor's PR can
+# pass this without the full benchmarking apparatus.
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  workflow_dispatch:
+
+env:
+  ORTHONYM_REQUIRE_JARS: "1"   # a missing jar fails tests instead of skipping them
+
+jobs:
+  build-and-smoke:
+    name: Install + naming smoke test
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Set up Python 3.12
+        uses: actions/setup-python@v6
+        with:
+          python-version: '3.12'
+          cache: pip
+
+      - name: Set up Java 17 (for OPSIN round-trip validation)
+        uses: actions/setup-java@v5
+        with:
+          distribution: temurin
+          java-version: '17'
+
+      - name: Install package
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e ".[dev]"
+
+      - name: Fetch and verify the OPSIN and centres jars
+        # The jars are not in the repository; this downloads them from their
+        # official releases and checks the pinned SHA-256 (fails the job otherwise).
+        run: orthonym --fetch-jars
+
+      - name: Naming smoke test
+        run: |
+          python - <<'PY'
+          from orthonym import name_compound
+          cases = {
+              "CCO": "ethanol",
+              "CC(=O)O": "acetic acid",
+              "c1ccccc1": "benzene",
+              "CCN": "ethanamine",
+          }
+          fails = []
+          for smi, want in cases.items():
+              got = name_compound(smi)
+              print(f"{smi:12s} -> {got!r}  (want {want!r})")
+              if got != want:
+                  fails.append((smi, got, want))
+          if fails:
+              raise SystemExit(f"smoke test failed: {fails}")
+          print("smoke OK")
+          PY
+
+  lint:
+    name: Lint (advisory)
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    continue-on-error: true
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v6
+        with:
+          python-version: '3.12'
+          cache: pip
+      - name: Install linters
+        run: |
+          python -m pip install --upgrade pip
+          pip install ruff
+      - name: Ruff check (advisory)
+        run: ruff check src || true

orthonym-1.0.0/.github/workflows/docs.yml

@@ -0,0 +1,73 @@
+name: Docs
+
+# Build the documentation site from guide/ and publish it with GitHub Pages.
+# The build imports the package for the API pages but names no molecule, so
+# it needs neither a Java runtime nor the OPSIN and centres jars.
+# Repository setting needed once: Settings > Pages > Source = GitHub Actions.
+# The site is published from Steinbeck-Lab/Orthonym only. Every other copy of the
+# repository (a mirror or a fork) still builds the site with -W as a check, but
+# neither configures Pages nor deploys, so it needs no Pages setting.
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: pages
+  cancel-in-progress: false
+
+jobs:
+  build:
+    name: Build the site
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    env:
+      ORTHONYM_SKIP_JAR_PREFETCH: "1"   # the build names nothing; no jar download at install
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Set up Python 3.12
+        uses: actions/setup-python@v6
+        with:
+          python-version: '3.12'
+          cache: pip
+
+      - name: Install the package and the docs tools
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e ".[docs]"
+
+      - name: Configure Pages
+        id: pages
+        if: github.repository == 'Steinbeck-Lab/Orthonym'
+        uses: actions/configure-pages@v5
+
+      - name: Build (warnings are errors)
+        env:
+          ORTHONYM_DOCS_BASEURL: ${{ steps.pages.outputs.base_url }}
+        run: sphinx-build -W -b html guide _build/html
+
+      - name: Upload the site
+        if: github.repository == 'Steinbeck-Lab/Orthonym'
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: _build/html
+
+  deploy:
+    name: Deploy to GitHub Pages
+    needs: build
+    if: github.repository == 'Steinbeck-Lab/Orthonym'
+    runs-on: ubuntu-latest
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - name: Deploy
+        id: deployment
+        uses: actions/deploy-pages@v4

orthonym-1.0.0/.github/workflows/pypi-release.yml

@@ -0,0 +1,287 @@
+name: pypi-release
+
+# Builds the sdist and the wheel from a release tag, checks them, and uploads them
+# to PyPI with Trusted Publishing (OpenID Connect; no API token secret exists).
+#
+# Started by the GitHub Release that release-please.yml creates. That Release is
+# created with the RELEASE_PLEASE_TOKEN personal access token, so its
+# `release: published` event DOES start this workflow; a Release created with the
+# built-in GITHUB_TOKEN would not (events caused by GITHUB_TOKEN start no new
+# workflow runs).
+#
+# A manual run (workflow_dispatch) rebuilds a given tag and uploads it to TestPyPI
+# by default, or to PyPI when target is `pypi`. A manual PyPI upload must be
+# started FROM the release tag ("Use workflow from: tag vX.Y.Z", or
+# `gh workflow run pypi-release.yml --ref vX.Y.Z -f tag=vX.Y.Z -f target=pypi`):
+# the publish-pypi job refuses any other ref, so a run from a branch (whose copy
+# of this file may differ) can never upload to PyPI.
+#
+# This is a separate top-level workflow, not a reusable one, because Trusted
+# Publishing cannot be used from within a reusable workflow.
+#
+# PyPI is switched on separately: every job also requires the repository variable
+# PYPI_ENABLED == 'true'. Until the maintainer sets it (after the PyPI setup), a
+# Release made by release-please skips this whole workflow. To upload an existing
+# tag later: set PYPI_ENABLED=true, then run this workflow from that tag (see above).
+#
+# Run in ONE home only: every job requires the repository variable
+# RELEASE_HOME == 'true', which is set in the release home only: exactly one
+# home, the one the maintainer's local publish tooling pushes first (see
+# release-please.yml).
+#
+# The approval gate. There is NO human approval step inside this workflow while
+# the repository is private: required reviewers on an environment need a PUBLIC
+# repository on GitHub Free, Pro and Team plans. The human gate is merging the
+# release PR (release-please.yml); the Release that merge produces uploads at
+# once. The `pypi` environment is still used, because the PyPI trusted publisher
+# is bound to it. While the repository is private, restrict the `pypi`
+# environment to the deployment tag rule `v*` (Settings -> Environments ->
+# Deployment branches and tags -> Selected branches and tags; available for
+# private repositories on a user-owned Pro plan; an organization on GitHub Free
+# cannot create environments for a private repository at all). Once the
+# repository is public, add required reviewers to `pypi` as well.
+#
+# One-time setup, outside this file: create the `pypi` and `testpypi`
+# environments first (a workflow that names a missing environment creates it
+# without any protection rules). Then add a (pending) trusted publisher for
+# project `orthonym` on PyPI and, with a separate account, on TestPyPI, naming
+# this repository's owner and name, this workflow file (pypi-release.yml) and the
+# environment (`pypi`, `testpypi`).
+#
+# The upload also publishes digital attestations (on by default with Trusted
+# Publishing); they name the source repository, workflow and commit in a public
+# transparency log, even while the repository is private.
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: 'Release tag to build, e.g. v1.1.0'
+        required: true
+        type: string
+      target:
+        description: 'Where to upload the build'
+        required: true
+        default: testpypi
+        type: choice
+        options:
+          - testpypi
+          - pypi
+
+permissions:
+  contents: read
+
+env:
+  # The tag to build: the published Release's tag, or the dispatch input. It is
+  # only ever read through this variable (never pasted into a script).
+  RELEASE_TAG: ${{ github.event_name == 'release' && github.event.release.tag_name || inputs.tag }}
+
+jobs:
+  build:
+    name: Build and check the distributions
+    if: vars.RELEASE_HOME == 'true' && vars.PYPI_ENABLED == 'true'
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+      - name: Check the tag name
+        run: |
+          if ! printf '%s\n' "$RELEASE_TAG" | grep -Eq '^v[0-9]+\.[0-9]+\.[0-9]+([.+-][0-9A-Za-z.+-]+)?$'; then
+            echo "::error::'$RELEASE_TAG' is not a release tag of the form vX.Y.Z"
+            exit 1
+          fi
+          echo "building tag $RELEASE_TAG"
+
+      - uses: actions/checkout@v5
+        with:
+          ref: refs/tags/${{ env.RELEASE_TAG }}
+          persist-credentials: false
+
+      - name: Set up Python 3.12
+        uses: actions/setup-python@v6
+        with:
+          python-version: '3.12'
+
+      - name: Set up Java 17 (for the OPSIN round-trip in the smoke test)
+        uses: actions/setup-java@v5
+        with:
+          distribution: temurin
+          java-version: '17'
+
+      - name: Install the build tools
+        run: |
+          python -m pip install --upgrade pip
+          pip install build twine
+
+      - name: Build the sdist and the wheel
+        env:
+          # The build hook would otherwise download the jars into the runner's
+          # cache. They are never part of the distributions either way.
+          ORTHONYM_SKIP_JAR_PREFETCH: "1"
+        run: python -m build
+
+      - name: twine check
+        run: twine check --strict dist/*
+
+      - name: No jar inside the wheel or the sdist
+        run: |
+          shopt -s nullglob
+          wheels=(dist/*.whl)
+          sdists=(dist/*.tar.gz)
+          if [ "${#wheels[@]}" -ne 1 ] || [ "${#sdists[@]}" -ne 1 ]; then
+            echo "::error::expected exactly one wheel and one sdist, got: $(ls dist)"
+            exit 1
+          fi
+          python -c 'import sys, zipfile; print("\n".join(zipfile.ZipFile(sys.argv[1]).namelist()))' \
+            "${wheels[0]}" > "$RUNNER_TEMP/wheel-files.txt"
+          tar -tzf "${sdists[0]}" > "$RUNNER_TEMP/sdist-files.txt"
+          echo "wheel: $(wc -l < "$RUNNER_TEMP/wheel-files.txt") files; sdist: $(wc -l < "$RUNNER_TEMP/sdist-files.txt") files"
+          if grep -Ei '\.jar$' "$RUNNER_TEMP/wheel-files.txt" "$RUNNER_TEMP/sdist-files.txt"; then
+            echo "::error::a jar is inside a distribution; the jars must never be redistributed"
+            exit 1
+          fi
+          echo "no jar in either archive"
+
+      - name: Versions agree (tag, pyproject.toml, wheel, sdist)
+        run: |
+          python - <<'PY'
+          import os, sys, tarfile, tomllib, zipfile
+          from pathlib import Path
+          from packaging.version import Version
+
+          tag = os.environ["RELEASE_TAG"]
+          want = tag[1:]                      # the tag without its leading "v"
+          project = tomllib.loads(Path("pyproject.toml").read_text())["project"]["version"]
+
+          def field(text, name):
+              for line in text.splitlines():
+                  if line.startswith(name + ": "):
+                      return line.split(": ", 1)[1].strip()
+              raise SystemExit(f"no {name} field")
+
+          whl = next(Path("dist").glob("*.whl"))
+          with zipfile.ZipFile(whl) as z:
+              meta = next(n for n in z.namelist() if n.endswith(".dist-info/METADATA"))
+              wheel_version = field(z.read(meta).decode(), "Version")
+          sd = next(Path("dist").glob("*.tar.gz"))
+          with tarfile.open(sd) as t:
+              info = next(m for m in t.getmembers() if m.name.count("/") == 1 and m.name.endswith("/PKG-INFO"))
+              sdist_version = field(t.extractfile(info).read().decode(), "Version")
+
+          print(f"tag {tag} -> {want}; pyproject {project}; wheel {wheel_version}; sdist {sdist_version}")
+          bad = []
+          if project != want:
+              bad.append(f"pyproject.toml version {project!r} != tag without v {want!r}")
+          for label, v in (("wheel", wheel_version), ("sdist", sdist_version)):
+              if Version(v) != Version(want):
+                  bad.append(f"{label} version {v!r} != {want!r}")
+          if bad:
+              sys.exit("VERSION MISMATCH: " + "; ".join(bad))
+          print("versions agree")
+          PY
+
+      - name: Install the wheel into a fresh venv, fetch the jars, smoke test
+        run: |
+          python -m venv "$RUNNER_TEMP/fresh"
+          FRESH="$RUNNER_TEMP/fresh/bin"
+          "$FRESH/python" -m pip install --upgrade pip
+          "$FRESH/python" -m pip install "$GITHUB_WORKSPACE"/dist/*.whl
+          # Run outside the checkout so nothing is imported from the source tree.
+          cd "$RUNNER_TEMP"
+          "$FRESH/orthonym" --fetch-jars
+          "$FRESH/python" - <<'PY'
+          from orthonym import name_compound
+          cases = {
+              "CCO": "ethanol",
+              "CC(=O)O": "acetic acid",
+              "c1ccccc1": "benzene",
+              "CCN": "ethanamine",
+          }
+          fails = []
+          for smi, want in cases.items():
+              got = name_compound(smi)
+              print(f"{smi:12s} -> {got!r}  (want {want!r})")
+              if got != want:
+                  fails.append((smi, got, want))
+          if fails:
+              raise SystemExit(f"smoke test failed: {fails}")
+          print("smoke OK")
+          PY
+          "$FRESH/python" -c 'import os, orthonym; v = os.environ["RELEASE_TAG"][1:]; assert orthonym.__version__ == v, (orthonym.__version__, v); print("orthonym.__version__ ==", v)'
+
+      - name: Upload the distributions
+        uses: actions/upload-artifact@v6
+        with:
+          name: dist
+          path: dist/
+          if-no-files-found: error
+
+  publish-pypi:
+    name: Upload to PyPI
+    needs: build
+    # A published Release, or a manual run with target=pypi.
+    if: >-
+      vars.RELEASE_HOME == 'true' && vars.PYPI_ENABLED == 'true' &&
+      (github.event_name == 'release' ||
+       (github.event_name == 'workflow_dispatch' && inputs.target == 'pypi'))
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    environment:
+      name: pypi
+      url: https://pypi.org/p/orthonym
+    permissions:
+      id-token: write   # Trusted Publishing; no token secret
+    steps:
+      # A manual run must be started from the tag it uploads, so a run from a
+      # branch can never reach PyPI. (This guard lives in the workflow file, which
+      # a branch could change; the `v*` deployment tag rule on the `pypi`
+      # environment is the check GitHub enforces. Neither stops someone with
+      # write access from creating a new v* tag on any commit and uploading from
+      # it: only a tag ruleset limiting who may create v* tags, or required
+      # reviewers once the repository is public, closes that.)
+      - name: Refuse unless running from the release tag
+        env:
+          REF: ${{ github.ref }}
+        run: |
+          case "$REF" in
+            refs/tags/v*) ;;
+            *) echo "::error::this run is on '$REF'; a PyPI upload must run from the release tag (refs/tags/v...)"; exit 1 ;;
+          esac
+          if [ "$REF" != "refs/tags/$RELEASE_TAG" ]; then
+            echo "::error::this run is on '$REF' but uploads '$RELEASE_TAG'; start it from refs/tags/$RELEASE_TAG"
+            exit 1
+          fi
+          echo "running from $REF"
+
+      - uses: actions/download-artifact@v7
+        with:
+          name: dist
+          path: dist/
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@v1.14.2
+
+  publish-testpypi:
+    name: Upload to TestPyPI
+    needs: build
+    if: >-
+      vars.RELEASE_HOME == 'true' && vars.PYPI_ENABLED == 'true' &&
+      github.event_name == 'workflow_dispatch' && inputs.target == 'testpypi'
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    environment:
+      name: testpypi
+      url: https://test.pypi.org/p/orthonym
+    permissions:
+      id-token: write   # Trusted Publishing; no token secret
+    steps:
+      - uses: actions/download-artifact@v7
+        with:
+          name: dist
+          path: dist/
+
+      - name: Publish to TestPyPI
+        uses: pypa/gh-action-pypi-publish@v1.14.2
+        with:
+          repository-url: https://test.pypi.org/legacy/

orthonym-1.0.0/.github/workflows/release-please.yml

@@ -0,0 +1,85 @@
+name: release-please
+
+# release-please keeps ONE pull request open that accumulates the next release:
+# the CHANGELOG.md entry, .release-please-manifest.json and the version bump in
+# pyproject.toml ([project] version) and src/orthonym/__init__.py (__version__). The
+# python strategy updates both version files by itself; the `extra-files` entry in
+# release-please-config.json also rewrites the __init__ line through its
+# `x-release-please-version` marker. Merging that PR makes release-please create
+# the tag (vX.Y.Z) and the GitHub Release on the next run.
+#
+# CHANGELOG.md: release-please inserts each release above the previous one, below
+# the file's preamble, in its own format (`## [X.Y.Z](compare link) (date)` and
+# `### Features` / `### Bug Fixes` / ...), not in the Keep a Changelog layout the
+# preamble describes. The first release's compare link points at `v1.0.0`, which
+# is not a tag on GitHub, so that one link does not resolve.
+#
+# Nothing is built or deployed from this workflow. The PyPI upload is a separate
+# workflow (pypi-release.yml), started by the GitHub Release this one creates.
+# Merging the release PR is the human gate for a release: a required-reviewer
+# approval on the `pypi` environment is only available once the repository is
+# public (see pypi-release.yml).
+#
+# Run in ONE home only. The same history is pushed to two repositories
+# (Kohulan/Orthonym and Beilstein-Institut/Orthonym). Only the home whose
+# repository variable RELEASE_HOME is 'true' runs this job, so the other home
+# never opens a release PR and never tags. Set that variable in exactly one home,
+# and it must be the home that the maintainer's local publish tooling pushes
+# first.
+#
+# Versions come from the Conventional Commit types of the commits after
+# `bootstrap-sha` (release-please-config.json) until the first release exists, and
+# after the last release from then on: `!` or a BREAKING CHANGE footer -> major;
+# feat -> minor; fix, perf, deps, revert and docs -> patch (all five appear in the
+# python changelog); chore, ci, build, test, style and refactor alone -> no release.
+# The maintainer's local publish tooling writes those messages; they carry the
+# release type only.
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+# The action works only with the personal access token passed as `token` below;
+# it never uses the built-in GITHUB_TOKEN, so that token gets read access only.
+permissions:
+  contents: read
+
+jobs:
+  release-please:
+    if: vars.RELEASE_HOME == 'true'
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    outputs:
+      # For the record only: pypi-release.yml starts on the `release: published`
+      # event, not from these outputs.
+      release_created: ${{ steps.release.outputs.release_created }}
+      tag_name: ${{ steps.release.outputs.tag_name }}
+    steps:
+      - uses: googleapis/release-please-action@v5
+        id: release
+        with:
+          config-file: release-please-config.json
+          manifest-file: .release-please-manifest.json
+          # A personal access token is REQUIRED here. Both homes report
+          # can_approve_pull_request_reviews=false and default_workflow_permissions=read,
+          # so the built-in GITHUB_TOKEN cannot open the release PR. A Release made
+          # with the PAT also starts pypi-release.yml; one made with GITHUB_TOKEN
+          # would not (events caused by GITHUB_TOKEN start no new workflow runs).
+          #
+          # A fine-grained PAT limited to this one repository, with these
+          # repository permissions:
+          #   Contents: Read and write       (release branch, tag, Release)
+          #   Pull requests: Read and write  (the release PR and its labels)
+          #   Workflows: Read and write      (a tag or Release on a commit that
+          #                                   changes .github/workflows/ needs it)
+          #   Issues: Read and write         (optional; labels also work through
+          #                                   Pull requests)
+          #   Metadata: Read                 (added automatically)
+          # Its resource owner must be the repository's owner. For an organization
+          # repository, an organization member creates it (an outside collaborator
+          # cannot), and by default an organization owner must approve it before it
+          # can write. It expires (organizations default to at most 366 days):
+          # renew it before then. A secret name cannot start with GITHUB_, hence
+          # RELEASE_PLEASE_TOKEN.
+          token: ${{ secrets.RELEASE_PLEASE_TOKEN }}

orthonym-1.0.0/.gitignore

@@ -0,0 +1,165 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# Testing
+.tox/
+.coverage
+.coverage.*
+htmlcov/
+.pytest_cache/
+.hypothesis/
+
+# Jupyter
+.ipynb_checkpoints/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Benchmark output
+benchmark_graded_results.csv
+benchmark_graded_results.json
+
+# Local development
+*.local
+.env
+
+stereo_gap_trace_results.json
+
+# Phase 145: raw corpus caches (too large to commit)
+
+
+
+# Phase 145.1-04: byte-identical verification output dirs (ISS-006)
+tmp_byte_identical_subset/
+tmp_byte_identical_full/
+
+# OPSIN reference codebase (vendored at repo root for code reference per the contributor guide;
+# not part of Orthonym source. ~ 14 MB, 8 entries — keep local but untracked.)
+opsin/
+
+# Gate run artifacts ( + v22_gate.py completion sentinel)
+gate_verdict.json
+gate_run.log
+# Concurrency locks guarding those artifacts against a second gate. flock-based,
+# so they are never stale -- the kernel releases them even on SIGKILL.
+*.lock
+
+# JVM crash dumps. 19 of these had accumulated untracked in the repo root and
+# were acknowledged in NO doc or commit; they are all from the JPype in-process
+# JVM (argv `-Xmx512m -Djava.awt.headless=true --enable-native-access=ALL-UNNAMED`,
+# no `-jar`), 15 within three days. Ignoring them keeps `git status` readable --
+# it does NOT mean they are benign. The open investigation and what is and is not
+# established about their cause:  §H4.
+hs_err_pid*.log
+replay_pid*.log
+core.[0-9]*
+
+# v37 SP0 census harness output ():
+# a per-molecule JSONL over the full 111,843-unique-SMILES ChEBI corpus is a
+# measurement artifact, not source -- keep it local like  output.
+
+
+# Personal, per-machine  Code overrides. This file was TRACKED until
+# 2026-08-04, which put one developer's machine-specific permission allowlist
+# (conda paths, absolute /home paths) into the shared repo and would make any
+# second developer's local overrides collide with it. `./settings.json`
+# stays tracked -- that is the team-wide file, and it carries the agent-teams
+# flag plus the guardrails in the contributor guide. Only the `.local.` sibling is personal.
+./settings.local.json
+
+# ======================================================================
+# Public-release: internal / local-only material (kept on disk, never shipped)
+# ======================================================================
+# Internal planning, agent tooling, and dev docs. Local-only.
+
+./
+.superpowers/
+.agents/
+docs/
+
+data/pubchem_cache.json
+# Full internal engineering invariants live here locally; the tracked
+# the contributor guide is the scrubbed public contributor guide.
+.local.md
+
+# Internal reports (local-only)
+/TECHNICAL_REPORT.md
+/FAILURE_ANALYSIS.md
+/COMPREHENSIVE_PHASES.md
+/PRODUCT.md
+
+# Copyrighted reference document (local-only)
+/IUPAC_BlueBook_Organic_Naming_Guide.docx
+
+# Large regenerable data dumps (local-only; derive from ChEBI)
+/ChEBI_IUPAC.txt
+/ChEBI_SMILES.txt
+/ChEBI_IUPAC_OPSIN.txt
+/ChEBI_OPSIN_Retranslation
+/chebi_iupac_filtered.tsv
+/l
+
+# Root benchmark / debug artifacts (local-only)
+/benchmark_*.json
+/benchmark_*.csv
+/benchmark_summary.md
+/_drop23_*.json
+/pipeline_traces.json
+/gap_summary.json
+/opsin_all_classifications.json
+/opsin_discrimination.json
+/Untitled.ipynb
+/test_orthonym.ipynb
+/test_bicyclo_check.py
+/test_composer_routing_debug.py
+/test_lactone_detection.py
+/test_pentacyclic_lactone_debug.py
+/test_phase2_fused_rings.py
+
+# Reference-engine comparison harnesses + their outputs (local-only; they
+# import external tools not part of Orthonym and are not shipped publicly).
+
+
+benchmarks/*/rows_reference-engine.jsonl.gz
+benchmarks/*/hh_10k_*.json
+
+# Stray leftover test-data snippet (unreferenced)
+/test.tsv
+
+# Third-party jars are downloaded at install, never committed
+*.jar
+
+# Documentation build output (sphinx-build guide _build/html)
+_build/