Skip to main content

Madly

Madly's minimal Dr. Evil-inspired portrait, with a bald head, high collar and finger at the mouth

Markdown reports and Vue presentations. One installation. Clean project folders.

Madly is the mischievous genius coordinating a team of excellent tools. It sits on top of Quarto and Typst for professional documents, and Slidev and Vue for beautiful presentations. You write Markdown and add images; Madly takes care of setup, preview, incremental builds and publishing through one command.

Markdown and images enter Madly, which manages shared caches and incremental builds, then produces Slidev/Vue presentations in HTML and PDF or Quarto/Typst documents in PDF and HTML

PyPI package · Changelog

Quick start — Linux

Requires Linux x86-64, Python 3.12+ and pipx. Install pipx first if needed; Windows users start with WSL2.

Install once:

pipx install madly

Installation takes a few minutes: it installs Madly, Pixi, Quarto/Typst, Node, Slidev and the PDF browser in your user environment. Every project reuses these tools. There is no setup command or renderer download on the first build.

Beautiful presentation

Create Vue slides, generate a PDF slide deck and open the presentation website:

madly create my-slides --type slides
cd my-slides
madly edit --title "Project review" --author "Austin Powell"
madly build
madly serve --open

Edit slides in src/slides.md and src/chapters/, with images in src/images/. The PDF is in output/pdf/; the preview includes an Open PDF link.

Professional document

Create a Quarto/Typst report, generate its PDF and open the document website:

madly create my-report --type report
cd my-report
madly edit --title "Technical report" --author "Austin Powell"
madly build
madly serve --open

Edit text in src/index.md and src/chapters/, with images in src/images/. The PDF is in output/pdf/; the preview includes an Open PDF link.

Choose either quick start. Both templates, including example content and layouts, are installed with Madly and work offline. my-report and my-slides are destination folders; choose any names you like. --type selects the template. Use madly create . --type report to create a report in the current empty folder.

Edit, build and preview

Inside either project:

madly edit          # interactively change title, author and other mad.yml metadata
# Edit Markdown and images in src/ with your usual text editor.
madly build         # write HTML and PDF to output/; print a clickable PDF file link
madly serve --open  # serve HTML and PDF; update both after edits

madly edit changes project metadata; document text and slides stay in your editor. Use options such as madly edit --title "Annual report" --author "Austin Powell" to update specific fields without prompts.

serve also builds both formats when run on its own. It prints clickable HTTP links to the preview and PDF, and adds Open PDF in the browser. After source edits, it rebuilds both formats and reloads the preview. Use madly serve --format html to preview just HTML. Press Ctrl+C to stop. Unchanged renders are reused.

Update

pipx upgrade madly

Existing projects work whenever their document format is supported, independently of the Madly application version. No project lockfile or routine project upgrade is required. Madly manages its own Pixi version and renderer dependencies. Updating Madly leaves authored project files, including copied template filters and styles, unchanged.

Help and completion

madly             # getting-started guide and commands
madly help build  # help for one command; madly build --help also works
madly --install-completion

The last command enables optional shell completion. It detects your shell and installs completion for new Bash, Zsh or Fish terminals; run it again when you change shells. Use madly --show-completion to inspect the generated script. Package installers do not configure your interactive shell automatically.

Templates

--type report and --type slides select the local report and slides templates. A fresh installation uses the bundled defaults. Personal templates with those names can override them; madly templates list shows the selected source directories. To choose a different template, supply it explicitly:

madly create project_quotation --template ./my-templates/quotation
madly create project_review --template 'git+https://gitlab.com/example/templates.git' --subdir slides

The destination is always the directory after create. A custom template supplies its own project type, so --type is unnecessary when using --template. Only an explicit Git URL downloads a template.

How it works

  • One installation and update route. pipx installs Madly from PyPI in an isolated user environment, including both rendering toolchains, and exposes the madly command. pipx upgrade madly updates the application and its tools.
  • Powerful engines, already integrated. Quarto with its embedded Typst for document PDFs and HTML; Slidev with Vue for presentation HTML and PDF exports.
  • Shared caches. Madly uses Pixi internally to manage the toolchain. Python, Node, renderer dependencies and browsers are reused across projects.
  • Incremental builds. Pixi tracks inputs and outputs, reusing unchanged HTML and PDF renders. Source edits, removed inputs and missing outputs trigger the relevant build task.
  • Content stays portable. Markdown, images, layouts and configuration stay in your project. There are no project-local virtual environments or node_modules.
  • One workflow. Create from local or Git templates, build, preview, clean, and publish to GitLab Pages or GitHub Pages with the same commands for both types.

Command reference

The syntax is madly [GLOBAL OPTIONS] COMMAND [OPTIONS] [DIRECTORY]. Actions are commands (create, build, serve, publish); choices use named options (--type, --format, --provider).

Both project types have the same commands:

Command Result
madly create my-report --type report, madly create my-slides --type slides Create a project in the named destination directory
madly edit Interactively edit title, author and other metadata in mad.yml
madly edit --title "Annual report" --author "Austin Powell" Change selected metadata without prompts
madly edit --status review Change the current history entry's lifecycle status
madly doctor Show selected project, runtime and output locations
madly build Generate both HTML and PDF incrementally
madly build --format html, madly build --format pdf Generate one format
madly build --force Regenerate even when cached outputs are current
madly build --format pdf --watch Regenerate PDF after edits
madly serve --port 3030 Serve HTML with a PDF link; rebuild both formats after edits
madly serve --open Also open the preview in a browser
madly serve --format html Build and preview only HTML, without a PDF link
madly serve --no-watch Build and serve HTML and PDF without watching sources
madly publish --provider github Publish HTML through GitHub Pages CI
madly publish --provider gitlab --format all Publish HTML with PDF downloads through GitLab Pages CI
madly clean Remove this project's generated output
madly clean --cache Also remove this project's cached renders
madly cache prune --days 30 Remove unused renders, Git templates and installer caches; keep installed tools

Use madly --project /path/to/project build --format pdf from another directory. Relative project paths, such as madly --project ../report build, start from your working directory. Global options precede the command. --output / -o overrides the output directory for build, serve and clean; relative output paths are resolved from the project root. build --base-path /reports/ sets the HTML deployment path. Only empty or Madly-owned output directories can be replaced or cleaned. An existing nonempty unrelated directory is preserved and produces an error.

All commands support -h / --help. Typer provides completion for commands and option choices, including project types, formats, providers and template names. templates list/export and cache path/prune group actions on those resources; project types and rendering formats are option values, never extra commands. The interface follows the Command Line Interface Guidelines for named options and the pip Git URL convention for optional git+https:// and git+ssh:// template sources.

Live preview uses production HTML and PDF builds followed by incremental rebuilds and browser reloads. The PDF link always serves the current generated file, even after a version or filename change. The preview's Open PDF link and reload script are added only to HTTP responses; exported HTML and PDFs are unchanged. Its behavior is the same for documents and presentations. It does not provide Slidev's editor or Vue component hot replacement. Preview binds to 127.0.0.1 by default; --host changes that explicitly. A browser opens only when --open is supplied.

What to copy or commit

report-or-slides/
├── mad.yml                 # document schema, type, entry, metadata, history and template origin
├── README.md
├── .gitignore
├── src/
│   ├── index.md            # document entry; presentation uses slides.md
│   ├── chapters/           # optional; files can also be directly under src/
│   ├── images/
│   └── ...                 # authored styles, fonts, layouts, render configuration
├── resources/              # optional supporting authored inputs
└── output/                 # generated and ignored
    ├── html/               # complete static site
    └── pdf/                # current PDF

Share editable work: copy the project excluding output/, or clone its Git repository. The recipient installs Madly separately. There is no environment or tool implementation to copy. Share a finished PDF: send the PDF in output/pdf/. Share offline HTML: send all of output/html/ and serve it over HTTP; a single index.html does not contain its JavaScript, CSS, fonts and images.

src/ and resources/ are copied into a cached render workspace. Python locates the project from the caller or --project; it never assumes user content is next to the installed Python module. Authored source symlinks are rejected so a shared project cannot silently depend on files outside its directory.

Renderer configuration and styling are authored project data. They stay with the project so it remains editable and visually reproducible. Node and Python dependencies are tool data and are installed centrally. Projects do not need a package.json, pyproject.toml, pixi.toml, wrapper script, node_modules, .venv, .pixi, or environment symlink.

Documents: Quarto and Typst

The report template is a generic document with a cover, management summary, history, contents, chapters, references and shared HTML/PDF styling. It is not tied to a questionnaire or any particular industry.

Quarto configuration lives in src/_quarto.yml; the supplied report layout lives in src/_extensions/report/. Put common metadata in mad.yml, and keep chapter order, typography, citations and renderer settings in _quarto.yml. Duplicate common metadata across the two files is rejected. For a Quarto book, the title is injected into book.title automatically.

PDF rendering always selects typst or a custom *-typst format. Quarto supplies its own Typst binary. Madly does not install a second Typst binary or a TeX stack. The supplied Lua filter manages report front matter, history and references; it does not contain questionnaire-specific formatting rules.

A single-file document also works: use entry: src/index.md in mad.yml, remove the book configuration, and use this _quarto.yml:

project:
  type: default
format:
  html: {}
  typst: {}

Presentations: Slidev and Vue

The slides template includes neutral Vue layouts, reusable cards, local Manrope fonts and an example image. Content starts at src/slides.md. You may keep every slide there, separated by ---, or include chapter files using Slidev's native syntax:

---
src: ./chapters/overview.md
---

Keep native Slidev options in the entry file's front matter. Keep title, author and other shared metadata in mad.yml. Images belong in src/images/, custom Vue components in src/components/, layouts in src/layouts/, and styles in src/style.css. Use relative image and font references so deployment under a subdirectory works. The lockfile deliberately pins FloatingVue 5.2.2 because the selected Shiki Twoslash integration relies on its component structure. Madly defaults preloadImages to false: Slidev's optional extra preloader uses raw Markdown image URLs, which do not match Vite's bundled assets. Normal image loading still works. An explicit native front-matter setting can override this.

Templates and personal defaults

create creates a working project in the destination folder you give it. The folder name is your choice. --type selects a default template, while --template selects a specific template to copy.

# Create ./project_quotation using the default report template
madly create project_quotation --type report

# Create ./project_review using the default slides template
madly create project_review --type slides

# Create a project directly in the current empty folder
madly create . --type report

For example, madly create report --type slides would create a slides project in a folder named report. The destination name never selects a template. Use descriptive names such as project_quotation to make that distinction clear.

To customize and reuse templates:

# Show the available template names and source folders
madly templates list

# Copy editable templates into ./my-templates/report and ./my-templates/slides
madly templates export ./my-templates

# Edit ./my-templates/report, then copy it into a new working project
madly create project_quotation --template ./my-templates/report

templates export copies reusable templates. create copies a selected template into a project with its own identity and metadata. Editing the resulting project does not edit the template. A custom template supplies its own report/slides type.

You can also select a template from another local folder:

madly create project_quotation --template ../company-templates/quotation
madly create . --template /path/to/my-template

Relative paths are resolved from the caller's directory (or --project), not from the installed tool. --template also fetches templates directly from Git:

# Repository whose root contains mad.yml
madly create project_quotation --template git+https://gitlab.com/example/report-template.git
madly create project_quotation --template git@gitlab.com:example/report-template.git
madly create project_quotation --template git+ssh://git@gitlab.com/example/report-template.git

# A folder in a template collection, optionally pinned to a branch, tag or commit
madly create project_quotation --template git+https://gitlab.com/safetygence-oss/tools/madly.git \
  --subdir templates/report --ref main

# The same repository, revision and folder in one quoted URL
madly create project_quotation --template 'git+https://gitlab.com/safetygence-oss/tools/madly.git@main#subdirectory=templates/report'

# A GitLab browser link directly to the desired template folder
madly create project_review --template https://gitlab.com/safetygence-oss/tools/madly/-/tree/main/templates/slides

HTTPS repository URLs with or without .git and standard SSH clone URLs work, with optional git+ prefixes on HTTPS/SSH scheme URLs. For a single source string, git+https://REPOSITORY.git@REF#subdirectory=FOLDER (or git+ssh://...) selects a revision and folder. Quote URLs containing shell punctuation. A GitLab browser folder URL also works with a git+https:// prefix.

--subdir selects a folder inside the repository; the default is its root. --ref defaults to the repository's current HEAD. Use a tag or commit for a fixed template version. GitLab folder links supply both values directly; for branch names containing /, use the clone URL with --ref and --subdir, or percent-encode the slash in the link's revision component. Explicit --ref and --subdir options override selections embedded in a URL. For a local template, pass its directory directly; Git selection options do not apply.

Git uses your existing SSH agent/configuration or HTTPS credential helper. URL passwords and access tokens are not accepted or written into project files. Each creation fetches the requested revision and records the repository, folder, requested ref and resolved commit under template in mad.yml. A failed fetch reports an error without silently using an older cached revision or creating a partial project.

The bare Git repository and its current extracted template stay in ~/.cache/mad/templates/. Creation copies only authored template files, without Git history, tool dependencies or environments. One extracted template per URL is retained, even when switching revisions; madly cache prune --days 30 also removes inactive Git-template caches. Git acquisition does not run template setup scripts or fetch submodules. Ordinary local template paths remain usable offline.

Exported templates live in ~/.local/share/mad/templates/, a durable location outside caches. You can instead run madly templates export ~/bin/mad-templates. Export never overwrites existing templates. A template is a normal authored project; creation copies its sources and assets, gives it a fresh project ID, and records its template origin. Existing nonempty destinations are refused.

Template lookup uses paths configured in ~/.config/mad/config.yml, then the standard user template directory, ~/bin/mad-templates, and bundled defaults:

defaults:
  author: Austin Powell
template-paths:
  - ~/company-templates

--author and --title override template values. This supports personal and company templates without putting private branding or customer information into the public tool repository.

Version and lifecycle status

History is optional and works for either project type. If present, its last entry defines the current version, date and status. The report filter renders that history; there is no second manually maintained history table.

madly status
madly version
madly version --bump minor --message "Added analysis"
madly version 1.0 --message "First release"
madly edit --status review
madly edit --status approved --date 2026-10-16
madly edit --title "Technical report" --author "Austin Powell"

madly --version prints the installed tool version; madly version prints the project version. Set a version number or use --bump major|minor, with a required --message / -m. New history entries accept --author, --status and --date; status defaults to draft and date to today. madly edit --status changes the current history entry without adding another version. With no options, madly edit prompts for metadata; supplied options update only the named values.

PDF names follow <name>-v<version>-<status>.pdf; approved PDFs omit the status. Without history the name is simply <name>.pdf. Output is replaced on each successful render, so obsolete filenames do not accumulate. Keep deliberately released versions in a separate authored releases/ directory or a release registry; clean only owns generated output.

Publishing

Set the actual Pages site root in mad.yml. Git remote URLs cannot reliably identify it, especially with GitLab unique domains or custom domains.

publish:
  gitlab:
    remote: origin
    branch: github_pages
    base-url: https://example.gitlab.io/reports/
    subdir: annual-report
  github:
    remote: github
    branch: github_pages
    base-url: https://example.github.io/reports/
    subdir: annual-report

The resulting URL is base-url + subdir + /. Use subdir: '' to deploy at the site root. That replaces the whole site; a nonempty subdirectory replaces only that project's subtree and preserves siblings. Configure separate subdirectories for projects sharing one deployment branch.

When mad.yml configures exactly one provider, madly publish selects it automatically. Pass --provider when no provider or both providers are configured, or to override that selection.

madly publish --provider gitlab --format all --dry-run
madly publish --provider gitlab --format all
madly publish --provider github --branch pages --base-url https://example.github.io/reports/

The default branch is github_pages for both providers. All configuration fields can be overridden on the command line. Publishing requires a Git repository with at least one source commit, a configured remote, Git identity and push access. It uses a temporary worktree, boots an orphan deployment branch when needed, and pushes normally without force-pushing or switching the source checkout. Uncommitted source edits remain intact.

The default deployment: pipeline keeps rendered artifacts under site/. GitLab receives a real Pages job with pages.publish: site. GitHub receives a pinned Actions workflow that uploads and deploys the Pages artifact. For GitHub pipeline deployment, select GitHub Actions in repository Settings → Pages before the first deployment; ensure any environment branch restrictions allow the deployment branch. GitLab needs an available runner and Pages enabled. Existing conflicting CI configuration is preserved and reported as an error.

For an existing GitHub Pages site that uses Deploy from a branch, select deployment: branch instead:

publish:
  github:
    remote: origin
    branch: github_pages
    deployment: branch
    base-url: https://example.github.io/reports/
    subdir: annual-report
madly publish --format all --dry-run
madly publish --format all

Branch deployment puts artifacts directly under annual-report/ in the deployment branch, rather than site/annual-report/, and adds .nojekyll at the branch root. It does not create an Actions workflow or change repository settings. Nonempty subdirectories preserve other reports and existing workflows. An empty subdir replaces the branch's site content while retaining Git metadata. The existing Pages settings must serve the configured branch's root directory. github_pages, github-pages and gh-pages are ordinary configurable branch names, not provider names; use the name your repository already serves. --deployment branch overrides the configuration. Branch deployment is supported only for GitHub; GitLab still requires its Pages pipeline.

A successful push is reported as deployment pending, not as confirmation that the site is live. Both deployment modes require Git push access and connectivity to the publishing remote.

--format html (the default) publishes the site only, excluding PDFs left by previous builds. --format all also places PDFs under downloads/ with a download index. Pages publishing requires HTML; standalone PDF delivery uses madly build --format pdf. Speaker notes are omitted from published slides by default; use --include-notes to include them. Local builds retain notes.

Caching, cleanup and reproducibility

Pixi's native task input/output fingerprints decide whether HTML and PDF need rendering. The task inputs include the source tree, resources, metadata, lockfile, output options and tool implementation signature. Missing outputs and removed inputs invalidate the relevant task. Madly mirrors input deletions into staging and replaces complete output directories after successful rendering. A failed build leaves the last successful project output intact.

The application and all rendering tools live in pipx's user environment. Pixi manages their locked versions during installation and runs the build graph without installing anything during normal rendering. The first render only restores local filesystem links and adjusts native paths, which takes a moment.

The shared cache layout is approximately:

~/.cache/mad/
├── bundles/<build-hash>/    # reusable installation build artifacts
├── pixi/<version>/          # verified manager used while building the installation
├── toolchains/<tool-hash>/  # manifests, native Pixi task cache and project workspaces
├── templates/<url-hash>/    # downloaded Git repository and current template
└── locks/                  # serialize changes to a project
~/.cache/rattler/            # downloaded native packages used during installation

Every project shares runtime installations; render workspaces are isolated by absolute project path and publishing variant. Copying a project creates an independent cache. XDG locations are respected; MAD_CACHE_HOME can override Madly's cache directory and must be outside the authored project.

The package build downloads its pinned Pixi from prefix-dev's official GitHub release and verifies the archive's SHA-256. It leaves any separate Pixi installation alone. Updating Madly selects the tested manager and renderer versions shipped with that release; users do not maintain those tools separately.

Use madly clean for deliverables, madly clean --cache for one project's render cache, and madly cache prune --days 30 for inactive project, Git-template and installation build caches. Pruning skips active installations. These commands retain installed runtimes and personal templates. pipx owns installed runtime files and removes them when the application is uninstalled. Installation build caches are not needed to render. Source development also uses shared Node and browser caches outside the checkout.

schema in mad.yml identifies the document format and its processing contract, independently of the Madly application version. Madly 1.0 supports schemas 1 and 2. New projects use schema 2, which stores template origin in mad.yml and needs no mad.lock. Existing schema-1 projects work without conversion, with or without their old lockfile. Legacy lockfiles are ignored and left untouched; retain one if you need its historical template-origin information. The madly lock command has been removed.

The application checks supported document formats locally. A newer format asks the user to update Madly. A retired format asks for an explicit project migration or an older compatible release. Changing the schema number alone is not a migration. There are currently no retired formats or automatic format migrations. Users do not need to edit the schema after application updates, and Madly never automatically rewrites projects or checks online for newer releases. New document features may introduce a new schema; ordinary bug fixes do not.

Rendering uses the installed toolchain. Native and Node dependencies remain pinned inside Madly; using the same release and authored inputs helps reproduce earlier output. Remote images, custom code that fetches data and host-provided fonts are outside the cache's dependency graph. Vendor those inputs into src/ or resources/ when reproducibility matters. Templates and custom renderer code execute locally, so use templates from sources you trust.

Development and verification

See CONTRIBUTING.md for the contribution workflow, required checks and contribution license.

Only contributors need a source checkout and a separate Pixi installation:

git clone https://gitlab.com/safetygence-oss/tools/madly.git
cd madly
pixi run --locked madly --help
pixi run --locked lint
pixi run --locked test
pixi run --locked integration
pixi run --locked package

Unit tests cover project isolation, metadata, path safety and publication to temporary bare Git repositories for both providers. Template tests fetch real synthetic repositories through HTTPS/SSH URL rewrites and cover revisions, provenance, source isolation, download failures and cache cleanup. Integration tests render single-file and chapter-based documents/presentations and verify cache reuse, input deletion, missing-output regeneration, source isolation and cleanup. Source integration tests prepare the same locked native tools in development caches. Wheels and source archives are written to output/packages/. CI tests pipx installations from the source archive and the complete platform wheel, outside the checkout. It renders reports and slides to HTML and PDF with Pixi offline and download proxies disabled, verifies unchanged build reuse, and checks that authored directories contain no environments or dependencies. A synthetic old release verifies the ordinary pipx upgrade madly command and renders all four outputs again after upgrading.

PyPI distributes a small source archive. During pipx install, its standard Python build hook uses Pixi and the Node lockfile to prepare a complete platform wheel, including the headless Chromium browser and its native libraries. pip can reuse that wheel without running the build hook again: it contains the actual runtime files, not references to the build machine's cache. Native paths are relocated locally before first use. No post-install Python startup hooks or shell profile changes are used. Native dependencies remain pinned in pixi.toml / pixi.lock; development-only Python tools are excluded from the rendering environment.

PyPI releases

The publish-pypi GitLab job uploads the verified source archive on protected release tags matching vX.Y.Z. Tests require the tag, CLI, pyproject.toml and Pixi workspace versions to agree. Branch pipelines never publish. The job uses PyPI trusted publishing and uv publish --trusted-publishing always; no permanent PyPI token is needed. Before uploading, the same job generates a PyPI publish attestation using its GitLab Sigstore identity. Both the source archive and its attestation are passed explicitly to uv. The job then verifies the published archive's provenance against the GitLab repository before reporting success. The attestation binds that archive to the publishing pipeline; it does not attest to runtime files later downloaded while building a wheel during installation.

The distribution and executable are both named madly. Published versions and downloads are listed on PyPI.

Before tagging a release, verify a clean pipx installation and upgrade. Both fresh source installations and cached wheels must include the complete runtime. The large platform wheel is built locally and is not uploaded to PyPI.

Publisher configuration

The package owner manages the trusted publisher under Publishing in the PyPI project's settings. Select GitLab CI/CD and use:

PyPI field Value
PyPI project madly
Namespace safetygence-oss/tools
GitLab project / repository name madly
Top-level pipeline file path .gitlab-ci.yml
Environment name pypi

The namespace is the repository's hosting address. For the first release, register these values as a pending publisher under PyPI account → Publishing. The first successful upload creates the project; see PyPI's pending-publisher instructions.

If a publishing job reports invalid-publisher, a package owner should check these values in PyPI's project publishing settings. The namespace includes /tools, the filename starts with a dot, and the environment is pypi (the job name is publish-pypi). After correcting the configuration, click Retry on the failed GitLab job while its verification artifacts remain available. The upload job uses those artifacts without rebuilding them. See PyPI's instructions for managing a publisher on an existing project.

Later releases

GitLab already protects the v* tag pattern and allows Maintainers to create release tags. Update all package/CLI versions together, run the verification commands, and push a new matching release tag. The publishing job consumes the artifacts produced by verify; it does not rebuild them. Published tags and package versions stay unchanged. Confirm that the publishing job succeeds and the version appears on PyPI before announcing its PyPI availability.

License

Copyright © 2026 SAFETYGENCE sp. z o.o.

Created by Piotr Serwa. Maintained by SAFETYGENCE sp. z o.o.

Madly is free and open source. Current tool development is licensed under the Mozilla Public License 2.0. The original report and slides templates remain under 0BSD; each includes its own license, which is copied into projects created from that template. Previously published 0.1.0 and 0.1.1 packages and tags retain their original 0BSD license. Bundled third-party assets retain their licenses; see NOTICE. Fedora/Ubuntu repositories and a public Conda channel are not distribution targets yet.

Metadata

Release files for madly 1.0.1

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for madly 1.0.1
File Size Uploaded Provenance Actions
madly-1.0.1.tar.gz 968.2 kB With provenance Details for madly-1.0.1.tar.gz

Release files / madly-1.0.1.tar.gz

Download URL madly-1.0.1.tar.gz
Size 968.2 kB
Tags Source
SHA-256 checksum
How to use checksums
4c8d658f54264eae06ee3fefbd2a91f54bd2a8d3d2a493e77d6b195e319ad9dc
BLAKE2b-256 checksum
How to use checksums
3730347f3924eacd845a8f997ab7053544992d5a5f58033e2b1a40b2bdeaf662
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via uv/0.12.19 {"installer":{"name":"uv","version":"0.12.19","subcommand":["publish"]},"python":null,"implementation":{"name":null,"version":null},"distro":{"name":"Ubuntu","version":"24.04","id":"noble","libc":null},"system":{"name":null,"release":null},"cpu":null,"openssl_version":null,"setuptools_version":null,"rustc_version":null,"ci":true}

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitLab CI/CD, verified by PyPI on Nov 8, 2026.

Transparency log

Security for madly 1.0.1

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

Full provenance

1 file in this release has been uploaded with provenance metadata.

Attestation for madly-1.0.1.tar.gz

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitLab CI/CD, verified by PyPI on Nov 8, 2026.

Transparency log

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page