diff --git a/.github/dependabot.yml b/.github/dependabot.yml index fb2bce8..db69680 100644 --- a/.github/dependabot.yml +++ b/.github/dependabot.yml @@ -8,11 +8,3 @@ updates: dependencies: patterns: - "*" - - package-ecosystem: pip - directory: /docs - schedule: - interval: monthly - groups: - docs: - patterns: - - "*" diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml new file mode 100644 index 0000000..6814f15 --- /dev/null +++ b/.github/workflows/docs.yml @@ -0,0 +1,64 @@ +# Build the documentation the way `pixi run -e docs docbld` does: Org export, +# API pages from the code, Sphinx with warnings and unresolved references as +# errors, the Zig autodoc site, and the internal link check. External links +# are checked in their own step. On main the site is published to +# https://stackhands.github.io/zig-common/. +name: docs + +on: + push: + branches: [main] + pull_request: + workflow_dispatch: + schedule: + # Weekly, so a link that went dead elsewhere is noticed. + - cron: "17 5 * * 1" + +permissions: + contents: read + +concurrency: + group: docs-${{ github.ref }} + cancel-in-progress: true + +jobs: + build: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + + - uses: prefix-dev/setup-pixi@9936258fee697aff89b3fed6ca1f80a382ef694e # v0.11.3 + with: + environments: docs + cache: true + locked: true + + - name: Build + run: pixi run -e docs docbld + env: + DOCS_SOURCE_REF: ${{ github.sha }} + + - name: External links + run: pixi run -e docs linkcheck + env: + GITHUB_TOKEN: ${{ github.token }} + + - uses: actions/upload-pages-artifact@fc324d3547104276b827a68afc52ff2a11cc49c9 # v5.0.0 + with: + path: docs/build/html + + deploy: + if: github.event_name == 'push' && github.ref == 'refs/heads/main' + needs: build + runs-on: ubuntu-latest + permissions: + pages: write + id-token: write + environment: + name: github-pages + url: ${{ steps.deployment.outputs.page_url }} + steps: + - id: deployment + uses: actions/deploy-pages@368f82528645a54fb793d4d04e342629a3f51346 # v5.0.1 diff --git a/.github/workflows/pages.yml b/.github/workflows/pages.yml deleted file mode 100644 index 247868e..0000000 --- a/.github/workflows/pages.yml +++ /dev/null @@ -1,43 +0,0 @@ -name: pages -# Build the documentation with warnings as errors; on main, publish it to -# https://stackhands.github.io/zig-common/ -on: - push: - branches: [main] - pull_request: -permissions: - contents: read -concurrency: - group: pages-${{ github.ref }} - cancel-in-progress: true -jobs: - build: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v7 - - uses: actions/setup-python@v7 - with: - python-version: "3.12" - - run: python -m pip install -r docs/requirements.txt - - run: python -m sphinx -W -b html docs docs/_build/html - - uses: mlugg/setup-zig@v2 - with: - version: 0.17.1 - - run: zig build docs --prefix zig-out && cp -r zig-out/docs docs/_build/html/api - - uses: actions/upload-pages-artifact@v5 - if: github.event_name == 'push' && github.ref == 'refs/heads/main' - with: - path: docs/_build/html - deploy: - if: github.event_name == 'push' && github.ref == 'refs/heads/main' - needs: build - runs-on: ubuntu-latest - permissions: - pages: write - id-token: write - environment: - name: github-pages - url: ${{ steps.deployment.outputs.page_url }} - steps: - - id: deployment - uses: actions/deploy-pages@v5 diff --git a/.gitignore b/.gitignore index abca454..cbfd42c 100644 --- a/.gitignore +++ b/.gitignore @@ -4,3 +4,16 @@ .zig-cache/ zig-out/ *.o + +# Documentation build (docs-plan template): generated, never committed. +/docs/build/ +/docs/source/**/*.rst +/docs/source/reference/api/ +/docs/source/**/*.png +/docs/source/**/*.svg +/docs/source/**/*.jpg +/docs/source/**/*.webp +!/docs/source/_static/** +/docs/**/__pycache__/ +/.pixi/ +/.lycheecache diff --git a/changelog.d/+doc-comments.doc.md b/changelog.d/+doc-comments.doc.md new file mode 100644 index 0000000..4636ddf --- /dev/null +++ b/changelog.d/+doc-comments.doc.md @@ -0,0 +1 @@ +Every `pub` declaration has a doc comment, whose first sentence is the summary the API pages list. diff --git a/changelog.d/+docs-pages.doc.md b/changelog.d/+docs-pages.doc.md new file mode 100644 index 0000000..987695c --- /dev/null +++ b/changelog.d/+docs-pages.doc.md @@ -0,0 +1 @@ +The site has how-to guides for replacing a file and keeping its access control lists, keeping private state in `/tmp`, compressing logs that `.licensed-logs` marks, matching a Python tool's output and upgrading zig-common; explanations of process groups and deadlines, system calls without a C library, and Python compatibility; and a reference of the messages, exit statuses and version line that `cli` gives the tools. diff --git a/changelog.d/+docs-site.doc.md b/changelog.d/+docs-site.doc.md new file mode 100644 index 0000000..9c048c0 --- /dev/null +++ b/changelog.d/+docs-site.doc.md @@ -0,0 +1 @@ +The documentation site is built from Org pages in `docs/orgmode/` with Sphinx, in four parts: the tutorial "Write a small tool on zig-common", how-to guides, explanation and reference. Each module's API page is generated from its doc comments, and the site publishes an `objects.inv` of every `pub` declaration for the tools' sites to link into. `pixi run -e docs docbld` builds it as CI does and fails on a warning, an unresolved name or a dead internal link; `pixi run -e docs linkcheck` checks the external links. The `docs` workflow publishes the site to GitHub Pages; `docs/requirements.txt` and `pages.yml` are gone. diff --git a/docs/compat.md b/docs/compat.md deleted file mode 100644 index 694fca1..0000000 --- a/docs/compat.md +++ /dev/null @@ -1,2 +0,0 @@ -```{include} ../COMPAT.md -``` diff --git a/docs/conf.py b/docs/conf.py deleted file mode 100644 index dc68827..0000000 --- a/docs/conf.py +++ /dev/null @@ -1,69 +0,0 @@ -"""Sphinx configuration for the zig-common documentation.""" - -project = "zig-common" -author = "zig-common developers" -copyright = "Copyright (c) zig-common developers" - -extensions = ["myst_parser", "sphinx_copybutton"] -myst_enable_extensions = ["colon_fence", "deflist"] -myst_heading_anchors = 3 -exclude_patterns = ["_build"] - -html_theme = "shibuya" -html_title = "zig-common" -html_static_path = ["_static"] -html_favicon = "_static/favicon.svg" -html_baseurl = "https://stackhands.github.io/zig-common/" -html_theme_options = { - "github_url": "https://github.com/stackhands/zig-common", - "accent_color": "teal", - "dark_code": True, - "light_logo": "_static/logo-light.svg", - "dark_logo": "_static/logo-dark.svg", - "nav_links": [ - # stackhands:begin (generated by stackhands/.github branding/sync.py) - { - "title": "stackhands", - "children": [ - { - "title": "eb-stack", - "url": "https://eb-stack.rgoswami.me/", - "summary": "Solve, shard and plan an EasyBuild build list; admit builds under a scratch inode budget", - }, - { - "title": "eb-staged-rebuild", - "url": "https://stackhands.github.io/eb-staged-rebuild/", - "summary": "Rebuild an installation in a staged tree and swap it in, so running jobs keep their paths", - }, - { - "title": "eessi-arch-guard", - "url": "https://stackhands.github.io/eessi-arch-guard/", - "summary": "Reload EESSI in a Slurm task that inherited it for another CPU or GPU", - }, - { - "title": "eb-local", - "url": "https://stackhands.github.io/eb-local/", - "summary": "Install software with EasyBuild on top of EESSI into a directory a user or project owns", - }, - { - "title": "eb-keep-logs", - "url": "https://stackhands.github.io/eb-keep-logs/", - "summary": "Keep a failed build's EasyBuild log and command output; rotate a pipeline's log tree", - }, - { - "title": "rfc9162", - "url": "https://stackhands.github.io/rfc9162/", - "summary": "Append-only Merkle logs hashed as RFC 9162, with tiled storage and signed checkpoints", - }, - ], - }, - # stackhands:end - ], -} -html_context = { - "source_type": "github", - "source_user": "stackhands", - "source_repo": "zig-common", - "source_version": "main", - "source_docs_path": "/docs/", -} diff --git a/docs/export.el b/docs/export.el new file mode 100644 index 0000000..3253546 --- /dev/null +++ b/docs/export.el @@ -0,0 +1,208 @@ +;;; export.el --- Publish docs/orgmode to docs/source -*- lexical-binding: t; -*- + +;; Run from docs/: emacs -Q --batch --load export.el +;; +;; Every .org page under orgmode/ becomes a .rst page under source/ at the +;; same path; images are copied beside them. A page that fails to export +;; fails the run. +;; +;; ox-rst is GPL-2+ and is not stored in the tree. The pinned upstream +;; commit is fetched into a cache outside it ($STACKHANDS_OX_RST_CACHE, else +;; $XDG_CACHE_HOME/stackhands-docs/ox-rst//), its sha256 checked, and +;; that file loaded. +;; +;; Org 9.7 stores the text of ~code~ and =verbatim= as a deferred value, +;; which ox-rst passes to replace-regexp-in-string; deferred values are +;; resolved on the parse tree before any transcoder runs. +;; +;; Links between pages are written as Org file links and come out as :doc: +;; roles. These link types write the other Sphinx roles: +;; +;; [[zig:zig_common.proc.run]] :zig:obj:`zig_common.proc.run` +;; [[autodoc:zig_common.proc]] :zig:autodoc:`zig_common.proc` +;; [[autodoc:/][Zig autodoc]] the autodoc site's front page +;; [[py:eessi_arch_guard.decide]] :py:obj:`eessi_arch_guard.decide` +;; [[rust:struct:eb_stack::Plan]] :rust:struct:`eb_stack::Plan` +;; [[site:eb-local:howto/index]] :external+eb-local:doc:`howto/index` +;; [[man:bwrap(1)]] :manpage:`bwrap(1)` +;; [[term:EESSI]] :term:`EESSI` +;; +;; A description, [[zig:zig_common.proc.run][run]], becomes the link text. + +(require 'org) +(require 'ox-publish) + +(defconst stackhands-ox-rst-revision + "b73eff187eebac24b457688bfd27f09eff434860") +(defconst stackhands-ox-rst-sha256 + "17ac300861f22e62166785a8ac1b97d32bb8a131ee5ba1b7a9db8977b07e7ede") +(defconst stackhands-ox-rst-url + (concat "https://raw.githubusercontent.com/msnoigrs/ox-rst/" + stackhands-ox-rst-revision + "/ox-rst.el")) + +(defvar stackhands-export-failures nil + "Alist of (file . message) for pages that failed to publish.") + +(defun stackhands-export-fail (format-string &rest args) + "Print FORMAT-STRING with ARGS and exit non-zero." + (apply #'message format-string args) + (kill-emacs 1)) + +(defun stackhands-ox-rst-cache-file () + "Absolute path of the pinned ox-rst source, outside the repository." + (expand-file-name + (concat stackhands-ox-rst-revision "/ox-rst.el") + (or (getenv "STACKHANDS_OX_RST_CACHE") + (expand-file-name + "stackhands-docs/ox-rst" + (or (getenv "XDG_CACHE_HOME") + (expand-file-name ".cache" + (or (getenv "HOME") + temporary-file-directory))))))) + +(defun stackhands-file-sha256 (file) + "Return the sha256 hex digest of FILE." + (with-temp-buffer + (set-buffer-multibyte nil) + (insert-file-contents-literally file) + (secure-hash 'sha256 (current-buffer)))) + +(defun stackhands-fetch-ox-rst (dest) + "Download the pinned ox-rst to DEST, or exit non-zero." + (let ((part (concat dest ".partial"))) + (make-directory (file-name-directory dest) t) + (when (file-exists-p part) + (delete-file part)) + (message "export: fetching ox-rst %s" stackhands-ox-rst-revision) + (let ((status (call-process "curl" nil nil nil + "-fsSL" "--retry" "3" "--retry-delay" "1" + "-o" part stackhands-ox-rst-url))) + (unless (and (eq status 0) (file-readable-p part)) + (when (file-exists-p part) + (delete-file part)) + (stackhands-export-fail "export failed: could not fetch %s (curl exited %s)" + stackhands-ox-rst-url status))) + (let ((got (stackhands-file-sha256 part))) + (unless (string= got stackhands-ox-rst-sha256) + (delete-file part) + (stackhands-export-fail "export failed: ox-rst checksum mismatch (expected %s, got %s)" + stackhands-ox-rst-sha256 got))) + (rename-file part dest t))) + +(let ((dest (stackhands-ox-rst-cache-file))) + (unless (and (file-readable-p dest) + (string= (stackhands-file-sha256 dest) stackhands-ox-rst-sha256)) + (stackhands-fetch-ox-rst dest)) + ;; NOSUFFIX, so a stale ox-rst.elc beside it is never loaded. + (load dest nil nil t)) + +(message "export: Org %s; ox-rst %s" (org-version) stackhands-ox-rst-revision) + +;; Source blocks are shown, never run. +(setq org-export-use-babel nil) +;; x86_64 and EESSI_USER_INSTALL are names, not subscripts; only _{...} and +;; ^{...} are. +(setq org-export-with-sub-superscripts '{}) + +(defun stackhands-resolve-deferred (tree _backend _info) + "Replace deferred properties in TREE with their values." + (when (fboundp 'org-element-properties-resolve) + (org-element-map tree t + (lambda (node) + (unless (stringp node) + (org-element-properties-resolve node t))))) + tree) + +(add-to-list 'org-export-filter-parse-tree-functions #'stackhands-resolve-deferred) + +;; ox-rst writes a link to another Org page as a link to its .rst file, and +;; leaves a link to a generated .md page as it is; Sphinx needs a :doc: role +;; to reach either rendered page. +(defun stackhands-doc-link-filter (text backend _info) + (if (org-export-derived-backend-p backend 'rst) + (replace-regexp-in-string + "`\\([^`]+\\) <\\([^>:]+\\)\\.\\(rst\\|md\\)>`_" + ":doc:`\\1 <\\2>`" + text) + text)) + +(add-to-list 'org-export-filter-link-functions #'stackhands-doc-link-filter) + +(defun stackhands-role (role target desc) + "The Sphinx ROLE for TARGET, with DESC as its text when given." + (if (and desc (not (string-empty-p desc)) (not (string= desc target))) + (format ":%s:`%s <%s>`" role desc target) + (format ":%s:`%s`" role target))) + +(defun stackhands-define-role-link (type role-fn) + "Make Org links of TYPE export to the role ROLE-FN returns for their path." + (org-link-set-parameters + type + :export (lambda (path desc backend &optional _info) + (if (org-export-derived-backend-p backend 'rst) + (let ((role-target (funcall role-fn path))) + (stackhands-role (car role-target) (cdr role-target) desc)) + (or desc path))))) + +(stackhands-define-role-link "zig" (lambda (path) (cons "zig:obj" path))) +(stackhands-define-role-link "autodoc" (lambda (path) (cons "zig:autodoc" path))) +(stackhands-define-role-link "py" (lambda (path) (cons "py:obj" path))) +(stackhands-define-role-link "man" (lambda (path) (cons "manpage" path))) +(stackhands-define-role-link "term" (lambda (path) (cons "term" path))) +;; A heading on another page, by the CUSTOM_ID ox-rst writes as its label. +(stackhands-define-role-link "ref" (lambda (path) (cons "ref" path))) +(stackhands-define-role-link + "rust" (lambda (path) + ;; rust:struct:a::B names the role; rust:anyhow::Error does not. + (if (string-match "\\`\\([a-z]+\\):\\([^:].*\\)\\'" path) + (cons (concat "rust:" (match-string 1 path)) (match-string 2 path)) + (cons "rust:any" path)))) +(stackhands-define-role-link + "site" (lambda (path) + (unless (string-match "\\`\\([^:]+\\):\\(.+\\)\\'" path) + (error "site link needs SITE:PAGE, got %s" path)) + (cons (format "external+%s:doc" (match-string 1 path)) (match-string 2 path)))) + +(setq org-publish-project-alist + '(("sphinx-rst" + :base-directory "./orgmode/" + :base-extension "org" + :publishing-directory "./source/" + :publishing-function org-rst-publish-to-rst + :recursive t + :headline-levels 4 + :with-toc nil + :section-numbers nil) + ("sphinx-images" + :base-directory "./orgmode/" + :base-extension "svg\\|png\\|jpg\\|jpeg\\|webp" + :publishing-directory "./source/" + :publishing-function org-publish-attachment + :recursive t) + ("sphinx" :components ("sphinx-rst" "sphinx-images")))) + +(defun stackhands-publish-file (orig filename &optional project no-cache) + "Call ORIG to publish FILENAME, recording a failure instead of stopping." + (condition-case err + (funcall orig filename project no-cache) + (error + (let ((msg (error-message-string err))) + (message "export failed: %s: %s" filename msg) + (push (cons filename msg) stackhands-export-failures) + nil)))) + +(advice-add 'org-publish-file :around #'stackhands-publish-file) + +;; Every .rst under source/ is an export, so one whose page was renamed or +;; deleted would otherwise stay in the build. +(dolist (stale (directory-files-recursively "./source/" "\\.rst\\'")) + (delete-file stale)) + +(org-publish "sphinx" t) + +(when stackhands-export-failures + (message "export: %d page(s) failed" (length stackhands-export-failures)) + (dolist (fail (nreverse stackhands-export-failures)) + (message "export failed: %s: %s" (car fail) (cdr fail))) + (kill-emacs 1)) diff --git a/docs/index.md b/docs/index.md deleted file mode 100644 index e3dc931..0000000 --- a/docs/index.md +++ /dev/null @@ -1,29 +0,0 @@ -# zig-common - -```{image} _static/logo-light.svg -:alt: zig-common -:width: 420px -:class: light-only -``` - -```{image} _static/logo-dark.svg -:alt: zig-common -:width: 420px -:class: dark-only -``` - -```{include} ../README.md -:start-after: -:end-before: -``` - -```{toctree} -:hidden: -:maxdepth: 1 - -compat -releasing -``` - -The Zig API reference, generated by `zig build docs` from the doc comments, is at [api/](https://stackhands.github.io/zig-common/api/). - diff --git a/docs/orgmode/changelog.org b/docs/orgmode/changelog.org new file mode 100644 index 0000000..157f055 --- /dev/null +++ b/docs/orgmode/changelog.org @@ -0,0 +1,10 @@ +#+TITLE: Changelog +#+OPTIONS: toc:nil todo:nil num:nil author:nil title:nil + +# CHANGELOG.md at the top of the repository is the one changelog; this page +# shows it. + +#+begin_export rst +.. include:: ../../CHANGELOG.md + :parser: myst_parser.sphinx_ +#+end_export diff --git a/docs/orgmode/contributing.org b/docs/orgmode/contributing.org new file mode 100644 index 0000000..25490b0 --- /dev/null +++ b/docs/orgmode/contributing.org @@ -0,0 +1,67 @@ +#+TITLE: Contributing +#+OPTIONS: toc:nil todo:nil num:nil author:nil title:nil +#+STARTUP: content + +* Contributing + +Changes come as pull requests to [[https://github.com/stackhands/zig-common][stackhands/zig-common]]. +A change to behaviour changes the page that describes it in the same pull request. + +** Record the change + +Every change adds a news fragment, =changelog.d/+SLUG.TYPE.md=, with a short slug for the change and one of the types =towncrier.toml= configures: + +| Type | Section of the release notes | +|-----------+------------------------------| +| =feature= | Features | +| =bugfix= | Fixes | +| =doc= | Documentation | +| =removal= | Removals | +| =misc= | Miscellaneous | + +A fragment is one paragraph in the present tense that names the declarations it is about in backticks, as the entries in the [[file:changelog.org][changelog]] do. +=towncrier build --draft --version 0.9.1= shows the release notes the fragments make, and fails on a fragment whose type is not configured. +The release commit gathers them into =CHANGELOG.md=; [[https://github.com/stackhands/zig-common/blob/main/RELEASING.md][RELEASING.md]] has the rest of a release. + +** Build the documentation + +The documentation toolchain is pinned in =pixi.lock=: Emacs, Sphinx, lychee, and the tools that read the code. +With [[https://pixi.sh][pixi]] installed, from the top of the repository: + +#+begin_src bash +pixi run -e docs docbld +#+end_src + +The site is in =docs/build/html/=; open =docs/build/html/index.html=. +The build fails on any Sphinx warning, any cross-reference that does not resolve, any internal link or anchor that does not exist, and, outside the changelog, any name of a real site's machines or paths. +The first build needs the network, to fetch the other stackhands sites' inventories; later builds reuse them for 30 days. + +External links are checked separately, as they need the network: + +#+begin_src bash +pixi run -e docs linkcheck +#+end_src + +=pixi run -e docs docdel= removes everything the build generated. + +** Where things are + +| Path | What it holds | +|----------------------------+----------------------------------------------------| +| =docs/orgmode/= | the pages, in Org: edit these | +| =docs/export.el= | the Org to reStructuredText export | +| =docs/source/conf.py= | the Sphinx configuration | +| =docs/source/_ext/= | the Sphinx domain for Zig declarations | +| =docs/tools/zig_api.zig= | writes the Zig API pages from the doc comments | +| =docs/tools/check_site.py= | checks internal links, anchors and forbidden names | + +The =.rst= files under =docs/source/= and everything under =docs/source/reference/api/= are generated and not committed. + +** Write a page + +A page belongs to exactly one quadrant: a tutorial teaches by doing, a how-to guide gets one task done, an explanation says why, and a reference page lists what there is. +Start from the skeleton for its quadrant in =docs-kit/skeletons/= of [[https://github.com/stackhands/.github][stackhands/.github]], add it to the =toctree= of the quadrant's =index.org=, and follow =docs-kit/STYLE.md= there. +Examples use the neutral example site (=example.org=, =/opt/site=, =/home/alice=), never a real one. + +API documentation is written in the code, and the first sentence of each comment is the summary shown in lists. +In Zig it is a =///= comment above each =pub= declaration and a =//!= comment at the top of each file. diff --git a/docs/orgmode/explanation/descriptor-checks.org b/docs/orgmode/explanation/descriptor-checks.org new file mode 100644 index 0000000..035774d --- /dev/null +++ b/docs/orgmode/explanation/descriptor-checks.org @@ -0,0 +1,42 @@ +#+TITLE: Checks on the descriptor, not the path +#+OPTIONS: toc:nil todo:nil num:nil author:nil title:nil +#+STARTUP: content + +* Checks on the descriptor, not the path + +Why does [[zig:zig_common.fsx]] open a file first and check it afterwards, when the obvious order is the other way round? + +** The problem + +The stackhands tools work in directories other users can write: a shared =/tmp=, a project's installation tree, a build's scratch space. +A tool that checks a path and then opens it asks the file system the same question twice, and the answer can change in between. +Another user who replaces =/tmp/state= with a symbolic link to =/home/alice/.ssh/id_ed25519= after the check and before the open gets the tool to read or overwrite a file it never checked. +This is a time-of-check to time-of-use race. + +** How zig-common handles it + +Every check is made on the open descriptor. +[[zig:zig_common.fsx.openRegular]] opens the file once, with =O_NOFOLLOW= unless the caller asks to follow a final link and with =O_NONBLOCK= so a named pipe cannot stall it, and then calls [[man:fstat(2)]] on what it opened. +Whatever the path names a moment later, the descriptor still refers to the file that was checked. + +[[zig:zig_common.state]] builds on this for private files in a shared directory: a file is trusted only when the open descriptor is a regular file owned by this user, with one link and no group or other permission bits. +A write goes to a new file beside it, which is renamed over the old one. + +** What was considered and turned down + +- /Checking with =stat= and opening after./ + This is the race above. +- /Opening with =O_PATH= and checking that./ + An =O_PATH= descriptor cannot be read, so the file would be opened a second time by name. +- /Holding a lock while checking./ + Advisory locks bind only programs that take them; an attacker does not. + +** Limits + +The checks see the file as it is when opened. +A file that is still being written can change after the check; [[zig:zig_common.atomic]] covers the case where the bytes, owner, mode and access control lists (ACLs) must all survive a replacement. + +** Further reading + +- [[man:open(2)]], the =O_NOFOLLOW= and =O_NONBLOCK= flags. +- [[file:../reference/api/zig/zig_common.fsx.md][The fsx module's API]]. diff --git a/docs/orgmode/explanation/index.org b/docs/orgmode/explanation/index.org new file mode 100644 index 0000000..aa5b291 --- /dev/null +++ b/docs/orgmode/explanation/index.org @@ -0,0 +1,18 @@ +#+TITLE: Explanation +#+OPTIONS: toc:nil todo:nil num:nil author:nil title:nil +#+STARTUP: content + +* Explanation + +These pages say why zig-common works the way it does: the model behind it, the choices made and the ones turned down. +Nothing here is a step to follow. + +#+begin_export rst +.. toctree:: + :maxdepth: 1 + + descriptor-checks + process-groups-and-deadlines + system-calls-without-libc + python-compatibility +#+end_export diff --git a/docs/orgmode/explanation/process-groups-and-deadlines.org b/docs/orgmode/explanation/process-groups-and-deadlines.org new file mode 100644 index 0000000..6f8a11c --- /dev/null +++ b/docs/orgmode/explanation/process-groups-and-deadlines.org @@ -0,0 +1,76 @@ +#+TITLE: Process groups and deadlines +#+OPTIONS: toc:nil todo:nil num:nil author:nil title:nil +#+STARTUP: content + +* Process groups and deadlines + +Why does [[zig:zig_common.proc.run]] start every child in a session of its own, and stop the child's whole process group at a deadline, when the tool asked to run one program? + +** The problem + +A program a tool runs is seldom one process. +A module command runs Lmod, =eb= runs compilers, and =sh -c 'a | b'= runs two programs. +Each process the child starts inherits the child's stdout, the write end of the pipe the tool reads. + +When the deadline passes and the tool kills the child alone, the processes the child started go on. +They still hold the pipe, so the tool's read never sees the end of the output, and the tool waits for a child that is gone. +When the tool gives up and exits, they go on running on the node, writing into a directory that the next run uses. + +Three more events make a plain kill unsafe: + +- The child makes its own process group with [[man:setsid(2)]] after the fork, so for a moment there is no group to signal: =kill(-pgid)= then fails with =ESRCH=, and the child runs on. +- A process id is free again once the child is reaped, and the kernel can give it to another user's process; a kill sent by that number after the reap reaches the wrong process. +- A tool that is itself stopped, by =SIGTERM= from a batch system or =SIGINT= from a terminal, has to stop its child from a signal handler, where only a few system calls are safe. + +** How zig-common handles it + +The child leads a process group, and the group, not the process, is what =run= stops. + +1. The child calls =setsid= between the fork and the exec, so it leads a new session and a new process group, whose id is its process id. + Everything it starts is in that group, unless it makes a group of its own. +2. =run= writes stdin and reads stdout and stderr in one =poll= loop while it waits, so a child that fills one pipe while the tool reads the other stalls neither. +3. The deadline, =timeout_ms= after the start and 300 000 ms by default, is read from the monotonic clock. + At the deadline =run= sends =SIGTERM= to the group, waits =grace_ms=, 2 000 ms by default, for the child to exit, and then sends =SIGKILL= to the group. +4. The child is not reaped until the group has been signalled. + Until then the exited child is a zombie, which keeps its process id and with it the group id, so no other process can have that number when the signal is sent. +5. When the child exits on its own, =run= sends =SIGKILL= to the group as well: members that outlive the child are not the tool's to keep. + +[[zig:zig_common.proc.killGroup]] is the kill all of these use. +It signals the group; while there is no such group, it signals the child, which starts nothing before its exec, and then the group again, in case the child made it in between. + +A tool stopped from outside stops its child through the same group. +=Options.cancel= is a flag that a signal handler sets: the signal cuts the wait short, =run= sees the flag, kills the group and returns =error.Canceled=. +A handler that must stop the group itself reads the group id from =Options.pgid_out= and calls =killGroup=, which makes only =kill= system calls and does not wait, or [[zig:zig_common.proc.stopGroup]], which also waits up to 10 s until no member of the group is alive. + +A grandchild that keeps the pipe open after the child exits holds =run= until the deadline, as the output has not ended; =run= then returns =error.TimedOut= and kills the group. +With =Options.end_with_leader=, =run= returns when the child exits: it kills the group, keeps what the pipes already hold, and closes them. + +** What was considered and turned down + +- /Killing the child alone./ + This is the problem above: its children keep the pipe, and run on after the tool. +- /No deadline by default./ + A module command on a stalled network file system would then hold the tool for as long as the mount hangs. + =run= has a deadline unless the caller passes =null=. +- /The parent-death signal, =prctl(PR_SET_PDEATHSIG)=./ + It signals the child when the thread that started it ends. + It does not reach the child's own children, and it does nothing at a deadline. +- /A control group./ + Writing =1= to a control group's =cgroup.kill= file, on Linux 5.14 and later, stops every process in it, even one that left the process group. + It needs a control group of the tool's own, which systemd or root must delegate, and the tools also run where there is none. + +** Limits + +- A member that calls =setsid= itself leaves the group, and nothing =run= sends reaches it. + =sh -c 'setsid sleep 32 > /dev/null & sleep 0.3; echo started'= leaves =sleep 32= running after =run= returns. + =end_with_leader= keeps such a process from holding the call while it holds the pipe, but does not stop it. +- [[zig:zig_common.proc.groupAlive]], which =stopGroup= and =Options.wait_for_group= wait on, reads =/proc=. + A read that fails answers that the group is gone, so those waits are best effort. +- A caller that ignores =SIGCHLD= makes the kernel reap the child at once and drop its status; =run= then returns =error.NoChild=. +- With =Options.new_session= false the child stays in the tool's own group, and =run= signals the child alone. + +** Further reading + +- [[file:../howto/stop-a-slow-child.org][Stop a child program that runs too long]]. +- [[zig:zig_common.proc.Options]]: every option, with its default. +- [[man:setsid(2)]], [[man:kill(2)]], [[man:waitid(2)]] for =WNOWAIT=, and [[man:credentials(7)]] for sessions, process groups and process ids. diff --git a/docs/orgmode/explanation/python-compatibility.org b/docs/orgmode/explanation/python-compatibility.org new file mode 100644 index 0000000..40f23ea --- /dev/null +++ b/docs/orgmode/explanation/python-compatibility.org @@ -0,0 +1,66 @@ +#+TITLE: Python compatibility +#+OPTIONS: toc:nil todo:nil num:nil author:nil title:nil +#+STARTUP: content + +* Python compatibility + +Why do [[zig:zig_common.json]], [[zig:zig_common.pytext]] and [[zig:zig_common.sys.describe]] reproduce what Python writes, byte for byte, in a library for Zig programs? + +** The problem + +Several stackhands tools began as Python programs, and their Zig builds replace them on machines where the Python ones are in use. +For a time both run on the same nodes, and on the same files. +eessi-arch-guard's Python guard stays the default prolog until its Zig build has passed a shadow comparison, and its cache, a JavaScript Object Notation (JSON) file under =TMPDIR= or =/tmp=, is part of the interface its =COMPAT.md= tells a port to keep: the name, the key order, the escapes. +eb-staged-rebuild has two builds of the same tool, the Zig binary its releases carry and the Python package, whose outputs agree byte for byte except where its =COMPAT.md= lists a difference. + +One set of tests checks both. +eb-staged-rebuild's =tests/differential.sh= runs the two builds on the same invocations and fails on any difference in exit code, stdout or stderr, and compares the journals and trees they leave. +eessi-arch-guard's test suite runs against the binary through =TOOL_BIN=. + +A Zig program that writes the same data in its own way passes its own tests and breaks all of this. +Zig 0.17.1's =std.json= writes the float =2.0= as =2= and =1e16= as =10000000000000000=, where Python writes =2.0= and =1e+16=. +It writes a byte string that is not valid 8-bit Unicode Transformation Format (UTF-8) as an array of numbers, and its parser refuses =\udce9=, the escape Python writes for such a byte. +A cache entry the other build cannot read is a miss on every task, and a journal that differs fails the differential test. + +** How zig-common handles it + +Text stays bytes, read as Python reads them. +A Python tool decodes a byte string from the system with surrogateescape, so a byte that is not UTF-8 becomes one character, U+DC80 to U+DCFF, which encodes back to the same byte. +[[zig:zig_common.pytext.nextChar]] reads a byte string as that decoder does, and [[zig:zig_common.pytext.pyStrip]], [[zig:zig_common.pytext.pySplit]], [[zig:zig_common.pytext.shellQuote]] and [[zig:zig_common.json.pyTextLess]], Python's string order, work on those characters. + +JSON strings come in the two encodings the tools used: + +- cache text, =json.dumps= of surrogateescape text with =ensure_ascii=, in which a byte that is not UTF-8 is a lone =\udcXX=: [[zig:zig_common.json.decodeCache]] and [[zig:zig_common.json.writeCacheString]]; +- wire text, one character per byte as Latin-1 decodes it, so that every byte is =\u00XX= or itself: [[zig:zig_common.json.decodeWire]] and [[zig:zig_common.json.writeWireString]]. + +[[zig:zig_common.json.Py]] holds values as a Python program builds them, with ints and floats apart, and [[zig:zig_common.json.dumps]] writes them as =json.dumps(indent=N, sort_keys=...)= does, the =repr= of a float included. + +An error is worded as Python words an =OSError=. +[[zig:zig_common.sys.describe]] gives =[Errno N] text= for the errno the kernel returned, with glibc's =strerror= text, which Python's =os.strerror= also gives. +A person or a script that searched the Python tool's output for =[Errno 13] Permission denied= finds the same line. + +** What was considered and turned down + +- /Zig's =std.json=./ + It writes numbers and byte strings differently, as above, and refuses an escape Python writes. +- /A new file format with a version number./ + The two builds could not then share a cache while both are in use, and the files on disk at the switch would be unreadable to the new build. +- /Comparing outputs by meaning rather than by bytes./ + A test that parses both outputs before comparing them misses what a reader of the bytes meets: the order of keys, the digits of a float, an escape. + +** Limits + +zig-common reproduces what the tools needed, not all of Python: + +- =dumps= writes the indented form only. + The compact form, Python's default, is written by the tool from =writeCacheString= or =writeWireString=, as eessi-arch-guard writes its requests. +- [[zig:zig_common.json.parse]] refuses arrays and objects nested more than [[zig:zig_common.json.max_depth]], 32, deep, and =NaN= and =Infinity=, all of which =json.loads= reads. +- [[zig:zig_common.json.toPy]] refuses an integer that does not fit in 64 bits, which Python keeps exact. +- The errno text is glibc's; an errno that Zig does not name prints as =[Errno N] Unknown error N=, as [[file:../reference/compatibility.org][Compatibility]] shows. +- Each tool's =COMPAT.md= lists where its Zig build differs from its Python one on purpose. + +** Further reading + +- [[file:../howto/match-python-output.org][Match a Python tool's output]]. +- [[https://peps.python.org/pep-0383/][Python Enhancement Proposal (PEP) 383]], which defines surrogateescape. +- [[https://docs.python.org/3/library/json.html][Python's json module]]. diff --git a/docs/orgmode/explanation/system-calls-without-libc.org b/docs/orgmode/explanation/system-calls-without-libc.org new file mode 100644 index 0000000..84cdc7e --- /dev/null +++ b/docs/orgmode/explanation/system-calls-without-libc.org @@ -0,0 +1,62 @@ +#+TITLE: System calls without a C library +#+OPTIONS: toc:nil todo:nil num:nil author:nil title:nil +#+STARTUP: content + +* System calls without a C library + +Why do the stackhands Zig tools make their Linux system calls through [[zig:zig_common.sys]], with no C library linked, and read their environment through [[zig:zig_common.env]]? + +** The problem + +Each tool is released as one file per architecture, such as =eb-keep-logs-VERSION-x86_64-linux-musl=, which an EasyBuild recipe installs as a module or a user copies to =~/.local/bin=. +It has to start on whatever Linux distribution a login node or a compute node runs. +A program linked against the GNU C Library (glibc) of the machine it was built on does not start where the installed glibc is older: the dynamic loader refuses it, naming the symbol version it lacks, such as =GLIBC_2.34=. + +Without a C library, a system call through Zig's =std.os.linux= returns a raw number, in which a failure is a negative errno. +Each call site would have to decode it, and call again on =EINTR=. +A signal that arrives during a call, such as =SIGCHLD= when a child exits, makes the call fail with =EINTR= without doing anything, and a tool that takes that for an error fails at random. +The standard library's portable layer decodes the errno, but one it does not expect becomes =error.Unexpected= and the number is lost, so a message cannot say =[Errno 116] Stale file handle= as the Python tools did. + +A C library also holds the environment. +When a name appears twice, =getenv(3)= returns the first entry, and so does Python's =os.environ=; bash and Zig 0.17.1's =std.process.Init.environ_map= keep the last. +Given =A=1= and then =A=2=, a Python tool reads =1= and a Zig port that reads =environ_map= reads =2=, and a child started with the block as it came reads whichever entry its own runtime picks. + +** How zig-common handles it + +The tools link no C library. +Each builds one static executable per architecture, x86_64 or aarch64, for the target =ARCH-linux-musl= at the architecture's baseline processor model. +The executable has no dynamic loader and no shared library to find, and Zig 0.17.1 builds it for Linux 5.10 and later. + +[[zig:zig_common.sys]] is the one place the raw results are read. +[[zig:zig_common.sys.call]] makes a call again on =EINTR= and turns any other errno into an error of [[zig:zig_common.sys.Error]]. +Several errnos share an error, as =EACCES= and =EPERM= share =AccessDenied=, because both are Python's =PermissionError=. +[[zig:zig_common.sys.last_errno]] keeps the errno itself, so [[zig:zig_common.sys.describe]] prints the text Python prints, for the number the kernel gave. +[[zig:zig_common.sys.openat]] adds =O_CLOEXEC= to every open, so no descriptor reaches a child unless =proc.run= hands it over. +A path reaches the kernel through [[zig:zig_common.sys.z]], which refuses a zero byte (NUL), and a path of =path_max= (4096) bytes or more, before the call. + +[[zig:zig_common.env.Env]] reads the block of =NAME=value= strings the kernel passed, as bytes with no encoding assumed, and [[zig:zig_common.env.Env.get]] returns the first entry for a name, as =getenv= does. +A child's environment is built with [[zig:zig_common.env.Builder]] from those first entries, with each name once, so the child sees the value the tool acted on. +[[zig:zig_common.env.Builder.envp]] refuses an empty name, a name with ===, and a NUL byte, any of which would pass the child another variable than the one set. +=environ_map= stays fine where no Python original sets the rule: the tutorial's =kernel= reads =PATH= from it. + +** What was considered and turned down + +- /Linking glibc./ + A release would start only where glibc is at least as new as on the build machine, so it would have to be built on the oldest distribution in use. +- /Linking musl statically./ + It removes the version problem, but its calls still report a failure through =errno= and still fail with =EINTR=. + The tools would need the same layer around it, on top of a C library to build and keep up to date. +- /Zig's portable file system and process layers./ + They lose the errno of a failure they do not expect, which the messages need, and =environ_map= keeps the last of two entries, where the Python tools read the first. + +** Limits + +- zig-common builds for Linux only: another kernel has other calls and other numbers. +- An errno that Zig's =linux.E= does not name prints as =[Errno N] Unknown error N=; [[file:../reference/compatibility.org][Compatibility]] lists where this differs from Python. +- =last_errno= is one value per thread, which the next failed call overwrites, so a message reads it before the next call. + +** Further reading + +- [[man:syscalls(2)]], [[man:errno(3)]] and [[man:signal(7)]], for interrupted calls. +- [[man:getenv(3)]] and [[man:environ(7)]]. +- [[file:../reference/api/zig/zig_common.sys.md][The sys module's API]] and [[file:../reference/api/zig/zig_common.env.md][the env module's API]]. diff --git a/docs/orgmode/howto/compress-and-mark-logs.org b/docs/orgmode/howto/compress-and-mark-logs.org new file mode 100644 index 0000000..84d7672 --- /dev/null +++ b/docs/orgmode/howto/compress-and-mark-logs.org @@ -0,0 +1,100 @@ +#+TITLE: Compress logs and keep them marked +#+OPTIONS: toc:nil todo:nil num:nil author:nil title:nil +#+STARTUP: content + +* Compress logs and keep them marked + +Use this when a tool compresses build logs that may carry a licence number, as eb-keep-logs's =rotate= does. +Such a log is marked by a line in its directory's =.licensed-logs= list, which names it by its absolute path, so a log renamed to =NAME.gz= is renamed in the list too or its mark is lost. +[[zig:zig_common.logs.gzipInPlace]] compresses one file as =gzip -9= does, and [[zig:zig_common.logs.renameInList]] gives the list's new text. + +** Before you start + +- The tool depends on zig-common; [[file:../tutorials/first-tool.org][the tutorial]] sets that up. +- The tool runs as the logs' owner, or as root: the archive gets the log's owner only when the tool may set it. + +** Steps + +1. Open the directory, and take its absolute path as the kernel has it, which is how the list names files: + + #+begin_src zig + const dir = try common.fsx.openDir(common.fsx.cwd, args[1], false); + defer common.sys.close(dir); + var path_buf: [common.sys.path_max]u8 = undefined; + const here = try arena.dupe(u8, try common.fsx.realpathFd(dir, &path_buf)); + #+end_src + +2. Compress each log, and record its old and new path: + + #+begin_src zig + var renames: std.StringHashMapUnmanaged([]const u8) = .empty; + for (args[2..]) |name| { + try common.logs.gzipInPlace(gpa, init.io, dir, name); + const from = try arena.print("{s}/{s}", .{ here, name }); + try renames.put(arena, from, try arena.print("{s}.gz", .{from})); + } + #+end_src + + Each archive keeps the log's mode and its access and modification times, and its header carries the log's name. + The archive is written under a temporary name and renamed into place, and only then is the log removed. + +3. Rewrite the list when it names any of them: + + #+begin_src zig + const list = common.fsx.openRegular(dir, common.logs.licensed_list, false) catch |err| switch (err) { + error.NotFound => return 0, + else => |e| return e, + }; + defer common.sys.close(list.fd); + const text = try common.fsx.readAll(gpa, list.fd, 64 << 20); + defer gpa.free(text); + if (try common.logs.renameInList(gpa, text, &renames)) |new| { + defer gpa.free(new); + try common.fsx.replaceContents(gpa, dir, common.logs.licensed_list, new); + } + #+end_src + + =renameInList= returns null when no line changed, and the list is then left as it is. + [[zig:zig_common.fsx.replaceContents]] keeps the list's mode and access control list (ACL). + +** Check that it worked + +For a run directory under =$SCRATCH= that held the two logs of a failed build: + +#+begin_src bash +cd /scratch/alice/build-logs/20261116_101500 +ls -l +gzip -t Example-1.0-GCCcore-15.2.0.failed.ebout.log.gz && echo "archive ok" +cat .licensed-logs +#+end_src + +#+begin_example +total 88 +-rw------- 1 alice alice 42643 Nov 16 10:15 Example-1.0-GCCcore-15.2.0.failed.ebout.log.gz +-rw------- 1 alice alice 42637 Nov 16 10:15 Example-1.0-GCCcore-15.2.0.stdout.log.gz +archive ok +/scratch/alice/build-logs/20261116_101500/Example-1.0-GCCcore-15.2.0.failed.ebout.log.gz +/scratch/alice/build-logs/20261116_101500/Example-1.0-GCCcore-15.2.0.stdout.log.gz +#+end_example + +The archives keep the logs' mode, 0600, and their modification time, 10:15. +=gzip -lN= shows the name the header carries. + +** If it fails + +=gzipInPlace= refuses what =gzip= refuses, and leaves the log as it was. + +| Error | Cause | What to do | +|-------------------------+-------------------------------------------------------------+--------------------------------------------------------------------| +| =error.NotFound= | no log has that name; an earlier run may have compressed it | look for =NAME.gz= | +| =error.Exists= | =NAME.gz= is already there | compare the two, and remove the one that is not wanted | +| =error.TooManyLinks= | the log has another hard link, which would keep its bytes | find the other name with =find DIR -samefile NAME=, and remove one | +| =error.SymLink= | the name is a symbolic link | compress the file it points to, in its own directory | +| =error.InvalidArgument= | the name is a directory, a named pipe or a device | pass the names of regular files only | + +** Related + +- [[zig:zig_common.logs.GzipError]]: the errors =gzipInPlace= returns. +- [[zig:zig_common.logs.licensed_list]]: the list's name and format. +- [[https://github.com/stackhands/eb-keep-logs][eb-keep-logs]], which writes the list and rotates log trees. +- [[https://www.gnu.org/software/gzip/manual/gzip.html][The gzip manual]], for the format and the checks. diff --git a/docs/orgmode/howto/index.org b/docs/orgmode/howto/index.org new file mode 100644 index 0000000..b0eab06 --- /dev/null +++ b/docs/orgmode/howto/index.org @@ -0,0 +1,20 @@ +#+TITLE: How-to guides +#+OPTIONS: toc:nil todo:nil num:nil author:nil title:nil +#+STARTUP: content + +* How-to guides + +Each guide gets one task done for a reader who already knows what they want. +The title names the task. + +#+begin_export rst +.. toctree:: + :maxdepth: 1 + + stop-a-slow-child + replace-a-file-keeping-its-acls + keep-private-state-in-tmp + compress-and-mark-logs + match-python-output + upgrade-zig-common +#+end_export diff --git a/docs/orgmode/howto/keep-private-state-in-tmp.org b/docs/orgmode/howto/keep-private-state-in-tmp.org new file mode 100644 index 0000000..604adc8 --- /dev/null +++ b/docs/orgmode/howto/keep-private-state-in-tmp.org @@ -0,0 +1,114 @@ +#+TITLE: Keep private state in /tmp +#+OPTIONS: toc:nil todo:nil num:nil author:nil title:nil +#+STARTUP: content + +* Keep private state in /tmp + +Use this when a tool keeps a small file between runs in a directory every user may write, such as =/tmp= on =node017=, and must neither read a file another user put there nor write through a link another user made. +[[zig:zig_common.state]] trusts a file only when the open descriptor is a regular file of this user with one link and no group or other permission bits, and replaces it by renaming a new file over it. +[[file:../explanation/descriptor-checks.org][Checks on the descriptor, not the path]] says why. + +** Before you start + +- The tool depends on zig-common; [[file:../tutorials/first-tool.org][the tutorial]] sets that up. +- The state is small: the tool reads it with a size limit, and a larger file counts as no state. + +** Steps + +1. Choose the lock by which runs it must keep apart: + + | Lock | Keeps apart | Files | + |----------------------------------------+-----------------------------------------------------------------------------------------------------+---------------------------------------------| + | [[zig:zig_common.state.lockExclusive]] | runs of the tool on one machine | one lock file the tool names | + | [[zig:zig_common.state.RootLock]] | runs on every node that shares a state directory, where the file system keeps record locks coherent | =.lock= and =.lock.posix= in that directory | + + The steps that follow use =lockExclusive=, for files in =/tmp=. + +2. Name the files after the user id, so that two users never want the same name: + + #+begin_src zig + const uid = common.sys.getuid(); + var name_buf: [64]u8 = undefined; + const name = try std.fmt.bufPrint(&name_buf, "example-tool-{d}.state", .{uid}); + var lock_buf: [64]u8 = undefined; + const lock_name = try std.fmt.bufPrint(&lock_buf, "example-tool-{d}.lock", .{uid}); + #+end_src + +3. Open =/tmp= once, then open and lock the lock file through it: + + #+begin_src zig + const tmp = try common.fsx.openDir(common.fsx.cwd, "/tmp", false); + defer common.sys.close(tmp); + const lock = try common.state.openPrivate(tmp, lock_name, true) orelse + common.cli.die("tool", "/tmp/{s} is not a private file of this user", .{lock_name}); + defer common.sys.close(lock); + common.state.lockExclusive(lock, 10_000) catch |err| switch (err) { + error.TimedOut => common.cli.die("tool", "another run holds /tmp/{s}", .{lock_name}), + else => |e| return e, + }; + #+end_src + + [[zig:zig_common.state.openPrivate]] with =create= true makes the file mode 0600 when it is absent, and returns null when the name is anything but a private file of this user. + The lock goes when the descriptor is closed, at the latest when the tool exits. + +4. Read the state, and write the next one. + The example counts its runs: + + #+begin_src zig + const old = try common.state.readPrivate(gpa, tmp, name, 64 * 1024); + defer if (old) |o| gpa.free(o); + const runs: u32 = if (old) |o| std.fmt.parseInt(u32, std.mem.trimEnd(u8, o, "\n"), 10) catch 0 else 0; + var out_buf: [16]u8 = undefined; + const bytes = try std.fmt.bufPrint(&out_buf, "{d}\n", .{runs + 1}); + try common.state.writePrivate(gpa, tmp, name, bytes); + common.cli.out("run {d}\n", .{runs + 1}); + #+end_src + + [[zig:zig_common.state.readPrivate]] returns null for a file that is absent, larger than the limit or not private, so the tool starts over instead of trusting it. + [[zig:zig_common.state.writePrivate]] writes =.NAME.PID.RANDOM.tmp= with mode 0600 and renames it over the name. + +** Check that it worked + +Run the tool twice, and list its files: + +#+begin_src bash +tool +tool +ls -l /tmp/example-tool-$(id -u).* +#+end_src + +#+begin_example +run 1 +run 2 +-rw------- 1 alice alice 0 Nov 16 15:27 /tmp/example-tool-1000.lock +-rw------- 1 alice alice 2 Nov 16 15:27 /tmp/example-tool-1000.state +#+end_example + +Make the state file readable by others, and run the tool again: + +#+begin_src bash +chmod 644 /tmp/example-tool-$(id -u).state +tool +#+end_src + +#+begin_example +run 1 +#+end_example + +The file was not trusted, so the count started over, and the file is mode 0600 again. + +** If it fails + +=cli.die= exits with status 2. + +| Message | Cause | What to do | +|------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------| +| =tool: another run holds /tmp/example-tool-1000.lock= | another run kept the lock for all of the 10 000 ms | let that run finish; its lock goes when it exits | +| =tool: /tmp/example-tool-1000.lock is not a private file of this user= | the name is a symbolic link, a named pipe, a file with group or other bits, or a file another user owns | look at it with =ls -l=; remove it if it is yours | +| =error.AccessDenied= from =readPrivate= or =writePrivate= | another user's file has the state's name, and the sticky bit of =/tmp= lets only its owner replace it | a file at your user id's name from another user was put there on purpose: tell the node's administrators | + +** Related + +- [[zig:zig_common.state.privateOk]]: the test every file passes. +- [[zig:zig_common.state.RootLock]], for a state directory that several nodes share. +- [[man:flock(2)]] and [[man:fcntl(2)]], for the two kinds of lock. diff --git a/docs/orgmode/howto/match-python-output.org b/docs/orgmode/howto/match-python-output.org new file mode 100644 index 0000000..f0dd8f3 --- /dev/null +++ b/docs/orgmode/howto/match-python-output.org @@ -0,0 +1,127 @@ +#+TITLE: Match a Python tool's output +#+OPTIONS: toc:nil todo:nil num:nil author:nil title:nil +#+STARTUP: content + +* Match a Python tool's output + +Use this when a Zig tool replaces a Python one and must print, write and read the same bytes, so that the two can run side by side and one test suite checks both. +[[zig:zig_common.json]] writes JavaScript Object Notation (JSON) as Python's =json.dumps= does and reads it as =json.loads= does, [[zig:zig_common.pytext]] treats a byte string as Python's text, and [[zig:zig_common.sys.describe]] words an error as Python's =OSError=. +[[file:../explanation/python-compatibility.org][Python compatibility]] says why the tools keep to Python's bytes. + +** Before you start + +- The tool depends on zig-common; [[file:../tutorials/first-tool.org][the tutorial]] sets that up. +- The Python version to match is installed, here Python 3.12.3, to compare against. + +** Steps + +1. Find the Python call that makes each output, and its counterpart: + + | Python | zig-common | + |-------------------------------------------+-------------------------------------------------------------------------| + | =json.dumps(v, indent=2, sort_keys=True)= | [[zig:zig_common.json.dumps]] with =2, true= | + | =json.loads(s)= | [[zig:zig_common.json.parse]], then [[zig:zig_common.json.toPy]] | + | =os.fsdecode(b)= | the bytes as they are: =json= and =pytext= read them as Python does | + | =s.strip()= and =s.split()= | [[zig:zig_common.pytext.pyStrip]] and [[zig:zig_common.pytext.pySplit]] | + | =shlex.quote(s)= | [[zig:zig_common.pytext.shellQuote]] | + | =b.decode("utf-8", "replace")= | [[zig:zig_common.pytext.decodeReplace]] | + | =str(OSError(...))= | [[zig:zig_common.sys.describe]] | + +2. Build each value as the Python tool builds it, with [[zig:zig_common.json.Py]], and write it: + + #+begin_src zig + const Py = common.json.Py; + const doc: Py = .{ .dict = &.{ + .{ .key = "target", .value = Py.s("x86_64/amd/zen4") }, + .{ .key = "modules", .value = .{ .list = &.{Py.s("Example/1.0-GCCcore-15.2.0")} } }, + .{ .key = "prefix", .value = Py.s("/home/alice/caf\xe9") }, + .{ .key = "checked", .value = .{ .float = 1794549600.5 } }, + .{ .key = "user", .value = Py.opt(null) }, + } }; + common.cli.out("{s}\n", .{try common.json.dumps(arena, doc, 2, true)}); + #+end_src + + The byte =\xe9= is not valid 8-bit Unicode Transformation Format (UTF-8). + Python's =os.fsdecode= makes it the lone surrogate U+DCE9, and =dumps= writes it as =json.dumps= does, =\udce9=. + +3. Word text and errors with the same calls: + + #+begin_src zig + common.cli.out("{s}\n", .{try common.pytext.shellQuote(arena, "it's in /home/alice")}); + common.cli.out("{s}\n", .{common.pytext.pyStrip("\xc2\xa0 zen4\n")}); + common.cli.out("{s}\n", .{common.sys.describe(error.NotFound)}); + #+end_src + + =pyStrip= removes what =str.strip= removes, the no-break space U+00A0 included, written here as its two UTF-8 bytes =\xc2\xa0=. + After a failed call, =describe= gives the errno the kernel returned, so call it before the next system call. + +4. Write the Python lines that print the same, in =want.py=: + + #+begin_src python + import errno + import json + import os + import shlex + + doc = { + "target": "x86_64/amd/zen4", + "modules": ["Example/1.0-GCCcore-15.2.0"], + "prefix": os.fsdecode(b"/home/alice/caf\xe9"), + "checked": 1794549600.5, + "user": None, + } + print(json.dumps(doc, indent=2, sort_keys=True)) + print(shlex.quote("it's in /home/alice")) + print("\u00a0 zen4\n".strip()) + print(OSError(errno.ENOENT, os.strerror(errno.ENOENT))) + #+end_src + +** Check that it worked + +Run both and compare the bytes: + +#+begin_src bash +python3 want.py > want.txt +tool > got.txt +cmp want.txt got.txt && echo "same" +#+end_src + +#+begin_example +same +#+end_example + +Both print: + +#+begin_example +{ + "checked": 1794549600.5, + "modules": [ + "Example/1.0-GCCcore-15.2.0" + ], + "prefix": "/home/alice/caf\udce9", + "target": "x86_64/amd/zen4", + "user": null +} +'it'"'"'s in /home/alice' +zen4 +[Errno 2] No such file or directory +#+end_example + +** If it fails + +=cmp= names the first byte that differs; =diff want.txt got.txt= shows the lines. + +| What differs | Cause | What to do | +|---------------------------------------------+----------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------| +| the keys come in another order | the Python call sorts the keys and the Zig call does not, or the other way round | pass =sort_keys= as =dumps='s last argument; unsorted, list the entries in Python's order | +| =2= where Python wrote =2.0= | the value is an =.int=; Python had a float | use =.float= | +| =\u00e9= where Python wrote =\udce9= | one side decoded the bytes as Latin-1, the other with surrogateescape | use one encoding on both sides; the =json= module's summary names the two | +| the whole document on one line in Python | the Python call has no =indent= | =dumps= writes only the indented form; write the compact one with [[zig:zig_common.json.writeCacheString]] | +| =[Errno 13]= where Python wrote =[Errno 1]= | another system call failed in between, and =describe= read its errno | call =describe= right after the call that failed | +| no newline at the end | =print= adds one; =cli.out= does not | end the format with =\n= | + +** Related + +- [[file:../reference/api/zig/zig_common.json.md][The json module's API]] and [[file:../reference/api/zig/zig_common.pytext.md][the pytext module's API]]. +- [[file:../reference/compatibility.org][Compatibility]]: where errno text differs from Python's. +- [[https://docs.python.org/3/library/json.html][Python's json module]]. diff --git a/docs/orgmode/howto/replace-a-file-keeping-its-acls.org b/docs/orgmode/howto/replace-a-file-keeping-its-acls.org new file mode 100644 index 0000000..4bc9677 --- /dev/null +++ b/docs/orgmode/howto/replace-a-file-keeping-its-acls.org @@ -0,0 +1,97 @@ +#+TITLE: Replace a file and keep its access control lists +#+OPTIONS: toc:nil todo:nil num:nil author:nil title:nil +#+STARTUP: content + +* Replace a file and keep its access control lists + +Use this when a tool rewrites a file whose owner, group, mode or access control lists (ACLs) decide who may read it, such as a module file under =/project/climate= that the project's members read through an ACL. +[[zig:zig_common.atomic.atomicWrite]] writes the new bytes to a temporary file beside the old one, gives it the old file's owner, group, mode and ACLs, reads them back, and only then renames it over the old file. +A reader sees the old file or the new one, never a part of either, and never the new bytes with other permissions. +[[file:../explanation/descriptor-checks.org][Checks on the descriptor, not the path]] says why each check is made on an open file. + +** Before you start + +- The tool depends on zig-common; [[file:../tutorials/first-tool.org][the tutorial]] sets that up. +- The tool may create files in the directory that holds the file: the temporary file, =.NAME.new=, is made there. +- The tool runs as the file's owner, or as root to replace another user's file: only root may give the new file that owner. + +** Steps + +1. Choose the call by what must survive the replacement: + + | Call | Keeps | For | + |----------------------------------------+------------------------------------------------------------------------+---------------------------------------------------------| + | [[zig:zig_common.atomic.atomicWrite]] | owner, group, mode and every ACL form, read back before the rename | a file whose access must not change, or not be replaced | + | [[zig:zig_common.fsx.replaceContents]] | mode, the most native ACL form, and the owner when the tool may set it | a file in a directory the tool holds open | + + The steps that follow use =atomicWrite=. + +2. Call it with a [[zig:zig_common.atomic.Why]], which receives the reason for a refusal, and free that with =deinit=: + + #+begin_src zig + var why: common.atomic.Why = .{}; + defer why.deinit(gpa); + common.atomic.atomicWrite(gpa, path, bytes, .{}, &why) catch |err| switch (err) { + error.Refused => { + common.cli.err("tool: {s}\n", .{why.msg}); + return 1; + }, + else => |e| { + common.cli.err("tool: {s}: {s}\n", .{ path, common.atomic.describe(e) }); + return 1; + }, + }; + #+end_src + + [[zig:zig_common.atomic.describe]] words any other error as Python's =OSError= does, such as =[Errno 28] No space left on device=. + +3. To give the new file the access of another file, such as a file prepared beside the live one it is to replace, name that file in [[zig:zig_common.atomic.WriteOptions]]: + + #+begin_src zig + const opts: common.atomic.WriteOptions = .{ + .metadata_from = "/project/climate/modules/Example/1.0-GCCcore-15.2.0.lua", + }; + #+end_src + + =.mode= sets the permission bits in place of the old file's. + A new file with neither gets mode 0644 less the umask. + +** Check that it worked + +Save the file's ACL with =getfacl=, from the =acl= package: + +#+begin_src bash +getfacl -p /project/climate/modules/Example/1.0-GCCcore-15.2.0.lua > before.txt +#+end_src + +Run the tool, then compare: + +#+begin_src bash +getfacl -p /project/climate/modules/Example/1.0-GCCcore-15.2.0.lua | diff before.txt - && echo "ACL kept" +#+end_src + +#+begin_example +ACL kept +#+end_example + +=ls -li= shows a new inode number and the same =-rw-r-----+=: the file was replaced, not written in place, and the =+= is its ACL. +No =.1.0-GCCcore-15.2.0.lua.new= is left beside it. + +** If it fails + +The messages are the text of =why.msg=, after the tool's own =tool: =. + +| Message | Cause | What to do | +|-------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------+-----------------------------------------------------------| +| =refusing to replace a symlink: PATH= | the path is a symbolic link | give the tool the path of the file itself | +| =cannot read access metadata for PATH: [Errno 13] Permission denied= | the tool may not open the file | run the tool as the file's owner, or as root | +| =cannot preserve access metadata for PATH: [Errno 1] Operation not permitted= | another user owns the file, and only root may give the new file that owner | run the tool as the file's owner, or as root | +| =temporary file must be an owned regular file with one link: DIR/.NAME.new= | another user's file, a link or a directory has the temporary name; the tool removes only its own | look at it with =ls -l=, then have its owner remove it | +| =access metadata of PATH changed before PATH was replaced= | the owner, mode or an ACL changed while the tool wrote | run the tool again; the file is as it was | +| =unsupported access-control attribute NAME= | the file has a =system.= attribute that is not one of the three ACL forms zig-common keeps | replace the file with a program that keeps that attribute | + +** Related + +- [[zig:zig_common.atomic.WriteOptions]]: every option, with its default. +- [[zig:zig_common.atomic.acl_attributes]]: the ACL forms kept, most native first. +- [[man:acl(5)]] and [[man:rename(2)]], for the Portable Operating System Interface (POSIX) ACL and the replacement. diff --git a/docs/orgmode/howto/stop-a-slow-child.org b/docs/orgmode/howto/stop-a-slow-child.org new file mode 100644 index 0000000..588f485 --- /dev/null +++ b/docs/orgmode/howto/stop-a-slow-child.org @@ -0,0 +1,60 @@ +#+TITLE: Stop a child program that runs too long +#+OPTIONS: toc:nil todo:nil num:nil author:nil title:nil +#+STARTUP: content + +* Stop a child program that runs too long + +Use this when a tool runs a program that can hang, such as a module command on a stalled file system, and the tool must go on. +The deadline applies to the child's whole process group, so a grandchild that inherited the pipes is stopped too. + +** Before you start + +- The tool depends on zig-common; [[file:../tutorials/first-tool.org][the tutorial]] sets that up. +- The program is named by an absolute path. + Find it with [[zig:zig_common.proc.which]] first. + +** Steps + +1. Set the deadline and the grace period in [[zig:zig_common.proc.Options]]: + + #+begin_src zig + const opts: common.proc.Options = .{ + .timeout_ms = 30_000, // SIGTERM to the group after 30 s + .grace_ms = 2_000, // then SIGKILL, 2 s later + }; + #+end_src + + Keep =new_session= at its default, =true=: the deadline kills the group the child leads. + +2. Run the program and handle the timeout apart from other failures: + + #+begin_src zig + const result = common.proc.run(gpa, exe, argv, envp, opts) catch |err| switch (err) { + error.TimedOut => { + common.cli.err("tool: {s} took longer than 30 s and was stopped\n", .{exe}); + return 1; + }, + else => |e| return e, + }; + defer result.deinit(gpa); + #+end_src + +3. To stop the child early from a signal handler, give =run= a flag to watch in =cancel=, and set it in the handler. + =run= then kills the group and returns =error.Canceled=. + A handler that must kill the group itself calls [[zig:zig_common.proc.killGroup]] with the group =pgid_out= published; it makes only =kill= system calls, so a handler may call it. + +** Check that it worked + +Run the tool against a program that sleeps past the deadline, such as =/bin/sleep 60= with =timeout_ms = 1_000=. +The call returns =error.TimedOut= after about one second, as =sleep= exits on SIGTERM; a child that ignores SIGTERM is killed =grace_ms= later. +No =sleep= process is left: + +#+begin_src bash +pgrep -x sleep || echo "none left" +#+end_src + +** Related + +- [[zig:zig_common.proc.Options]]: every option, with its default. +- [[zig:zig_common.proc.Error]]: the errors =run= returns. +- [[man:setsid(2)]] and [[man:kill(2)]], for how a process group is made and signalled. diff --git a/docs/orgmode/howto/upgrade-zig-common.org b/docs/orgmode/howto/upgrade-zig-common.org new file mode 100644 index 0000000..e6b6eee --- /dev/null +++ b/docs/orgmode/howto/upgrade-zig-common.org @@ -0,0 +1,78 @@ +#+TITLE: Upgrade zig-common in a tool +#+OPTIONS: toc:nil todo:nil num:nil author:nil title:nil +#+STARTUP: content + +* Upgrade zig-common in a tool + +Use this when a zig-common release has a fix or a call that a tool needs. +A tool's =build.zig.zon= names one tagged release and a hash of its contents; the upgrade replaces both and builds the tool against the new code. +Each tool moves in a commit of its own, as [[https://github.com/stackhands/zig-common/blob/main/RELEASING.md][RELEASING.md]] says. + +** Before you start + +- The tool builds, and its tests pass at the current pin: + + #+begin_src bash + zig build test --summary all + #+end_src + +- The Zig on =PATH= is the version the new release needs, which [[file:../reference/compatibility.org][Compatibility]] gives: Zig 0.17.1 for every release up to 0.9.0. + +** Steps + +1. Read the [[file:../changelog.org][changelog]] entries after the pinned version, up to the new one. + A release's Removals section lists what a tool may have to change, and its Fixes section what a call now does differently. + +2. Move the pin to the new tag: + + #+begin_src bash + zig fetch --save git+https://github.com/stackhands/zig-common#v0.9.0 + #+end_src + + #+begin_example + info: resolved ref "v0.9.0" to commit 82b1fbd43f2497a8e5e434e7e60a7487d1c5122c + warning: overwriting existing dependency named "zig_common" + #+end_example + + =zig fetch= writes the =.url= and the =.hash= of =.zig_common= together. + Do not edit the =.url= by hand: Zig looks a package up by its =.hash= first, so a new =.url= beside the old =.hash= goes on building the old release, without a message. + +3. Build the tool and run its tests: + + #+begin_src bash + zig build test --summary all + #+end_src + + A compile error at a call into zig-common is a change that the changelog lists; change the call as the entry says. + +4. Commit =build.zig.zon= and those changes together, with the new version in the message. + +** Check that it worked + +=build.zig.zon= names the new tag, its commit, and a hash that starts with the version: + +#+begin_src bash +grep -F -A2 '.zig_common = ' build.zig.zon +#+end_src + +#+begin_example + .zig_common = .{ + .url = "git+https://github.com/stackhands/zig-common?ref=v0.9.0#82b1fbd43f2497a8e5e434e7e60a7487d1c5122c", + .hash = "zig_common-0.9.0-kBaPeTD7AwAbkwHxmKWBkkYReiqxirdKRJq9VSO4dPvU", +#+end_example + +=zig build test --summary all= passes. + +** If it fails + +| Message | Cause | What to do | +|-----------------------------------------------------------------------------------------------------------------+--------------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------| +| =error: ref not found: v9.9.9= | there is no tag of that name | take the version from the changelog; tags are =vX.Y.Z= | +| =error: hash mismatch: manifest declares zig_common-0.8.1-... but the fetched package has zig_common-0.9.0-...= | the =.url= was edited without the =.hash=, and the old release was not on this machine, so Zig fetched the new one | run the =zig fetch --save= of step 2 again | +| a compile error at a call into zig-common | the call changed between the two releases | read that call's entry in the changelog, and its API page | + +** Related + +- [[file:../reference/compatibility.org][Compatibility]]: the Zig version and the tools of each release. +- [[file:../changelog.org][Changelog]]: what each release changed. +- [[https://github.com/stackhands/zig-common/blob/main/RELEASING.md][RELEASING.md]]: how a release is made. diff --git a/docs/orgmode/index.org b/docs/orgmode/index.org new file mode 100644 index 0000000..8937cb2 --- /dev/null +++ b/docs/orgmode/index.org @@ -0,0 +1,52 @@ +#+TITLE: zig-common +#+OPTIONS: toc:nil todo:nil num:nil author:nil title:nil +#+STARTUP: content + +* zig-common + +The pieces the stackhands Zig tools share: Linux system calls with named errors, file handling checked on the open descriptor, running a child program, gzip in place and the =.licensed-logs= list, and command-line plumbing. +It holds only what at least two tools need, or what one tool needs in a form the next port will reuse. +It is Linux only and needs Zig 0.17.1. + +New here? +[[file:tutorials/first-tool.org][Write a small tool on zig-common]] ends with =kernel=, a program that runs =uname= with a deadline and an empty environment and prints the kernel release. + +| You want to | Read | +|--------------------------------------------------+---------------------------------------------| +| learn by doing, start to finish | [[file:tutorials/index.org][Tutorials]] | +| get one task done | [[file:howto/index.org][How-to guides]] | +| understand why it works this way | [[file:explanation/index.org][Explanation]] | +| look up a declaration, a convention or a version | [[file:reference/index.org][Reference]] | + +#+begin_export rst +.. toctree:: + :hidden: + :caption: Tutorials + + tutorials/index + +.. toctree:: + :hidden: + :caption: How-to guides + + howto/index + +.. toctree:: + :hidden: + :caption: Explanation + + explanation/index + +.. toctree:: + :hidden: + :caption: Reference + + reference/index + +.. toctree:: + :hidden: + :caption: Project + + contributing + changelog +#+end_export diff --git a/docs/orgmode/reference/api.org b/docs/orgmode/reference/api.org new file mode 100644 index 0000000..1b57d09 --- /dev/null +++ b/docs/orgmode/reference/api.org @@ -0,0 +1,18 @@ +#+TITLE: API +#+OPTIONS: toc:nil todo:nil num:nil author:nil title:nil +#+STARTUP: content + +* API + +The API pages are generated from the code on every build, so they match the commit the site was built from. +A declaration's doc comment is its description. + +- [[file:api/zig/index.md][Zig API]]: every =pub= declaration, one page per source file, read with the compiler's own parser by =docs/tools/zig_api.zig=, each linked to its source line at that commit. +- [[autodoc:/][Zig autodoc]]: the same declarations in the browser =zig build docs= makes, with search and source views. + +#+begin_export rst +.. toctree:: + :hidden: + + api/zig/index +#+end_export diff --git a/docs/orgmode/reference/cli-conventions.org b/docs/orgmode/reference/cli-conventions.org new file mode 100644 index 0000000..43ca4d5 --- /dev/null +++ b/docs/orgmode/reference/cli-conventions.org @@ -0,0 +1,60 @@ +#+TITLE: Command-line conventions +#+OPTIONS: toc:nil todo:nil num:nil author:nil title:nil +#+STARTUP: content + +* Command-line conventions + +The messages, exit statuses and version line that the stackhands Zig tools share, through [[zig:zig_common.cli]]. + +** Messages + +| Call | Writes | To | +|------------------------------+---------------------------------------------+----------------------| +| [[zig:zig_common.cli.put]] | the bytes as given | the descriptor given | +| [[zig:zig_common.cli.print]] | the arguments, formatted | the descriptor given | +| [[zig:zig_common.cli.out]] | the arguments, formatted | stdout, descriptor 1 | +| [[zig:zig_common.cli.err]] | the arguments, formatted | stderr, descriptor 2 | +| [[zig:zig_common.cli.die]] | =TOOL: message= and a newline, then exits 2 | stderr, descriptor 2 | + +- Only =die= adds a newline. +- A write that fails, as one to a closed stdout or to =/dev/full= does, is ignored: it changes neither what the tool did nor its exit status. +- A message longer than 8 KiB is formatted on the heap; when that allocation fails, nothing is written. + +** Exit status + +| Status | Meaning | +|---------+---------------------------------------------------------------------------------------------------------------------------------| +| 2 | the invocation was refused: [[zig:zig_common.cli.usage_exit]], which =die= exits with | +| 128 + N | a child the tool ran was killed by signal N, as [[zig:zig_common.proc.Term.code]] gives it, when the tool passes that status on | + +Every other status is the tool's own, and its reference pages list them. + +** Version line + +#+begin_example +TOOL VERSION (ARCH-OS-ABI, MODE, zig ZIG_VERSION, COMMIT) +#+end_example + +[[zig:zig_common.cli.versionLine]] builds the line at compile time, with a newline at the end. + +| Field | Value | +|-------------+---------------------------------------------------------------------------------------------------------------------------------------------------| +| TOOL | the tool's name, the first argument | +| VERSION | the tool's version, the second argument | +| ARCH-OS-ABI | the architecture, operating system and application binary interface (ABI) of the build: =x86_64-linux-musl= or =aarch64-linux-musl= for a release | +| MODE | the optimize mode: =debug=, =safe=, =fast= or =small= | +| ZIG_VERSION | the version of Zig that built the binary | +| COMMIT | the third argument; the tools pass their =-Dcommit= build option, which is =unknown= when it is not given | + +The first two words are what a script that read an older version line reads. + +eb-keep-logs 0.2.1, built with =zig build -Drelease=true -Dcommit=0123abc=: + +#+begin_example +eb-keep-logs 0.2.1 (x86_64-linux-musl, safe, zig 0.17.1, 0123abc) +#+end_example + +** See also + +- [[file:api/zig/zig_common.cli.md][The cli module's API]]. +- [[file:../explanation/system-calls-without-libc.org][System calls without a C library]], for why a release is one static file per architecture. diff --git a/docs/orgmode/reference/compatibility.org b/docs/orgmode/reference/compatibility.org new file mode 100644 index 0000000..914279a --- /dev/null +++ b/docs/orgmode/reference/compatibility.org @@ -0,0 +1,9 @@ +#+TITLE: Compatibility +#+OPTIONS: toc:nil todo:nil num:nil author:nil title:nil + +# COMPAT.md at the top of the repository is the one record; this page shows it. + +#+begin_export rst +.. include:: ../../../COMPAT.md + :parser: myst_parser.sphinx_ +#+end_export diff --git a/docs/orgmode/reference/index.org b/docs/orgmode/reference/index.org new file mode 100644 index 0000000..6589374 --- /dev/null +++ b/docs/orgmode/reference/index.org @@ -0,0 +1,17 @@ +#+TITLE: Reference +#+OPTIONS: toc:nil todo:nil num:nil author:nil title:nil +#+STARTUP: content + +* Reference + +Descriptions of what there is: commands, options, files, environment variables, exit codes and the API. +Each page states facts in the order the thing itself has them. + +#+begin_export rst +.. toctree:: + :maxdepth: 1 + + cli-conventions + compatibility + api +#+end_export diff --git a/docs/orgmode/tutorials/first-tool.org b/docs/orgmode/tutorials/first-tool.org new file mode 100644 index 0000000..5b3bb1b --- /dev/null +++ b/docs/orgmode/tutorials/first-tool.org @@ -0,0 +1,109 @@ +#+TITLE: Write a small tool on zig-common +#+OPTIONS: toc:nil todo:nil num:nil author:nil title:nil +#+STARTUP: content + +* Write a small tool on zig-common + +By the end of this tutorial you will have =kernel=, a program that finds =uname= in =PATH=, runs it with a deadline and an empty environment, and prints what it said. +It takes five commands on any Linux machine with Zig 0.17.1. + +** What you will need + +- Linux, x86_64 or aarch64. + zig-common uses Linux system calls directly and builds nowhere else. +- Zig 0.17.1: + + #+begin_src bash + zig version + #+end_src + + #+begin_example + 0.17.1 + #+end_example + +- Network access to github.com, to download zig-common. + +** Create the project + +Make a directory and let Zig write a project skeleton into it: + +#+begin_src bash +mkdir kernel && cd kernel +zig init +#+end_src + +#+begin_example +info: created build.zig +info: created build.zig.zon +info: created src/main.zig +info: created src/root.zig +info: see `zig build --help` for a menu of options +#+end_example + +** Add zig-common as a dependency + +=zig fetch= downloads a tagged release, checks it, and records it with its hash in =build.zig.zon=: + +#+begin_src bash +zig fetch --save git+https://github.com/stackhands/zig-common#v0.9.0 +#+end_src + +#+begin_example +info: resolved ref "v0.9.0" to commit 82b1fbd43f2497a8e5e434e7e60a7487d1c5122c +#+end_example + +=build.zig.zon= now names it under =.dependencies=: + +#+begin_src zig +.zig_common = .{ + .url = "git+https://github.com/stackhands/zig-common?ref=v0.9.0#82b1fbd43f2497a8e5e434e7e60a7487d1c5122c", + .hash = "zig_common-0.9.0-kBaPeTD7AwAbkwHxmKWBkkYReiqxirdKRJq9VSO4dPvU", +}, +#+end_src + +** Make the module importable + +Open =build.zig=. +Add the first line below directly above =const exe = b.addExecutable(.{=, and the second to the =.imports= list inside it: + +#+begin_src zig +const common = b.dependency("zig_common", .{ .target = target, .optimize = optimize }); +#+end_src + +#+begin_src zig +.{ .name = "zig_common", .module = common.module("zig_common") }, +#+end_src + +** Write the program + +Replace =src/main.zig= with: + +#+INCLUDE: "first-tool/main.zig" src zig + +** Run it + +#+begin_src bash +zig build run +#+end_src + +#+begin_example +kernel 6.12.113+ +#+end_example + +The number is your machine's kernel release. + +** What just happened + +1. [[zig:zig_common.proc.which]] looked =uname= up in the =PATH= you passed it, and returned an absolute path. + [[zig:zig_common.proc.run]] takes nothing else: a child is never looked up in a =PATH= its own environment sets. +2. =run= started the child with an empty environment, an empty signal mask and no descriptors above 2, in a session of its own. +3. It read the child's output while waiting, and would have killed the child's whole process group after =timeout_ms=. +4. [[zig:zig_common.proc.Term.code]] turned the exit status into the number a shell would show, which became the program's own exit status. + +** Next steps + +- [[file:../howto/stop-a-slow-child.org][Stop a child program that runs too long]] +- [[file:../explanation/descriptor-checks.org][Checks on the descriptor, not the path]] +- [[file:../reference/api/zig/zig_common.proc.md][The proc module's API]] + +Checked with Zig 0.17.1 and zig-common 0.9.0 on 2026-11-16. diff --git a/docs/orgmode/tutorials/first-tool/main.zig b/docs/orgmode/tutorials/first-tool/main.zig new file mode 100644 index 0000000..3ab7ef0 --- /dev/null +++ b/docs/orgmode/tutorials/first-tool/main.zig @@ -0,0 +1,19 @@ +const std = @import("std"); +const common = @import("zig_common"); + +pub fn main(init: std.process.Init) !u8 { + const gpa = init.gpa; + const path = init.environ_map.get("PATH") orelse "/usr/bin:/bin"; + const uname = try common.proc.which(gpa, "uname", path) orelse + common.cli.die("kernel", "uname is not on PATH", .{}); + defer gpa.free(uname); + + const no_env = [_:null]?[*:0]const u8{}; + const result = try common.proc.run(gpa, uname, &.{ "uname", "-r" }, &no_env, .{ + .timeout_ms = 5_000, + }); + defer result.deinit(gpa); + + common.cli.out("kernel {s}", .{result.stdout}); + return @intCast(result.term.code()); +} diff --git a/docs/orgmode/tutorials/index.org b/docs/orgmode/tutorials/index.org new file mode 100644 index 0000000..9e7559b --- /dev/null +++ b/docs/orgmode/tutorials/index.org @@ -0,0 +1,15 @@ +#+TITLE: Tutorials +#+OPTIONS: toc:nil todo:nil num:nil author:nil title:nil +#+STARTUP: content + +* Tutorials + +A tutorial is a lesson: follow it from the top on a machine like the one it names and it ends with something working. +It explains only what the next step needs; [[file:../explanation/index.org][Explanation]] has the reasons. + +#+begin_export rst +.. toctree:: + :maxdepth: 1 + + first-tool +#+end_export diff --git a/docs/releasing.md b/docs/releasing.md deleted file mode 100644 index 2d2f9c8..0000000 --- a/docs/releasing.md +++ /dev/null @@ -1,2 +0,0 @@ -```{include} ../RELEASING.md -``` diff --git a/docs/requirements.txt b/docs/requirements.txt deleted file mode 100644 index f14828e..0000000 --- a/docs/requirements.txt +++ /dev/null @@ -1,4 +0,0 @@ -Sphinx==8.2.3 -myst-parser==5.1.0 -shibuya==2025.12.13 -sphinx-copybutton==0.5.2 diff --git a/docs/source/_ext/zig_domain.py b/docs/source/_ext/zig_domain.py new file mode 100644 index 0000000..3b2f143 --- /dev/null +++ b/docs/source/_ext/zig_domain.py @@ -0,0 +1,280 @@ +"""A Sphinx domain for Zig declarations. + +docs/tools/zig_api.zig writes one ``zig:`` directive per public declaration:: + + :::{zig:function} zig_common.proc.run + :signature: pub fn run(gpa: Allocator, argv: []const []const u8, ...) Error!Result + :source: https://github.com/stackhands/zig-common/blob//src/proc.zig#L120 + + The doc comment, as Markdown. + ::: + +The argument is the fully qualified name; it is the HTML anchor and the +key for cross-references and for the objects.inv inventory, so other +stackhands sites reach it through intersphinx. Roles: ``zig:mod``, +``zig:type``, ``zig:fn``, ``zig:const``, ``zig:var``, ``zig:field``, +``zig:err``, and ``zig:obj`` for any kind. A target matches a full name, or +failing that a unique dotted suffix (``proc.run``); ``~`` before the target +shows only its last part. ``zig:autodoc`` links into the autodoc site at +``zig_autodoc_root``, which every directive also links to. +""" + +from __future__ import annotations + +import posixpath +import re +from typing import Any, ClassVar, Iterable + +from docutils import nodes +from docutils.nodes import Element, Node +from docutils.parsers.rst import directives +from sphinx import addnodes +from sphinx.addnodes import desc_signature, pending_xref +from sphinx.application import Sphinx +from sphinx.builders import Builder +from sphinx.directives import ObjectDescription +from sphinx.domains import Domain, ObjType +from sphinx.environment import BuildEnvironment +from sphinx.roles import XRefRole +from sphinx.util import logging +from sphinx.util.docutils import SphinxRole +from sphinx.util.nodes import make_refnode, split_explicit_title + +logger = logging.getLogger(__name__) + +LABELS = { + "module": "module", + "type": "type", + "errorset": "error set", + "function": "function", + "constant": "constant", + "variable": "variable", + "field": "field", + "error": "error", +} + + +def autodoc_href(env: BuildEnvironment, fqn: str) -> str | None: + """The autodoc URL of *fqn*, relative to the page being read.""" + root = env.config.zig_autodoc_root + if not root: + return None + up = posixpath.relpath(".", posixpath.dirname(env.docname) or ".") + base = posixpath.normpath(posixpath.join(up, root)) + "/" + fqn = fqn.strip("/") + return base + ("#" + fqn if fqn else "") + + +def link(text: str, href: str, cls: str) -> nodes.reference: + ref = nodes.reference("", "", internal=False, refuri=href, classes=[cls]) + ref += nodes.inline(text, text) + return ref + + +class ZigObject(ObjectDescription[str]): + """One declaration; its argument is the fully qualified name.""" + + has_content = True + required_arguments = 1 + final_argument_whitespace = False + option_spec: ClassVar[dict[str, Any]] = { + "signature": directives.unchanged, + "source": directives.unchanged, + "file": directives.unchanged, + "no-autodoc": directives.flag, + "no-index": directives.flag, + "no-index-entry": directives.flag, + "no-contents-entry": directives.flag, + } + + def handle_signature(self, sig: str, signode: desc_signature) -> str: + fqn = sig.strip() + short = fqn.rsplit(".", 1)[-1] + text = self.options.get("signature") or ("module " + fqn if self.objtype == "module" else short) + signode["fullname"] = fqn + match = re.search(r"(? None: + # The page title of a module named like a slug ("eb-local") already + # owns the bare id. Sphinx writes anchors into href attributes + # unescaped, so a quote or space would cut the link short. + anchor = re.sub(r"[^\w.\-]", "-", name) + if self.objtype == "module": + anchor = "module-" + anchor + signode["ids"].append(anchor) + self.state.document.note_explicit_target(signode) + domain: ZigDomain = self.env.domains["zig"] # type: ignore[assignment] + domain.note_object(name, self.objtype, anchor, location=signode) + if "no-index-entry" not in self.options: + label = LABELS[self.objtype] + self.indexnode["entries"].append(("single", f"{name} (Zig {label})", anchor, "", None)) + + def _object_hierarchy_parts(self, sig_node: desc_signature) -> tuple[str, ...]: + if self.objtype == "module" or "fullname" not in sig_node: + return () + return tuple(sig_node["fullname"].split(".")) + + def _toc_entry_name(self, sig_node: desc_signature) -> str: + parts = sig_node.get("_toc_parts") + if not parts: + return "" + parens = "()" if self.objtype == "function" and self.config.add_function_parentheses else "" + show = self.config.toc_object_entries_show_parents + if show == "all": + return ".".join(parts) + parens + return parts[-1] + parens + + +class ZigXRefRole(XRefRole): + def process_link( + self, env: BuildEnvironment, refnode: Element, has_explicit_title: bool, title: str, target: str + ) -> tuple[str, str]: + target = target.lstrip("~") + if not has_explicit_title: + title = title.lstrip(".") + if title.startswith("~"): + title = title[1:].rsplit(".", 1)[-1] + return title, target.lstrip(".") + + +class ZigAutodocRole(SphinxRole): + """``:zig:autodoc:`zig_common.proc```, or ``:zig:autodoc:`text ``` for the front page.""" + + def run(self) -> tuple[list[Node], list[nodes.system_message]]: + explicit, title, target = split_explicit_title(self.text) + target = target.strip() + href = autodoc_href(self.env, target) + if href is None: + return [nodes.Text(title)], [] + return [link(title if explicit else (target or "Zig autodoc"), href, "zig-autodoc-link")], [] + + +class ZigDomain(Domain): + name = "zig" + label = "Zig" + object_types: ClassVar[dict[str, ObjType]] = { + "module": ObjType("module", "mod", "obj"), + "type": ObjType("type", "type", "obj"), + "errorset": ObjType("error set", "err", "type", "obj"), + "function": ObjType("function", "fn", "func", "obj"), + "constant": ObjType("constant", "const", "obj"), + "variable": ObjType("variable", "var", "obj"), + "field": ObjType("field", "field", "obj"), + "error": ObjType("error", "err", "obj"), + } + directives: ClassVar[dict[str, type[ObjectDescription]]] = {k: ZigObject for k in object_types} + roles: ClassVar[dict[str, Any]] = { + **{r: ZigXRefRole() for r in ("mod", "type", "err", "fn", "func", "const", "var", "field", "obj")}, + "autodoc": ZigAutodocRole(), + } + initial_data: ClassVar[dict[str, Any]] = {"objects": {}} + data_version = 1 + + @property + def objects(self) -> dict[str, tuple[str, str, str]]: + """Full name -> (docname, anchor, object type).""" + return self.data.setdefault("objects", {}) + + def note_object(self, fqn: str, objtype: str, anchor: str, location: Any = None) -> None: + if fqn in self.objects: + other = self.objects[fqn][0] + logger.warning("duplicate Zig object %s, also in %s", fqn, other, location=location, type="zig", subtype="duplicate") + self.objects[fqn] = (self.env.docname, anchor, objtype) + + def clear_doc(self, docname: str) -> None: + for fqn, (doc, _anchor, _objtype) in list(self.objects.items()): + if doc == docname: + del self.objects[fqn] + + def merge_domaindata(self, docnames: Iterable[str], otherdata: dict[str, Any]) -> None: + for fqn, entry in otherdata["objects"].items(): + if entry[0] in docnames: + self.objects[fqn] = entry + + def find(self, target: str, objtypes: Iterable[str] | None) -> list[tuple[str, tuple[str, str, str]]]: + wanted = set(objtypes) if objtypes is not None else None + + def ok(entry: tuple[str, str, str]) -> bool: + return wanted is None or entry[2] in wanted + + entry = self.objects.get(target) + if entry is not None and ok(entry): + return [(target, entry)] + suffix = "." + target + return [(fqn, e) for fqn, e in self.objects.items() if fqn.endswith(suffix) and ok(e)] + + def resolve_xref( + self, + env: BuildEnvironment, + fromdocname: str, + builder: Builder, + typ: str, + target: str, + node: pending_xref, + contnode: Element, + ) -> nodes.reference | None: + matches = self.find(target, self.objtypes_for_role(typ)) + if not matches: + return None + if len(matches) > 1: + logger.warning( + "more than one Zig object matches %r: %s", + target, + ", ".join(sorted(m[0] for m in matches)), + location=node, + type="ref", + subtype="zig", + ) + fqn, (docname, anchor, _objtype) = matches[0] + return make_refnode(builder, fromdocname, docname, anchor, contnode, fqn) + + def resolve_any_xref( + self, + env: BuildEnvironment, + fromdocname: str, + builder: Builder, + target: str, + node: pending_xref, + contnode: Element, + ) -> list[tuple[str, nodes.reference]]: + results = [] + for fqn, (docname, anchor, objtype) in self.find(target, None): + role = self.role_for_objtype(objtype) or "obj" + results.append((f"zig:{role}", make_refnode(builder, fromdocname, docname, anchor, contnode, fqn))) + return results + + def get_objects(self) -> Iterable[tuple[str, str, str, str, str, int]]: + for fqn, (docname, anchor, objtype) in self.objects.items(): + yield fqn, fqn, objtype, docname, anchor, 1 + + def get_full_qualified_name(self, node: Element) -> str | None: + return node.get("reftarget") + + +def setup(app: Sphinx) -> dict[str, Any]: + app.add_config_value("zig_autodoc_root", "", "env", types=frozenset({str})) + app.add_domain(ZigDomain) + return {"version": "1", "env_version": 1, "parallel_read_safe": True, "parallel_write_safe": True} diff --git a/docs/_static/favicon.svg b/docs/source/_static/favicon.svg similarity index 100% rename from docs/_static/favicon.svg rename to docs/source/_static/favicon.svg diff --git a/docs/_static/logo-dark.svg b/docs/source/_static/logo-dark.svg similarity index 100% rename from docs/_static/logo-dark.svg rename to docs/source/_static/logo-dark.svg diff --git a/docs/_static/logo-light.svg b/docs/source/_static/logo-light.svg similarity index 100% rename from docs/_static/logo-light.svg rename to docs/source/_static/logo-light.svg diff --git a/docs/_static/mark-dark.svg b/docs/source/_static/mark-dark.svg similarity index 100% rename from docs/_static/mark-dark.svg rename to docs/source/_static/mark-dark.svg diff --git a/docs/_static/mark.svg b/docs/source/_static/mark.svg similarity index 100% rename from docs/_static/mark.svg rename to docs/source/_static/mark.svg diff --git a/docs/source/_static/stackhands.css b/docs/source/_static/stackhands.css new file mode 100644 index 0000000..9573490 --- /dev/null +++ b/docs/source/_static/stackhands.css @@ -0,0 +1,23 @@ +/* Zig API pages: keep long signatures readable and the links to source + and autodoc out of the way. */ +dl.zig > dt.sig { + flex-wrap: wrap; + row-gap: 0.25rem; +} + +dl.zig > dt.sig .zig-sig-rest { + white-space: pre-wrap; +} + +dl.zig > dt.sig .zig-source-link, +dl.zig > dt.sig .zig-autodoc-link { + margin-left: 0.75rem; + font-family: var(--sy-f-text, inherit); + font-size: 0.8em; + font-weight: normal; +} + +dl.zig.field > dt.sig, +dl.zig.error > dt.sig { + font-size: 0.95em; +} diff --git a/docs/source/conf.py b/docs/source/conf.py new file mode 100644 index 0000000..449fe7d --- /dev/null +++ b/docs/source/conf.py @@ -0,0 +1,254 @@ +"""Sphinx configuration for the zig-common documentation. + +The pages are Org files under docs/orgmode/, exported here as reStructuredText +by docs/export.el. The API reference under reference/api/ is generated from +the code. Neither is committed: `pixi run -e docs docbld` makes both. +""" + +import os +import re +import sys + +from docutils import nodes + +_here = os.path.dirname(os.path.abspath(__file__)) +_repo = os.path.abspath(os.path.join(_here, "..", "..")) +sys.path.insert(0, os.path.join(_here, "_ext")) + +project = "zig-common" +author = "stackhands developers" +copyright = "stackhands developers" + + +def _release(): + """The version the build files declare: build.zig.zon, pyproject.toml or Cargo.toml.""" + for name, pattern in ( + ("build.zig.zon", r'^\s*\.version\s*=\s*"([^"]+)"'), + ("pyproject.toml", r'^version\s*=\s*"([^"]+)"'), + ("Cargo.toml", r'^version\s*=\s*"([^"]+)"'), + ): + path = os.path.join(_repo, name) + if os.path.isfile(path): + found = re.search(pattern, open(path, encoding="utf-8").read(), re.M) + if found: + return found.group(1) + return "" + + +release = version = _release() + +extensions = [ + "myst_parser", + "sphinx.ext.intersphinx", + "sphinx_copybutton", + "sphinx_design", + "sphinx_sitemap", + "zig_domain", +] + +# Generated API pages are MyST Markdown, as doc comments are Markdown; the +# exported Org pages are reStructuredText. +source_suffix = {".rst": "restructuredtext", ".md": "markdown"} +myst_enable_extensions = ["colon_fence", "deflist", "fieldlist"] +exclude_patterns = [] +templates_path = ["_templates"] + +# Every cross-reference must resolve: sphinx-build runs with -W -n. +nitpicky = True +nitpick_ignore = [] +manpages_url = "https://man7.org/linux/man-pages/man{section}/{page}.{section}.html" +# Doc comments and docstrings name flags in plain text: --strict stays two +# hyphens. +smartquotes_action = "qe" + +# -- API reference ----------------------------------------------------------- +# Zig: docs/tools/zig_api.zig writes reference/api/zig/ (pixi task mkapi), and +# `zig build docs` puts the autodoc site at api/ (pixi task autodoc). +zig_autodoc_root = "api/" + +# Python: sphinx-autoapi reads the packages listed here, without importing +# them, into reference/api/python/. +PYTHON_PACKAGES = [] +if PYTHON_PACKAGES: + extensions.append("autoapi.extension") + autoapi_type = "python" + autoapi_dirs = [os.path.join(_repo, p) for p in PYTHON_PACKAGES] + autoapi_root = "reference/api/python" + autoapi_add_toctree_entry = False + autoapi_keep_files = False + autoapi_member_order = "groupwise" + # undoc-members: a module or class without a docstring is still listed, + # so the reference is complete and the gap shows. + autoapi_options = [ + "members", + "undoc-members", + "show-inheritance", + "show-module-summary", + "special-members", + "imported-members", + ] + autoapi_ignore = ["*/tests/*", "*/test_*.py", "*/conftest.py"] + +# Rust: sphinx-rustdocgen reads each crate listed here (crate name: its +# directory) into reference/api/rust//, for sphinxcontrib-rust. +RUST_CRATES = {} +if RUST_CRATES: + extensions.append("sphinxcontrib_rust") + rust_crates = {name: os.path.join(_repo, path) for name, path in RUST_CRATES.items()} + rust_doc_dir = os.path.join(_here, "reference", "api", "rust") + # Doc comments are Markdown, read by myst_parser. + rust_rustdoc_fmt = "md" + rust_generate_mode = "always" + # A rustdoc link to an item named like its module ([`gap`] in gap) also + # matches that module's page; MyST links the page, which lists the item. + suppress_warnings = ["myst.xref_ambiguous"] + # A type from std, core or another crate has no page here; a name in + # these crates that does not resolve still fails the build. + nitpick_ignore_regex = [ + (r"rust:.*", r"(?!(?:%s)(?:::|$)).*" % "|".join(RUST_CRATES)), + ("myst", r"\w+(?:::\w+)+"), + ] + +# -- Links to other sites ---------------------------------------------------- +# A link to another stackhands site resolves through that site's objects.inv, +# so a page or API name that does not exist there fails the build. A local +# build keeps the inventories it fetched for 30 days and works offline in +# that time; CI starts clean and always fetches them. +# stackhands-intersphinx:begin (written by docs-plan/template/apply.py) +intersphinx_mapping = { + "eb-staged-rebuild": ("https://stackhands.github.io/eb-staged-rebuild/", None), + "eessi-arch-guard": ("https://stackhands.github.io/eessi-arch-guard/", None), + "eb-local": ("https://stackhands.github.io/eb-local/", None), + "eb-keep-logs": ("https://stackhands.github.io/eb-keep-logs/", None), +} +# stackhands-intersphinx:end +intersphinx_mapping["python"] = ("https://docs.python.org/3", None) +intersphinx_cache_limit = 30 +intersphinx_timeout = 30 + +# -- HTML ---------------------------------------------------------------------- +html_theme = "shibuya" +html_title = "zig-common" +html_baseurl = "https://stackhands.github.io/zig-common/" +html_static_path = ["_static"] +html_css_files = ["stackhands.css"] +# The logos come from stackhands/.github branding (apply.py copies them). +_logos = { + name: "_static/" + name + for name in ("favicon.svg", "logo-light.svg", "logo-dark.svg") + if os.path.isfile(os.path.join(_here, "_static", name)) +} +html_favicon = _logos.get("favicon.svg") +html_copy_source = False +html_show_sourcelink = False +sitemap_url_scheme = "{link}" + +html_context = { + "source_type": "github", + "source_user": "stackhands", + "source_repo": "zig-common", + "source_version": "main", + "source_docs_path": "/docs/orgmode/", +} + +html_theme_options = { + "github_url": "https://github.com/stackhands/zig-common", + "accent_color": "teal", + "dark_code": True, + # Its "Copy page" menu links chat services, which check_site.py rejects. + "show_ai_links": False, + "globaltoc_expand_depth": 1, + "nav_links": [ + {"title": "Tutorial", "url": "tutorials/index"}, + {"title": "How-to", "url": "howto/index"}, + {"title": "Explanation", "url": "explanation/index"}, + {"title": "Reference", "url": "reference/index"}, + # stackhands:begin (generated by stackhands/.github branding/sync.py) + { + "title": "stackhands", + "children": [ + { + "title": "eb-stack", + "url": "https://eb-stack.rgoswami.me/", + "summary": "Solve, shard and plan an EasyBuild build list; admit builds under a scratch inode budget", + }, + { + "title": "eb-pipeline", + "url": "https://github.com/stackhands/eb-pipeline#readme", + "summary": "Drive an EasyBuild pipeline from one per-site TOML file, calling the other tools as subprocesses", + }, + { + "title": "eb-staged-rebuild", + "url": "https://stackhands.github.io/eb-staged-rebuild/", + "summary": "Rebuild an installation in a staged tree and swap it in, so running jobs keep their paths", + }, + { + "title": "eessi-arch-guard", + "url": "https://stackhands.github.io/eessi-arch-guard/", + "summary": "Reload EESSI in a Slurm task that inherited it for another CPU or GPU", + }, + { + "title": "eb-local", + "url": "https://stackhands.github.io/eb-local/", + "summary": "Install software with EasyBuild on top of EESSI into a directory a user or project owns", + }, + { + "title": "eb-keep-logs", + "url": "https://stackhands.github.io/eb-keep-logs/", + "summary": "Keep a failed build's EasyBuild log and command output; rotate a pipeline's log tree", + }, + { + "title": "rfc9162", + "url": "https://stackhands.github.io/rfc9162/", + "summary": "Append-only Merkle logs hashed as RFC 9162, with tiled storage and signed checkpoints", + }, + ], + }, + # stackhands:end + ], +} +if "logo-light.svg" in _logos and "logo-dark.svg" in _logos: + html_theme_options["light_logo"] = _logos["logo-light.svg"] + html_theme_options["dark_logo"] = _logos["logo-dark.svg"] + +html_sidebars = { + "**": [ + "sidebars/localtoc.html", + "sidebars/repo-stats.html", + "sidebars/edit-this-page.html", + ], +} + + +def _edit_link(app, pagename, templatename, context, doctree): + """Point "edit this page" at the Org source; generated pages have none.""" + if pagename.startswith("reference/api/"): + context["page_source_suffix"] = None + else: + context["page_source_suffix"] = ".org" + + +def _unlink_rust_paths(app, doctree, docname): + """A rustdoc link to an item outside these crates stays as code, unlinked.""" + if not docname.startswith("reference/api/rust/"): + return + for ref in list(doctree.findall(nodes.reference)): + if re.fullmatch(r"\w+(?:::\w+)+", ref.get("refid", "")): + ref.replace_self(ref.children) + + +def setup(app): + app.connect("html-page-context", _edit_link) + if RUST_CRATES: + app.connect("doctree-resolved", _unlink_rust_paths) + if "local_setup" in globals(): + globals()["local_setup"](app) + + +# -- This repository ----------------------------------------------------------- +# apply.py rewrites everything above and keeps what is between these markers: +# the place for settings only this repository has, such as the Rust crates +# for sphinxcontrib-rust or a nitpick_ignore entry. Event hooks go in a +# function local_setup(app), which setup() calls. +# local:begin +# local:end diff --git a/docs/tools/check_site.py b/docs/tools/check_site.py new file mode 100644 index 0000000..186611b --- /dev/null +++ b/docs/tools/check_site.py @@ -0,0 +1,177 @@ +#!/usr/bin/env python3 +"""Check a built site: internal links, anchors and forbidden names. + + python docs/tools/check_site.py docs/build/html [--sources docs/orgmode] + [--forbid REGEX]... [--no-default-forbid] [--exempt PAGE]... + +Every relative href and src in every HTML page must name a file in the site, +and a #fragment on a page Sphinx made must name an id on that page. Under +api/, the Zig autodoc site, only files are checked: its anchors are made by +script. External links are lychee's job (pixi task linkcheck). + +A page may not link to a generated .rst file (the edit links go to the Org +sources), and no page's text or link targets, and no Org source, may carry +a forbidden pattern: by default the names and paths of one real site, as +the pages describe a neutral example site, and links to AI chat services. +--exempt names a built page, such as changelog.html, that records history: +its text and link targets are not checked for forbidden names, but its +links must still resolve. + +Exit status: 0 when clean, 1 when anything is wrong, 2 on a usage error. +""" + +import argparse +import html.parser +import os +import re +import sys +import urllib.parse + +# The repositories' CI greps the whole tree for these names, this file +# included, so each keeps one letter in a class: the pattern matches the +# name, and its own text does not. +DEFAULT_FORBID = [ + r"snelli[u]s", + r"sne[l]-", + r"surf\.nl", + r"surfsara", + r"/gp[f]s/", + r"/project[s]/0", + r"rg\.terra", + r"scratch-shar[e]d", + r"scratch-nod[e]", + r"eblocalinstal[l]", + r"chatgpt\.com", + r"claude\.ai", + r"perplexity\.ai", +] + +SCRIPTED_ANCHORS = ("api/",) + + +class Page(html.parser.HTMLParser): + def __init__(self): + super().__init__(convert_charrefs=True) + self.ids = set() + self.links = [] + self.text = [] + self._skip = 0 + + def handle_starttag(self, tag, attrs): + attrs = dict(attrs) + for key in ("id", "name"): + if attrs.get(key) and (key == "id" or tag == "a"): + self.ids.add(attrs[key]) + for key in ("href", "src"): + value = attrs.get(key) + if value is not None and not (tag == "link" and attrs.get("rel") in ("preconnect", "dns-prefetch")): + self.links.append((value, self.getpos()[0])) + if tag in ("script", "style"): + self._skip += 1 + + def handle_endtag(self, tag): + if tag in ("script", "style") and self._skip: + self._skip -= 1 + + def handle_data(self, data): + if not self._skip: + self.text.append(data) + + +def parse(path): + page = Page() + with open(path, encoding="utf-8", errors="replace") as handle: + page.feed(handle.read()) + return page + + +def check_site(root, forbid, exempt=()): + errors = [] + pages = {} + for dirpath, _dirs, files in os.walk(root): + for name in files: + if name.endswith(".html"): + path = os.path.join(dirpath, name) + pages[os.path.relpath(path, root)] = parse(path) + + for rel, page in sorted(pages.items()): + scripted = rel.startswith(SCRIPTED_ANCHORS) + for href, line in page.links: + where = f"{rel}:{line}" + if re.search(r"\.rst(?:[?#]|$)", href.split("?")[0]): + errors.append(f"{where}: link to a generated .rst file: {href}") + parts = urllib.parse.urlsplit(href) + if parts.scheme or href.startswith("//") or href.startswith(("mailto:", "data:", "javascript:")): + continue + target_rel = rel if not parts.path else os.path.normpath( + os.path.join(os.path.dirname(rel), urllib.parse.unquote(parts.path)) + ) + if target_rel.startswith(".."): + errors.append(f"{where}: link leaves the site: {href}") + continue + target = os.path.join(root, target_rel) + if os.path.isdir(target): + target_rel = os.path.join(target_rel, "index.html") + target = os.path.join(root, target_rel) + if not os.path.isfile(target): + errors.append(f"{where}: no such file: {href}") + continue + fragment = urllib.parse.unquote(parts.fragment) + if not fragment or scripted or target_rel.startswith(SCRIPTED_ANCHORS): + continue + target_page = pages.get(os.path.normpath(target_rel)) + if target_page is not None and fragment not in target_page.ids: + errors.append(f"{where}: no anchor #{fragment} in {target_rel}") + if not scripted and rel not in exempt: + text = " ".join(page.text) + for pattern in forbid: + found = pattern.search(text) + if found: + errors.append(f"{rel}: forbidden text {found.group(0)!r} (pattern {pattern.pattern})") + for href, line in page.links: + if pattern.search(href): + errors.append(f"{rel}:{line}: forbidden link {href} (pattern {pattern.pattern})") + return errors, len(pages) + + +def check_sources(roots, forbid): + errors = [] + for top in roots: + for dirpath, _dirs, files in os.walk(top): + for name in sorted(files): + if not name.endswith((".org", ".md", ".rst", ".py", ".el")): + continue + path = os.path.join(dirpath, name) + with open(path, encoding="utf-8", errors="replace") as handle: + for number, line in enumerate(handle, 1): + for pattern in forbid: + found = pattern.search(line) + if found: + errors.append(f"{path}:{number}: forbidden text {found.group(0)!r}") + return errors + + +def main(argv): + parser = argparse.ArgumentParser(description=__doc__.split("\n", 1)[0]) + parser.add_argument("site", help="the built HTML directory") + parser.add_argument("--sources", action="append", default=[], help="a source tree to scan for forbidden text") + parser.add_argument("--forbid", action="append", default=[], help="another forbidden regular expression") + parser.add_argument("--no-default-forbid", action="store_true", help="drop the default forbidden patterns") + parser.add_argument("--exempt", action="append", default=[], metavar="PAGE", + help="a built page, relative to the site, whose text is not checked for forbidden names") + args = parser.parse_args(argv) + if not os.path.isfile(os.path.join(args.site, "index.html")): + print(f"check_site: no index.html in {args.site}", file=sys.stderr) + return 2 + patterns = ([] if args.no_default_forbid else DEFAULT_FORBID) + args.forbid + forbid = [re.compile(p, re.I) for p in patterns] + errors, count = check_site(args.site, forbid, set(args.exempt)) + errors += check_sources(args.sources, forbid) + for error in errors: + print(error) + print(f"check_site: {count} pages, {len(errors)} problem(s)", file=sys.stderr) + return 1 if errors else 0 + + +if __name__ == "__main__": + sys.exit(main(sys.argv[1:])) diff --git a/docs/tools/zig_api.zig b/docs/tools/zig_api.zig new file mode 100644 index 0000000..0ff5715 --- /dev/null +++ b/docs/tools/zig_api.zig @@ -0,0 +1,615 @@ +//! Write the API reference of a Zig module as MyST pages for Sphinx. +//! +//! zig run docs/tools/zig_api.zig -- --module NAME --root FILE --out DIR +//! [--source-url URL] [--title TEXT] [--follow-private-imports] +//! +//! The parser is std.zig.Ast, the one the compiler uses. From the root file +//! it follows every `@import("x.zig")` bound to a `pub` declaration (and to +//! any declaration with --follow-private-imports, which an executable needs: +//! its files are rarely imported as `pub`). Each file becomes one page, +//! `.md`, holding its `//!` comment and one `zig:` directive +//! per `pub` declaration, with its `///` comment as the body. Fields of a +//! container and the `pub` declarations inside it are nested under it. A +//! file imported along several paths takes the shortest of `pub` imports, +//! or of any imports when there is none. `index.md` lists the pages. An import of another package, such as +//! `@import("zig_common")`, is not followed; intersphinx links to that +//! package's own site. +//! +//! `{ref}` in the source URL becomes $DOCS_SOURCE_REF, else $GITHUB_SHA, +//! else `main`, so a page built in CI links to the commit it was built from. +//! DIR is emptied first: it holds only generated pages. +const std = @import("std"); +const Ast = std.zig.Ast; +const Allocator = std.mem.Allocator; +const Io = std.Io; +const Writer = std.Io.Writer; + +const usage = + \\usage: zig_api --module NAME --root FILE --out DIR [--source-url URL] + \\ [--title TEXT] [--follow-private-imports] + \\ +; + +const Options = struct { + module: []const u8 = "", + root: []const u8 = "", + out: []const u8 = "", + source_url: []const u8 = "", + title: []const u8 = "", + follow_private: bool = false, +}; + +const Kind = enum { + module, + type, + errorset, + function, + constant, + variable, + + fn directive(k: Kind) []const u8 { + return switch (k) { + .module => "zig:module", + .type => "zig:type", + .errorset => "zig:errorset", + .function => "zig:function", + .constant => "zig:constant", + .variable => "zig:variable", + }; + } + + fn heading(k: Kind) []const u8 { + return switch (k) { + .module => "Modules", + .type => "Types", + .errorset => "Error sets", + .function => "Functions", + .constant => "Constants", + .variable => "Variables", + }; + } +}; + +/// One file to document: the dotted name it is published under and its path. +const Page = struct { + fqn: []const u8, + path: []const u8, + summary: []const u8 = "", + /// Reached from the root through `pub` imports alone, so the autodoc + /// site, which shows only those, has its declarations. + public: bool = false, +}; + +const Ctx = struct { + gpa: Allocator, + io: Io, + opts: Options, + pages: std.ArrayList(Page) = .empty, + seen: std.StringHashMapUnmanaged(void) = .empty, +}; + +fn fail(comptime fmt: []const u8, args: anytype) noreturn { + std.debug.print("zig_api: " ++ fmt ++ "\n", args); + std.process.exit(2); +} + +pub fn main(init: std.process.Init) !void { + const arena = init.arena.allocator(); + const args = try init.minimal.args.toSlice(arena); + var opts: Options = .{}; + var i: usize = 1; + while (i < args.len) : (i += 1) { + const a = args[i]; + if (std.mem.eql(u8, a, "--follow-private-imports")) { + opts.follow_private = true; + continue; + } + if (std.mem.eql(u8, a, "-h") or std.mem.eql(u8, a, "--help")) { + std.debug.print("{s}", .{usage}); + return; + } + if (i + 1 >= args.len) fail("{s} needs a value\n{s}", .{ a, usage }); + const v = args[i + 1]; + i += 1; + if (std.mem.eql(u8, a, "--module")) { + opts.module = v; + } else if (std.mem.eql(u8, a, "--root")) { + opts.root = v; + } else if (std.mem.eql(u8, a, "--out")) { + opts.out = v; + } else if (std.mem.eql(u8, a, "--source-url")) { + opts.source_url = v; + } else if (std.mem.eql(u8, a, "--title")) { + opts.title = v; + } else { + fail("unknown option {s}\n{s}", .{ a, usage }); + } + } + if (opts.module.len == 0 or opts.root.len == 0 or opts.out.len == 0) fail("{s}", .{usage}); + const ref = init.environ_map.get("DOCS_SOURCE_REF") orelse init.environ_map.get("GITHUB_SHA") orelse "main"; + opts.source_url = try std.mem.replaceOwned(u8, arena, opts.source_url, "{ref}", ref); + + var ctx: Ctx = .{ .gpa = arena, .io = init.io, .opts = opts }; + try Io.Dir.cwd().deleteTree(init.io, opts.out); + try Io.Dir.cwd().createDirPath(init.io, opts.out); + try collect(&ctx); + for (ctx.pages.items) |*page| try writePage(&ctx, page); + try writeIndex(&ctx); +} + +fn readSource(ctx: *Ctx, path: []const u8) ![:0]const u8 { + return Io.Dir.cwd().readFileAllocOptions(ctx.io, path, ctx.gpa, .limited(64 << 20), .of(u8), 0) catch |err| + fail("cannot read {s}: {s}", .{ path, @errorName(err) }); +} + +fn parse(ctx: *Ctx, path: []const u8) !Ast { + const source = try readSource(ctx, path); + const tree = try Ast.parse(ctx.gpa, source, .{}); + if (tree.errors.len != 0) { + const e = tree.errors[0]; + const loc = tree.tokenLocation(0, e.token); + fail("{s}:{d}:{d}: does not parse ({s})", .{ path, loc.line + 1, loc.column + 1, @tagName(e.tag) }); + } + return tree; +} + +/// Find the files to document, breadth first, so each gets its shortest +/// name: through `pub` imports when it has one, which is the name the +/// autodoc knows, else through any import. +fn collect(ctx: *Ctx) !void { + try addPage(ctx, ctx.opts.module, ctx.opts.root, true); + try walk(ctx, true); + if (ctx.opts.follow_private) try walk(ctx, false); +} + +/// Add the files imported by the pages found so far, and by the pages +/// added meanwhile: by `pub` declarations of public pages, or by any +/// declaration of any page. +fn walk(ctx: *Ctx, public: bool) !void { + var i: usize = 0; + while (i < ctx.pages.items.len) : (i += 1) { + const page = ctx.pages.items[i]; + if (public and !page.public) continue; + var tree = try parse(ctx, page.path); + for (tree.rootDecls()) |decl| { + const vd = tree.fullVarDecl(decl) orelse continue; + if (public and vd.visib_token == null) continue; + const target = importPath(&tree, vd) orelse continue; + const name = tree.tokenSlice(vd.ast.mut_token + 1); + const fqn = try std.fmt.allocPrint(ctx.gpa, "{s}.{s}", .{ page.fqn, name }); + try addPage(ctx, fqn, try importedFile(ctx, page.path, target), public); + } + } +} + +fn addPage(ctx: *Ctx, fqn: []const u8, path: []const u8, public: bool) !void { + const gop = try ctx.seen.getOrPut(ctx.gpa, path); + if (gop.found_existing) return; + var tree = try parse(ctx, path); + try ctx.pages.append(ctx.gpa, .{ + .fqn = fqn, + .path = path, + .summary = try firstSentence(ctx.gpa, try containerDoc(ctx.gpa, &tree)), + .public = public, + }); +} + +/// The path of the file that `@import(target)` in the file `from` names. +fn importedFile(ctx: *Ctx, from: []const u8, target: []const u8) ![]const u8 { + return std.fs.path.join(ctx.gpa, &.{ std.fs.path.dirname(from) orelse ".", target }); +} + +/// The dotted name of the page for the file `@import(target)` in the file +/// `from` names; another path to that file may have given it its name. +fn pageOf(ctx: *Ctx, from: []const u8, target: []const u8) ![]const u8 { + const path = try importedFile(ctx, from, target); + for (ctx.pages.items) |page| { + if (std.mem.eql(u8, page.path, path)) return page.fqn; + } + fail("{s} imports {s}, which has no page", .{ from, path }); +} + +/// The file a declaration `@import`s, when it names a `.zig` file. +fn importPath(tree: *const Ast, vd: Ast.full.VarDecl) ?[]const u8 { + const init_node = vd.ast.init_node.unwrap() orelse return null; + switch (tree.nodeTag(init_node)) { + .builtin_call_two, .builtin_call_two_comma, .builtin_call, .builtin_call_comma => {}, + else => return null, + } + if (!std.mem.eql(u8, tree.tokenSlice(tree.nodeMainToken(init_node)), "@import")) return null; + var buf: [2]Ast.Node.Index = undefined; + const params = tree.builtinCallParams(&buf, init_node) orelse return null; + if (params.len != 1 or tree.nodeTag(params[0]) != .string_literal) return null; + const lit = tree.tokenSlice(tree.nodeMainToken(params[0])); + if (lit.len < 2) return null; + const name = lit[1 .. lit.len - 1]; + if (!std.mem.endsWith(u8, name, ".zig")) return null; + return name; +} + +/// The `//!` lines at the top of a file, without the marker. +fn containerDoc(gpa: Allocator, tree: *const Ast) ![]const u8 { + var out: Writer.Allocating = .init(gpa); + var tok: Ast.TokenIndex = 0; + while (tok < tree.tokens.len and tree.tokenTag(tok) == .container_doc_comment) : (tok += 1) { + try out.writer.print("{s}\n", .{stripMarker(tree.tokenSlice(tok))}); + } + return out.written(); +} + +/// The `///` lines directly above the token, without the marker. +fn docComment(gpa: Allocator, tree: *const Ast, first: Ast.TokenIndex) ![]const u8 { + var start = first; + while (start > 0 and tree.tokenTag(start - 1) == .doc_comment) start -= 1; + var out: Writer.Allocating = .init(gpa); + var tok = start; + while (tok < first) : (tok += 1) { + try out.writer.print("{s}\n", .{stripMarker(tree.tokenSlice(tok))}); + } + return out.written(); +} + +/// The name an identifier token spells: `@"rename-fallback"` is +/// rename-fallback. Anchors and cross-references use this form; the +/// signature keeps the source's. +fn identName(token: []const u8) []const u8 { + if (token.len >= 3 and std.mem.startsWith(u8, token, "@\"") and token[token.len - 1] == '"') + return token[2 .. token.len - 1]; + return token; +} + +fn stripMarker(line: []const u8) []const u8 { + var s = line[3..]; + if (s.len > 0 and s[0] == ' ') s = s[1..]; + return std.mem.trimEnd(u8, s, " \t\r"); +} + +fn firstSentence(gpa: Allocator, doc: []const u8) ![]const u8 { + const para_end = std.mem.indexOf(u8, doc, "\n\n") orelse doc.len; + const para = try collapse(gpa, doc[0..para_end]); + var i: usize = 0; + while (i + 1 < para.len) : (i += 1) { + if (para[i] == '.' and para[i + 1] == ' ') return para[0 .. i + 1]; + } + return para; +} + +/// Source text with every run of whitespace, newlines included, made one space. +fn collapse(gpa: Allocator, text: []const u8) ![]const u8 { + var out: std.ArrayList(u8) = .empty; + var space = false; + for (text) |c| { + if (std.ascii.isWhitespace(c)) { + space = out.items.len > 0; + continue; + } + if (space) try out.append(gpa, ' '); + space = false; + // zig fmt leaves a comma before a closing bracket on a wrapped list. + if ((c == ')' or c == '}' or c == ']') and out.items.len > 1 and + out.items[out.items.len - 1] == ' ' and out.items[out.items.len - 2] == ',') + { + out.items.len -= 2; + } + try out.append(gpa, c); + } + return out.items; +} + +fn tokenText(tree: *const Ast, first: Ast.TokenIndex, last: Ast.TokenIndex) []const u8 { + const start = tree.tokenStart(first); + const end = tree.tokenStart(last) + tree.tokenSlice(last).len; + return tree.source[start..end]; +} + +fn lineOf(tree: *const Ast, tok: Ast.TokenIndex) usize { + return tree.tokenLocation(0, tok).line + 1; +} + +const Member = struct { + kind: Kind, + name: []const u8, + signature: []const u8, + doc: []const u8, + line: usize, + /// For a container: its node, to document fields and nested declarations. + container: ?Ast.Node.Index = null, + /// For an error set: its node, to list the error names. + errors: ?Ast.Node.Index = null, + /// For an imported file: the `@import` operand, such as "proc.zig". + import: []const u8 = "", +}; + +fn isContainer(tree: *const Ast, node: Ast.Node.Index) bool { + return switch (tree.nodeTag(node)) { + .container_decl, + .container_decl_trailing, + .container_decl_arg, + .container_decl_arg_trailing, + .container_decl_two, + .container_decl_two_trailing, + .tagged_union, + .tagged_union_trailing, + .tagged_union_enum_tag, + .tagged_union_enum_tag_trailing, + .tagged_union_two, + .tagged_union_two_trailing, + => true, + else => false, + }; +} + +fn isTypeName(name: []const u8) bool { + return name.len > 0 and std.ascii.isUpper(name[0]) or std.mem.endsWith(u8, name, "_t"); +} + +/// The declarations of one container worth a directive: `pub` ones, plus +/// every field. Returns them in source order. +fn members(ctx: *Ctx, tree: *const Ast, decls: []const Ast.Node.Index, fields: *std.ArrayList(Member)) !std.ArrayList(Member) { + var list: std.ArrayList(Member) = .empty; + const gpa = ctx.gpa; + for (decls) |decl| { + switch (tree.nodeTag(decl)) { + .container_field_init, .container_field_align, .container_field => { + var cf = tree.fullContainerField(decl).?; + cf.convertToNonTupleLike(tree); + if (cf.ast.tuple_like) continue; + const first = cf.firstToken(); + try fields.append(gpa, .{ + .kind = .constant, + .name = identName(tree.tokenSlice(cf.ast.main_token)), + .signature = try collapse(gpa, tokenText(tree, first, tree.lastToken(decl))), + .doc = try docComment(gpa, tree, first), + .line = lineOf(tree, first), + }); + }, + .fn_decl, .fn_proto, .fn_proto_multi, .fn_proto_one, .fn_proto_simple => { + var buf: [1]Ast.Node.Index = undefined; + const fp = tree.fullFnProto(&buf, decl).?; + if (fp.visib_token == null) continue; + const name_tok = fp.name_token orelse continue; + const proto = if (tree.nodeTag(decl) == .fn_decl) tree.nodeData(decl).node_and_node[0] else decl; + try list.append(gpa, .{ + .kind = .function, + .name = identName(tree.tokenSlice(name_tok)), + .signature = try collapse(gpa, tokenText(tree, fp.firstToken(), tree.lastToken(proto))), + .doc = try docComment(gpa, tree, fp.firstToken()), + .line = lineOf(tree, fp.firstToken()), + }); + }, + .global_var_decl, .local_var_decl, .simple_var_decl, .aligned_var_decl => { + const vd = tree.fullVarDecl(decl).?; + if (vd.visib_token == null) continue; + const name = identName(tree.tokenSlice(vd.ast.mut_token + 1)); + const first = vd.firstToken(); + var m: Member = .{ + .kind = if (tree.tokenTag(vd.ast.mut_token) == .keyword_var) .variable else .constant, + .name = name, + .signature = "", + .doc = try docComment(gpa, tree, first), + .line = lineOf(tree, first), + }; + const init_node = vd.ast.init_node.unwrap(); + const head_end: Ast.TokenIndex = if (init_node) |n| tree.firstToken(n) - 1 else tree.lastToken(decl); + const head = try collapse(gpa, tokenText(tree, first, head_end)); + if (init_node) |n| { + if (importPath(tree, vd)) |target| { + m.kind = .module; + m.import = target; + m.signature = try collapse(gpa, tokenText(tree, first, tree.lastToken(n))); + } else if (m.kind == .constant and isContainer(tree, n)) { + var cbuf: [2]Ast.Node.Index = undefined; + const cd = tree.fullContainerDecl(&cbuf, n).?; + const lbrace = brace: { + var t = cd.ast.main_token; + while (tree.tokenTag(t) != .l_brace) t += 1; + break :brace t; + }; + m.kind = .type; + m.container = n; + m.signature = try std.fmt.allocPrint(gpa, "{s} {s}", .{ head, try collapse(gpa, tokenText(tree, tree.firstToken(n), lbrace - 1)) }); + } else if (m.kind == .constant and (tree.nodeTag(n) == .error_set_decl or tree.nodeTag(n) == .merge_error_sets)) { + m.kind = .errorset; + m.errors = n; + m.signature = try std.fmt.allocPrint(gpa, "{s} {s}", .{ head, if (tree.nodeTag(n) == .error_set_decl) "error{...}" else try collapse(gpa, tree.getNodeSource(n)) }); + } else { + const value = try collapse(gpa, tree.getNodeSource(n)); + if (m.kind == .constant and isTypeName(name)) m.kind = .type; + m.signature = if (value.len <= 72 and std.mem.indexOfScalar(u8, value, '{') == null) + try std.fmt.allocPrint(gpa, "{s} {s}", .{ head, value }) + else + try std.fmt.allocPrint(gpa, "{s} ...", .{head}); + } + } else { + m.signature = head; + } + try list.append(gpa, m); + }, + else => {}, + } + } + return list; +} + +fn writePage(ctx: *Ctx, page: *Page) !void { + const gpa = ctx.gpa; + var tree = try parse(ctx, page.path); + var out: Writer.Allocating = .init(gpa); + const w = &out.writer; + + try w.print("# {s}\n\n", .{page.fqn}); + try w.print("::::{{zig:module}} {s}\n:file: {s}\n", .{ page.fqn, page.path }); + if (ctx.opts.source_url.len > 0) try w.print(":source: {s}{s}\n", .{ ctx.opts.source_url, page.path }); + if (!page.public) try w.writeAll(":no-autodoc:\n"); + try w.writeAll("\n"); + try writeDoc(w, try containerDoc(gpa, &tree)); + try w.writeAll("::::\n\n"); + + var fields: std.ArrayList(Member) = .empty; + const list = try members(ctx, &tree, tree.rootDecls(), &fields); + inline for (.{ Kind.module, Kind.type, Kind.errorset, Kind.function, Kind.constant, Kind.variable }) |kind| { + var any = false; + for (list.items) |m| { + if (m.kind != kind) continue; + if (!any) try w.print("## {s}\n\n", .{kind.heading()}); + any = true; + if (kind == .module) { + // The imported file's own page declares the module. + const target = try pageOf(ctx, page.path, m.import); + try w.print("- {{zig:mod}}`{s}`: ", .{target}); + try writeProse(w, summaryOf(ctx, target)); + try w.writeAll("\n"); + } else { + try writeMember(ctx, w, &tree, page, page.fqn, m); + } + } + if (kind == .module and any) try w.writeAll("\n"); + } + + const name = try std.fmt.allocPrint(gpa, "{s}.md", .{page.fqn}); + var dir = try Io.Dir.cwd().openDir(ctx.io, ctx.opts.out, .{}); + defer dir.close(ctx.io); + try dir.writeFile(ctx.io, .{ .sub_path = name, .data = out.written() }); +} + +fn summaryOf(ctx: *Ctx, fqn: []const u8) []const u8 { + for (ctx.pages.items) |page| { + if (std.mem.eql(u8, page.fqn, fqn)) return page.summary; + } + return ""; +} + +/// Colons for a directive that holds `depth` levels of nested directives. +fn fence(gpa: Allocator, depth: usize) ![]const u8 { + const f = try gpa.alloc(u8, 3 + depth); + @memset(f, ':'); + return f; +} + +fn nesting(ctx: *Ctx, tree: *const Ast, m: Member) !usize { + const n = m.container orelse return if (m.errors != null) 1 else 0; + var cbuf: [2]Ast.Node.Index = undefined; + const cd = tree.fullContainerDecl(&cbuf, n).?; + var fields: std.ArrayList(Member) = .empty; + const inner = try members(ctx, tree, cd.ast.members, &fields); + var deepest: usize = if (fields.items.len > 0) 1 else 0; + for (inner.items) |child| deepest = @max(deepest, 1 + try nesting(ctx, tree, child)); + return deepest; +} + +fn writeMember(ctx: *Ctx, w: *Writer, tree: *const Ast, page: *const Page, parent: []const u8, m: Member) !void { + const gpa = ctx.gpa; + const fqn = try std.fmt.allocPrint(gpa, "{s}.{s}", .{ parent, m.name }); + const colons = try fence(gpa, try nesting(ctx, tree, m)); + try w.print("{s}{{{s}}} {s}\n", .{ colons, m.kind.directive(), fqn }); + try w.print(":signature: {s}\n", .{m.signature}); + if (ctx.opts.source_url.len > 0) try w.print(":source: {s}{s}#L{d}\n", .{ ctx.opts.source_url, page.path, m.line }); + if (!page.public) try w.writeAll(":no-autodoc:\n"); + try w.writeAll("\n"); + try writeDoc(w, m.doc); + + if (m.errors) |n| try writeErrors(ctx, w, tree, n, fqn); + if (m.container) |n| { + var cbuf: [2]Ast.Node.Index = undefined; + const cd = tree.fullContainerDecl(&cbuf, n).?; + var fields: std.ArrayList(Member) = .empty; + const inner = try members(ctx, tree, cd.ast.members, &fields); + for (fields.items) |f| { + try w.print(":::{{zig:field}} {s}.{s}\n:signature: {s}\n", .{ fqn, f.name, f.signature }); + if (ctx.opts.source_url.len > 0) try w.print(":source: {s}{s}#L{d}\n", .{ ctx.opts.source_url, page.path, f.line }); + try w.writeAll("\n"); + try writeDoc(w, f.doc); + try w.writeAll(":::\n\n"); + } + for (inner.items) |child| try writeMember(ctx, w, tree, page, fqn, child); + } + try w.print("{s}\n\n", .{colons}); +} + +/// Each name of an `error{...}` set, with its `///` comment. +fn writeErrors(ctx: *Ctx, w: *Writer, tree: *const Ast, node: Ast.Node.Index, fqn: []const u8) !void { + if (tree.nodeTag(node) != .error_set_decl) return; + const lbrace, const rbrace = tree.nodeData(node).token_and_token; + var tok = lbrace + 1; + while (tok < rbrace) : (tok += 1) { + if (tree.tokenTag(tok) != .identifier) continue; + try w.print(":::{{zig:error}} {s}.{s}\n:signature: error.{s}\n\n", .{ fqn, identName(tree.tokenSlice(tok)), tree.tokenSlice(tok) }); + try writeDoc(w, try docComment(ctx.gpa, tree, tok)); + try w.writeAll(":::\n\n"); + } +} + +/// A doc comment as MyST: Markdown already, except that a heading cannot sit +/// inside a directive, so it becomes a bold line. +fn writeDoc(w: *Writer, doc: []const u8) !void { + if (std.mem.trim(u8, doc, " \n").len == 0) return; + var lines = std.mem.splitScalar(u8, std.mem.trimEnd(u8, doc, "\n"), '\n'); + var in_code = false; + while (lines.next()) |line| { + if (std.mem.startsWith(u8, std.mem.trimStart(u8, line, " "), "```")) { + in_code = !in_code; + try w.print("{s}\n", .{line}); + continue; + } + if (in_code) { + try w.print("{s}\n", .{line}); + } else if (std.mem.startsWith(u8, line, "#")) { + const text = std.mem.trim(u8, std.mem.trimStart(u8, line, "#"), " "); + try w.writeAll("**"); + try writeProse(w, text); + try w.writeAll("**\n"); + } else { + try writeProse(w, line); + try w.writeAll("\n"); + } + } + try w.writeAll("\n"); +} + +/// One line of doc comment prose, with the syntax MyST adds to Markdown, and +/// Zig's autodoc does not have, escaped outside code spans: a footnote +/// reference `[^x]` (a regular expression's negated class) and a `%` comment +/// line. +fn writeProse(w: *Writer, line: []const u8) !void { + return writeEscaped(w, line, false); +} + +/// writeProse for a table cell, where a pipe ends the cell, inside a code +/// span too. +fn writeCell(w: *Writer, text: []const u8) !void { + return writeEscaped(w, text, true); +} + +fn writeEscaped(w: *Writer, line: []const u8, cell: bool) !void { + const indent = line.len - std.mem.trimStart(u8, line, " ").len; + var in_span = false; + for (line, 0..) |c, i| { + if (c == '`') in_span = !in_span; + const footnote = !in_span and c == '[' and i + 1 < line.len and line[i + 1] == '^'; + const comment = i == indent and c == '%'; + if (footnote or comment or (cell and c == '|')) try w.writeByte('\\'); + try w.writeByte(c); + } +} + +fn writeIndex(ctx: *Ctx) !void { + var out: Writer.Allocating = .init(ctx.gpa); + const w = &out.writer; + const title = if (ctx.opts.title.len > 0) ctx.opts.title else "Zig API"; + try w.print("# {s}\n\n", .{title}); + try w.print("Generated from the doc comments of `{s}` by `docs/tools/zig_api.zig`.\n", .{ctx.opts.module}); + try w.writeAll("Each page is one source file; the `pub` declarations are grouped by kind in source order.\n"); + try w.writeAll("Every declaration links to its source line and, where the {zig:autodoc}`Zig autodoc ` build has it, to the same declaration there.\n"); + try w.writeAll("\n| Module | Summary |\n|---|---|\n"); + for (ctx.pages.items) |page| { + try w.print("| {{zig:mod}}`{s}` | ", .{page.fqn}); + try writeCell(w, page.summary); + try w.writeAll(" |\n"); + } + try w.writeAll("\n```{toctree}\n:hidden:\n:maxdepth: 1\n\n"); + for (ctx.pages.items) |page| try w.print("{s}\n", .{page.fqn}); + try w.writeAll("```\n"); + var dir = try Io.Dir.cwd().openDir(ctx.io, ctx.opts.out, .{}); + defer dir.close(ctx.io); + try dir.writeFile(ctx.io, .{ .sub_path = "index.md", .data = out.written() }); +} diff --git a/lychee.toml b/lychee.toml new file mode 100644 index 0000000..9a1f778 --- /dev/null +++ b/lychee.toml @@ -0,0 +1,31 @@ +# External links in the built site (pixi run -e docs linkcheck). Internal +# links and anchors are checked offline by docs/tools/check_site.py. +max_retries = 3 +retry_wait_time = 2 +timeout = 20 +max_concurrency = 16 +accept = ["200..=299", "429"] +include_fragments = "none" +cache = true +max_cache_age = "1d" +no_progress = true + +exclude_path = [ + # The Zig autodoc site links only within itself. + "docs/build/html/api/", +] + +exclude = [ + # This site: every page names its published URL as canonical, and a new + # page is not published until this build deploys. check_site.py checks the + # site's own links. + '^https://stackhands\.github\.io/zig\-common/', + # Source links name the commit being built, which a pull request build + # may not have pushed anywhere yet; check_site.py checks the pages. + '^https://github\.com/stackhands/[^/]+/(blob|edit|tree)/', + # A Cloudflare challenge answers automated clients with 403. + '^https://eb-stack\.rgoswami\.me/', + # The repository's own, each with its reason; apply.py keeps this block. + # local:begin + # local:end +] diff --git a/pixi.lock b/pixi.lock new file mode 100644 index 0000000..7081eae --- /dev/null +++ b/pixi.lock @@ -0,0 +1,3859 @@ +version: 7 +platforms: +- name: linux-64 + virtual-packages: + - __unix=0 + - __linux=4.18 + - __glibc=2.28 + - __archspec=0=x86_64 +- name: osx-arm64 + virtual-packages: + - __unix=0 + - __osx=13.0 + - __archspec=0=m1 +environments: + default: + channels: + - url: https://conda.anaconda.org/conda-forge/ + packages: {} + docs: + channels: + - url: https://conda.anaconda.org/conda-forge/ + packages: + linux-64: + - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/astroid-4.3.4-py313hd5f5364_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/at-spi2-atk-2.38.0-h0630a04_3.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/at-spi2-core-2.40.3-h0630a04_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/atk-1.0-2.38.0-hc5c8e38_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.46.1-default_h4852527_103.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.46.1-default_hfdba357_103.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_10.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.9-hebe6cf0_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cairo-1.18.6-h3c89d7e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/charset-normalizer-3.5.2-h1114479_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/curl-8.23.0-ha042cf0_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/dbus-1.16.2-he8c428d_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/emacs-30.2-hda76a9e_6.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/epoxy-1.5.10-hb03c661_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/fontconfig-2.18.3-h4db4eae_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/freetype-2.14.3-ha770c72_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/fribidi-1.0.18-h7cc23a3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gdk-pixbuf-2.44.8-h68053f1_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/giflib-6.1.3-hebe6cf0_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/glib-tools-2.90.1-h876c321_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gmp-6.3.0-hfd2156b_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gnutls-3.8.13-h18acefa_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/graphite2-1.3.15-h54a6638_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gtk3-3.24.52-ha5ea40c_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/harfbuzz-15.0.0-ha770c72_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/hicolor-icon-theme-0.17-hfc2019e_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-78.3-py310h44b86e0_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.3-h7cc23a3_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.22.2-hbc21106_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.46.1-default_hbd61a6d_103.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/lerc-4.3.0-he78707d_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libclang-cpp22.1-22.1.8-default_h0acdd01_11.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcups-2.3.3-h7a8fb5f_6.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.23.0-ha042cf0_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libdeflate-1.26-h351257e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libdrm-2.4.129-h7cc23a3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20260512-pl5321h373387f_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libegl-1.7.0-ha4b6fd6_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libegl-devel-1.7.0-ha4b6fd6_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-h280c20c_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.9.0-hd2095e1_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.7.0-h81df57d_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype-2.14.3-ha770c72_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype6-2.14.3-h5e6c136_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-16.2.0-ha9f2e26_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-16.2.0-h69a702a_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgl-1.7.0-ha4b6fd6_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgl-devel-1.7.0-ha4b6fd6_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.90.1-hb382ddc_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libglvnd-1.7.0-ha4b6fd6_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libglx-1.7.0-ha4b6fd6_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libglx-devel-1.7.0-ha4b6fd6_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-16.2.0-he0feb66_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libharfbuzz-15.0.0-h23af247_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libharfbuzz-devel-15.0.0-h23af247_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h0cb94f2_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libidn2-2.3.8-hfac485b_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libjpeg-turbo-3.2.1-h7cc23a3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libllvm22-22.1.8-h474f4eb_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.3-hb03c661_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb03c661_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.71.0-hc5e5977_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libpango-1.58.2-hce4e988_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libpango-devel-1.58.2-h317d9d0_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libpciaccess-0.19-hb03c661_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libpng-1.6.59-h922cc85_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libpsl-0.23.1-hd9e3e90_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libpython-3.13.18-hd51c5da_100_cp313.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/librsvg-2.62.4-ha427ee3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.54.1-h13e7031_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.1-h6154650_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-16.2.0-h934c35e_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libtasn1-4.21.0-h7cc23a3_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.7.2-h6d37cbf_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libtree-sitter-0.25.9-h280c20c_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libunistring-0.9.10-h7f98852_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.4-hcfc3c73_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libwebp-base-1.6.0-hd42ef1d_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcb-1.17.0-hb83e432_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxkbcommon-1.13.2-h59c2f34_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-16-2.15.4-hf3af7cc_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.15.4-h7df9aa5_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/lychee-0.24.2-h39d0f39_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/markupsafe-3.0.4-py313h2af15c8_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/mpc-1.4.1-ha2cb11d_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/mpfr-4.2.2-ha2cb11d_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/nettle-3.10.1-h5ef0d04_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.5-h781a0a9_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/p11-kit-0.26.5-h8d769aa_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pango-1.58.2-h2f58602_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.49-h8b3dc9c_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pixman-0.46.4-h54a6638_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pthread-stubs-0.4-h7cc23a3_1004.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.13.18-hf47f18c_100_cp313.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pyyaml-6.0.3-py313h45b8176_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-hd6e31c0_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h1df4ec4_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/wayland-1.26.0-hc1c935e_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xkeyboard-config-2.48-hebe6cf0_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libice-1.1.2-h280c20c_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libsm-1.2.6-h0d788c3_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libx11-1.8.14-hb83e432_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxau-1.0.12-h7cc23a3_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxcomposite-0.4.7-hb03c661_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxcursor-1.2.3-h7cc23a3_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdamage-1.1.6-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdmcp-1.1.5-h7cc23a3_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxext-1.3.7-h7cc23a3_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxfixes-6.0.2-h7cc23a3_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxi-1.8.4-h7cc23a3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxinerama-1.1.6-hd2095e1_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrandr-1.5.5-h7cc23a3_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrender-0.9.13-h7cc23a3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxtst-1.2.6-h7cc23a3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxxf86vm-1.1.7-h7cc23a3_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-xorgproto-2025.1-hebe6cf0_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/yaml-0.2.5-hebe6cf0_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zig-0.17.1-89c0722_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zig_impl_linux-64-0.17.1-0addc32_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zig_linux-64-0.17.1-fa519dd_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_7.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/adwaita-icon-theme-51.0-unix_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/alabaster-1.0.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/babel-2.18.0-pyhcf101f3_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.10.23-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/certifi-2026.10.23-pyhd8ed1ab_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.13.18-py313hd8ed1ab_100.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/docutils-0.22.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-source-code-pro-2.038-h77eed37_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_4.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-ecosystem-1-0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-forge-1-hc364b38_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/idna-3.20-pyh5ded981_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/imagesize-2.0.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhcf101f3_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-4.18.0-he073ed8_9.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-15.3.0-h2b852eb_107.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-15.3.0-hb2c5482_107.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mdit-py-plugins-0.7.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/myst-parser-5.2.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.3-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.21.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-styles-0.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.13.18-h4df99d1_100.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.13-9_cp313.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/requests-2.34.2-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/roman-numerals-4.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/shibuya-2026.7.12-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/snowballstemmer-3.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-9.2.0-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-autoapi-3.9.0-pyh5ded981_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-copybutton-0.5.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-design-0.8.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-last-updated-by-git-0.3.8-pyhe01879c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-sitemap-2.9.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-applehelp-2.0.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-devhelp-2.0.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-htmlhelp-2.1.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-jsmath-2.0.0-pyh5ded981_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-qthelp-2.0.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-serializinghtml-2.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.28-h4ee821c_9.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026e-h5d301ff_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.8.0-pyh5ded981_1.conda + osx-arm64: + - conda: https://conda.anaconda.org/conda-forge/noarch/alabaster-1.0.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/babel-2.18.0-pyhcf101f3_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.10.23-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/certifi-2026.10.23-pyhd8ed1ab_3.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.5.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/docutils-0.22.4-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-source-code-pro-2.038-h77eed37_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_4.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-ecosystem-1-0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-forge-1-hc364b38_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/idna-3.20-pyh5ded981_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/imagesize-2.0.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhcf101f3_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mdit-py-plugins-0.7.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/myst-parser-5.2.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.3-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.21.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-styles-0.3.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.13-9_cp313.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/requests-2.34.2-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/roman-numerals-4.1.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/shibuya-2026.7.12-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/snowballstemmer-3.1.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-9.2.0-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-autoapi-3.9.0-pyh5ded981_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-copybutton-0.5.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-design-0.8.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-last-updated-by-git-0.3.8-pyhe01879c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-sitemap-2.9.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-applehelp-2.0.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-devhelp-2.0.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-htmlhelp-2.1.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-jsmath-2.0.0-pyh5ded981_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-qthelp-2.0.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-serializinghtml-2.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026e-h5d301ff_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.8.0-pyh5ded981_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/astroid-4.3.4-py313h6ee819a_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-h4e30115_10.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-ares-1.34.9-h74c22ad_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/cairo-1.18.6-h580cee5_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/curl-8.23.0-h6651222_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/dbus-1.16.2-hf049998_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/emacs-30.2-ha2f6bed_6.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/fontconfig-2.18.3-h81aa574_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/freetype-2.14.3-hce30654_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/fribidi-1.0.18-hb001647_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gdk-pixbuf-2.44.8-h5867e2c_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/giflib-6.1.3-h74c22ad_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gmp-6.3.0-hf5e55b1_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/gnutls-3.8.13-hfe86254_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/graphite2-1.3.15-h784d473_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/icu-78.3-py310h579977c_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/krb5-1.22.2-h34f8a20_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/lerc-4.3.0-h0699d0c_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libasprintf-0.25.1-hae62183_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp22.1-22.1.8-default_h79071a4_11.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcurl-8.23.0-h6651222_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-22.1.8-h55c6f16_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libdeflate-1.26-h72bfca4_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libedit-3.1.20260512-pl5321h26f1114_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libev-4.33-h1a92334_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.9.0-h6111c0a_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.7.0-h47dc5ef_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libfreetype-2.14.3-hce30654_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libfreetype6-2.14.3-h2ed5691_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgettextpo-0.25.1-hae62183_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libglib-2.90.0-hccd281b_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libharfbuzz-15.0.0-hcda0f7c_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libharfbuzz-devel-15.0.0-hcda0f7c_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.18-he4c29f2_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libidn2-2.3.8-ha90df94_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-0.25.1-hae62183_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libjpeg-turbo-3.2.1-hb001647_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm22-22.1.8-h759d1ac_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblzma-5.8.3-h8088a28_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libmpdec-4.0.0-h84a0fba_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.71.0-h29223de_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpango-1.58.2-hc2ac4f2_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpango-devel-1.58.2-haa2d88b_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpng-1.6.59-hf5e6511_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpsl-0.23.1-hdb0c161_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpython-3.13.18-h0af5753_100_cp313.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/librsvg-2.62.4-hc8ac265_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.54.1-hca69786_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libssh2-1.11.1-hbf2880b_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libtasn1-4.21.0-hb001647_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libtiff-4.7.2-h87d37ca_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libtree-sitter-0.25.9-he530434_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libunistring-0.9.10-h3422bc3_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libwebp-base-1.6.0-h202fb40_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-16-2.15.4-heb56d2d_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.15.4-h550178d_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/lychee-0.24.2-h9d00c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/markupsafe-3.0.4-py313h0984dbd_5.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-he64c551_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/nettle-3.10.1-hfc803ee_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.6.5-h55eecbc_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/p11-kit-0.26.5-h329a732_2.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pango-1.58.2-hc6efcc1_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pcre2-10.47-he63d830_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pixman-0.46.4-h784d473_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.13.18-hb59dee6_100_cp313.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyyaml-6.0.3-py313h5c85ca1_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.3-h8b90a29_1.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-hbeba79b_4.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/yaml-0.2.5-h74c22ad_3.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zig-0.17.1-0ccaba2_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zig_impl_osx-arm64-0.17.1-8405819_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zig_osx-arm64-0.17.1-a676bd3_0.conda + - conda: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.7-hf451053_7.conda +packages: +- conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-20_gnu.conda + build_number: 20 + sha256: 1dd3fffd892081df9726d7eb7e0dea6198962ba775bd88842135a4ddb4deb3c9 + md5: a9f577daf3de00bca7c3c76c0ecbd1de + depends: + - __glibc >=2.17,<3.0.a0 + - libgomp >=7.5.0 + constrains: + - openmp_impl <0.0a0 + license: BSD-3-Clause + license_family: BSD + run_exports: + strong: + - _openmp_mutex >=4.5 + size: 28948 + timestamp: 1770939786096 +- conda: https://conda.anaconda.org/conda-forge/linux-64/astroid-4.3.4-py313hd5f5364_0.conda + sha256: 771ff3b8e696eddcae366aec29fa141de8f86c775829bdc4a7b2178e9ef63a0f + md5: 07762eaac3a9abec3df4a843ea7b1137 + depends: + - python + - python_abi 3.13.* *_cp313 + license: LGPL-2.1-only + run_exports: {} + size: 577483 + timestamp: 1791464581441 +- conda: https://conda.anaconda.org/conda-forge/linux-64/at-spi2-atk-2.38.0-h0630a04_3.tar.bz2 + sha256: 26ab9386e80bf196e51ebe005da77d57decf6d989b4f34d96130560bc133479c + md5: 6b889f174df1e0f816276ae69281af4d + depends: + - at-spi2-core >=2.40.0,<2.41.0a0 + - atk-1.0 >=2.36.0 + - dbus >=1.13.6,<2.0a0 + - libgcc-ng >=9.3.0 + - libglib >=2.68.1,<3.0a0 + license: LGPL-2.1-or-later + license_family: LGPL + run_exports: + weak: + - at-spi2-atk >=2.38.0,<3.0a0 + size: 339899 + timestamp: 1619122953439 +- conda: https://conda.anaconda.org/conda-forge/linux-64/at-spi2-core-2.40.3-h0630a04_0.tar.bz2 + sha256: c4f9b66bd94c40d8f1ce1fad2d8b46534bdefda0c86e3337b28f6c25779f258d + md5: 8cb2fc4cd6cc63f1369cfa318f581cc3 + depends: + - dbus >=1.13.6,<2.0a0 + - libgcc-ng >=9.3.0 + - libglib >=2.68.3,<3.0a0 + - xorg-libx11 + - xorg-libxi + - xorg-libxtst + license: LGPL-2.1-or-later + license_family: LGPL + run_exports: + weak: + - at-spi2-core >=2.40.3,<2.41.0a0 + size: 658390 + timestamp: 1625848454791 +- conda: https://conda.anaconda.org/conda-forge/linux-64/atk-1.0-2.38.0-hc5c8e38_3.conda + sha256: 0a46bb5d2b830bafbc087e03e6dcfbe2bb0ed5367f7eb0f2ac30d814c90eb273 + md5: 0025e3fcf41f95f2d101a5314c203cd7 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - libglib >=2.90.1,<3.0a0 + - libzlib >=1.3.2,<2.0a0 + constrains: + - atk-1.0 2.38.0 + license: LGPL-2.0-or-later + license_family: LGPL + run_exports: + weak: + - atk-1.0 >=2.38.0 + size: 184172 + timestamp: 1794581195451 +- conda: https://conda.anaconda.org/conda-forge/linux-64/binutils-2.46.1-default_h4852527_103.conda + sha256: 1198587b78b20fa00ee397d4ea1bdb5098b08100c08ad7b3e6d10912cd487466 + md5: 3624cc8224aec1c58079dad844d354a2 + depends: + - binutils_impl_linux-64 >=2.46.1,<2.46.2.0a0 + license: GPL-3.0-only + license_family: GPL + run_exports: {} + size: 35373 + timestamp: 1791565504227 +- conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.46.1-default_hfdba357_103.conda + sha256: 98f9ddc6dc5d56a824b7eaea5bab6ad4bb47642288fc70d6b1b4024ac39d5595 + md5: e86f9dc615d7533c5be8b15b3a1dee8d + depends: + - ld_impl_linux-64 2.46.1 default_hbd61a6d_103 + - sysroot_linux-64 + - zstd >=1.5.7,<1.6.0a0 + license: GPL-3.0-only + license_family: GPL + run_exports: {} + size: 3706604 + timestamp: 1791565481839 +- conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-hda65f42_10.conda + sha256: 1a0d382c515ebf55f8ee1f38c8b81bc95af5c2acc42ad53b66bc5df932032f96 + md5: e675fabcf81499adc7edf58124fb1e01 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: bzip2-1.0.6 + license_family: BSD + run_exports: + weak: + - bzip2 >=1.0.8,<2.0a0 + size: 257808 + timestamp: 1785906269155 +- conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.9-hebe6cf0_0.conda + sha256: bd95dd25b80b5c4faf5349542377bf89b2794e23d0f7aa7f1c431e4f3b633f3c + md5: 78b505af04bf7a87ca957ef0cb5946f5 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + license: MIT + license_family: MIT + run_exports: + weak: + - c-ares >=1.34.9,<2.0a0 + size: 233759 + timestamp: 1792507024648 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cairo-1.18.6-h3c89d7e_0.conda + sha256: 5d0efc6f9981468aca72897460d9b2d17b74dff72787f20a9d2330e214064515 + md5: 7920701f9abcb488411495742cf365a7 + depends: + - __glibc >=2.17,<3.0.a0 + - fontconfig >=2.18.3,<3.0a0 + - fonts-conda-ecosystem + - icu >=78.3,<79.0a0 + - libexpat >=2.8.1,<3.0a0 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libgcc >=15 + - libglib >=2.90.0,<3.0a0 + - libpng >=1.6.58,<1.7.0a0 + - libstdcxx >=15 + - libxcb >=1.17.0,<2.0a0 + - libzlib >=1.3.2,<2.0a0 + - pixman >=0.46.4,<1.0a0 + - xorg-libice >=1.1.2,<2.0a0 + - xorg-libsm >=1.2.6,<2.0a0 + - xorg-libx11 >=1.8.13,<2.0a0 + - xorg-libxext >=1.3.7,<2.0a0 + - xorg-libxrender >=0.9.12,<0.10.0a0 + license: LGPL-2.1-only or MPL-1.1 + run_exports: + weak: + - cairo >=1.18.6,<2.0a0 + size: 1007110 + timestamp: 1790045358757 +- conda: https://conda.anaconda.org/conda-forge/linux-64/charset-normalizer-3.5.2-h1114479_0.conda + noarch: python + sha256: e4f04b45d68716fcc47c808aeacbf165f6f295fb91bd20b91aa38942b8d2cdc6 + md5: 78d5c6112c9320a1a797935cecfec7c2 + depends: + - python + - libgcc >=15 + - __glibc >=2.17,<3.0.a0 + - _python_abi3_support 1.* + - cpython >=3.9 + license: MIT + license_family: MIT + run_exports: {} + size: 217200 + timestamp: 1790766086110 +- conda: https://conda.anaconda.org/conda-forge/linux-64/curl-8.23.0-ha042cf0_0.conda + sha256: c34fd476d8ad5eede00a3742f33bf52400e01b35bc2777ab2306d6fc21121949 + md5: ae85b19bbac7336f4efc4802c351effa + depends: + - __glibc >=2.17,<3.0.a0 + - krb5 >=1.22.2,<1.23.0a0 + - libcurl 8.23.0 ha042cf0_0 + - libgcc >=15 + - libpsl >=0.23.1,<0.24.0a0 + - libssh2 >=1.11.1,<2.0a0 + - libzlib >=1.3.2,<2.0a0 + - openssl >=3.5.9,<4.0a0 + - zstd >=1.5.7,<1.6.0a0 + license: curl + license_family: MIT + run_exports: {} + size: 197652 + timestamp: 1791990906207 +- conda: https://conda.anaconda.org/conda-forge/linux-64/dbus-1.16.2-he8c428d_2.conda + sha256: 87a0a42d4ccc527597eff3234509dfb03e0d9bf67d5e2b6fc758e2ef389d8abe + md5: a6eb37b51be1a9a654dc3a8aca039b1a + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - libstdcxx >=15 + - libexpat >=2.8.1,<3.0a0 + - libzlib >=1.3.2,<2.0a0 + - libglib >=2.88.3,<3.0a0 + license: AFL-2.1 OR GPL-2.0-or-later + run_exports: + weak: + - dbus >=1.16.2,<2.0a0 + size: 449564 + timestamp: 1788197922783 +- conda: https://conda.anaconda.org/conda-forge/linux-64/emacs-30.2-hda76a9e_6.conda + sha256: 41085b883c2395030f0612c888897926bb11309a969c7fff4fde14ed0237de79 + md5: c89a80eb5ab4bcf59096bbc5c87c4e39 + depends: + - binutils + - __glibc >=2.17,<3.0.a0 + - libstdcxx >=15 + - libgcc >=15 + - xorg-libxext >=1.3.7,<2.0a0 + - libpng >=1.6.58,<1.7.0a0 + - giflib >=6.1.3,<6.2.0a0 + - zstd >=1.5.7,<1.6.0a0 + - libsqlite >=3.53.4,<4.0a0 + - gmp >=6.3.0,<7.0a0 + - libglib >=2.88.3,<3.0a0 + - fontconfig >=2.18.3,<3.0a0 + - fonts-conda-ecosystem + - xorg-libx11 >=1.8.13,<2.0a0 + - libwebp-base >=1.6.0,<2.0a0 + - xorg-libsm >=1.2.6,<2.0a0 + - libtree-sitter >=0.25.9,<0.26.0a0 + - cairo >=1.18.4,<2.0a0 + - xorg-libxrandr >=1.5.5,<2.0a0 + - xorg-libice >=1.1.2,<2.0a0 + - xorg-libxfixes >=6.0.2,<7.0a0 + - xorg-libxcomposite >=0.4.7,<1.0a0 + - libxml2 + - libxml2-16 >=2.14.6 + - gtk3 >=3.24.52,<4.0a0 + - adwaita-icon-theme + - libjpeg-turbo >=3.2.0,<4.0a0 + - libharfbuzz >=14.3.0 + - libiconv >=1.18,<2.0a0 + - libzlib >=1.3.2,<2.0a0 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - ncurses >=6.6,<7.0a0 + - librsvg >=2.62.3,<3.0a0 + - xorg-libxi >=1.8.3,<2.0a0 + - xorg-libxrender >=0.9.12,<0.10.0a0 + - mpfr >=4.2.2,<5.0a0 + - libxcb >=1.17.0,<2.0a0 + - gdk-pixbuf >=2.44.8,<3.0a0 + - libtiff >=4.7.2,<4.8.0a0 + - gnutls >=3.8.11,<3.9.0a0 + - pango >=1.58.2,<2.0a0 + - xorg-libxinerama >=1.1.6,<1.2.0a0 + - dbus >=1.16.2,<2.0a0 + - libexpat >=2.8.1,<3.0a0 + - mpc >=1.4.0,<2.0a0 + license: GPL-3.0-only + license_family: GPL + run_exports: {} + size: 73507511 + timestamp: 1786884762437 +- conda: https://conda.anaconda.org/conda-forge/linux-64/epoxy-1.5.10-hb03c661_2.conda + sha256: a5b51e491fec22bcc1765f5b2c8fff8a97428e9a5a7ee6730095fb9d091b0747 + md5: 057083b06ccf1c2778344b6dabace38b + depends: + - __glibc >=2.17,<3.0.a0 + - libdrm >=2.4.125,<2.5.0a0 + - libegl >=1.7.0,<2.0a0 + - libegl-devel + - libgcc >=14 + - libgl >=1.7.0,<2.0a0 + - libgl-devel + - libglx >=1.7.0,<2.0a0 + - libglx-devel + - xorg-libx11 >=1.8.12,<2.0a0 + - xorg-libxdamage >=1.1.6,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 + - xorg-libxfixes >=6.0.1,<7.0a0 + - xorg-libxxf86vm >=1.1.6,<2.0a0 + license: MIT + license_family: MIT + run_exports: + weak: + - epoxy >=1.5.10,<1.6.0a0 + size: 411735 + timestamp: 1758743520805 +- conda: https://conda.anaconda.org/conda-forge/linux-64/fontconfig-2.18.3-h4db4eae_2.conda + sha256: 49d5b86a00d441d23e6351a6371429fea311538e2aa8b855e61c4d3dbe3e8762 + md5: 2385ef6446d1a75b26a681449a6e32a7 + depends: + - __glibc >=2.17,<3.0.a0 + - libexpat >=2.9.0,<3.0a0 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libgcc >=15 + - libuuid >=2.42.4,<3.0a0 + - libzlib >=1.3.2,<2.0a0 + license: MIT + run_exports: + weak: + - fontconfig >=2.18.3,<3.0a0 + - fonts-conda-ecosystem + size: 296751 + timestamp: 1794699581275 +- conda: https://conda.anaconda.org/conda-forge/linux-64/freetype-2.14.3-ha770c72_2.conda + sha256: 612a8e0c1a6ecae23da54d81ef395f6ebb5c8e4468ec2611593ebce75876a4e0 + md5: 2d0ea23b23603e07ca47f23f949f67b6 + depends: + - libfreetype 2.14.3 ha770c72_2 + - libfreetype6 2.14.3 h5e6c136_2 + license: GPL-2.0-only OR FTL + run_exports: + weak: + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + size: 175239 + timestamp: 1786641011029 +- conda: https://conda.anaconda.org/conda-forge/linux-64/fribidi-1.0.18-h7cc23a3_0.conda + sha256: 6cabdf62dad4973ef0fe8b0d80c4b5b5d76ac9249da91f26f663cb44acdcc6a1 + md5: a14a9f11f543b9a5c03ae6a5c2245b0a + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + license: LGPL-2.1-or-later + run_exports: + weak: + - fribidi >=1.0.18,<2.0a0 + size: 64767 + timestamp: 1793323486599 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gdk-pixbuf-2.44.8-h68053f1_2.conda + sha256: 32f3ebd1871cb6ac7eac36c78c410860f38e8d252d5857a80f6abfcb79c7e0ff + md5: d7bd6ccfc58eb6796bd6bba85878fc0e + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - libglib >=2.88.3,<3.0a0 + - libjpeg-turbo >=3.2.0,<4.0a0 + - liblzma >=5.8.3,<6.0a0 + - libpng >=1.6.58,<1.7.0a0 + - libtiff >=4.7.2,<4.8.0a0 + license: LGPL-2.1-or-later + license_family: LGPL + run_exports: + weak: + - gdk-pixbuf >=2.44.8,<3.0a0 + size: 581961 + timestamp: 1788490424411 +- conda: https://conda.anaconda.org/conda-forge/linux-64/giflib-6.1.3-hebe6cf0_2.conda + sha256: 917c3a622c3870f822d25a882f1856e757d91e31a3dd52a499849a392ca865d2 + md5: 07bdd65afe03df3fb5dbcaa8257c64a3 + depends: + - libgcc >=15 + - __glibc >=2.17,<3.0.a0 + license: MIT + license_family: MIT + run_exports: + weak: + - giflib >=6.1.3,<6.2.0a0 + size: 86117 + timestamp: 1788948683783 +- conda: https://conda.anaconda.org/conda-forge/linux-64/glib-tools-2.90.1-h876c321_3.conda + sha256: 6f7be2f6545fe3f2e2c62428021623e489daa98ca0d9dbcd9d3fc5297de3bc8b + md5: f68c210114fbae3b35e07a9f1a230972 + depends: + - libglib ==2.90.1 hb382ddc_3 + - libffi + - libgcc >=15 + - __glibc >=2.17,<3.0.a0 + license: LGPL-2.1-or-later + run_exports: {} + size: 238585 + timestamp: 1794580555960 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gmp-6.3.0-hfd2156b_3.conda + sha256: f36c336efc874f346a53a9011f67e997f9faac505562cc18c13b6d399cfe61c7 + md5: 576e32739f323438bf69ab006c21be7b + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libstdcxx >=14 + license: GPL-2.0-or-later OR LGPL-3.0-or-later + run_exports: + weak: + - gmp >=6.3.0,<7.0a0 + size: 493498 + timestamp: 1786629164954 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gnutls-3.8.13-h18acefa_0.conda + sha256: dbdbb714064914281c755650bc54e1855412e7e2f4c99ad171b5123ed704b2b1 + md5: 7c3de21891993e89aabdadaa603ed835 + depends: + - __glibc >=2.17,<3.0.a0 + - gmp >=6.3.0,<7.0a0 + - libgcc >=14 + - libidn2 >=2,<3.0a0 + - libstdcxx >=14 + - libtasn1 >=4.21.0,<5.0a0 + - nettle >=3.10.1,<3.11.0a0 + - p11-kit >=0.26.2,<0.27.0a0 + license: LGPL-2.1-or-later + license_family: LGPL + run_exports: + weak: + - gnutls >=3.8.13,<3.9.0a0 + size: 2054535 + timestamp: 1778044634746 +- conda: https://conda.anaconda.org/conda-forge/linux-64/graphite2-1.3.15-h54a6638_1.conda + sha256: 7fa3b6a9c081fa3e545573152a788d061a0a0ba57df7251cc0f4f75225fc93e7 + md5: f9fe2984587fa8235a6af6004760cd18 + depends: + - __glibc >=2.17,<3.0.a0 + - libstdcxx >=14 + - libgcc >=14 + license: LGPL-2.0-or-later + license_family: LGPL + run_exports: + weak: + - graphite2 >=1.3.15,<2.0a0 + size: 102835 + timestamp: 1786118485753 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gtk3-3.24.52-ha5ea40c_0.conda + sha256: c6bb4f06331bcb0a566d84e0f0fad7af4b9035a03b13e2d5ecfaf13be57e6e10 + md5: bcaea22d85999a4f17918acfab877e61 + depends: + - __glibc >=2.17,<3.0.a0 + - at-spi2-atk >=2.38.0,<3.0a0 + - atk-1.0 >=2.38.0 + - cairo >=1.18.4,<2.0a0 + - epoxy >=1.5.10,<1.6.0a0 + - fontconfig >=2.17.1,<3.0a0 + - fonts-conda-ecosystem + - fribidi >=1.0.16,<2.0a0 + - gdk-pixbuf >=2.44.5,<3.0a0 + - glib-tools + - harfbuzz >=13.2.1 + - hicolor-icon-theme + - libcups >=2.3.3,<2.4.0a0 + - libcups >=2.3.3,<3.0a0 + - libexpat >=2.7.4,<3.0a0 + - libfreetype >=2.14.2 + - libfreetype6 >=2.14.2 + - libgcc >=14 + - libglib >=2.86.4,<3.0a0 + - liblzma >=5.8.2,<6.0a0 + - libxkbcommon >=1.13.1,<2.0a0 + - libzlib >=1.3.2,<2.0a0 + - pango >=1.56.4,<2.0a0 + - wayland >=1.25.0,<2.0a0 + - xorg-libx11 >=1.8.13,<2.0a0 + - xorg-libxcomposite >=0.4.7,<1.0a0 + - xorg-libxcursor >=1.2.3,<2.0a0 + - xorg-libxdamage >=1.1.6,<2.0a0 + - xorg-libxext >=1.3.7,<2.0a0 + - xorg-libxfixes >=6.0.2,<7.0a0 + - xorg-libxi >=1.8.2,<2.0a0 + - xorg-libxinerama >=1.1.6,<1.2.0a0 + - xorg-libxrandr >=1.5.5,<2.0a0 + - xorg-libxrender >=0.9.12,<0.10.0a0 + license: LGPL-2.0-or-later + license_family: LGPL + run_exports: + weak: + - gtk3 >=3.24.52,<4.0a0 + - adwaita-icon-theme + size: 5939083 + timestamp: 1774288645605 +- conda: https://conda.anaconda.org/conda-forge/linux-64/harfbuzz-15.0.0-ha770c72_0.conda + sha256: 66e49a0888ad60b69766c8a82a4c5b8be0000b1b0d595710ffaba079fd717e5e + md5: 3bb1373c9a1ca102437ca168e5282cc0 + depends: + - libharfbuzz-devel 15.0.0 h23af247_0 + license: MIT + license_family: MIT + run_exports: + weak: + - libharfbuzz >=15.0.0 + size: 11075 + timestamp: 1792769341313 +- conda: https://conda.anaconda.org/conda-forge/linux-64/hicolor-icon-theme-0.17-hfc2019e_4.conda + sha256: 3eadfa497feb83b48e115383468d756b0637bdd3db7c93d8880c3a68e5f63c68 + md5: bd55e24a51101bcdc51e2c7c8850b333 + license: GPL-2.0-or-later + license_family: GPL + run_exports: {} + size: 15246 + timestamp: 1794120683401 +- conda: https://conda.anaconda.org/conda-forge/linux-64/icu-78.3-py310h44b86e0_2.conda + sha256: 9f07834f0c546ab14d885ce0366285f61f44e326c0edd1fc63b8294e113ae432 + md5: 72a381cbad04f24b1c2a43ef707f45b4 + depends: + - __glibc >=2.17,<3.0.a0 + - libstdcxx >=14 + - libgcc >=14 + license: MIT + license_family: MIT + run_exports: + weak: + - icu >=78.3,<79.0a0 + size: 14459115 + timestamp: 1786545741408 +- conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.3-h7cc23a3_1.conda + sha256: dd053c96dcb0dcfd59422aefea9d2fe937a190167f34fba7893ec1e10a7e8963 + md5: ba55d1b89fd7775e67de8291029b4059 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + license: LGPL-2.1-or-later + run_exports: + weak: + - keyutils >=1.6.3,<2.0a0 + size: 135295 + timestamp: 1786739238128 +- conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.22.2-hbc21106_2.conda + sha256: 2a5c38c85e63df84c4e69ee71439841ce570d259ae3060627bb9a49a938d66f4 + md5: 53318d715316929a574f83591308b1f8 + depends: + - __glibc >=2.17,<3.0.a0 + - keyutils >=1.6.3,<2.0a0 + - libedit >=3.1.20250104,<3.2.0a0 + - libedit >=3.1.20250104,<4.0a0 + - libgcc >=15 + - libstdcxx >=15 + - openssl >=3.5.7,<4.0a0 + license: MIT + license_family: MIT + run_exports: + weak: + - krb5 >=1.22.2,<1.23.0a0 + size: 1394333 + timestamp: 1786762112514 +- conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.46.1-default_hbd61a6d_103.conda + sha256: 901649b1edbe841fd4ee7e2d491a05184ed540eb01cdae506872f344babc1d28 + md5: 2362c70e7e79827c32db35547d9c179b + depends: + - __glibc >=2.17,<3.0.a0 + - zstd >=1.5.7,<1.6.0a0 + constrains: + - binutils_impl_linux-64 2.46.1 + license: GPL-3.0-only + license_family: GPL + run_exports: {} + size: 742109 + timestamp: 1791565468810 +- conda: https://conda.anaconda.org/conda-forge/linux-64/lerc-4.3.0-he78707d_0.conda + sha256: 467aa52e9ba7a438f17944909e1904399eab863778ab501cf271e30cfa4bc6f3 + md5: 78908f9592dbe2cebd57082bf8c57000 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - libstdcxx >=15 + license: Apache-2.0 + license_family: Apache + run_exports: + weak: + - lerc >=4.3.0,<5.0a0 + size: 269911 + timestamp: 1793411350746 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libclang-cpp22.1-22.1.8-default_h0acdd01_11.conda + sha256: e7a3df524a2900677c460e8cd1407db8aabadc3d19e6a713a58a4f29b1d4bef7 + md5: eccc111e6808c3aa5dd458a448c597e6 + depends: + - __glibc >=2.17,<3.0.a0 + - libstdcxx >=15 + - libgcc >=15 + - libxml2 + - libxml2-16 >=2.15.4 + - zstd >=1.5.7,<1.6.0a0 + - libzlib >=1.3.2,<2.0a0 + - libllvm22 >=22.1.8,<22.2.0a0 + license: Apache-2.0 WITH LLVM-exception + license_family: APACHE + run_exports: + weak: + - libclang-cpp22.1 >=22.1.8,<22.2.0a0 + size: 24529645 + timestamp: 1791934037580 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcups-2.3.3-h7a8fb5f_6.conda + sha256: 205c4f19550f3647832ec44e35e6d93c8c206782bdd620c1d7cf66237580ff9c + md5: 49c553b47ff679a6a1e9fc80b9c5a2d4 + depends: + - __glibc >=2.17,<3.0.a0 + - krb5 >=1.22.2,<1.23.0a0 + - libgcc >=14 + - libstdcxx >=14 + - libzlib >=1.3.1,<2.0a0 + license: Apache-2.0 + license_family: Apache + run_exports: + weak: + - libcups >=2.3.3,<2.4.0a0 + size: 4518030 + timestamp: 1770902209173 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcurl-8.23.0-ha042cf0_0.conda + sha256: d2db14d80efb4f2e76e76561c633f1767f7543987f2bcb54a067a9d264d432ab + md5: 0ad16151226df493aed967f0efce0e80 + depends: + - __glibc >=2.17,<3.0.a0 + - krb5 >=1.22.2,<1.23.0a0 + - libgcc >=15 + - libnghttp2 >=1.68.1,<2.0a0 + - libpsl >=0.23.1,<0.24.0a0 + - libssh2 >=1.11.1,<2.0a0 + - libzlib >=1.3.2,<2.0a0 + - openssl >=3.5.9,<4.0a0 + - zstd >=1.5.7,<1.6.0a0 + license: curl + license_family: MIT + run_exports: + weak: + - libcurl >=8.23.0,<9.0a0 + size: 505683 + timestamp: 1791990900844 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libdeflate-1.26-h351257e_0.conda + sha256: f437f68abb1fa1dededd082a0c2800bec40495e01cf9ec46f4e693e34d60b644 + md5: d0c17fc12939a990f0865b7a14b49cfe + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + license: MIT + license_family: MIT + run_exports: + weak: + - libdeflate >=1.26,<1.27.0a0 + size: 74338 + timestamp: 1787442593524 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libdrm-2.4.129-h7cc23a3_0.conda + sha256: ea46b0ca0fa16af1f8b329b740e6cd8b4577c5378fa8717b28a885f70668633d + md5: 64cc91512b6278c315349dc13c53f680 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - libpciaccess >=0.19,<0.20.0a0 + license: MIT + license_family: MIT + run_exports: + weak: + - libdrm >=2.4.129,<2.5.0a0 + size: 313461 + timestamp: 1786684701973 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20260512-pl5321h373387f_0.conda + sha256: 45301f14f4eb66da57cfaf2d265f3eeee73f8b07e99614ee3afc5b26eea91126 + md5: 27dbd7e2984b8fe48e069379636ccfdd + depends: + - ncurses + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - ncurses >=6.6,<7.0a0 + license: BSD-2-Clause + license_family: BSD + run_exports: + weak: + - libedit >=3.1.20260512,<3.2.0a0 + size: 135877 + timestamp: 1791327370514 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libegl-1.7.0-ha4b6fd6_5.conda + sha256: 13d3fde9c1dcf254968cc70652222a43f25d04e69555ccf855553110e753288e + md5: 3a1b41c4591a0a1734382af3e2b8bc08 + depends: + - __glibc >=2.17,<3.0.a0 + - libglvnd 1.7.0 ha4b6fd6_5 + license: LicenseRef-libglvnd + run_exports: {} + size: 46694 + timestamp: 1787310030923 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libegl-devel-1.7.0-ha4b6fd6_5.conda + sha256: fd2794bbcff7e692fb476c17886702702893d074071d429217bad7cfb072abfd + md5: 577800fc8c9d8b7d9727246bbfde704e + depends: + - __glibc >=2.17,<3.0.a0 + - libegl 1.7.0 ha4b6fd6_5 + - libgl-devel 1.7.0 ha4b6fd6_5 + - xorg-libx11 + license: LicenseRef-libglvnd + run_exports: + weak: + - libegl >=1.7.0,<2.0a0 + size: 31242 + timestamp: 1787310065866 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libev-4.33-h280c20c_3.conda + sha256: e4418f68d01a6307c4431b585c71b584f40189877364e542ee87deb777f5e85b + md5: 7bc31538d6e3fb349e897353969237ec + depends: + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + license: BSD-2-Clause OR GPL-2.0-or-later + license_family: GPL + run_exports: + weak: + - libev >=4.33,<4.34.0a0 + size: 43220 + timestamp: 1785917328200 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.9.0-hd2095e1_0.conda + sha256: 7b930a8b6bc6553cb754b4977a11f9c862c719a652fc2d128d89270992ce8beb + md5: 317ecabe4a58b3068c7958dc5eb89e43 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + constrains: + - expat 2.9.0.* + license: MIT + license_family: MIT + run_exports: {} + size: 78894 + timestamp: 1793054221966 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.7.0-h81df57d_1.conda + sha256: c8c7583ef063bc3c430f1d48298e5ad24f796a35c22ed5b14183325825a61106 + md5: 6525a0b06aa4fd390795f0740636a9dd + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + license: MIT + license_family: MIT + run_exports: + weak: + - libffi >=3.7.0,<3.8.0a0 + size: 68004 + timestamp: 1787753412298 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype-2.14.3-ha770c72_2.conda + sha256: fb12ecb46c30d18d928c0e8fc346ab13b5f6fc8a9cacae4f2f4bb188782586f5 + md5: f8054e759d0ddddaf34a5c8fedc900a1 + depends: + - libfreetype6 >=2.14.3 + license: GPL-2.0-only OR FTL + run_exports: {} + size: 8407 + timestamp: 1786641007099 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype6-2.14.3-h5e6c136_2.conda + sha256: ec607dd5445dd17ff6bf8b7fe6832e5504c226dd91d3aaea7ba83569808b0ce4 + md5: b72a266a9317036fd0464cb98b027cd0 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - libpng >=1.6.58,<1.7.0a0 + - libzlib >=1.3.2,<2.0a0 + constrains: + - freetype >=2.14.3 + license: GPL-2.0-only OR FTL + run_exports: {} + size: 387671 + timestamp: 1786641006460 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-16.2.0-ha9f2e26_7.conda + sha256: e031634c3a928f9594eba868bc46ef5230d6571a364a0c63215b06c4563bfcea + md5: 735629b400b70eeab21a2ba8f5b1c2ce + depends: + - __glibc >=2.17,<3.0.a0 + - _openmp_mutex >=4.5 + constrains: + - libgcc-ng ==16.2.0=*_7 + - libgomp 16.2.0 he0feb66_7 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + run_exports: {} + size: 1058444 + timestamp: 1790303109576 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-16.2.0-h69a702a_7.conda + sha256: 03b54d7008de080a17cc2174b0e4acd6d06e1c981b2eb19846f46d8f59966034 + md5: 2005515ac9340f816fb2ac7e83afe553 + depends: + - libgcc 16.2.0 ha9f2e26_7 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + run_exports: + strong: + - libgcc + size: 28616 + timestamp: 1790303114248 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgl-1.7.0-ha4b6fd6_5.conda + sha256: 7b2e7e31e8a4f5a01c45ecadcd8aa68c8f733b035240bc7ba9881835ef4bf7b4 + md5: 81141db127a106eb5a91df69a29c9918 + depends: + - __glibc >=2.17,<3.0.a0 + - libglvnd 1.7.0 ha4b6fd6_5 + - libglx 1.7.0 ha4b6fd6_5 + license: LicenseRef-libglvnd + run_exports: {} + size: 131988 + timestamp: 1787310049847 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgl-devel-1.7.0-ha4b6fd6_5.conda + sha256: 3bebdbeb3ce451287794dddd5cc4d7f4970aac200b2fb797f0d17ac727a71cb7 + md5: f5f7fc038c611a25b22758c0a40d25c9 + depends: + - __glibc >=2.17,<3.0.a0 + - libgl 1.7.0 ha4b6fd6_5 + - libglx-devel 1.7.0 ha4b6fd6_5 + license: LicenseRef-libglvnd + run_exports: + weak: + - libgl >=1.7.0,<2.0a0 + size: 116212 + timestamp: 1787310061570 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.90.1-hb382ddc_3.conda + sha256: ff0405851f6e95c2b350eb11c505cb5b13c9aca1fe2b854499286b64c78249d8 + md5: e84cb2c1d7ef14f65b92d854b0545ff5 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - pcre2 >=10.49,<10.50.0a0 + - libffi >=3.7.0,<3.8.0a0 + - libiconv >=1.18,<2.0a0 + - libzlib >=1.3.2,<2.0a0 + constrains: + - glib >2.66 + license: LGPL-2.1-or-later + run_exports: + weak: + - libglib >=2.90.1,<3.0a0 + size: 4856026 + timestamp: 1794580555960 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libglvnd-1.7.0-ha4b6fd6_5.conda + sha256: 6eb77601a44b78c4631d886d54ef54f321c2bdc69fdefc4065a1e0491f030c76 + md5: cfcf11edcfd4acf0094771a9c3b8587f + depends: + - __glibc >=2.17,<3.0.a0 + license: LicenseRef-libglvnd + run_exports: {} + size: 133827 + timestamp: 1787310026653 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libglx-1.7.0-ha4b6fd6_5.conda + sha256: d1f0d51aea6bcc5d915969cbed32e72a8ed6a95931b87357ef8d0866573688c4 + md5: 614e10aae180f87b84f0d1ca8ceb7d9e + depends: + - __glibc >=2.17,<3.0.a0 + - libglvnd 1.7.0 ha4b6fd6_5 + - xorg-libx11 >=1.8.13,<2.0a0 + license: LicenseRef-libglvnd + run_exports: {} + size: 79834 + timestamp: 1787310042550 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libglx-devel-1.7.0-ha4b6fd6_5.conda + sha256: aff3841e3404d78e1887fef988ca4842930c577399d566fa0980808756b1df51 + md5: fb00b4fb800f2d431303a5c1625ef9d0 + depends: + - __glibc >=2.17,<3.0.a0 + - libglx 1.7.0 ha4b6fd6_5 + - xorg-libx11 >=1.8.13,<2.0a0 + - xorg-xorgproto + license: LicenseRef-libglvnd + run_exports: + weak: + - libglx >=1.7.0,<2.0a0 + size: 27698 + timestamp: 1787310053582 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-16.2.0-he0feb66_7.conda + sha256: 92a0bb350c7be6a4eedcb4e111c60aefd176018e6b1c009a6e025dbe9bbcd758 + md5: d904c7ddd95e026254b4b80808ee9e12 + depends: + - __glibc >=2.17,<3.0.a0 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + run_exports: + strong: + - _openmp_mutex >=4.5 + size: 640566 + timestamp: 1790303046034 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libharfbuzz-15.0.0-h23af247_0.conda + sha256: d3190aedc31b449627ba5bdb8423a62fd234623ab99959c0a5a580e4d6ef6420 + md5: f8beff45d7ea8bea3c6675a7ef568337 + depends: + - __glibc >=2.17,<3.0.a0 + - cairo >=1.18.6,<2.0a0 + - graphite2 >=1.3.15,<2.0a0 + - icu >=78.3,<79.0a0 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libgcc >=15 + - libglib >=2.90.0,<3.0a0 + - libpng >=1.6.59,<1.7.0a0 + - libstdcxx >=15 + - libzlib >=1.3.2,<2.0a0 + license: MIT + license_family: MIT + run_exports: {} + size: 1628948 + timestamp: 1792769313795 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libharfbuzz-devel-15.0.0-h23af247_0.conda + sha256: 1409a10889a683a95eff4eac5bd2f99631f40c3ef51f7fbd139a90cc3bc36862 + md5: 0ca7e3876bc01ee2c0d3c1e3b0217cc4 + depends: + - __glibc >=2.17,<3.0.a0 + - cairo >=1.18.6,<2.0a0 + - freetype + - graphite2 >=1.3.15,<2.0a0 + - icu >=78.3,<79.0a0 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libgcc >=15 + - libglib >=2.90.0,<3.0a0 + - libharfbuzz 15.0.0 h23af247_0 + - libpng >=1.6.59,<1.7.0a0 + - libstdcxx >=15 + - libzlib >=1.3.2,<2.0a0 + license: MIT + license_family: MIT + run_exports: + weak: + - libharfbuzz >=15.0.0 + size: 2464838 + timestamp: 1792769333155 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h0cb94f2_3.conda + sha256: f943117edb9cd4d9c61cc972eee5a34291dc55ea7a6e9e38da104995841cbcb6 + md5: f92233bf33e24a25668bb2119e2c51f9 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + license: LGPL-2.1-only + run_exports: + weak: + - libiconv >=1.18,<2.0a0 + size: 789471 + timestamp: 1787033836207 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libidn2-2.3.8-hfac485b_1.conda + sha256: cc38c900b9a20fe75e61cbb594e749c57a06d96510722f5ddfa309682062b065 + md5: 842a81de672ddcf476337c8bde3cad33 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libunistring >=0,<1.0a0 + license: LGPL-2.0-only + license_family: LGPL + run_exports: + weak: + - libidn2 >=2,<3.0a0 + size: 139036 + timestamp: 1760385590993 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libjpeg-turbo-3.2.1-h7cc23a3_0.conda + sha256: 2f7d092a3212884825c43814575225fde8a9190611bc0e38c55e0dae45e329ac + md5: 5fd2b2218f7c28c71e95738a4fffaf78 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + constrains: + - jpeg <0.0.0a + license: IJG AND BSD-3-Clause AND Zlib + run_exports: + weak: + - libjpeg-turbo >=3.2.1,<4.0a0 + size: 653905 + timestamp: 1793157024388 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libllvm22-22.1.8-h474f4eb_3.conda + sha256: 135b8b9bfed6a20cdbda657ddb4584d483203eb0e4c29e448a60d4bcc762f391 + md5: c927dba789a253045c0089cb25af44ac + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - libstdcxx >=15 + - libxml2 + - libxml2-16 >=2.15.4 + - libzlib >=1.3.2,<2.0a0 + - zstd >=1.5.7,<1.6.0a0 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + run_exports: + weak: + - libllvm22 >=22.1.8,<22.2.0a0 + size: 44629067 + timestamp: 1790110003063 +- conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.3-hb03c661_1.conda + sha256: 9787df8c22a59c9a70d3e5a10db9ad663485e75e9ccc3f09bd092cb7b95e0dab + md5: 1390b7c5ac0b1d8e447bc5efa6d3c8c2 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + constrains: + - xz 5.8.3.* + license: 0BSD + run_exports: + weak: + - liblzma >=5.8.3,<6.0a0 + size: 112995 + timestamp: 1786348617826 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb03c661_2.conda + sha256: 46820b4a835e175940ae20bec00fdddaff804cda27a1408ab1b95e77a2196437 + md5: fcfed1dc5053eb1901b66e7b1fc32588 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: BSD-2-Clause + license_family: BSD + run_exports: {} + size: 92759 + timestamp: 1786650399772 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libnghttp2-1.71.0-hc5e5977_0.conda + sha256: a4386712ad6d5bc18943b198407c39e2f8ae2fa9c6418bb37bba96f1d382f109 + md5: 726df214814a8b06135a6a674bc54589 + depends: + - libev >=4.33,<5.0a0 + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - libstdcxx >=15 + - libev >=4.33,<4.34.0a0 + - c-ares >=1.34.9,<2.0a0 + - libzlib >=1.3.2,<2.0a0 + - openssl >=3.5.9,<4.0a0 + license: MIT + license_family: MIT + run_exports: + weak: + - libnghttp2 >=1.71.0,<2.0a0 + size: 822778 + timestamp: 1793628201366 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libpango-1.58.2-hce4e988_3.conda + sha256: 251dfa10f843dfb14ccc8c33d7ec0f18ac75f51be119100f65468a046b1b33ce + md5: d1ad1c07f3ae04176c0b218d7fe3be9b + depends: + - libgcc >=15 + - __glibc >=2.17,<3.0.a0 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - fontconfig >=2.18.3,<3.0a0 + - fonts-conda-ecosystem + - cairo >=1.18.6,<2.0a0 + - fribidi >=1.0.17,<2.0a0 + - libglib >=2.90.0,<3.0a0 + - libharfbuzz >=14.6.0 + license: LGPL-2.1-or-later + run_exports: {} + size: 343535 + timestamp: 1792050659391 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libpango-devel-1.58.2-h317d9d0_3.conda + sha256: 75df9cf6e8c8b94648beaa8c7bf0d3c1efd7c3e0ebfb26529e415185a065c2a3 + md5: 8f2e0739636fe033c7324130121ab11c + depends: + - libpango ==1.58.2 hce4e988_3 + - freetype + - libharfbuzz-devel + - libgcc >=15 + - __glibc >=2.17,<3.0.a0 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - fontconfig >=2.18.3,<3.0a0 + - fonts-conda-ecosystem + - cairo >=1.18.6,<2.0a0 + - fribidi >=1.0.17,<2.0a0 + - libglib >=2.90.0,<3.0a0 + - libharfbuzz >=14.6.0 + license: LGPL-2.1-or-later + run_exports: + weak: + - libpango >=1.58.2,<2.0a0 + size: 211407 + timestamp: 1792050659391 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libpciaccess-0.19-hb03c661_1.conda + sha256: addc80c69d362a9e6c40305c493139a8e9ee504b2f45a6687dbdaa9da3c6183c + md5: 35fa2b34bbced424e6976d30f5fde576 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: MIT + license_family: MIT + run_exports: + weak: + - libpciaccess >=0.19,<0.20.0a0 + size: 30070 + timestamp: 1785971678815 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libpng-1.6.59-h922cc85_0.conda + sha256: c7381be8ef713501f6cd2f5ad473e401f2edeaec3c46788296b8dbf0de165e15 + md5: 8c9caf742a485ac688ffa88bbadbf0be + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - libzlib >=1.3.2,<2.0a0 + license: zlib-acknowledgement + run_exports: + weak: + - libpng >=1.6.59,<1.7.0a0 + size: 316872 + timestamp: 1790805159503 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libpsl-0.23.1-hd9e3e90_1.conda + sha256: 09e8effdc89bc5d021349318d32b85594f5b8d8e3ab8f90a85b81f8fe695a566 + md5: 77be60417aa572afcb48cbe0f967401d + depends: + - libstdcxx >=15 + - libgcc >=15 + - __glibc >=2.17,<3.0.a0 + - icu >=78.3,<79.0a0 + license: MIT + license_family: MIT + run_exports: + weak: + - libpsl >=0.23.1,<0.24.0a0 + size: 72519 + timestamp: 1786970753847 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libpython-3.13.18-hd51c5da_100_cp313.conda + build_number: 100 + sha256: 8fb44e69c90a7cb942a6388fae4c7493dbebbae3c9e11cc34d1c464256dc3af1 + md5: eb85e5c7b22eb523e07fa1140b91b9ef + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + license: Python-2.0 + run_exports: + weak: + - libpython >=3.13,<4.0a0 + size: 9721079 + timestamp: 1793015613296 +- conda: https://conda.anaconda.org/conda-forge/linux-64/librsvg-2.62.4-ha427ee3_0.conda + sha256: b8036adad17ceddcef416790131492fd236d34c64a0b2754934903087fa84279 + md5: f9bda2728debbde4c641bd1af103c623 + depends: + - libgcc >=15 + - __glibc >=2.17,<3.0.a0 + - libglib >=2.90.0,<3.0a0 + - pango >=1.58.2,<2.0a0 + - fontconfig >=2.18.3,<3.0a0 + - fonts-conda-ecosystem + - libxml2-16 >=2.15.4 + - cairo >=1.18.6,<2.0a0 + - libharfbuzz >=14.5.0 + - gdk-pixbuf >=2.44.8,<3.0a0 + constrains: + - __glibc >=2.17 + license: LGPL-2.1-or-later + run_exports: + weak: + - librsvg >=2.62.4,<3.0a0 + size: 4692221 + timestamp: 1790276295756 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.54.1-h13e7031_0.conda + sha256: 07b3c98282022f05781122d073f84e944bfb4299946e8457ece3ce6c384ff78e + md5: 8f15f0ec9b69344df5c3bb5cce1751a1 + depends: + - __glibc >=2.17,<3.0.a0 + - icu >=78.3,<79.0a0 + - libgcc >=15 + - libzlib >=1.3.2,<2.0a0 + license: blessing + run_exports: + weak: + - libsqlite >=3.54.1,<4.0a0 + size: 983668 + timestamp: 1792175587601 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libssh2-1.11.1-h6154650_1.conda + sha256: 7e463000fa1cba3f3a6597b776f6ab301d425a96e3bc20d0d9d76a3b9f237aa3 + md5: 5c526561e1d2a2e071941174eae84557 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - libzlib >=1.3.2,<2.0a0 + - openssl >=3.5.7,<4.0a0 + license: BSD-3-Clause + license_family: BSD + run_exports: + weak: + - libssh2 >=1.11.1,<2.0a0 + size: 306045 + timestamp: 1786713107897 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-16.2.0-h934c35e_7.conda + sha256: fa7018298629fc429971fffd6ecba3d27a7b02e4e890d6a93ea01ffebe8cb745 + md5: 9b6707e0caca917fa6ea9ee473f37a5d + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc 16.2.0 ha9f2e26_7 + constrains: + - libstdcxx-ng ==16.2.0=*_7 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + run_exports: {} + size: 6615436 + timestamp: 1790303132935 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libtasn1-4.21.0-h7cc23a3_1.conda + sha256: 8db5fe4b5ca8e9f35622d3903e9dcdb28e4e289fcdba3212ee48c9be9dca91f5 + md5: efe26e97b4c332d0c8b2ae6306747133 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + license: LGPL-2.1-or-later + run_exports: + weak: + - libtasn1 >=4.21.0,<5.0a0 + size: 118904 + timestamp: 1793068469782 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.7.2-h6d37cbf_2.conda + sha256: 3406eed96ee929309ecd3937308d5a81302f4ca2eddd30e832071cbe9121a6c7 + md5: 18023fe8fbec4f031ca88444572590e4 + depends: + - __glibc >=2.17,<3.0.a0 + - lerc >=4.3.0,<5.0a0 + - libdeflate >=1.26,<1.27.0a0 + - libgcc >=15 + - libjpeg-turbo >=3.2.1,<4.0a0 + - liblzma >=5.8.3,<6.0a0 + - libstdcxx >=15 + - libwebp-base >=1.6.0,<2.0a0 + - libzlib >=1.3.2,<2.0a0 + - zstd >=1.5.7,<1.6.0a0 + license: HPND + run_exports: + weak: + - libtiff >=4.7.2,<4.8.0a0 + size: 459656 + timestamp: 1794045728051 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libtree-sitter-0.25.9-h280c20c_0.conda + sha256: de4133900552a22fb1d8f5de690b15f784d2bbd7cdd967ad282bd34c965124bf + md5: a9a506002eda117e7cd473305c825f1a + depends: + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + license: MIT + license_family: MIT + run_exports: + weak: + - libtree-sitter >=0.25.9,<0.26.0a0 + size: 205332 + timestamp: 1757201839815 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libunistring-0.9.10-h7f98852_0.tar.bz2 + sha256: e88c45505921db29c08df3439ddb7f771bbff35f95e7d3103bf365d5d6ce2a6d + md5: 7245a044b4a1980ed83196176b78b73a + depends: + - libgcc-ng >=9.3.0 + license: GPL-3.0-only OR LGPL-3.0-only + run_exports: + weak: + - libunistring >=0,<1.0a0 + size: 1433436 + timestamp: 1626955018689 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.42.4-hcfc3c73_1.conda + sha256: 0e2e8f2daa9306e67f046e31092d637431d8cf0a26c407ab22401d108c2d4631 + md5: d852293faea3c04a6e896b908b43aded + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + license: BSD-3-Clause + license_family: BSD + run_exports: + weak: + - libuuid >=2.42.4,<3.0a0 + size: 36134 + timestamp: 1793891599274 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libwebp-base-1.6.0-hd42ef1d_1.conda + sha256: 8415001414f488c85b72b9d8cc2071dfb3981a47bc3c8eb56ef91a57d12eae7f + md5: 9332b53d0ea93c5d39e33be03a0c611a + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + constrains: + - libwebp 1.6.0 + license: BSD-3-Clause + license_family: BSD + run_exports: + weak: + - libwebp-base >=1.6.0,<2.0a0 + size: 428430 + timestamp: 1785954557217 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libxcb-1.17.0-hb83e432_3.conda + sha256: 38021f35547021762c04860d1c9f2d3186b83e090e5f1773216045de06cf10cc + md5: 661d9e1392a1b672d19d76df3a1feb07 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - pthread-stubs + - xorg-libxau >=1.0.12,<2.0a0 + - xorg-libxdmcp >=1.1.5,<2.0a0 + license: MIT + license_family: MIT + run_exports: + weak: + - libxcb >=1.17.0,<2.0a0 + size: 398900 + timestamp: 1794246094531 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libxkbcommon-1.13.2-h59c2f34_2.conda + sha256: 156fdf41b9f3efc54c077b5b8570b810a87800b978c12348c27ec6e0ddc20359 + md5: b85ed11539022fbbf4e63117692179ec + depends: + - xkeyboard-config + - libgcc >=15 + - libstdcxx >=15 + - __glibc >=2.17,<3.0.a0 + - libxml2 + - libxml2-16 >=2.15.4 + - xorg-libxau >=1.0.12,<2.0a0 + - libxcb >=1.17.0,<2.0a0 + license: MIT AND MIT-open-group AND HPND AND HPND-sell-variant AND ISC + run_exports: + weak: + - libxkbcommon >=1.13.2,<2.0a0 + size: 945345 + timestamp: 1792810173656 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-16-2.15.4-hf3af7cc_1.conda + sha256: d1906463070c21f3215cd5de93164f31c44d5bac6ae9b5d8f5adf42b1e304039 + md5: 046d9eada488e1a1657c80b55c23da52 + depends: + - __glibc >=2.17,<3.0.a0 + - icu >=78.3,<79.0a0 + - libgcc >=15 + - libiconv >=1.18,<2.0a0 + - liblzma >=5.8.3,<6.0a0 + - libzlib >=1.3.2,<2.0a0 + constrains: + - libxml2 2.15.4 + license: MIT + license_family: MIT + run_exports: {} + size: 569062 + timestamp: 1791465631497 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.15.4-h7df9aa5_1.conda + sha256: 8c32be9e8720bc413d2b4267517459d7d71fad4a5f398a2aa8319b6d7b8a00e6 + md5: 51e5162f95bd6840f6b2b3169125fff5 + depends: + - __glibc >=2.17,<3.0.a0 + - icu >=78.3,<79.0a0 + - libgcc >=15 + - libiconv >=1.18,<2.0a0 + - liblzma >=5.8.3,<6.0a0 + - libxml2-16 2.15.4 hf3af7cc_1 + - libzlib >=1.3.2,<2.0a0 + license: MIT + license_family: MIT + run_exports: + weak: + - libxml2 + - libxml2-16 >=2.15.4 + size: 46570 + timestamp: 1791465635923 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_3.conda + sha256: eb8a0db0aa570124f7d2a93d7c7f596e3390df5e047818d873baad32985fc736 + md5: 0de0122d9570a8ab637c6b73db268389 + depends: + - __glibc >=2.17,<3.0.a0 + constrains: + - zlib 1.3.2 *_3 + license: Zlib + license_family: Other + run_exports: + weak: + - libzlib >=1.3.2,<2.0a0 + size: 63713 + timestamp: 1785362952714 +- conda: https://conda.anaconda.org/conda-forge/linux-64/lychee-0.24.2-h39d0f39_1.conda + sha256: 59a5afe396a93269ddc4b67262412f0cb707d1294393944d461b2f29164ab5dc + md5: 81747139d7e9fba97af275d1c8f7fe0a + depends: + - libgcc >=15 + - __glibc >=2.17,<3.0.a0 + constrains: + - __glibc >=2.17 + license: Apache-2.0 OR MIT + run_exports: {} + size: 5760830 + timestamp: 1791278254472 +- conda: https://conda.anaconda.org/conda-forge/linux-64/markupsafe-3.0.4-py313h2af15c8_5.conda + sha256: def2a3d0cda3f815b569d5224ef65200555164136cdd3acba30c07321ecfeff6 + md5: eae8eb68bfde138aab698e02a6a19809 + depends: + - python + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - python_abi 3.13.* *_cp313 + constrains: + - jinja2 >=3.0.0 + license: BSD-3-Clause + run_exports: {} + size: 27791 + timestamp: 1794823807688 +- conda: https://conda.anaconda.org/conda-forge/linux-64/mpc-1.4.1-ha2cb11d_0.conda + sha256: ab81712f560a055277a23435b17c113e4aa8b2b15d31042dbc959e236cc5c528 + md5: 8ca4b2b9325e2d22aaf7639aaa5369a1 + depends: + - __glibc >=2.17,<3.0.a0 + - gmp >=6.3.0,<7.0a0 + - libgcc >=15 + - mpfr >=4.2.2,<5.0a0 + license: LGPL-3.0-or-later + run_exports: + weak: + - mpc >=1.4.1,<2.0a0 + size: 101262 + timestamp: 1794641220776 +- conda: https://conda.anaconda.org/conda-forge/linux-64/mpfr-4.2.2-ha2cb11d_1.conda + sha256: 0be79ef2ee536e0c5d3ddb4a52bbae9f26d08560623299f33db2f4c4a17c525a + md5: 7dcc10f6c0bc3596d5519a710a84dfd4 + depends: + - __glibc >=2.17,<3.0.a0 + - gmp >=6.3.0,<7.0a0 + - libgcc >=15 + license: LGPL-3.0-only + license_family: LGPL + run_exports: + weak: + - mpfr >=4.2.2,<5.0a0 + size: 730409 + timestamp: 1787236218159 +- conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.6-hdb14827_1.conda + sha256: 5d46557214ed184381dafe835b7c94a474a1c3b307a08a250b1ea4779b44ffb3 + md5: ee6c0cd80a60961a1f48aa3e0b91f986 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + license: X11 AND BSD-3-Clause + run_exports: + weak: + - ncurses >=6.6,<7.0a0 + size: 911196 + timestamp: 1786355078102 +- conda: https://conda.anaconda.org/conda-forge/linux-64/nettle-3.10.1-h5ef0d04_1.conda + sha256: 9f08df8a8d6660c4c5d8c810da2da2a5b099cd00ca30e1174be6d8df27a82120 + md5: 7b8f8d1226c95f61a51436a657c84770 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - gmp >=6.3.0,<7.0a0 + license: GPL-2.0-or-later OR LGPL-3.0-or-later + run_exports: + weak: + - nettle >=3.10.1,<3.11.0a0 + size: 1052171 + timestamp: 1787065085312 +- conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.6.5-h781a0a9_0.conda + sha256: 9c1533f1cf784f0e250919c0c9762d0b0e6bc727a79290ffb7cea1ceca1d038c + md5: 5a51a2ea653f120240b1a9bf76e0aae9 + depends: + - __glibc >=2.17,<3.0.a0 + - ca-certificates + - libgcc >=15 + license: Apache-2.0 + license_family: Apache + run_exports: + weak: + - openssl >=3.6.5,<4.0a0 + size: 3195299 + timestamp: 1791098052301 +- conda: https://conda.anaconda.org/conda-forge/linux-64/p11-kit-0.26.5-h8d769aa_2.conda + sha256: 16bcb050de08f5423b0e898dea9eb08a66ff93c1b347233137ffc17b2ec7e66c + md5: aeb4e6fe52e15c22f44f73476510c005 + depends: + - __glibc >=2.17,<3.0.a0 + - libffi >=3.7.0,<3.8.0a0 + - libgcc >=15 + - libtasn1 >=4.21.0,<5.0a0 + license: MIT + license_family: MIT + run_exports: + weak: + - p11-kit >=0.26.5,<0.27.0a0 + size: 3945183 + timestamp: 1788196153960 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pango-1.58.2-h2f58602_3.conda + sha256: 255c7311441dddee7858279b799156387a6719d3a114dce861cbf379f6fb9d6e + md5: 4a1bbf999cdcdcf3ca1bfd819259f795 + depends: + - libpango-devel ==1.58.2 h317d9d0_3 + license: LGPL-2.1-or-later + run_exports: + weak: + - libpango >=1.58.2,<2.0a0 + size: 15014 + timestamp: 1792050659391 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.49-h8b3dc9c_0.conda + sha256: 63784a2dd0231cf8944b31a781b4ebab48954a94cd455d13585874370e46b658 + md5: db724d35be3a1c7b6cd49b7a03de4027 + depends: + - __glibc >=2.17,<3.0.a0 + - bzip2 >=1.0.8,<2.0a0 + - libgcc >=15 + - libzlib >=1.3.2,<2.0a0 + license: BSD-3-Clause + license_family: BSD + run_exports: + weak: + - pcre2 >=10.49,<10.50.0a0 + size: 1234818 + timestamp: 1793902484896 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pixman-0.46.4-h54a6638_3.conda + sha256: 829d8288764282de5a9f7b9169acb75cc7dc0b6c3fe2535cfe87dea3436bbc5d + md5: 0ee5bb30034b081a1386c1e2c98ab0a7 + depends: + - libstdcxx >=14 + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + license: MIT + license_family: MIT + run_exports: + weak: + - pixman >=0.46.4,<1.0a0 + size: 376704 + timestamp: 1786106621354 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pthread-stubs-0.4-h7cc23a3_1004.conda + sha256: 4a44fd00ea73b79ca2c89b0727b9ccf61c506ead71e67a9abfa4c590042b5a4a + md5: bb66b610707b811e3c65181a6431e7a8 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + license: MIT + license_family: MIT + run_exports: {} + size: 9630 + timestamp: 1788381877753 +- conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.13.18-hf47f18c_100_cp313.conda + build_number: 100 + sha256: 8c20b663f2da07fee96f5406651854727a18d173e84735b71136cf06d7032b47 + md5: 8a8f008a3e3ae6e4eb6e149d639ab43e + depends: + - __glibc >=2.17,<3.0.a0 + - bzip2 >=1.0.8,<2.0a0 + - ld_impl_linux-64 >=2.36.1 + - libexpat >=2.8.5,<3.0a0 + - libffi >=3.7.0,<3.8.0a0 + - libgcc >=15 + - liblzma >=5.8.3,<6.0a0 + - libmpdec >=4.0.0,<5.0a0 + - libpython 3.13.18 hd51c5da_100_cp313 + - libsqlite >=3.54.1,<4.0a0 + - libuuid >=2.42.4,<3.0a0 + - libzlib >=1.3.2,<2.0a0 + - ncurses >=6.6,<7.0a0 + - openssl >=3.5.9,<4.0a0 + - python_abi 3.13.* *_cp313 + - readline >=8.3,<9.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + license: Python-2.0 + run_exports: + weak: + - python_abi 3.13.* *_cp313 + noarch: + - python + size: 24309726 + timestamp: 1793015646233 + python_site_packages_path: lib/python3.13/site-packages +- conda: https://conda.anaconda.org/conda-forge/linux-64/pyyaml-6.0.3-py313h45b8176_3.conda + sha256: 3e90c35deffbc80fe714ddfc28201589604f6b1144593a78d28929be899b1b60 + md5: b53b2182e0df385ce82e39a38a4a7b05 + depends: + - python + - yaml + - libgcc >=15 + - __glibc >=2.17,<3.0.a0 + - yaml >=0.2.5,<0.3.0a0 + - python_abi 3.13.* *_cp313 + license: MIT + license_family: MIT + run_exports: {} + size: 226628 + timestamp: 1793655133957 +- conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.3-hd6e31c0_1.conda + sha256: 01b3fe073a66e321970d09e04b388708f8cbdca5cdfbfcb7c9eeb470ad10383d + md5: 69c01c781e7c8190bbdaf79e3848c5ca + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - ncurses >=6.6,<7.0a0 + license: GPL-3.0-only + license_family: GPL + run_exports: + weak: + - readline >=8.3,<9.0a0 + size: 348899 + timestamp: 1787033801506 +- conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_h1df4ec4_4.conda + build_number: 104 + sha256: a1a241d172c1ccab067ba245206dd048bc3c2d1b84504b53c9468e99adfc16a1 + md5: 676a2f9b1c4fcf57b70aa5c65f6c60d0 + depends: + - libgcc >=15 + - __glibc >=2.17,<3.0.a0 + - libzlib >=1.3.2,<2.0a0 + constrains: + - xorg-libx11 >=1.8.13,<2.0a0 + license: TCL + run_exports: + weak: + - tk >=8.6.13,<8.7.0a0 + size: 3566806 + timestamp: 1787272857910 +- conda: https://conda.anaconda.org/conda-forge/linux-64/wayland-1.26.0-hc1c935e_2.conda + sha256: df65b987979e6d7f88e756494da5a230d4f2d08d17437d04eecd35559c3a04e4 + md5: 88a47e22b53e50865b1cabe2eb648352 + depends: + - __glibc >=2.17,<3.0.a0 + - libexpat >=2.8.1,<3.0a0 + - libffi >=3.7.0,<3.8.0a0 + - libgcc >=15 + - libstdcxx >=15 + license: MIT + license_family: MIT + run_exports: + weak: + - wayland >=1.26.0,<2.0a0 + size: 340058 + timestamp: 1787793849093 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xkeyboard-config-2.48-hebe6cf0_1.conda + sha256: 5d803109509756b39e018b780746ed4210cff640eb428fd58fa6c64c9c15ae6b + md5: 1d0383de55470a551d61ccdc225c0d88 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - xorg-libx11 >=1.8.14,<2.0a0 + license: MIT + license_family: MIT + run_exports: {} + size: 441638 + timestamp: 1792698743043 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libice-1.1.2-h280c20c_0.conda + sha256: 49b532d1df875c6749d9078b56a76f3f5db49a5abe0ca620b593ed474ef0ebf1 + md5: 85c9442aec283b4e464fa9ecc484a2f3 + depends: + - libgcc >=14 + - __glibc >=2.17,<3.0.a0 + license: MIT + license_family: MIT + run_exports: + weak: + - xorg-libice >=1.1.2,<2.0a0 + size: 62517 + timestamp: 1786474410404 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libsm-1.2.6-h0d788c3_1.conda + sha256: ef907caee0665cf3b0f775602cc50e388e3bade8ce22ecade0873ff26604b2fd + md5: aa7459ed9ad086ba11dda843d764b33d + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - xorg-libice >=1.1.2,<2.0a0 + - libuuid >=2.42.2,<3.0a0 + license: MIT + license_family: MIT + run_exports: + weak: + - xorg-libsm >=1.2.6,<2.0a0 + size: 30739 + timestamp: 1786545374265 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libx11-1.8.14-hb83e432_0.conda + sha256: 1815dc9900bf3a4678caeb343bccbbc74cd5e5a5ff3f6e0a2c01c5e19cd9d30b + md5: e7752792cb214013a34e265cc0838352 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - libxcb >=1.17.0,<2.0a0 + license: MIT + license_family: MIT + run_exports: + weak: + - xorg-libx11 >=1.8.14,<2.0a0 + size: 846774 + timestamp: 1792545407029 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxau-1.0.12-h7cc23a3_2.conda + sha256: 3ec065b94554dc48a4ca582a960a5484bc166b26e83ce0954653e08d17e8bd53 + md5: da33efee1a93603d92e06d4a2b68def6 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + license: MIT + license_family: MIT + run_exports: + weak: + - xorg-libxau >=1.0.12,<2.0a0 + size: 18793 + timestamp: 1788960512381 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxcomposite-0.4.7-hb03c661_0.conda + sha256: 048c103000af9541c919deef03ae7c5e9c570ffb4024b42ecb58dbde402e373a + md5: f2ba4192d38b6cef2bb2c25029071d90 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=14 + - xorg-libx11 >=1.8.12,<2.0a0 + - xorg-libxfixes >=6.0.2,<7.0a0 + license: MIT + license_family: MIT + run_exports: + weak: + - xorg-libxcomposite >=0.4.7,<1.0a0 + size: 14415 + timestamp: 1770044404696 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxcursor-1.2.3-h7cc23a3_1.conda + sha256: 5a819cd8d06656559349175be63bab398947e9755fe54692fab1bfab5385211a + md5: 6115d96e6728a7518358314701a27f75 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - xorg-libx11 >=1.8.14,<2.0a0 + - xorg-libxfixes >=6.0.2,<7.0a0 + - xorg-libxrender >=0.9.13,<0.10.0a0 + license: MIT + license_family: MIT + run_exports: + weak: + - xorg-libxcursor >=1.2.3,<2.0a0 + size: 34792 + timestamp: 1793235593597 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdamage-1.1.6-hb9d3cd8_0.conda + sha256: 43b9772fd6582bf401846642c4635c47a9b0e36ca08116b3ec3df36ab96e0ec0 + md5: b5fcc7172d22516e1f965490e65e33a4 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - xorg-libx11 >=1.8.10,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 + - xorg-libxfixes >=6.0.1,<7.0a0 + license: MIT + license_family: MIT + run_exports: + weak: + - xorg-libxdamage >=1.1.6,<2.0a0 + size: 13217 + timestamp: 1727891438799 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdmcp-1.1.5-h7cc23a3_2.conda + sha256: 8a095df9bc1d2e50f2504ce8858a047ae29ea634aad6cc0b43298c63361da6d9 + md5: eabfc45786244de252090cf8d55128a8 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + license: MIT + license_family: MIT + run_exports: + weak: + - xorg-libxdmcp >=1.1.5,<2.0a0 + size: 22606 + timestamp: 1789676943335 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxext-1.3.7-h7cc23a3_1.conda + sha256: aa9bbe8b278aacc194e280ff5037f9f9a1f2c5b33ed97de8e7f01cfbe90dda43 + md5: e5b6b28536b81b3f4cb20db4668a4642 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - xorg-libx11 >=1.8.13,<2.0a0 + license: MIT + license_family: MIT + run_exports: + weak: + - xorg-libxext >=1.3.7,<2.0a0 + size: 53124 + timestamp: 1787100841900 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxfixes-6.0.2-h7cc23a3_1.conda + sha256: aec84f554fc897bf4085c7bc8b8f0740e4c224e13bca3cc51c93e7699d56f83a + md5: 09132e874fe0e1f5e4492b0b6b904b6e + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - xorg-libx11 >=1.8.13,<2.0a0 + license: MIT + license_family: MIT + run_exports: + weak: + - xorg-libxfixes >=6.0.2,<7.0a0 + size: 21440 + timestamp: 1787248059682 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxi-1.8.4-h7cc23a3_0.conda + sha256: bb12543188be23b6e16e478d8b550d4e60bb52dc9c6f0667a5c865ceb3e7a881 + md5: 4ae02f09591c09bbe61a2b675d799ce5 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - xorg-libx11 >=1.8.13,<2.0a0 + - xorg-libxext >=1.3.7,<2.0a0 + - xorg-libxfixes >=6.0.2,<7.0a0 + license: MIT + license_family: MIT + run_exports: + weak: + - xorg-libxi >=1.8.4,<2.0a0 + size: 49659 + timestamp: 1792543111146 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxinerama-1.1.6-hd2095e1_1.conda + sha256: 4bd09fade2b2ca9f69cd6c5211f7fb172b81a43697aa1f009cab48eec5a233bf + md5: ff48e795cb92fc74087c7e818d4dcff1 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - libstdcxx >=15 + - xorg-libx11 >=1.8.14,<2.0a0 + - xorg-libxext >=1.3.7,<2.0a0 + license: MIT + license_family: MIT + run_exports: + weak: + - xorg-libxinerama >=1.1.6,<1.2.0a0 + size: 16227 + timestamp: 1794185243418 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrandr-1.5.5-h7cc23a3_1.conda + sha256: 05a7f25d7f7f5cd32b27a019233ece97167fd8ade255bc13a0e49e53387f4c30 + md5: 798a8c9d171859a022e1cb89e7d0eb10 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - xorg-libx11 >=1.8.13,<2.0a0 + - xorg-libxext >=1.3.7,<2.0a0 + - xorg-libxrender >=0.9.12,<0.10.0a0 + license: MIT + license_family: MIT + run_exports: + weak: + - xorg-libxrandr >=1.5.5,<2.0a0 + size: 31106 + timestamp: 1787246614086 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrender-0.9.13-h7cc23a3_0.conda + sha256: 008d610d6ec1d021ad678024afd5dcf534ff84d9c1e9d2877ff36d112c89896f + md5: 7249ce52789c3680e889e7335a2e1c3e + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - xorg-libx11 >=1.8.13,<2.0a0 + license: MIT + license_family: MIT + run_exports: + weak: + - xorg-libxrender >=0.9.13,<0.10.0a0 + size: 34604 + timestamp: 1792530399214 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxtst-1.2.6-h7cc23a3_0.conda + sha256: 9d8e7a2db860da3f362284650b447a96688b834bdb3122707b04bae512a1a178 + md5: 05e756ed9e8b2358591d47f6b8939db4 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - xorg-libx11 >=1.8.13,<2.0a0 + - xorg-libxext >=1.3.7,<2.0a0 + - xorg-libxi >=1.8.3,<2.0a0 + license: MIT + license_family: MIT + run_exports: + weak: + - xorg-libxtst >=1.2.6,<2.0a0 + size: 34918 + timestamp: 1792204941937 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxxf86vm-1.1.7-h7cc23a3_1.conda + sha256: 264ddaeba8de4fe17fb25d10c6f6c2aac5d8d41d8883a0976dae59b528ef9520 + md5: ac05771f924d124349ef9cc3140e9876 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + - xorg-libx11 >=1.8.14,<2.0a0 + - xorg-libxext >=1.3.7,<2.0a0 + license: MIT + license_family: MIT + run_exports: + weak: + - xorg-libxxf86vm >=1.1.7,<2.0a0 + size: 20109 + timestamp: 1794184632365 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-xorgproto-2025.1-hebe6cf0_3.conda + sha256: 8e9c7ca4fcfe9f0c300e4aa853b79c25411fc4e470decfe8f909b74f60dfb6dd + md5: c3d0a6f03ba3aa312777b41b20a71ec0 + depends: + - libgcc >=15 + - __glibc >=2.17,<3.0.a0 + license: MIT + license_family: MIT + run_exports: {} + size: 596340 + timestamp: 1788874111132 +- conda: https://conda.anaconda.org/conda-forge/linux-64/yaml-0.2.5-hebe6cf0_3.conda + sha256: d164dfa75ecd538f6fd68765defcc06aa875bc697b9b215362d79a2a73125dd0 + md5: e741576fb8f89821ac7c1c537322a33d + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=15 + license: MIT + license_family: MIT + run_exports: + weak: + - yaml >=0.2.5,<0.3.0a0 + size: 84936 + timestamp: 1787228426393 +- conda: https://conda.anaconda.org/conda-forge/linux-64/zig-0.17.1-89c0722_0.conda + sha256: 36fe7fd9960cca013e843798706fa21f93ebb9839527334c7b43bc77b0592193 + md5: 7ba9f63b0c91252ef787d6a574a11c15 + depends: + - zig_linux-64 ==0.17.1 fa519dd_0 + - libstdcxx >=15 + - libgcc >=15 + license: MIT AND Apache-2.0 WITH LLVM-exception AND Apache-2.0 AND LGPL-2.1-or-later AND BSD-2-Clause AND BSD-3-Clause AND ZPL-2.1 AND LicenseRef-Public-Domain + run_exports: + weak: + - zig >=0.17.1,<0.17.2.0a0 + size: 230408 + timestamp: 1794496954055 +- conda: https://conda.anaconda.org/conda-forge/linux-64/zig_impl_linux-64-0.17.1-0addc32_0.conda + sha256: a059082ebd358256c76914c0ecf061b23a79cf705be9f877f3f3e7bcbab13ab3 + md5: d6666c72896f39a252c28a5fd57d929e + depends: + - libstdcxx >=15 + - libgcc >=15 + - __glibc >=2.17,<3.0.a0 + - libclang-cpp22.1 >=22.1.8,<22.2.0a0 + - libllvm22 >=22.1.8,<22.2.0a0 + - libxml2 + - libzlib >=1.3.2,<2.0a0 + - zstd >=1.5.7,<1.6.0a0 + license: MIT AND Apache-2.0 WITH LLVM-exception AND Apache-2.0 AND LGPL-2.1-or-later AND BSD-2-Clause AND BSD-3-Clause AND ZPL-2.1 AND LicenseRef-Public-Domain + run_exports: {} + size: 77529577 + timestamp: 1794496954055 +- conda: https://conda.anaconda.org/conda-forge/linux-64/zig_linux-64-0.17.1-fa519dd_0.conda + sha256: 69801f7b6201bab75250a094b6af4ae6e5457f40e6bce6ef66f0788d43397b1e + md5: b3c1277859f37ea8acf2aec28dc29016 + depends: + - zig_impl_linux-64 ==0.17.1 0addc32_0 + - libstdcxx-devel_linux-64 15.* + - libgcc-devel_linux-64 15.* + - __glibc >=2.17,<3.0.a0 + license: MIT AND Apache-2.0 WITH LLVM-exception AND Apache-2.0 AND LGPL-2.1-or-later AND BSD-2-Clause AND BSD-3-Clause AND ZPL-2.1 AND LicenseRef-Public-Domain + run_exports: + strong: + - libstdcxx >=15 + - libgcc >=15 + size: 362660 + timestamp: 1794496954055 +- conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_7.conda + sha256: 47d682b9f6d6ec9eb1a6e6c3e75ea6273e899e78fb7fc59f81d39745009fbc60 + md5: aa459086047c0e5e27023ab19f8cb86a + depends: + - __glibc >=2.17,<3.0.a0 + - libzlib >=1.3.2,<2.0a0 + license: BSD-3-Clause + license_family: BSD + run_exports: + weak: + - zstd >=1.5.7,<1.6.0a0 + size: 601301 + timestamp: 1786599621503 +- conda: https://conda.anaconda.org/conda-forge/noarch/_python_abi3_support-1.0-hd8ed1ab_3.conda + sha256: 2a7204314663eeda5dec482a956f0e2eaf289bd5b9953eaaaad0e81aa64638f2 + md5: 3845f3d75991bae0fb90884662f4327c + depends: + - cpython + - python-gil + license: MIT + license_family: MIT + run_exports: {} + size: 8144 + timestamp: 1784221492234 +- conda: https://conda.anaconda.org/conda-forge/noarch/adwaita-icon-theme-51.0-unix_0.conda + sha256: def01b148aa54d4de29b7d4bf58d941c8699582201db14cf78c6c89fa1666434 + md5: 6f62266fb2bfc35a5071cfa1d6ffdcc9 + depends: + - __unix + - hicolor-icon-theme + - librsvg + license: LGPL-3.0-or-later OR CC-BY-SA-3.0 + run_exports: {} + size: 687517 + timestamp: 1790100765464 +- conda: https://conda.anaconda.org/conda-forge/noarch/alabaster-1.0.0-pyhd8ed1ab_1.conda + sha256: 6c4456a138919dae9edd3ac1a74b6fbe5fd66c05675f54df2f8ab8c8d0cc6cea + md5: 1fd9696649f65fd6611fcdb4ffec738a + depends: + - python >=3.10 + license: BSD-3-Clause + license_family: BSD + run_exports: {} + size: 18684 + timestamp: 1733750512696 +- conda: https://conda.anaconda.org/conda-forge/noarch/babel-2.18.0-pyhcf101f3_1.conda + sha256: a14a9ad02101aab25570543a59c5193043b73dc311a25650134ed9e6cb691770 + md5: f1976ce927373500cc19d3c0b2c85177 + depends: + - python >=3.10 + - python + constrains: + - pytz >=2015.7 + license: BSD-3-Clause + license_family: BSD + run_exports: {} + size: 7684321 + timestamp: 1772555330347 +- conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.10.23-hbd8a1cb_0.conda + sha256: 95619b9c1184be7175392eeb0ee7eeb5ccf25d280951f4225f2d62e725790be3 + md5: 3fd02989038a1e1cee627c14c2d73f29 + depends: + - __unix + license: ISC + run_exports: {} + size: 130057 + timestamp: 1792772446739 +- conda: https://conda.anaconda.org/conda-forge/noarch/certifi-2026.10.23-pyhd8ed1ab_3.conda + sha256: e17d21d2f133cae8eede0eef5a8acfa076b1999d00f11e714e1d18c2c8fd02c6 + md5: 6e761a5c8fd92be3a9fec46ade31b481 + depends: + - ca-certificates >=2026.10.23 + - python >=3.10 + license: ISC + run_exports: {} + size: 13539 + timestamp: 1793720135524 +- conda: https://conda.anaconda.org/conda-forge/noarch/charset-normalizer-3.5.1-pyhd8ed1ab_0.conda + sha256: cb60ef3e0631c8bacb4f7057196dee4496091a22baa3bb4b9bccb12c7e1c921b + md5: e0ac3accc64e23e40969d660e5f58ac8 + depends: + - python >=3.10 + license: MIT + license_family: MIT + run_exports: {} + size: 64487 + timestamp: 1786835648298 +- conda: https://conda.anaconda.org/conda-forge/noarch/colorama-0.4.6-pyhd8ed1ab_1.conda + sha256: ab29d57dc70786c1269633ba3dff20288b81664d3ff8d21af995742e2bb03287 + md5: 962b9857ee8e7018c22f2776ffa0b2d7 + depends: + - python >=3.9 + license: BSD-3-Clause + license_family: BSD + run_exports: {} + size: 27011 + timestamp: 1733218222191 +- conda: https://conda.anaconda.org/conda-forge/noarch/cpython-3.13.18-py313hd8ed1ab_100.conda + noarch: generic + sha256: 283ec2ea28bb5f6de4bb74abebca67b984d95879eef436a13b5635396328e082 + md5: 7ffd95656f21420f6c2d0655e3735656 + depends: + - python >=3.13,<3.14.0a0 + - python_abi * *_cp313 + license: Python-2.0 + run_exports: {} + size: 50090 + timestamp: 1793014423191 +- conda: https://conda.anaconda.org/conda-forge/noarch/docutils-0.22.4-pyhd8ed1ab_0.conda + sha256: 0d605569a77350fb681f9ed8d357cc71649b59a304099dc9d09fbeec5e84a65e + md5: d6bd3cd217e62bbd7efe67ff224cd667 + depends: + - python >=3.10 + license: CC-PDDC AND BSD-3-Clause AND BSD-2-Clause AND ZPL-2.1 + run_exports: {} + size: 438002 + timestamp: 1766092633160 +- conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 + sha256: 58d7f40d2940dd0a8aa28651239adbf5613254df0f75789919c4e6762054403b + md5: 0c96522c6bdaed4b1566d11387caaf45 + license: BSD-3-Clause + license_family: BSD + run_exports: {} + size: 397370 + timestamp: 1566932522327 +- conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 + sha256: c52a29fdac682c20d252facc50f01e7c2e7ceac52aa9817aaf0bb83f7559ec5c + md5: 34893075a5c9e55cdafac56607368fc6 + license: OFL-1.1 + license_family: Other + run_exports: {} + size: 96530 + timestamp: 1620479909603 +- conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-source-code-pro-2.038-h77eed37_0.tar.bz2 + sha256: 00925c8c055a2275614b4d983e1df637245e19058d79fc7dd1a93b8d9fb4b139 + md5: 4d59c254e01d9cde7957100457e2d5fb + license: OFL-1.1 + license_family: Other + run_exports: {} + size: 700814 + timestamp: 1620479612257 +- conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_4.conda + sha256: a7384ac883b1acf492fd1aef27431f0f1a647bbb8b5709a1bfab11b0a765f5e5 + md5: 1df978a6efeb98fa80b96f2860b9b280 + license: Ubuntu-font-1.0 + license_family: Other + run_exports: {} + size: 1619009 + timestamp: 1794346192807 +- conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-ecosystem-1-0.tar.bz2 + sha256: a997f2f1921bb9c9d76e6fa2f6b408b7fa549edd349a77639c9fe7a23ea93e61 + md5: fee5683a3f04bd15cbd8318b096a27ab + depends: + - fonts-conda-forge + license: BSD-3-Clause + license_family: BSD + run_exports: {} + size: 3667 + timestamp: 1566974674465 +- conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-forge-1-hc364b38_1.conda + sha256: 54eea8469786bc2291cc40bca5f46438d3e062a399e8f53f013b6a9f50e98333 + md5: a7970cd949a077b7cb9696379d338681 + depends: + - font-ttf-ubuntu + - font-ttf-inconsolata + - font-ttf-dejavu-sans-mono + - font-ttf-source-code-pro + license: BSD-3-Clause + license_family: BSD + run_exports: {} + size: 4059 + timestamp: 1762351264405 +- conda: https://conda.anaconda.org/conda-forge/noarch/idna-3.20-pyh5ded981_0.conda + sha256: e044b1ec829e2e24f971fa3f3408eb26f1db836e521a58f08b0fd9a03fee47be + md5: ee73be987f9de9ea5c2fdaeefa7b6491 + depends: + - python >=3.11 + - python + license: BSD-3-Clause + license_family: BSD + run_exports: {} + size: 178572 + timestamp: 1790020377150 +- conda: https://conda.anaconda.org/conda-forge/noarch/imagesize-2.0.1-pyhd8ed1ab_0.conda + sha256: 4e787f9ccc31053ccea56d98ecd284a4f788988a3f9c4627db72fdd0b127529b + md5: ebc56022e4ef7e74a829be94c53797ca + depends: + - python >=3.10 + license: MIT + license_family: MIT + run_exports: {} + size: 21467 + timestamp: 1787649248672 +- conda: https://conda.anaconda.org/conda-forge/noarch/jinja2-3.1.6-pyhcf101f3_1.conda + sha256: fc9ca7348a4f25fed2079f2153ecdcf5f9cf2a0bc36c4172420ca09e1849df7b + md5: 04558c96691bed63104678757beb4f8d + depends: + - markupsafe >=2.0 + - python >=3.10 + - python + license: BSD-3-Clause + license_family: BSD + run_exports: {} + size: 120685 + timestamp: 1764517220861 +- conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-4.18.0-he073ed8_9.conda + sha256: 41557eeadf641de6aeae49486cef30d02a6912d8da98585d687894afd65b356a + md5: 86d9cba083cd041bfbf242a01a7a1999 + constrains: + - sysroot_linux-64 ==2.28 + license: LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later + license_family: GPL + run_exports: {} + size: 1278712 + timestamp: 1765578681495 +- conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-15.3.0-h2b852eb_107.conda + sha256: 5200a1402eb3c3e9b0e4ba38b3cf163be136d020a15477fb86ce6e754d3ae515 + md5: 057ab488a4da13485caa3b672df9824a + depends: + - __unix + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + run_exports: {} + size: 3085843 + timestamp: 1790302578256 +- conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-15.3.0-hb2c5482_107.conda + sha256: 4b2d94a9abf2feedea354e4256756c5dc255b84080e7faed9a324a101cf20e74 + md5: edce245dade1c29f691983796b4b8414 + depends: + - __unix + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + run_exports: {} + size: 20673146 + timestamp: 1790302599776 +- conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.3.0-pyhd8ed1ab_0.conda + sha256: 4ccea503ad204bba76b8911fce9245488456bf31249fc6e3d95c072602dc1143 + md5: 975dce37a9e7d56c4f56981666578b07 + depends: + - mdurl >=0.1,<1 + - python >=3.10 + license: MIT + license_family: MIT + run_exports: {} + size: 74305 + timestamp: 1794422554733 +- conda: https://conda.anaconda.org/conda-forge/noarch/mdit-py-plugins-0.7.0-pyhd8ed1ab_0.conda + sha256: 9757a597362961195f6bf0cb93b77ed41814f8461fb99e5728a676193d676b1a + md5: b3f1ff606285e87cb76017e004d3b463 + depends: + - markdown-it-py >=3.0.0,<5.0.0 + - python >=3.10 + license: MIT + license_family: MIT + run_exports: {} + size: 56027 + timestamp: 1794422336457 +- conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda + sha256: 78c1bbe1723449c52b7a9df1af2ee5f005209f67e40b6e1d3c7619127c43b1c7 + md5: 592132998493b3ff25fd7479396e8351 + depends: + - python >=3.9 + license: MIT + license_family: MIT + run_exports: {} + size: 14465 + timestamp: 1733255681319 +- conda: https://conda.anaconda.org/conda-forge/noarch/myst-parser-5.2.0-pyhd8ed1ab_0.conda + sha256: a1d937b0705e31496ed97866b7f714b3926b76b4ca111475a68675cc4bde2020 + md5: ec615efa256902ded31b2dd69d011d1b + depends: + - docutils >=0.20,<0.24 + - jinja2 + - markdown-it-py >=4.2.0,<5 + - mdit-py-plugins >=0.7.0,<1 + - python >=3.11 + - pyyaml + - sphinx >=8,<10 + license: MIT + license_family: MIT + run_exports: {} + size: 90015 + timestamp: 1794425517871 +- conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.3-pyhc364b38_0.conda + sha256: c432626b16768b8dab228bfb706f7060c2d462a21c516d240f68f2f902b5a044 + md5: 936687ed80f295a1f5dbcf8bd34c252c + depends: + - python >=3.9 + - python + license: Apache-2.0 + license_family: APACHE + run_exports: {} + size: 116363 + timestamp: 1785888127370 +- conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.21.0-pyhcf101f3_0.conda + sha256: f5f015ff1bc3e1b7fc08eee096b1865234189ae0b82bebdb86a5369116e42fa0 + md5: 2882dee445dfa45b0c5afce3ffb7730a + depends: + - python >=3.10 + - python + license: BSD-2-Clause + license_family: BSD + run_exports: {} + size: 959376 + timestamp: 1786995678795 +- conda: https://conda.anaconda.org/conda-forge/noarch/pygments-styles-0.3.0-pyhd8ed1ab_0.conda + sha256: 451e28671386bc66ecd6fdd999aa8a62502596760cb77e4226ad298edef0a76a + md5: 7bcc971fbb4ef305d6953ce95c6179b7 + depends: + - pygments + - python >=3.10 + license: BSD-3-Clause + license_family: BSD + run_exports: {} + size: 21902 + timestamp: 1762266264143 +- conda: https://conda.anaconda.org/conda-forge/noarch/python-gil-3.13.18-h4df99d1_100.conda + sha256: 5fcdc5f22a5d6354230e3757347165f4ddcdcc04fd523b361b59a0d679cd6c91 + md5: 9c939d47ea820fdf3cdbc9582188bb70 + depends: + - cpython 3.13.18.* + - python_abi * *_cp313 + license: Python-2.0 + run_exports: {} + size: 50086 + timestamp: 1793014429956 +- conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.13-9_cp313.conda + build_number: 9 + sha256: 9dc0cb6a20ebc7e9bcd8c6868f2bec083c114b0ba20b7118405c036533d5c522 + md5: c5abc97af551bc12d71305852392f75c + constrains: + - python 3.13.* *_cp313 + license: BSD-3-Clause + license_family: BSD + run_exports: {} + size: 6769 + timestamp: 1788302828005 +- conda: https://conda.anaconda.org/conda-forge/noarch/requests-2.34.2-pyhcf101f3_0.conda + sha256: 1715246b19c9f85ee022933b4845f2fc14ac9184981b7b7d9b728bec8e9588da + md5: 4a85203c1d80c1059086ae860836ffb9 + depends: + - python >=3.10 + - certifi >=2023.5.7 + - charset-normalizer >=2,<4 + - idna >=2.5,<4 + - urllib3 >=1.26,<3 + - python + constrains: + - chardet >=3.0.2,<8 + license: Apache-2.0 + license_family: APACHE + run_exports: {} + size: 68709 + timestamp: 1778851103479 +- conda: https://conda.anaconda.org/conda-forge/noarch/roman-numerals-4.1.0-pyhd8ed1ab_0.conda + sha256: 30f3c04fcfb64c44d821d392a4a0b8915650dbd900c8befc20ade8fde8ec6aa2 + md5: 0dc48b4b570931adc8641e55c6c17fe4 + depends: + - python >=3.10 + license: 0BSD OR CC0-1.0 + run_exports: {} + size: 13814 + timestamp: 1766003022813 +- conda: https://conda.anaconda.org/conda-forge/noarch/shibuya-2026.7.12-pyhd8ed1ab_0.conda + sha256: acbbe4fff1f88e9988fc934311845b72ffca5e0f074cd7a9f31c045cb32781d4 + md5: d9011d5b8d6cb55b2bad3d76aa6fa710 + depends: + - pygments-styles + - python >=3.10 + - sphinx + license: BSD-3-Clause + license_family: BSD + run_exports: {} + size: 87339 + timestamp: 1783799362860 +- conda: https://conda.anaconda.org/conda-forge/noarch/snowballstemmer-3.1.1-pyhd8ed1ab_0.conda + sha256: ad89284ea94821c20ff87e64b948e4afc690cf5202d14c009355b0594cf23aea + md5: 46b6abe31482f6bca064b965696ae807 + depends: + - python >=3.10 + license: BSD-3-Clause + license_family: BSD + run_exports: {} + size: 74456 + timestamp: 1780468201547 +- conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-9.2.0-pyhc364b38_0.conda + sha256: 43c6100fbd2980786c0d3dd3cc76906200597a5d6d83995cc0b8e5afbce00c71 + md5: c1dbc9be69a349a057de3ab17160c887 + depends: + - python >=3.13 + - alabaster >=0.7.14 + - babel >=2.13 + - docutils >=0.21,<0.23 + - imagesize >=1.3 + - jinja2 >=3.1 + - packaging >=23.0 + - pygments >=2.17 + - requests >=2.30.0 + - roman-numerals >=1.0.0 + - snowballstemmer >=2.2 + - sphinxcontrib-applehelp >=1.0.7 + - sphinxcontrib-devhelp >=1.0.6 + - sphinxcontrib-htmlhelp >=2.0.6 + - sphinxcontrib-jsmath >=1.0.1 + - sphinxcontrib-qthelp >=1.0.6 + - sphinxcontrib-serializinghtml >=1.1.9 + - colorama >=0.4.6 + - python + license: BSD-2-Clause + license_family: BSD + run_exports: {} + size: 1588783 + timestamp: 1792587728747 +- conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-autoapi-3.9.0-pyh5ded981_0.conda + sha256: 093453d2c50bf7de814f65e62c5568d7d0d1118473eebb7d2ea0e0d095ac4b94 + md5: cdd46294d340a6847af94f2790518752 + depends: + - python >=3.11 + - astroid >=3.0 + - jinja2 + - pyyaml + - sphinx >=7.4.0 + - python + license: MIT + license_family: MIT + run_exports: {} + size: 37103 + timestamp: 1793487424258 +- conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-copybutton-0.5.2-pyhd8ed1ab_1.conda + sha256: 8cd892e49cb4d00501bc4439fb0c73ca44905f01a65b2b7fa05ba0e8f3924f19 + md5: bf22cb9c439572760316ce0748af3713 + depends: + - python >=3.9 + - sphinx >=1.8 + license: MIT + license_family: MIT + run_exports: {} + size: 17893 + timestamp: 1734573117732 +- conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-design-0.8.0-pyhd8ed1ab_0.conda + sha256: 80ad3e0f137df6a7f6380de78c71e911d551f69ffa856043aa53cce289c13f0f + md5: 6a9ef411fc8221580ee1bbd023edee81 + depends: + - python >=3.11 + - sphinx >=7.2,<10 + license: MIT + license_family: MIT + run_exports: {} + size: 1054687 + timestamp: 1794431986619 +- conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-last-updated-by-git-0.3.8-pyhe01879c_0.conda + sha256: f761670b793dcc10a4a2d855de163d9dfd4016636ef093fb3e3d83ac25ed6e97 + md5: 405a232fb900fc631d2f1b5cdf01dea9 + depends: + - python >=3.9 + - sphinx >=1.8 + - python + license: BSD-2-Clause + license_family: BSD + run_exports: {} + size: 17546 + timestamp: 1750694360605 +- conda: https://conda.anaconda.org/conda-forge/noarch/sphinx-sitemap-2.9.0-pyhcf101f3_0.conda + sha256: 1be6289124207256df5dfbfe6ff0a652e313ac5c3e50560c9e510afa76eb702b + md5: 3baeff262222dc87e978a68702bc5797 + depends: + - python >=3.10 + - sphinx-last-updated-by-git + - python + license: MIT + license_family: MIT + run_exports: {} + size: 13441 + timestamp: 1759753011102 +- conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-applehelp-2.0.0-pyhd8ed1ab_1.conda + sha256: d7433a344a9ad32a680b881c81b0034bc61618d12c39dd6e3309abeffa9577ba + md5: 16e3f039c0aa6446513e94ab18a8784b + depends: + - python >=3.9 + - sphinx >=5 + license: BSD-2-Clause + license_family: BSD + run_exports: {} + size: 29752 + timestamp: 1733754216334 +- conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-devhelp-2.0.0-pyhd8ed1ab_1.conda + sha256: 55d5076005d20b84b20bee7844e686b7e60eb9f683af04492e598a622b12d53d + md5: 910f28a05c178feba832f842155cbfff + depends: + - python >=3.9 + - sphinx >=5 + license: BSD-2-Clause + license_family: BSD + run_exports: {} + size: 24536 + timestamp: 1733754232002 +- conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-htmlhelp-2.1.0-pyhd8ed1ab_1.conda + sha256: c1492c0262ccf16694bdcd3bb62aa4627878ea8782d5cd3876614ffeb62b3996 + md5: e9fb3fe8a5b758b4aff187d434f94f03 + depends: + - python >=3.9 + - sphinx >=5 + license: BSD-2-Clause + license_family: BSD + run_exports: {} + size: 32895 + timestamp: 1733754385092 +- conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-jsmath-2.0.0-pyh5ded981_0.conda + sha256: 59cedf5b1c202005f3af3c276e3fb1c7806bb7dbff476f8f8d46abcade227aed + md5: 7e9e28f90ddccdafa9e16a0541841bc4 + depends: + - python >=3.11 + - python + license: BSD-2-Clause + license_family: BSD + run_exports: {} + size: 25630 + timestamp: 1792589772735 +- conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-qthelp-2.0.0-pyhd8ed1ab_1.conda + sha256: c664fefae4acdb5fae973bdde25836faf451f41d04342b64a358f9a7753c92ca + md5: 00534ebcc0375929b45c3039b5ba7636 + depends: + - python >=3.9 + - sphinx >=5 + license: BSD-2-Clause + license_family: BSD + run_exports: {} + size: 26959 + timestamp: 1733753505008 +- conda: https://conda.anaconda.org/conda-forge/noarch/sphinxcontrib-serializinghtml-2.0.0-pyhd8ed1ab_0.conda + sha256: 20b49741065fd7d3fabf98caf6d19b6436badb06b6d41f66b58f1fc2b52f37a1 + md5: f77df1fcf9af03b7287342638befca77 + depends: + - python >=3.10 + - sphinx >=5 + license: BSD-2-Clause + license_family: BSD + run_exports: {} + size: 30640 + timestamp: 1781260357443 +- conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.28-h4ee821c_9.conda + sha256: c47299fe37aebb0fcf674b3be588e67e4afb86225be4b0d452c7eb75c086b851 + md5: 13dc3adbc692664cd3beabd216434749 + depends: + - __glibc >=2.28 + - kernel-headers_linux-64 4.18.0 he073ed8_9 + - tzdata + license: LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later + license_family: GPL + run_exports: + strong: + - __glibc >=2.28,<3.0.a0 + size: 24008591 + timestamp: 1765578833462 +- conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2026e-h5d301ff_0.conda + sha256: 2b7ca858879f183ce2dcc65b300f48a0133d5430550f35b23d80d405a0788dbf + md5: abccc3810d2b97e570dee487f2b46e38 + license: LicenseRef-Public-Domain + run_exports: {} + size: 119208 + timestamp: 1792758382821 +- conda: https://conda.anaconda.org/conda-forge/noarch/urllib3-2.8.0-pyh5ded981_1.conda + sha256: f892d267de12e031d887b90ea44718358f3558c052dfbac45b10b6cd4cee6705 + md5: 8ce0b6bfc873bf2c25b083dd5ee29489 + depends: + - python >=3.11 + - python + license: MIT + license_family: MIT + run_exports: {} + size: 113282 + timestamp: 1794575230703 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/astroid-4.3.4-py313h6ee819a_0.conda + sha256: 2fbc671a15170292020d2d12d2a9c0f98479639c4e34a82a1c7fbc19a8b22166 + md5: df0851b9d0c7dfda3acf6a1acc8396e8 + depends: + - python + - python_abi 3.13.* *_cp313 + license: LGPL-2.1-only + run_exports: {} + size: 576673 + timestamp: 1791464588433 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/bzip2-1.0.8-h4e30115_10.conda + sha256: 8ec22f0ba25cbfc2e64d70cf29459eccd7ffdf6436f6a6ff15bbfef799f7d4f6 + md5: b50612e7d190b8061ab4e7dc119cf4d5 + depends: + - __osx >=11.0 + license: bzip2-1.0.6 + license_family: BSD + run_exports: + weak: + - bzip2 >=1.0.8,<2.0a0 + size: 124965 + timestamp: 1785906749812 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/c-ares-1.34.9-h74c22ad_0.conda + sha256: 74b52d784b3576643da3aea1240a4120c1f25ee057f14ae5a89e8a7b3fb2e69f + md5: 84dac5da92970cdde9789fcbfe63cb3a + depends: + - __osx >=11.0 + license: MIT + license_family: MIT + run_exports: + weak: + - c-ares >=1.34.9,<2.0a0 + size: 201979 + timestamp: 1792507050139 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/cairo-1.18.6-h580cee5_0.conda + sha256: 32ad9b731d0b4c6dd82061201206164b07bd695bc695e5eb3addc0087ed54cca + md5: 0d25672f63cd1c9b08653a0becfbf31a + depends: + - __osx >=11.0 + - fontconfig >=2.18.3,<3.0a0 + - fonts-conda-ecosystem + - icu >=78.3,<79.0a0 + - libcxx >=21 + - libexpat >=2.8.1,<3.0a0 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libglib >=2.90.0,<3.0a0 + - libpng >=1.6.58,<1.7.0a0 + - libzlib >=1.3.2,<2.0a0 + - pixman >=0.46.4,<1.0a0 + license: LGPL-2.1-only or MPL-1.1 + run_exports: + weak: + - cairo >=1.18.6,<2.0a0 + size: 844614 + timestamp: 1790045326889 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/curl-8.23.0-h6651222_0.conda + sha256: c9628a012fba18552ef02a8a2b46db48153d10b9209c57bdec0a33afcdc508a5 + md5: de96eb952f8c91d2b5161eb55f9a24f0 + depends: + - __osx >=11.0 + - krb5 >=1.22.2,<1.23.0a0 + - libcurl 8.23.0 h6651222_0 + - libpsl >=0.23.1,<0.24.0a0 + - libssh2 >=1.11.1,<2.0a0 + - libzlib >=1.3.2,<2.0a0 + - openssl >=3.5.9,<4.0a0 + - zstd >=1.5.7,<1.6.0a0 + license: curl + license_family: MIT + run_exports: {} + size: 183387 + timestamp: 1792014031633 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/dbus-1.16.2-hf049998_2.conda + sha256: 60e265d5ac83198f1d13a43ab5cd2de097b10b460a5ad0764ed62af875b4ecdc + md5: a199888312b83a5c5e2d2880919eb1f2 + depends: + - __osx >=11.0 + - libcxx >=21 + - libglib >=2.88.3,<3.0a0 + - libexpat >=2.8.1,<3.0a0 + - libzlib >=1.3.2,<2.0a0 + license: AFL-2.1 OR GPL-2.0-or-later + run_exports: + weak: + - dbus >=1.16.2,<2.0a0 + size: 398252 + timestamp: 1788197996006 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/emacs-30.2-ha2f6bed_6.conda + sha256: 4b31cfee001921ffa2342d85c6e19f45b9c4de984a1ff35c892c7ad0cd08c723 + md5: 5615ed71fb7ccbfe82475d322d6213b8 + depends: + - dbus + - __osx >=11.0 + - gnutls >=3.8.11,<3.9.0a0 + - libtree-sitter >=0.25.9,<0.26.0a0 + - libsqlite >=3.53.4,<4.0a0 + - libwebp-base >=1.6.0,<2.0a0 + - libjpeg-turbo >=3.2.0,<4.0a0 + - gmp >=6.3.0,<7.0a0 + - ncurses >=6.6,<7.0a0 + - librsvg >=2.62.3,<3.0a0 + - libzlib >=1.3.2,<2.0a0 + - libxml2 + - libxml2-16 >=2.14.6 + - libpng >=1.6.58,<1.7.0a0 + - libtiff >=4.7.2,<4.8.0a0 + - gdk-pixbuf >=2.44.8,<3.0a0 + - dbus >=1.16.2,<2.0a0 + - giflib >=6.1.3,<6.2.0a0 + - libglib >=2.88.3,<3.0a0 + - libexpat >=2.8.1,<3.0a0 + license: GPL-3.0-only + license_family: GPL + run_exports: {} + size: 53125036 + timestamp: 1786884731551 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/fontconfig-2.18.3-h81aa574_1.conda + sha256: 004570d35fb0eff73ce3ae49b209a47622d0c2e580dd0dc4c61d59626b386a09 + md5: 8ac8cc3fe744b484de4387703134d8b2 + depends: + - __osx >=11.0 + - libexpat >=2.8.1,<3.0a0 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libintl >=0.25.1,<1.0a0 + - libzlib >=1.3.2,<2.0a0 + license: MIT + license_family: MIT + run_exports: + weak: + - fontconfig >=2.18.3,<3.0a0 + - fonts-conda-ecosystem + size: 265659 + timestamp: 1786667932256 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/freetype-2.14.3-hce30654_2.conda + sha256: 90681f1d0658cb2fd49a074f644eb4774272499290487a4bebb1c4df01d6997b + md5: 2f4cc7dc2e6622591735c49dda1b92aa + depends: + - libfreetype 2.14.3 hce30654_2 + - libfreetype6 2.14.3 h2ed5691_2 + license: GPL-2.0-only OR FTL + run_exports: + weak: + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + size: 175388 + timestamp: 1786641016583 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/fribidi-1.0.18-hb001647_0.conda + sha256: 0eb7cf0378cfd45c4729e2eedd896bc1fab01872d1ed204d6ea8bbf853a0138d + md5: 08fef45968356b6a9093c19f05d2364e + depends: + - __osx >=11.0 + license: LGPL-2.1-or-later + run_exports: + weak: + - fribidi >=1.0.18,<2.0a0 + size: 64404 + timestamp: 1793323489033 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/gdk-pixbuf-2.44.8-h5867e2c_2.conda + sha256: 96dcac22eaea2f24b9c92e8be078c3e39058829aa4db2a8103c1a4e85f8925ed + md5: 3a84786e0c929f4a05d08c07be5ec9b3 + depends: + - __osx >=11.0 + - libglib >=2.88.3,<3.0a0 + - libintl >=0.25.1,<1.0a0 + - libjpeg-turbo >=3.2.0,<4.0a0 + - liblzma >=5.8.3,<6.0a0 + - libpng >=1.6.58,<1.7.0a0 + - libtiff >=4.7.2,<4.8.0a0 + license: LGPL-2.1-or-later + license_family: LGPL + run_exports: + weak: + - gdk-pixbuf >=2.44.8,<3.0a0 + size: 552802 + timestamp: 1788490405006 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/giflib-6.1.3-h74c22ad_2.conda + sha256: 36a1605ea258ea805fd5a0f23f07ce3febcf4ac041d1ea99d0b31902b79f4358 + md5: edc562dcbe5872664817e64575aa325f + depends: + - __osx >=11.0 + license: MIT + license_family: MIT + run_exports: + weak: + - giflib >=6.1.3,<6.2.0a0 + size: 82055 + timestamp: 1788948759889 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/gmp-6.3.0-hf5e55b1_3.conda + sha256: 980cb1bbc3656d6f923d44297a2c4ab75f20482b8930c70537fd7f1ef2378894 + md5: bbfa5bd261b68536ddcda39e03d3407f + depends: + - libcxx >=19 + - __osx >=11.0 + license: GPL-2.0-or-later OR LGPL-3.0-or-later + run_exports: + weak: + - gmp >=6.3.0,<7.0a0 + size: 399307 + timestamp: 1786629210135 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/gnutls-3.8.13-hfe86254_0.conda + sha256: d36222db9e35788af78b6f41f66dc702d20b18375a9059c81ee074ea4c63d72a + md5: 9fafe1b7ed7d1264dc032e55227e2529 + depends: + - __osx >=11.0 + - gmp >=6.3.0,<7.0a0 + - libasprintf >=0.25.1,<1.0a0 + - libcxx >=19 + - libgettextpo >=0.25.1,<1.0a0 + - libidn2 >=2,<3.0a0 + - libintl >=0.25.1,<1.0a0 + - libtasn1 >=4.21.0,<5.0a0 + - nettle >=3.10.1,<3.11.0a0 + - p11-kit >=0.26.2,<0.27.0a0 + license: LGPL-2.1-or-later + license_family: LGPL + run_exports: + weak: + - gnutls >=3.8.13,<3.9.0a0 + size: 1906035 + timestamp: 1778045117683 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/graphite2-1.3.15-h784d473_1.conda + sha256: 471f34a187fdb4f2df33e26f2e471b16c239a5b277903f643d9c3a8c9a9f44ec + md5: 0c7b78d9ffff4f5a6ca28d346f734d8f + depends: + - libcxx >=19 + - __osx >=11.0 + license: LGPL-2.0-or-later + license_family: LGPL + run_exports: + weak: + - graphite2 >=1.3.15,<2.0a0 + size: 86493 + timestamp: 1786118637573 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/icu-78.3-py310h579977c_2.conda + sha256: 6cdb5dee54c72e56ab189fb3ad33cb28533553d42590e7e831160248f4416a43 + md5: a5efc0b42bb8b42e97d0a29ae3e3c187 + depends: + - __osx >=11.0 + license: MIT + license_family: MIT + run_exports: + weak: + - icu >=78.3,<79.0a0 + size: 14070242 + timestamp: 1786545847761 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/krb5-1.22.2-h34f8a20_2.conda + sha256: aaea1d42b07769920db2af7471ece9399d2613448863da64ad8272998db5db34 + md5: 15235dd10450d67bc25ccafd5b46d2bc + depends: + - __osx >=11.0 + - libcxx >=21 + - libedit >=3.1.20250104,<3.2.0a0 + - libedit >=3.1.20250104,<4.0a0 + - openssl >=3.5.7,<4.0a0 + license: MIT + license_family: MIT + run_exports: + weak: + - krb5 >=1.22.2,<1.23.0a0 + size: 1165740 + timestamp: 1786762145768 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/lerc-4.3.0-h0699d0c_0.conda + sha256: 93b1189cf3e47b93fe613dc08213cf22b892650097e8df77519e50f9301e9f62 + md5: b0a537a2f2650404b5fe49f46db50c9d + depends: + - __osx >=11.0 + - libcxx >=21 + license: Apache-2.0 + license_family: Apache + run_exports: + weak: + - lerc >=4.3.0,<5.0a0 + size: 188293 + timestamp: 1793411290334 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libasprintf-0.25.1-hae62183_2.conda + sha256: af6e0e598ace7cdac145daec66c39916016ebcd4d960246b5e90c4247e47be52 + md5: fa3b4ff4b5cbde3a77824949f5d0b1ef + depends: + - __osx >=11.0 + - libcxx >=21 + license: LGPL-2.1-or-later + run_exports: + weak: + - libasprintf >=0.25.1,<1.0a0 + size: 52487 + timestamp: 1790118662123 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libclang-cpp22.1-22.1.8-default_h79071a4_11.conda + sha256: f5e3e35d9a855636a09cd872ea16e195bdd32171ecee295a417f1b7ac2c50a6b + md5: 1eae4048550ca47885ed2bdf6b139aa4 + depends: + - libcxx >=22.1.8 + - __osx >=11.0 + - libzlib >=1.3.2,<2.0a0 + - zstd >=1.5.7,<1.6.0a0 + - libxml2 + - libxml2-16 >=2.15.4 + - libllvm22 >=22.1.8,<22.2.0a0 + license: Apache-2.0 WITH LLVM-exception + license_family: APACHE + run_exports: + weak: + - libclang-cpp22.1 >=22.1.8,<22.2.0a0 + size: 15941660 + timestamp: 1791933888154 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcurl-8.23.0-h6651222_0.conda + sha256: d9f60525b665e50da15c84fcb4e74e6b1f0a56ea4c89a02d4258f23c3fe1f02c + md5: b955db4c41b9820eba0aa2c9a3c74a37 + depends: + - __osx >=11.0 + - krb5 >=1.22.2,<1.23.0a0 + - libnghttp2 >=1.68.1,<2.0a0 + - libpsl >=0.23.1,<0.24.0a0 + - libssh2 >=1.11.1,<2.0a0 + - libzlib >=1.3.2,<2.0a0 + - openssl >=3.5.9,<4.0a0 + - zstd >=1.5.7,<1.6.0a0 + license: curl + license_family: MIT + run_exports: + weak: + - libcurl >=8.23.0,<9.0a0 + size: 425637 + timestamp: 1792014025908 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libcxx-22.1.8-h55c6f16_0.conda + sha256: a2e7abab5add9750fab064c024394de48e49f97631c605ad5db5c8ac3fc769ef + md5: 89f76a2a21a3ec3ec983b5eb237c4113 + depends: + - __osx >=11.0 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + run_exports: {} + size: 569349 + timestamp: 1781670209146 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libdeflate-1.26-h72bfca4_0.conda + sha256: f9c75ef67dbcc8e3c255d37e32948550bc8aa6752102c181686630b9ede96b8d + md5: 3f49c4c4ebcdb9fa285e5c73441063c1 + depends: + - __osx >=11.0 + license: MIT + license_family: MIT + run_exports: + weak: + - libdeflate >=1.26,<1.27.0a0 + size: 55312 + timestamp: 1787442891411 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libedit-3.1.20260512-pl5321h26f1114_0.conda + sha256: 5692a969e49b200c7874d1e869d281753361980b2ecfe9191b571d7e550f8b92 + md5: ef2ab2462744ec6ba3a54c34dcc6a06e + depends: + - ncurses + - __osx >=11.0 + - ncurses >=6.6,<7.0a0 + license: BSD-2-Clause + license_family: BSD + run_exports: + weak: + - libedit >=3.1.20260512,<3.2.0a0 + size: 108512 + timestamp: 1791327440683 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libev-4.33-h1a92334_3.conda + sha256: c0100064506ae8abb432c5a506d474f10af2cf48c33d62bc221fb28b6d6ff6ac + md5: 19e86c8a6a47e92bb2e70ca12e758c5c + depends: + - __osx >=11.0 + license: BSD-2-Clause OR GPL-2.0-or-later + license_family: GPL + run_exports: + weak: + - libev >=4.33,<4.34.0a0 + size: 39991 + timestamp: 1785917376956 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libexpat-2.9.0-h6111c0a_0.conda + sha256: b155c524118f751ad8b1c823397bab8b7f715f7e3ca10479925867a7e23e7e9d + md5: f85a1fda9a2758a7aef2a7787d9c0203 + depends: + - __osx >=11.0 + constrains: + - expat 2.9.0.* + license: MIT + license_family: MIT + run_exports: {} + size: 69681 + timestamp: 1793054210049 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libffi-3.7.0-h47dc5ef_1.conda + sha256: 2783389a7b9dda04c62cc54c6bbeb03dd3cef24b3fc642715d02a3fa19464a9a + md5: 216bbcc23c11e9695b3db4a8771d76eb + depends: + - __osx >=11.0 + license: MIT + license_family: MIT + run_exports: + weak: + - libffi >=3.7.0,<3.8.0a0 + size: 43637 + timestamp: 1787753403688 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libfreetype-2.14.3-hce30654_2.conda + sha256: 19ce8bd320414cb6b9889ecbf48a3ded848b0d1068b76ff6bea099bd7387d6f3 + md5: ee1fc5bba400ff0cae27fbf141a1ae0c + depends: + - libfreetype6 >=2.14.3 + license: GPL-2.0-only OR FTL + run_exports: {} + size: 8367 + timestamp: 1786641013393 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libfreetype6-2.14.3-h2ed5691_2.conda + sha256: d9b203d6484ad491b5b5f33d49a9d7a91189d776a9adae53d2b63af18ec11e6a + md5: 881cfb44ea02cc9849f612725a959660 + depends: + - __osx >=11.0 + - libpng >=1.6.58,<1.7.0a0 + - libzlib >=1.3.2,<2.0a0 + constrains: + - freetype >=2.14.3 + license: GPL-2.0-only OR FTL + run_exports: {} + size: 340923 + timestamp: 1786641012794 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libgettextpo-0.25.1-hae62183_2.conda + sha256: ea81b8992214e8c4cd289ba4b9092004aa941ddb12900a32cfbc28be6d3156ff + md5: 93e3f213a8e3fa21fb7b1407d6a4cd44 + depends: + - __osx >=11.0 + - libiconv >=1.18,<2.0a0 + - libintl 0.25.1 hae62183_2 + license: GPL-3.0-or-later + license_family: GPL + run_exports: + weak: + - libgettextpo >=0.25.1,<1.0a0 + size: 182332 + timestamp: 1790118703147 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libglib-2.90.0-hccd281b_0.conda + sha256: 4ec64c476881b31f211842952f192208a3af0925a596da227f4d97fb9a63e0ac + md5: 8f63a5f35547d0c6d819830ebe0d3245 + depends: + - __osx >=11.0 + - libintl >=0.25.1,<1.0a0 + - libzlib >=1.3.2,<2.0a0 + - libffi >=3.7.0,<3.8.0a0 + - libiconv >=1.18,<2.0a0 + - pcre2 >=10.47,<10.48.0a0 + constrains: + - glib >2.66 + license: LGPL-2.1-or-later + run_exports: + weak: + - libglib >=2.90.0,<3.0a0 + size: 4489939 + timestamp: 1789478088421 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libharfbuzz-15.0.0-hcda0f7c_0.conda + sha256: 1cf7900cfd17b60a8e3f76a31ca95140deca4781899e290b499b6caad82058b2 + md5: 2bf1803b0f15fa26d9f22ce8364d16df + depends: + - __osx >=11.0 + - cairo >=1.18.6,<2.0a0 + - graphite2 >=1.3.15,<2.0a0 + - icu >=78.3,<79.0a0 + - libcxx >=21 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libglib >=2.90.0,<3.0a0 + - libpng >=1.6.59,<1.7.0a0 + - libzlib >=1.3.2,<2.0a0 + license: MIT + license_family: MIT + run_exports: {} + size: 1146987 + timestamp: 1792769126357 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libharfbuzz-devel-15.0.0-hcda0f7c_0.conda + sha256: 764b95c1630e66f7eebca2f75ab3dd2cb039aa1d007d00c763e122cd29564a8a + md5: 14a65f11238f07714323d65bc2c9034f + depends: + - __osx >=11.0 + - cairo >=1.18.6,<2.0a0 + - freetype + - graphite2 >=1.3.15,<2.0a0 + - icu >=78.3,<79.0a0 + - libcxx >=21 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - libglib >=2.90.0,<3.0a0 + - libharfbuzz 15.0.0 hcda0f7c_0 + - libpng >=1.6.59,<1.7.0a0 + - libzlib >=1.3.2,<2.0a0 + license: MIT + license_family: MIT + run_exports: + weak: + - libharfbuzz >=15.0.0 + size: 1673578 + timestamp: 1792769143858 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libiconv-1.18-he4c29f2_3.conda + sha256: 689a14968267f2f97c07112fca5636e7d756036b9aee969911267c20bd3eea1f + md5: 17f4744c0873e9f77ac9b5cd0a27c187 + depends: + - __osx >=11.0 + license: LGPL-2.1-only + run_exports: + weak: + - libiconv >=1.18,<2.0a0 + size: 750816 + timestamp: 1787033961086 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libidn2-2.3.8-ha90df94_1.conda + sha256: 6d9d2db2c8a645f63073553e9497ea266507c940de42800f2f0faddbf00149cd + md5: d4b2e2dd2a1a1e2df8b4a3f05034beb4 + depends: + - __osx >=11.0 + - libintl >=0.25.1,<1.0a0 + - libunistring >=0,<1.0a0 + license: LGPL-2.0-only + license_family: LGPL + run_exports: + weak: + - libidn2 >=2,<3.0a0 + size: 145706 + timestamp: 1760385907428 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libintl-0.25.1-hae62183_2.conda + sha256: b43c6645e668f86d04d5c06d6dc17efe921bbd9244be4b77946d56fb950a3fcc + md5: a3a4193101bc5427e6cf8be81d5eeddf + depends: + - __osx >=11.0 + - libiconv >=1.18,<2.0a0 + license: LGPL-2.1-or-later + run_exports: + weak: + - libintl >=0.25.1,<1.0a0 + size: 90024 + timestamp: 1790118675563 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libjpeg-turbo-3.2.1-hb001647_0.conda + sha256: 957469c69b3b9c9e6ae48dc1267c5c9dfe0db9e1aefa5fa9abf9798224aa23c9 + md5: d420b10837f3b64259b1febf263b5f7a + depends: + - __osx >=11.0 + constrains: + - jpeg <0.0.0a + license: IJG AND BSD-3-Clause AND Zlib + run_exports: + weak: + - libjpeg-turbo >=3.2.1,<4.0a0 + size: 555606 + timestamp: 1793156969006 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libllvm22-22.1.8-h759d1ac_3.conda + sha256: 70d7bbba65233fec41fb2294e81351d81b8d7e21206113135604fed4dd7fdcf6 + md5: 3b912a5fea164495d16d3edc64242f3a + depends: + - __osx >=11.0 + - libcxx >=21 + - libxml2 + - libxml2-16 >=2.15.4 + - libzlib >=1.3.2,<2.0a0 + - zstd >=1.5.7,<1.6.0a0 + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + run_exports: + weak: + - libllvm22 >=22.1.8,<22.2.0a0 + size: 30242555 + timestamp: 1790103714094 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/liblzma-5.8.3-h8088a28_1.conda + sha256: 23d0630046a3e8b164d8f80f2b74ed2605af2e7050ab9913018056402fae4311 + md5: 8ab10323068b107661a4b9a4af84f3b5 + depends: + - __osx >=11.0 + constrains: + - xz 5.8.3.* + license: 0BSD + run_exports: + weak: + - liblzma >=5.8.3,<6.0a0 + size: 91720 + timestamp: 1786348695846 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libmpdec-4.0.0-h84a0fba_2.conda + sha256: 04cc136c5a956a73aa14e0a160b5822b0b29714e67b299fa1b1fd16dbcba5366 + md5: ff33a4dbd93abc8a798cc4e0e7c8136d + depends: + - __osx >=11.0 + license: BSD-2-Clause + license_family: BSD + run_exports: {} + size: 73289 + timestamp: 1786651074391 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libnghttp2-1.71.0-h29223de_0.conda + sha256: d533256cdb91c676b106728e8437a5d96e9c02dc6a99b948f1b04b04a92620c2 + md5: a8f77fc66cd70f2c883764a318fa2f26 + depends: + - libev >=4.33,<5.0a0 + - __osx >=11.0 + - libcxx >=21 + - c-ares >=1.34.9,<2.0a0 + - libev >=4.33,<4.34.0a0 + - openssl >=3.5.9,<4.0a0 + - libzlib >=1.3.2,<2.0a0 + license: MIT + license_family: MIT + run_exports: + weak: + - libnghttp2 >=1.71.0,<2.0a0 + size: 671516 + timestamp: 1793628217888 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpango-1.58.2-hc2ac4f2_3.conda + sha256: 90118019ce64d713888abbe41a15be9e5885bdc8d5d4f84480e615299d2b5a01 + md5: 1261a045589c8d98219cbd258b71ea95 + depends: + - __osx >=11.0 + - fribidi >=1.0.17,<2.0a0 + - libglib >=2.90.0,<3.0a0 + - libharfbuzz >=14.6.0 + - cairo >=1.18.6,<2.0a0 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - fontconfig >=2.18.3,<3.0a0 + - fonts-conda-ecosystem + license: LGPL-2.1-or-later + run_exports: {} + size: 308102 + timestamp: 1792050658787 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpango-devel-1.58.2-haa2d88b_3.conda + sha256: 2434b8c792ce63ba089da94a21acb25ec45430a053d5cbe537d18f18771b27a7 + md5: 4bac42499647d2567ef309b6193d63f6 + depends: + - libpango ==1.58.2 hc2ac4f2_3 + - freetype + - libharfbuzz-devel + - __osx >=11.0 + - fribidi >=1.0.17,<2.0a0 + - libglib >=2.90.0,<3.0a0 + - libharfbuzz >=14.6.0 + - cairo >=1.18.6,<2.0a0 + - libfreetype >=2.14.3 + - libfreetype6 >=2.14.3 + - fontconfig >=2.18.3,<3.0a0 + - fonts-conda-ecosystem + license: LGPL-2.1-or-later + run_exports: + weak: + - libpango >=1.58.2,<2.0a0 + size: 213942 + timestamp: 1792050658787 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpng-1.6.59-hf5e6511_0.conda + sha256: 4de4dc4cb7432c328c1eaf4f7cc9c6b48c073eab1e9c6723d4533e6d57e7d595 + md5: 4f99571d5354c39f2621b8b6e3a9afa3 + depends: + - __osx >=11.0 + - libzlib >=1.3.2,<2.0a0 + license: zlib-acknowledgement + run_exports: + weak: + - libpng >=1.6.59,<1.7.0a0 + size: 290299 + timestamp: 1790805167385 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpsl-0.23.1-hdb0c161_1.conda + sha256: c8c3153df39abedf3413483f672151ad70f1adb0c06c192bdf7ec432c3616b07 + md5: 5d270f716a2b4bc13df9af8612071b17 + depends: + - __osx >=11.0 + - libcxx >=21 + - icu >=78.3,<79.0a0 + license: MIT + license_family: MIT + run_exports: + weak: + - libpsl >=0.23.1,<0.24.0a0 + size: 72673 + timestamp: 1786970928205 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libpython-3.13.18-h0af5753_100_cp313.conda + build_number: 100 + sha256: 2ccf200438a519589d86acb96c75822f7ba6f6a9e654d1da355521cec4adfac3 + md5: 57bd17817c81cfe8d491e328dcb59a43 + depends: + - __osx >=11.0 + license: Python-2.0 + run_exports: + weak: + - libpython >=3.13,<4.0a0 + size: 1823071 + timestamp: 1793014722078 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/librsvg-2.62.4-hc8ac265_0.conda + sha256: 3bd54de0136907782249a0d5797744ecac5bbd77026f5f2712dd62390c5c9f77 + md5: 878c79beee628e3b683ddc9094aaad1e + depends: + - __osx >=11.0 + - pango >=1.58.2,<2.0a0 + - libglib >=2.90.0,<3.0a0 + - fontconfig >=2.18.3,<3.0a0 + - fonts-conda-ecosystem + - libxml2-16 >=2.15.4 + - gdk-pixbuf >=2.44.8,<3.0a0 + - libharfbuzz >=14.5.0 + - cairo >=1.18.6,<2.0a0 + constrains: + - __osx >=11.0 + license: LGPL-2.1-or-later + run_exports: + weak: + - librsvg >=2.62.4,<3.0a0 + size: 3888310 + timestamp: 1790276358897 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libsqlite-3.54.1-hca69786_0.conda + sha256: 998cd122027b2523f2f25807b1d476b82a168489d16b1430fd848a9a6b606a80 + md5: b3fc67af56dfdf7c9ee7d8fdae21f654 + depends: + - __osx >=11.0 + - icu >=78.3,<79.0a0 + - libzlib >=1.3.2,<2.0a0 + license: blessing + run_exports: + weak: + - libsqlite >=3.54.1,<4.0a0 + size: 953427 + timestamp: 1792175622950 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libssh2-1.11.1-hbf2880b_1.conda + sha256: a056e518c3d2d09fbb1778cea80c0c95338fb24adf1a817bbf90fb484850a304 + md5: d957a8eda98c49b073e8dcfd677c127a + depends: + - libzlib >=1.3.2,<2.0a0 + - openssl >=3.5.7,<4.0a0 + license: BSD-3-Clause + license_family: BSD + run_exports: + weak: + - libssh2 >=1.11.1,<2.0a0 + size: 280492 + timestamp: 1786714226814 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libtasn1-4.21.0-hb001647_1.conda + sha256: a18d0abb7414e4caba4043c3b9e7f981b62b016ed6f203437d7232b175ba2e67 + md5: c298706579b4d8ac9af0df9557fdebae + depends: + - __osx >=11.0 + license: LGPL-2.1-or-later + run_exports: + weak: + - libtasn1 >=4.21.0,<5.0a0 + size: 117547 + timestamp: 1793068747771 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libtiff-4.7.2-h87d37ca_2.conda + sha256: 3c1cf481a60ed8598093641b3a41ee1a7bb78413029ec566a238927504e941bd + md5: ac0e529ed6020472c12f740602e58ab5 + depends: + - __osx >=11.0 + - lerc >=4.3.0,<5.0a0 + - libcxx >=21 + - libdeflate >=1.26,<1.27.0a0 + - libjpeg-turbo >=3.2.1,<4.0a0 + - liblzma >=5.8.3,<6.0a0 + - libwebp-base >=1.6.0,<2.0a0 + - libzlib >=1.3.2,<2.0a0 + - zstd >=1.5.7,<1.6.0a0 + license: HPND + run_exports: + weak: + - libtiff >=4.7.2,<4.8.0a0 + size: 380333 + timestamp: 1794045696512 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libtree-sitter-0.25.9-he530434_0.conda + sha256: 439049f9222d51c0747d004a324cf97dc66138eff9f449627007f7acd4fad971 + md5: 805b557db147781ba60665802414d3e8 + depends: + - __osx >=11.0 + license: MIT + license_family: MIT + run_exports: + weak: + - libtree-sitter >=0.25.9,<0.26.0a0 + size: 207080 + timestamp: 1757201895620 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libunistring-0.9.10-h3422bc3_0.tar.bz2 + sha256: a1afe12ab199f82f339eae83405d293d197f2485d45346a709703bc7e8299949 + md5: d88e77a4861e20bd96bde6628ee7a5ae + license: GPL-3.0-only OR LGPL-3.0-only + run_exports: + weak: + - libunistring >=0,<1.0a0 + size: 1577561 + timestamp: 1626955172521 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libwebp-base-1.6.0-h202fb40_1.conda + sha256: 0ff54650d470c7e54cbeffdd53a8c063e055a7bcf784388c0385ce5c4741b0f4 + md5: 168a13e329259710b28277abc1395b8e + depends: + - __osx >=11.0 + constrains: + - libwebp 1.6.0 + license: BSD-3-Clause + license_family: BSD + run_exports: + weak: + - libwebp-base >=1.6.0,<2.0a0 + size: 294522 + timestamp: 1785955350410 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-16-2.15.4-heb56d2d_1.conda + sha256: 1acd4dd49c6f54440dc172ab469d0e2c7c3c02de5b1f21158a233eb585ec3c38 + md5: ef82ce9c5e6a0bb8bc9cb0e6935f18ca + depends: + - __osx >=11.0 + - icu >=78.3,<79.0a0 + - libiconv >=1.18,<2.0a0 + - liblzma >=5.8.3,<6.0a0 + - libzlib >=1.3.2,<2.0a0 + constrains: + - libxml2 2.15.4 + license: MIT + license_family: MIT + run_exports: {} + size: 469239 + timestamp: 1791465646245 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libxml2-2.15.4-h550178d_1.conda + sha256: f333b4c6c823ea317aeb0b817520ae3ba2fb16277923d848f5f2aee2049198e5 + md5: 5881b9ab679553078d590db82d7e57b3 + depends: + - __osx >=11.0 + - icu >=78.3,<79.0a0 + - libiconv >=1.18,<2.0a0 + - liblzma >=5.8.3,<6.0a0 + - libxml2-16 2.15.4 heb56d2d_1 + - libzlib >=1.3.2,<2.0a0 + license: MIT + license_family: MIT + run_exports: + weak: + - libxml2 + - libxml2-16 >=2.15.4 + size: 41382 + timestamp: 1791465651969 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/libzlib-1.3.2-h8088a28_3.conda + sha256: a18fa5d5bac452401459f966cf0d872224e8080c4ff93c77e168d43ab42ef9d7 + md5: f39288f0ea63ae962e1a2e4f355a0d75 + depends: + - __osx >=11.0 + constrains: + - zlib 1.3.2 *_3 + license: Zlib + license_family: Other + run_exports: + weak: + - libzlib >=1.3.2,<2.0a0 + size: 47822 + timestamp: 1785277049190 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/lychee-0.24.2-h9d00c72_1.conda + sha256: 9c35bbfe243d26c07a21375cfb863f376991e4dd6de3d6bfb147569c60d65cf0 + md5: 1ec074eabe183deb5a7e65fb9e776c3e + depends: + - __osx >=11.0 + constrains: + - __osx >=11.0 + license: Apache-2.0 OR MIT + run_exports: {} + size: 5351911 + timestamp: 1791278249049 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/markupsafe-3.0.4-py313h0984dbd_5.conda + sha256: c996dadcd7c6f0df9ade4e019cf0858761039a62c9dde312475e0822468af8d9 + md5: 4a83df2cb081468887b1ba02de0736a2 + depends: + - python + - __osx >=11.0 + - python_abi 3.13.* *_cp313 + constrains: + - jinja2 >=3.0.0 + license: BSD-3-Clause + run_exports: {} + size: 28227 + timestamp: 1794823823453 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/ncurses-6.6-he64c551_1.conda + sha256: 7024a48c8c0d0114ed4ab53c76bf9275d50e91ba7cea367a9aead638d3c29c68 + md5: 3dfa0d0316dc246cd44937a557de4501 + depends: + - __osx >=11.0 + license: X11 AND BSD-3-Clause + run_exports: + weak: + - ncurses >=6.6,<7.0a0 + size: 804298 + timestamp: 1786355189145 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/nettle-3.10.1-hfc803ee_1.conda + sha256: f57e68f8e7e3197340fa6edc6cc66afd6015f1dc52850a7c2ab20cec66b766d0 + md5: b0229aa5ed12f2d0f33ac3e88a63e1db + depends: + - __osx >=11.0 + - gmp >=6.3.0,<7.0a0 + license: GPL-2.0-or-later OR LGPL-3.0-or-later + run_exports: + weak: + - nettle >=3.10.1,<3.11.0a0 + size: 456749 + timestamp: 1787065337321 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/openssl-3.6.5-h55eecbc_0.conda + sha256: 44fbc526456571a9fb8fa18157f6f269d4d4bd40eef20183a93b9c9296f94497 + md5: 45d9179cdf6e53d88aec034246f0dad6 + depends: + - __osx >=11.0 + - ca-certificates + license: Apache-2.0 + license_family: Apache + run_exports: + weak: + - openssl >=3.6.5,<4.0a0 + size: 3111573 + timestamp: 1791097959641 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/p11-kit-0.26.5-h329a732_2.conda + sha256: ba17447c428db9e0a7c74067e30ef7c9aab29835d69676dad3076e62ae9f8763 + md5: b6dc8c0520f47b73a42dec38794bad8c + depends: + - __osx >=11.0 + - libffi >=3.7.0,<3.8.0a0 + - libtasn1 >=4.21.0,<5.0a0 + license: MIT + license_family: MIT + run_exports: + weak: + - p11-kit >=0.26.5,<0.27.0a0 + size: 800354 + timestamp: 1788196674456 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pango-1.58.2-hc6efcc1_3.conda + sha256: 4206a8d179dbc2ae070d7c5ed148b73ccf5ec8a962f428e2645527bad9c016de + md5: 17bb0626b5ac18be2c28e65b6d949e3a + depends: + - libpango-devel ==1.58.2 haa2d88b_3 + license: LGPL-2.1-or-later + run_exports: + weak: + - libpango >=1.58.2,<2.0a0 + size: 15035 + timestamp: 1792050658787 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pcre2-10.47-he63d830_1.conda + sha256: f8c415329b542e1fca1ff2917b80e687c18302dfa0353530668b90cb225b494f + md5: 5ab90033816cbe4097e8a297e5179f67 + depends: + - __osx >=11.0 + - bzip2 >=1.0.8,<2.0a0 + - libzlib >=1.3.2,<2.0a0 + license: BSD-3-Clause + license_family: BSD + run_exports: + weak: + - pcre2 >=10.47,<10.48.0a0 + size: 851704 + timestamp: 1787294559157 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pixman-0.46.4-h784d473_3.conda + sha256: 4779cd57231ce2e96fac643fcbdd4a6f51a57986264545445574e9c4acf526d3 + md5: 9a99c0b60efe41c194d01c182d000733 + depends: + - __osx >=11.0 + - libcxx >=19 + license: MIT + license_family: MIT + run_exports: + weak: + - pixman >=0.46.4,<1.0a0 + size: 198717 + timestamp: 1786106922508 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/python-3.13.18-hb59dee6_100_cp313.conda + build_number: 100 + sha256: ca7809f986ebd644a418bd52e3bfa1ece8979441917c08e47d341b9e818c652b + md5: fe33fb185e1b63c33394512bccf8807f + depends: + - __osx >=11.0 + - bzip2 >=1.0.8,<2.0a0 + - libexpat >=2.8.5,<3.0a0 + - libffi >=3.7.0,<3.8.0a0 + - liblzma >=5.8.3,<6.0a0 + - libmpdec >=4.0.0,<5.0a0 + - libpython 3.13.18 h0af5753_100_cp313 + - libsqlite >=3.54.1,<4.0a0 + - libzlib >=1.3.2,<2.0a0 + - ncurses >=6.6,<7.0a0 + - openssl >=3.5.9,<4.0a0 + - python_abi 3.13.* *_cp313 + - readline >=8.3,<9.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + license: Python-2.0 + run_exports: + weak: + - python_abi 3.13.* *_cp313 + noarch: + - python + size: 11971526 + timestamp: 1793014757271 + python_site_packages_path: lib/python3.13/site-packages +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/pyyaml-6.0.3-py313h5c85ca1_3.conda + sha256: a5c89aa6d093077b4569c5f33182c93ca7de4fe8536d2ce27a5bec6a407f0ecc + md5: bd7d78d5a001b042e7520cbd724b21a5 + depends: + - python + - yaml + - __osx >=11.0 + - python_abi 3.13.* *_cp313 + - yaml >=0.2.5,<0.3.0a0 + license: MIT + license_family: MIT + run_exports: {} + size: 204613 + timestamp: 1793655118128 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/readline-8.3-h8b90a29_1.conda + sha256: d6782b430e6dce4fe8c7ac118cd988d5a193eb4a7f60741edfaede58016b6110 + md5: 9347fd56a002e6b58946831d48fe62f6 + depends: + - __osx >=11.0 + - ncurses >=6.6,<7.0a0 + license: GPL-3.0-only + license_family: GPL + run_exports: + weak: + - readline >=8.3,<9.0a0 + size: 314395 + timestamp: 1787033878899 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/tk-8.6.13-hbeba79b_4.conda + sha256: 857d89087ae7f2c328cf256728affcb7343031a148b4af847334d248a9cf564c + md5: 90a01bf394d1c594e0eb9258f967d828 + depends: + - __osx >=11.0 + - libzlib >=1.3.2,<2.0a0 + license: TCL + run_exports: + weak: + - tk >=8.6.13,<8.7.0a0 + size: 3342183 + timestamp: 1787272852357 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/yaml-0.2.5-h74c22ad_3.conda + sha256: 3e78c43207502418fc5fb2317bbbefe5df8b6fc1051d90bdcd1c881c76bb4193 + md5: 31cf6dcc138abe673c9440cd6fe6c6fe + depends: + - __osx >=11.0 + license: MIT + license_family: MIT + run_exports: + weak: + - yaml >=0.2.5,<0.3.0a0 + size: 77530 + timestamp: 1787228556857 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/zig-0.17.1-0ccaba2_0.conda + sha256: b79e9a60a36a4001178fe43eb454e74d67266f5ff0828e5581e455e41d8634f7 + md5: 515c9a0205dc70ea68d556fd361a2c69 + depends: + - zig_osx-arm64 ==0.17.1 a676bd3_0 + - libcxx >=22 + license: MIT AND Apache-2.0 WITH LLVM-exception AND Apache-2.0 AND LGPL-2.1-or-later AND BSD-2-Clause AND BSD-3-Clause AND ZPL-2.1 AND LicenseRef-Public-Domain + run_exports: + weak: + - zig >=0.17.1,<0.17.2.0a0 + size: 229303 + timestamp: 1794496879060 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/zig_impl_osx-arm64-0.17.1-8405819_0.conda + sha256: a5cf38eef3105506af4a1488c5cee42e182e8c47bfa56228899cd30dc9c7ee1f + md5: aa771c478390ba34eb22842cdc320334 + depends: + - libcxx 22.* + - libcxx >=22 + - __osx >=11.0 + - libxml2 + - libxml2-16 >=2.15.4 + - zstd >=1.5.7,<1.6.0a0 + - libllvm22 >=22.1.8,<22.2.0a0 + - libzlib >=1.3.2,<2.0a0 + - libclang-cpp22.1 >=22.1.8,<22.2.0a0 + license: MIT AND Apache-2.0 WITH LLVM-exception AND Apache-2.0 AND LGPL-2.1-or-later AND BSD-2-Clause AND BSD-3-Clause AND ZPL-2.1 AND LicenseRef-Public-Domain + run_exports: {} + size: 76882981 + timestamp: 1794496879060 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/zig_osx-arm64-0.17.1-a676bd3_0.conda + sha256: f65739411083e5b9d486bf73af89f1f9dc49032b3135690fbd2dabd49e0bb672 + md5: 74a14e85555a80674578bfa6b77b93cf + depends: + - zig_impl_osx-arm64 ==0.17.1 8405819_0 + license: MIT AND Apache-2.0 WITH LLVM-exception AND Apache-2.0 AND LGPL-2.1-or-later AND BSD-2-Clause AND BSD-3-Clause AND ZPL-2.1 AND LicenseRef-Public-Domain + run_exports: + strong: + - libcxx >=22 + size: 335709 + timestamp: 1794496879060 +- conda: https://conda.anaconda.org/conda-forge/osx-arm64/zstd-1.5.7-hf451053_7.conda + sha256: da867f5092eb0cb746d353694f0098031fd9817a4ce7d5743121209ae0f406ca + md5: 4ec2684c73812cc2c3d78379384a39cc + depends: + - __osx >=11.0 + - libzlib >=1.3.2,<2.0a0 + license: BSD-3-Clause + license_family: BSD + run_exports: + weak: + - zstd >=1.5.7,<1.6.0a0 + size: 433687 + timestamp: 1786599629846 diff --git a/pixi.toml b/pixi.toml new file mode 100644 index 0000000..d46396f --- /dev/null +++ b/pixi.toml @@ -0,0 +1,42 @@ +# The documentation toolchain, pinned by pixi.lock. `pixi run -e docs docbld` +# builds docs/build/html the way CI does; docs/orgmode/contributing.org has +# the steps. In a repository that already has a pixi.toml, copy the +# [feature.docs.*] tables and the docs environment into it. +[workspace] +name = "zig-common" +channels = ["conda-forge"] +platforms = ["linux-64", "osx-arm64"] + +[feature.docs.dependencies] +python = "3.13.*" +emacs = "30.*" +curl = "*" +lychee = "*" +zig = "0.17.1.*" +sphinx = "9.*" +myst-parser = "*" +shibuya = "*" +sphinx-copybutton = "*" +sphinx-design = "*" +sphinx-sitemap = "*" +sphinx-autoapi = "*" + +[feature.docs.tasks] +# Org pages to reStructuredText, docs/orgmode -> docs/source. +mkrst = { cmd = "emacs -Q --batch --load export.el", cwd = "docs" } +# API pages from the code, into docs/source/reference/api/. +mkapi = { cmd = "zig run docs/tools/zig_api.zig -- --module zig_common --root src/root.zig --out docs/source/reference/api/zig --source-url 'https://github.com/stackhands/zig-common/blob/{ref}/' --title 'Zig API'" } +sphinxbld = { cmd = "sphinx-build -W -n --keep-going -d docs/build/doctrees -b html docs/source docs/build/html", depends-on = ["mkrst", "mkapi"] } +# The Zig autodoc site, served beside the Sphinx pages at api/. +autodoc = { cmd = "zig build docs --prefix docs/build/autodoc && rm -rf docs/build/html/api && cp -r docs/build/autodoc/docs docs/build/html/api", depends-on = ["sphinxbld"] } +# Every internal link and anchor resolves, and no page names a site. The +# changelog may name what a release removed; its links are still checked. +doccheck = { cmd = "python docs/tools/check_site.py docs/build/html --sources docs/orgmode --exempt changelog.html", depends-on = ["autodoc"] } +docbld = { depends-on = ["doccheck"] } +# External links; needs the network, so CI runs it as its own step. +linkcheck = { cmd = "lychee --config lychee.toml --no-progress 'docs/build/html/**/*.html'" } +# Generated files are the ignored ones under docs/source (see .gitignore). +docdel = { cmd = "rm -rf docs/build && git clean -fdX docs/source" } + +[environments] +docs = { features = ["docs"], no-default-feature = true } diff --git a/src/atomic.zig b/src/atomic.zig index a16aed8..2618440 100644 --- a/src/atomic.zig +++ b/src/atomic.zig @@ -12,6 +12,7 @@ const fsx = @import("fsx.zig"); const Allocator = std.mem.Allocator; +/// The ACL forms `atomicWrite` keeps, most native first: `fsx.acl_attributes`. pub const acl_attributes = fsx.acl_attributes; const posix_access = "system.posix_acl_access"; @@ -92,14 +93,20 @@ pub fn describe(err: Error) []const u8 { /// message is allocated from the allocator given with `why` and belongs to /// the caller: `deinit` frees it. pub const Why = struct { + /// The reason for the refusal; empty until there is one. msg: []const u8 = "", + /// Free the message when it was allocated from `a`, and empty it. An + /// empty `Why` may be passed, and `deinit` may be called again. pub fn deinit(why: *Why, a: Allocator) void { if (why.msg.len > 0 and why.msg.ptr != unallocated_refusal.ptr) a.free(why.msg); why.* = .{}; } }; +/// The errors of this module: `error.Refused`, with the reason in the +/// caller's `Why`; `error.OutOfMemory`; or the `sys.Error` of a failed +/// call, which `describe` words as Python does. pub const Error = error{ Refused, OutOfMemory } || sys.Error; /// The message of a refusal that could not allocate its own. @@ -112,8 +119,11 @@ fn refuse(a: Allocator, why: *Why, comptime f: []const u8, args: anytype) Error /// The value of each ACL attribute present, keyed by its name. pub const Acls = struct { + /// One slot per `acl_attributes` form, in that order: the attribute's + /// bytes, or null when the file does not have that form. present: [acl_attributes.len]?[]const u8 = .{ null, null, null }, + /// True when `x` and `y` have the same forms, with the same bytes. pub fn eql(x: Acls, y: Acls) bool { for (x.present, y.present) |p, q| { if ((p == null) != (q == null)) return false; @@ -128,10 +138,13 @@ pub const Acls = struct { } }; +/// The access metadata of a file, as `readMetadata` returns it: its stat, +/// for the owner, group and mode, and its ACLs. pub const Metadata = struct { info: fsx.Stat, acls: Acls, + /// Free the ACL values, allocated from `a` by `readMetadata`. pub fn deinit(m: Metadata, a: Allocator) void { m.acls.deinit(a); } @@ -283,10 +296,14 @@ fn restoreMetadata(a: Allocator, fd: sys.fd_t, metadata: ?Metadata, mode: u32, w /// In a replaceable build (tests, a tool's -Dtest-ops artifact) `fail_fn` /// can also make the step fail; in any other build it is never asked. pub const Faults = struct { + /// Passed to both functions. ctx: ?*anyopaque = null, reach_fn: ?*const fn (?*anyopaque, []const u8) void = null, + /// True makes the step fail. Asked only in a replaceable build. fail_fn: ?*const fn (?*anyopaque, []const u8) bool = null, + /// Call `reach_fn`, when there is one, with the name of the step about + /// to run. pub fn reach(f: Faults, step: []const u8) void { if (f.reach_fn) |r| r(f.ctx, step); } @@ -350,6 +367,8 @@ pub fn fileMode(path: []const u8) u32 { return 0o644 & ~currentUmask(); } +/// Open `path` read-only and fsync it. For a directory, that makes a +/// rename or a new name in it durable. pub fn fsyncDir(path: []const u8) sys.Error!void { const fd = try sys.openat(fsx.cwd, path, .{}, 0); defer sys.close(fd); @@ -370,10 +389,18 @@ pub fn makedirs(path: []const u8) sys.Error!void { }; } +/// What `atomicWrite` gives the new file besides its bytes, and the names +/// of its fault points. pub const WriteOptions = struct { + /// The permission bits. Null takes those of the metadata source, or, + /// for a new file without one, 0644 less the umask. mode: ?u32 = null, + /// A file whose owner, group, mode and ACLs the new file gets in place + /// of the existing file's. metadata_from: ?[]const u8 = null, faults: Faults = .{}, + /// The first part of each fault point's name: `STEP.write`, + /// `STEP.fsync` and `STEP.rename`. step: []const u8 = "write", }; diff --git a/src/cli.zig b/src/cli.zig index 42414fa..bb7106a 100644 --- a/src/cli.zig +++ b/src/cli.zig @@ -13,6 +13,9 @@ pub fn put(fd: sys.fd_t, bytes: []const u8) void { sys.writeAll(fd, bytes) catch {}; } +/// Format `args` with `fmt` and `put` the text to `fd`. A text longer than +/// 8 KiB is formatted on the heap; when that allocation fails, nothing is +/// written. pub fn print(fd: sys.fd_t, comptime fmt: []const u8, args: anytype) void { var buf: [8192]u8 = undefined; const s = std.mem.print(&buf, fmt, args) catch { @@ -25,10 +28,12 @@ pub fn print(fd: sys.fd_t, comptime fmt: []const u8, args: anytype) void { put(fd, s); } +/// `print` to stdout. No newline is added. pub fn out(comptime fmt: []const u8, args: anytype) void { print(1, fmt, args); } +/// `print` to stderr. No newline is added. pub fn err(comptime fmt: []const u8, args: anytype) void { print(2, fmt, args); } diff --git a/src/env.zig b/src/env.zig index 69a9c54..19186ca 100644 --- a/src/env.zig +++ b/src/env.zig @@ -5,6 +5,8 @@ const std = @import("std"); const Allocator = std.mem.Allocator; +/// An environment block as execve(2) takes it: NUL-terminated +/// `NAME=value` strings, ended by a null pointer. pub const Envp = [*:null]const ?[*:0]const u8; /// True for a name the shell accepts: [A-Za-z_][A-Za-z0-9_]*. @@ -22,8 +24,12 @@ fn split(entry: []const u8) struct { name: []const u8, value: ?[]const u8 } { /// A read-only view of an environment block. pub const Env = struct { + /// The block's strings in order. An entry with no `=` is kept here and + /// is not a variable. entries: []const [*:0]const u8, + /// A view of `envp` up to its null pointer. Nothing is copied: the view + /// is valid while the block is. pub fn fromEnvp(envp: Envp) Env { var n: usize = 0; while (envp[n] != null) n += 1; @@ -68,10 +74,14 @@ pub const Builder = struct { names: std.ArrayList([]const u8) = .empty, values: std.StringHashMapUnmanaged([]const u8) = .empty, + /// An empty environment. What it stores comes from an arena over + /// `gpa`, which `deinit` frees. pub fn init(gpa: Allocator) Builder { return .{ .arena = std.heap.ArenaAllocator.init(gpa) }; } + /// Free every name, value and block the builder made, the blocks + /// `envp` returned included. pub fn deinit(b: *Builder) void { b.arena.deinit(); } @@ -89,6 +99,9 @@ pub const Builder = struct { return b; } + /// Set `name` to `value`, both copied. A name already set keeps its + /// place in the order; a new name goes last. The name is checked only + /// when `envp` builds the block. pub fn set(b: *Builder, name: []const u8, value: []const u8) Allocator.Error!void { const a = b.arena.allocator(); const v = try a.dupe(u8, value); @@ -101,6 +114,7 @@ pub const Builder = struct { try b.values.put(a, n, v); } + /// Remove `name`. A name that is not set is no error. pub fn unset(b: *Builder, name: []const u8) void { if (!b.values.remove(name)) return; for (b.names.items, 0..) |n, i| if (std.mem.eql(u8, n, name)) { @@ -109,6 +123,7 @@ pub const Builder = struct { }; } + /// The value `name` has in the builder, or null when it is not set. pub fn get(b: *const Builder, name: []const u8) ?[]const u8 { return b.values.get(name); } diff --git a/src/fsx.zig b/src/fsx.zig index 0a82550..0df8424 100644 --- a/src/fsx.zig +++ b/src/fsx.zig @@ -5,35 +5,53 @@ const linux = std.os.linux; const sys = @import("sys.zig"); const Allocator = std.mem.Allocator; +/// A file descriptor, as `sys.fd_t`. pub const fd_t = sys.fd_t; +/// The errors of this module's calls: `sys.Error`. pub const Error = sys.Error; +/// The `dir` that makes a path relative to the current directory, +/// `AT_FDCWD`. An absolute path ignores `dir`. pub const cwd: fd_t = linux.AT.FDCWD; +/// The file type bits of `Stat.mode`, as stat(2) names them. pub const S = struct { + /// The mask of the file type bits. pub const IFMT: u32 = 0o170000; + /// A regular file. pub const IFREG: u32 = 0o100000; + /// A directory. pub const IFDIR: u32 = 0o040000; + /// A symbolic link. pub const IFLNK: u32 = 0o120000; }; +/// What `fstat` and `statAt` return: the statx(2) fields these tools use. pub const Stat = struct { + /// The file type bits (`S`) and the permission bits (`perm`). mode: u32, uid: linux.uid_t, gid: linux.gid_t, nlink: u32, + /// Bytes. size: u64, atime: linux.timespec, mtime: linux.timespec, ctime: linux.timespec = .{ .sec = 0, .nsec = 0 }, + /// The device the file is on: the major number in the high 32 bits, the + /// minor number in the low 32. dev: u64 = 0, ino: u64 = 0, + /// True for a regular file. pub fn isReg(s: Stat) bool { return s.mode & S.IFMT == S.IFREG; } + /// True for a directory. pub fn isDir(s: Stat) bool { return s.mode & S.IFMT == S.IFDIR; } + /// True for a symbolic link. `statAt` with `follow` true never returns + /// one. pub fn isLink(s: Stat) bool { return s.mode & S.IFMT == S.IFLNK; } @@ -71,6 +89,7 @@ fn fromStatx(x: linux.Statx) Stat { }; } +/// The `Stat` of an open descriptor, from statx(2) with `AT_EMPTY_PATH`. pub fn fstat(fd: fd_t) Error!Stat { var x: linux.Statx = undefined; _ = try sys.call(linux.statx, .{ fd, "", linux.AT.EMPTY_PATH, statx_mask, &x }); @@ -115,6 +134,10 @@ pub fn openRegular(dir: fd_t, path: []const u8, follow: bool) Error!struct { fd: return .{ .fd = fd, .stat = st }; } +/// Open the directory `dir/path` for reading with `O_DIRECTORY`. `follow` +/// decides whether a final symbolic link is followed; one that is not is +/// `error.NotDir`, as the kernel reports `O_NOFOLLOW` on a link with +/// `O_DIRECTORY`. The caller closes the descriptor. pub fn openDir(dir: fd_t, path: []const u8, follow: bool) Error!fd_t { return sys.openat(dir, path, .{ .DIRECTORY = true, .NOFOLLOW = !follow }, 0); } @@ -304,10 +327,17 @@ pub fn replaceContents(gpa: Allocator, dir: fd_t, name: []const u8, bytes: []con done = true; } +/// The `d_type` values of a directory entry, as `std.os.linux.DT`: +/// `DT.REG`, `DT.DIR`, `DT.LNK`, `DT.UNKNOWN` and the rest. pub const DT = linux.DT; +/// One entry of a directory, as `DirIter.next` returns it. pub const Entry = struct { + /// Points into the iterator's buffer: valid until the next call to + /// `DirIter.next`. name: []const u8, + /// A `DT` value; `DT.UNKNOWN` when the file system does not say, which + /// `entryType` resolves. type: u8, }; @@ -326,10 +356,13 @@ pub const DirIter = struct { return .{ .fd = fd, .buf = try gpa.alignedAlloc(u8, .@"8", 32 * 1024) }; } + /// Free the buffer `init` allocated. The descriptor stays open; the + /// caller closes it. pub fn deinit(it: *DirIter, gpa: Allocator) void { gpa.free(it.buf); } + /// The next entry, or null after the last one. pub fn next(it: *DirIter) Error!?Entry { while (true) { if (it.pos >= it.end) { diff --git a/src/json.zig b/src/json.zig index 8ed13ec..dd28426 100644 --- a/src/json.zig +++ b/src/json.zig @@ -15,6 +15,10 @@ const text = @import("pytext.zig"); const Allocator = std.mem.Allocator; +/// One parsed JSON value. Strings and numbers are their JSON text, sliced +/// from the text given to `parse`, which must outlive the value; the codecs +/// and `toPy` decode them. Arrays and objects are allocated from the arena +/// given to `parse`. pub const Value = union(enum) { null, bool: bool, @@ -26,6 +30,10 @@ pub const Value = union(enum) { /// Members in order; a later duplicate key wins, as json.loads keeps it. object: []const Member, + /// The value of `key` in an object, or null when `v` is not an object + /// or has no such key. A key that appears twice gives its last value, + /// as json.loads does. A stored key is compared with its escapes + /// decoded, so `"\u006bind"` matches `kind`. pub fn get(v: Value, key: []const u8) ?Value { if (v != .object) return null; var found: ?Value = null; @@ -36,6 +44,8 @@ pub const Value = union(enum) { } }; +/// One member of an object: the key's JSON text between the quotes, escapes +/// not yet decoded, and its value. pub const Member = struct { key: []const u8, value: Value }; /// A raw JSON key equals `want` (ASCII, as every key the guard looks up @@ -82,6 +92,8 @@ fn hex4(raw: []const u8, i: usize) error{Encoding}!u16 { return std.fmt.parseInt(u16, raw[i .. i + 4], 16) catch unreachable; } +/// The errors of `parse`: `error.Syntax` for text that is not one JSON +/// document nested at most `max_depth` deep, or `error.OutOfMemory`. pub const ParseError = Allocator.Error || error{Syntax}; /// Arrays and objects nest at most this deep. The parser recurses once per @@ -238,6 +250,8 @@ pub fn parse(arena: Allocator, s: []const u8) ParseError!Value { return v; } +/// The errors of the decoders and `toPy`: `error.Encoding` for a string +/// or number the codec cannot represent, or `error.OutOfMemory`. pub const DecodeError = Allocator.Error || error{Encoding}; /// Code points of a raw JSON string, surrogate pairs joined; a lone @@ -457,12 +471,16 @@ pub const Py = union(enum) { list: []const Py, dict: []const Entry, + /// One key and its value in a `Py.dict`. `dumps` writes them in this + /// order unless it sorts the keys. pub const Entry = struct { key: []const u8, value: Py }; + /// `v` as a Python string. pub fn s(v: []const u8) Py { return .{ .str = v }; } + /// `v` as a Python string, or `null` (Python's None) when `v` is null. pub fn opt(v: ?[]const u8) Py { return if (v) |x| .{ .str = x } else .null; } diff --git a/src/logs.zig b/src/logs.zig index e388aed..abce3f1 100644 --- a/src/logs.zig +++ b/src/logs.zig @@ -9,8 +9,13 @@ const Allocator = std.mem.Allocator; const Io = std.Io; const flate = std.compress.flate; +/// The name of the list of log files that may carry a licence number, one +/// path per line. `renameInList` gives its text after files are renamed. pub const licensed_list = ".licensed-logs"; +/// The errors of `gzipInPlace`: the `sys.Error` of a failed call, +/// `error.OutOfMemory`, or `error.WriteFailed` from writing the +/// compressed stream. pub const GzipError = sys.Error || Allocator.Error || error{WriteFailed}; /// Replace `dir/name` with `dir/name.gz`, as `gzip -9 name` does: the header diff --git a/src/proc.zig b/src/proc.zig index c6726b9..bc198fd 100644 --- a/src/proc.zig +++ b/src/proc.zig @@ -11,10 +11,15 @@ const sys = @import("sys.zig"); const fsx = @import("fsx.zig"); const Allocator = std.mem.Allocator; +/// The child's environment block, as execve(2) takes it; `env.Builder.envp` +/// makes one. pub const Envp = [*:null]const ?[*:0]const u8; +/// How the child ended. pub const Term = union(enum) { + /// Its exit status, 0 to 255. exited: u8, + /// The number of the signal that killed it. signaled: u32, /// The shell's view of the status: the exit code, or 128 + signal. @@ -26,6 +31,9 @@ pub const Term = union(enum) { } }; +/// How `run` starts the child and waits for it. By default stdout may be +/// up to 1 MiB, stderr goes to /dev/null, and the child's process group is +/// killed 300 000 ms after the start. pub const Options = struct { /// Bytes written to the child's stdin, which is then closed; null means /// stdin is /dev/null. @@ -71,17 +79,39 @@ pub const Options = struct { exec_error: bool = false, }; +/// What `run` returns once the child has ended: how, and what it wrote. +/// The two outputs are allocated from the allocator given to `run`; +/// `deinit` frees them. pub const Result = struct { term: Term, + /// What the child wrote to stdout, at most `Options.stdout_limit` + /// bytes. stdout: []u8, + /// What the child wrote to stderr, at most `Options.stderr_limit` + /// bytes; empty when that is 0. stderr: []u8, + /// Free `stdout` and `stderr`, with the allocator `run` was given. pub fn deinit(r: Result, gpa: Allocator) void { gpa.free(r.stdout); gpa.free(r.stderr); } }; +/// The errors of `run`. Each of the first three kills the child's process +/// group, or with `new_session` false the child, before it is returned: +/// +/// - `error.TimedOut`: the child was still running at `Options.timeout_ms` +/// - `error.Canceled`: `Options.cancel` was set +/// - `error.StreamTooLong`: stdout passed `Options.stdout_limit`, with +/// `stdout_overflow` at `.fail` +/// - `error.NotAbsolute`: `exe` does not start with `/` +/// - `error.InvalidArgument`: `exe` or an argument has a NUL byte +/// - `error.NoChild`: the caller ignores SIGCHLD, so the status is lost +/// +/// With `Options.exec_error`, a failed exec is its errno's `sys.Error`, +/// such as `error.NotFound` for ENOENT. Otherwise it is a child that +/// exits 127. pub const Error = sys.Error || Allocator.Error || error{ StreamTooLong, TimedOut, Canceled, NotAbsolute }; /// Search `path_env` (colon-separated, an empty entry meaning the current diff --git a/src/pytext.zig b/src/pytext.zig index c3c28d9..89b987a 100644 --- a/src/pytext.zig +++ b/src/pytext.zig @@ -10,9 +10,11 @@ fn isAlnumU(c: u8) bool { return std.ascii.isAlphanumeric(c) or c == '_'; } +/// One character of a byte string, as `nextChar` reads it. pub const Char = struct { /// The code point, or null for a byte that is not part of valid UTF-8. cp: ?u21, + /// Its length in bytes: 1 to 4, and 1 when `cp` is null. len: u3, }; diff --git a/src/root.zig b/src/root.zig index 256b4ed..58fbc0f 100644 --- a/src/root.zig +++ b/src/root.zig @@ -1,13 +1,23 @@ //! zig-common: the pieces the stackhands Zig tools share. Linux only. +/// Linux system calls with errno mapped to a Zig error set. pub const sys = @import("sys.zig"); +/// File handling with the checks done on the open file descriptor. pub const fsx = @import("fsx.zig"); +/// Running a child program. pub const proc = @import("proc.zig"); +/// Log files: gzip in place, and the `.licensed-logs` list. pub const logs = @import("logs.zig"); +/// Messages, the exit code for usage errors, and the version line. pub const cli = @import("cli.zig"); +/// The environment as the C library sees it. pub const env = @import("env.zig"); +/// Private state files in a directory other users may write. pub const state = @import("state.zig"); +/// JSON as the Python tools these programs replace read and wrote it. pub const json = @import("json.zig"); +/// Python's view of byte strings. pub const pytext = @import("pytext.zig"); +/// Replacing a file whose owner, mode and ACLs must survive. pub const atomic = @import("atomic.zig"); test { diff --git a/src/state.zig b/src/state.zig index d2217c4..14802c5 100644 --- a/src/state.zig +++ b/src/state.zig @@ -9,6 +9,7 @@ const sys = @import("sys.zig"); const fsx = @import("fsx.zig"); const Allocator = std.mem.Allocator; +/// The errors of this module's calls: `sys.Error`. pub const Error = sys.Error; /// Regular, owned by `uid`, one link, mode & 0o077 == 0. @@ -40,6 +41,8 @@ pub fn openPrivate(dir: fsx.fd_t, name: []const u8, create: bool) Error!?fsx.fd_ return fd; } +/// The errors of `lockExclusive`: the `sys.Error` of a failed flock, or +/// `error.TimedOut` when another holder kept the lock past the timeout. pub const LockError = Error || error{TimedOut}; /// flock(LOCK_EX) on `fd`, giving up after `timeout_ms` when one is given. @@ -205,14 +208,20 @@ test "a lock that fails reports its errno, with or without a timeout" { /// name is never opened, and the file behind a planted hard link, or a file /// another user owns, is never truncated. pub const RootLock = struct { + /// STATE_ROOT/.lock, with the flock held. gate: fsx.fd_t, + /// STATE_ROOT/.lock.posix, with the record lock held. posix: fsx.fd_t, /// The process that took the lock. A forked child that releases it only /// closes its descriptors: unlocking the shared gate would drop the /// parent's lock. owner: linux.pid_t, + /// The errors of `acquire`, beside the `sys.Error` of a failed call. + /// `error.OutOfMemory` stays in the set with the `gpa` argument; it is + /// not returned. pub const AcquireError = Error || error{ + /// Another holder kept a lock past `timeout_ms`. Busy, /// STATE_ROOT/.lock.posix is not a regular file of this user with /// one link. @@ -370,6 +379,8 @@ pub const LockOps = struct { var test_lock_ops: LockOps = .{}; const real_lock_ops: LockOps = .{}; +/// The calls in use. A replaceable build may assign through it +/// (`lock_ops.* = ...`); any other build points it at constant real calls. pub const lock_ops = if (@import("atomic.zig").replaceable) &test_lock_ops else &real_lock_ops; fn realFlock(fd: fsx.fd_t, op: i32) usize { diff --git a/src/sys.zig b/src/sys.zig index ec130c7..56056c1 100644 --- a/src/sys.zig +++ b/src/sys.zig @@ -4,11 +4,34 @@ const std = @import("std"); const linux = std.os.linux; +/// A file descriptor, as `std.os.linux.fd_t`. pub const fd_t = linux.fd_t; +/// The open(2) flags, as `std.os.linux.O`. `openat` adds `CLOEXEC` to +/// every set it is given. pub const O = linux.O; +/// The constants of the `*at` calls, as `std.os.linux.AT`: `AT.FDCWD`, +/// `AT.REMOVEDIR`, `AT.SYMLINK_NOFOLLOW` and the rest. pub const AT = linux.AT; +/// The size of a path buffer, NUL included: Linux's `PATH_MAX`. `z` refuses +/// a path of this many bytes or more with `error.NameTooLong`. pub const path_max = 4096; +/// The error a failed call returns, named for its errno. Several errnos +/// share one error, and `last_errno` keeps the errno itself: +/// +/// - `AccessDenied`: EACCES and EPERM +/// - `NoSpace`: ENOSPC and EDQUOT +/// - `Busy`: EBUSY and ETXTBSY +/// - `InvalidArgument`: EINVAL and EBADF +/// - `Unsupported`: EOPNOTSUPP and ENOSYS +/// - `Unexpected`: any errno not named here +/// +/// Each other error has one errno: `NotFound` ENOENT, `Exists` EEXIST, +/// `SymLink` ELOOP, `NotDir` ENOTDIR, `IsDir` EISDIR, `NotEmpty` ENOTEMPTY, +/// `CrossDevice` EXDEV, `NameTooLong` ENAMETOOLONG, `TooManyLinks` EMLINK, +/// `ReadOnly` EROFS, `NoData` ENODATA, `Range` ERANGE, `NoChild` ECHILD and +/// `NoProcess` ESRCH. EINTR is not an error: `call` retries it, and +/// `result` returns null for it. pub const Error = error{ NotFound, Exists, @@ -296,6 +319,11 @@ pub fn z(buf: *[path_max:0]u8, s: []const u8) Error![:0]const u8 { return buf[0..s.len :0]; } +/// openat(2) of `path` relative to `dir`, with `CLOEXEC` added to `flags`; +/// `mode` applies when `flags` creates the file. Returns the new +/// descriptor, which the caller closes. A path with a NUL byte is +/// `error.InvalidArgument`, one of `path_max` bytes or more +/// `error.NameTooLong`. pub fn openat(dir: fd_t, path: []const u8, flags: O, mode: linux.mode_t) Error!fd_t { var buf: [path_max:0]u8 = undefined; var f = flags; @@ -304,14 +332,19 @@ pub fn openat(dir: fd_t, path: []const u8, flags: O, mode: linux.mode_t) Error!f return @intCast(rc); } +/// close(2). The result is ignored: Linux frees the descriptor even when +/// close fails, so there is nothing to retry. pub fn close(fd: fd_t) void { _ = linux.close(fd); } +/// read(2) into `buf`: the number of bytes read, 0 at the end of the file. pub fn read(fd: fd_t, buf: []u8) Error!usize { return call(linux.read, .{ fd, buf.ptr, buf.len }); } +/// write(2) until all of `bytes` is written, going on after a short write. +/// A write that returns 0 is `error.NoSpace`. pub fn writeAll(fd: fd_t, bytes: []const u8) Error!void { var off: usize = 0; while (off < bytes.len) { @@ -321,29 +354,40 @@ pub fn writeAll(fd: fd_t, bytes: []const u8) Error!void { } } +/// fchmod(2): set the permission bits of an open file to `mode`. pub fn fchmod(fd: fd_t, mode: linux.mode_t) Error!void { _ = try call(linux.fchmod, .{ fd, mode }); } +/// fchown(2): set the owner and group of an open file. Changing the owner +/// needs privilege, and is `error.AccessDenied` without it. pub fn fchown(fd: fd_t, uid: linux.uid_t, gid: linux.gid_t) Error!void { _ = try call(linux.fchown, .{ fd, uid, gid }); } +/// fsync(2): return once the file's data and metadata are on stable +/// storage. For a directory, that includes the names in it. pub fn fsync(fd: fd_t) Error!void { _ = try call(linux.fsync, .{fd}); } +/// unlinkat(2) of `path` relative to `dir`. `flags` is 0 for a file and +/// `AT.REMOVEDIR` for an empty directory. pub fn unlinkat(dir: fd_t, path: []const u8, flags: u32) Error!void { var buf: [path_max:0]u8 = undefined; _ = try call(linux.unlinkat, .{ dir, (try z(&buf, path)).ptr, flags }); } +/// renameat(2): rename `old_dir/old` to `new_dir/new`, replacing `new` in +/// one step when it exists. Both must be on one file system, or it is +/// `error.CrossDevice`. pub fn renameat(old_dir: fd_t, old: []const u8, new_dir: fd_t, new: []const u8) Error!void { var a: [path_max:0]u8 = undefined; var b: [path_max:0]u8 = undefined; _ = try call(linux.renameat, .{ old_dir, (try z(&a, old)).ptr, new_dir, (try z(&b, new)).ptr }); } +/// The real user id of this process, getuid(2). pub fn getuid() linux.uid_t { return linux.getuid(); }