Official agent skill

Python Recipe Runnability Test Generator

by google in google/adk-recipes

Generates a minimal tests/test_runnability.py for a Python agent recipe that imports the agent module and checks root_agent, adding only the mocks and env vars it needs.

OfficialApache-2.0Auto-check passedTesting & QA

Install Python Recipe Runnability Test Generator

skills CLI
$ npx skills add google/adk-recipes --skill generate-python-runnability-test -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install google/adk-recipes generate-python-runnability-test --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/google/adk-recipes.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.agents/skills/generate-python-runnability-test .claude/skills/generate-python-runnability-test && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
generate-python-runnability-test
GitHub stars
10k
Token cost
~3.3k tokens
SKILL.md length
1,505 words
Files
4 (incl. scripts)
Skills in repo
14
Repo updated
First seen
Licence
Apache-2.0

At a glance

Generates a minimal tests/test_runnability.py for a Python agent recipe that imports the agent module and checks root_agent, adding only the mocks and env vars it needs.

  • Works in 6 steps: Locate agent.py. Walks the recipe safely… → Parse agent.py AND every ancestor… → Scan all source .py files in the recipe… → …
  • Adding the required runnability test to a new Python recipe
  • SKILL.md covers What This Skill Does, Rules for the Agent, Input and Run, plus 1 more section
  • Runs Python scripts from its folder; calls uv, ruff and git

What it does

The generated test is deliberately small: it imports the recipe's agent module and asserts that `root_agent` is not None, and `app` too if the module defines one. The skill runs `scripts/generate_runnability_test.py` against a recipe directory, finds the shallowest `agent.py` while skipping virtualenvs, build output, caches, `node_modules` and tests, and writes one file per run. If none is found it stops and suggests the `--agent-file` option.

To decide what boilerplate is needed, it parses `agent.py` and every ancestor package `__init__.py` with `ast`. It looks for top-level `root_agent` and `app` assignments, import-time calls such as `vertexai.init` and `google.auth.default` that must be mocked, and reads of `GOOGLE_CLOUD_PROJECT` that the test must set. Writes to the environment are ignored, and detection is intentionally broad so a missed call cannot crash the test. It runs in a dry-run mode that reports and previews, or an apply mode that writes the file, and it fixes the missing-file check in `python-validate-recipe.yml`.

When your agent uses it

  • Adding the required runnability test to a new Python recipe
  • Fixing a CI failure about a missing tests/test_runnability.py
  • Previewing which mocks and environment variables a recipe's import needs

Example prompts

  • “Generate test_runnability.py for the cross-session-memory recipe, dry run first.”
  • “Add a smoke test to plugins/retail/returns-agent so the recipe validation check passes.”
  • “The agent.py is in a nested folder. Generate the runnability test with --agent-file.”

Requirements

  • Python, to run the generator script
  • A Python agent recipe with an agent.py file

Workflow steps

6 steps, taken from the first numbered list in SKILL.md.

  1. Locate agent.py. Walks the recipe safely (excludes .venv, venv, env, build, dist, pycache, node_modules, tests, *.egg-info, and…
  2. Parse agent.py AND every ancestor package __init__.py with ast to detect
  3. Scan all source .py files in the recipe directory tree (same safe walker) for INTEGRATION_TEST env-var reads. This is a per-package…
  4. Emit the test. Two shapes
  5. Check that the import can actually resolve. The generated test does import , which only works if the RECIPE ROOT is on sys.path. That is…
  6. Write it to /tests/test_runnability.py (creating tests/ if needed), plus tests/conftest.py when step 5 called for it. Refuses to clobber…

What it can do on your machine

Read from SKILL.md and the folder at commit fa9bdde. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 1 file in scripts/ (Python), which the agent can run.

    Shell commands in SKILL.md call:

    • uv
    • ruff
    • git

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use uv and git, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Python Recipe Runnability Test Generator loads about 3.3k tokens when it runs. Until then it costs about 196 tokens; SKILL.md has 1,505 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~196
When it runs · the whole SKILL.md, loaded when a task matches
~3.3k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from google/adk-recipes at commit fa9bdde, republished under its Apache-2.0 licence (© google). 1,505 words, ~3,275 tokens.

Download SKILL.mdSave it as .claude/skills/generate-python-runnability-test/SKILL.md (or your agent's skills folder). This skill also uses 3 other files; get the full folder from GitHub.
name
generate-python-runnability-test
description
Generates a lightweight `tests/test_runnability.py` for a Python recipe. The test just imports the recipe's agent module and asserts that `root_agent is not None` (and `app is not None` if the module defines one). The skill parses agent.py with `ast` to figure out which import-time side effects need mocking (`vertexai.init`, `google.auth.default`) and which env vars need setting (`GOOGLE_CLOUD_PROJECT`, `INTEGRATION_TEST`), and only emits the boilerplate the recipe actually needs. Runs in dry-run (report + preview) and apply (write to disk) modes. Use when the user wants to "add a runnability test", "generate test_runnability.py", "create a smoke test for the recipe", or fix the missing-required-file failure from `python-validate-recipe.yml`.
metadata.author
Google
metadata.license
Apache-2.0
metadata.version
1.1.0

Generate Python Runnability Test

Use this skill to create the tests/test_runnability.py file that every Python recipe under core/python/, contrib/python/, or plugins/<vertical>/<solution>/ must ship (see python-validate-recipe.yml Check 4). The generated test is deliberately minimal — it just verifies the agent module imports and defines the expected globals. Business-logic testing lives elsewhere.


What This Skill Does

Runs scripts/generate_runnability_test.py against a recipe directory. Steps:

  1. Locate agent.py. Walks the recipe safely (excludes .venv, venv, env, build, dist, __pycache__, node_modules, tests, *.egg-info, and dot-directories) and picks the shallowest agent.py match. If none is found, errors out and suggests --agent-file. Only one file is generated per invocation.

  2. Parse agent.py AND every ancestor package __init__.py with ast to detect:

    • Top-level assignments (agent.py only, per convention) — is root_agent = ... present? Is app = ... present?
    • Import-time calls (agent.py + every ancestor __init__.py) — does vertexai.init(...) fire at module load? Does google.auth.default()? Every ancestor __init__.py is checked because Python runs each of them in order when the test does import a.b.agent (a/__init__.py, then a/b/__init__.py, then the module), so a side effect in any of them matters as much as one in agent.py. Historical bug closed by this: cross-session-memory has _, project_id = google.auth.default() in __init__.py; before, the scanner missed it and the generated test crashed in CI without ADC. Detection uses ast.walk (any depth), so it is intentionally broad — a call nested in a function body still flags the recipe; the resulting patch is a harmless no-op if it never fires at import time, whereas a missed import-time call would crash the generated test.
    • Env-var access (agent.py + every ancestor __init__.py) — does the code read GOOGLE_CLOUD_PROJECT via os.getenv / os.environ.get / os.environ["…"]? Only reads count: an os.environ["…"] = value write means the recipe sets its own value and doesn't depend on the test providing one, so it's ignored.
  3. Scan all source .py files in the recipe directory tree (same safe walker) for INTEGRATION_TEST env-var reads. This is a per-package convention: agent.py often calls a helper (e.g. retrievers.create_search_tool) at module load, and THAT helper — which may live anywhere in the recipe tree, not necessarily beside agent.py — is what reads INTEGRATION_TEST. Restricting the scan to agent.py would miss it.

  4. Emit the test. Two shapes:

    • Minimal (no side effects detected) — module-level import <module> + assert root_agent is not None (and app is not None if present).
    • Guarded (any side effect detected) — env-var setdefault calls at the top of the test function; a with patch(...): block around the import listing every patch needed (patch("vertexai.init") when vertexai is used, patch("google.auth.default", return_value=(MagicMock(), "test-project")) when the recipe touches google.auth); and assertions outside the with block (the patches are only needed during import; keeping them active around assertions would be misleading).

    The google.auth.default patch is what makes the test survive a recipe that calls google.auth.default() unconditionally at import time (like cross-session-memory's __init__.py). Just setting GOOGLE_CLOUD_PROJECT isn't enough for that pattern — the call still fires and still needs valid ADC — hence the patch.

    Emission is post-processed through ruff format when available, so multi-patch with (...): blocks come out already wrapped per the repo's ruff config.

  5. Check that the import can actually resolve. The generated test does import <module_name>, which only works if the RECIPE ROOT is on sys.path. That is not automatic — under pytest's default prepend import mode only the test file's own directory (<recipe>/tests) is inserted. The recipe root gets there in one of these ways, reported as import_support:

    import_supportMeaning
    installablepyproject.toml declares a [build-system], so uv sync installs the project and the package is importable.
    pythonpath-ini[tool.pytest.ini_options].pythonpath includes ".".
    existing-conftestA conftest.py sits at the recipe root (sufficient whatever it contains — pytest puts each conftest's own directory on sys.path, and for that one it IS the recipe root), or a tests/conftest.py that demonstrably extends sys.path.
    generated-conftestNone of the above held, so the skill wrote tests/conftest.py with a path shim.

    A tests/conftest.py is judged by AST, not text search: it counts only if it really touches sys.path, so a comment or docstring that merely mentions sys.path cannot wrongly certify it.

    Historical bug closed by this: the recipe root being importable was assumed rather than checked. A recipe with no [build-system] — common for vertical plugins under plugins/, where code lives in a plain scripts/ directory rather than an installed package — got a test that always died with ModuleNotFoundError, while prepare-python-recipe's py_compile verification still reported success.

    Adding a [build-system] is the better fix; the generated conftest says so and tells the maintainer to delete it once they do.

  6. Write it to <recipe-dir>/tests/test_runnability.py (creating tests/ if needed), plus tests/conftest.py when step 5 called for it. Refuses to clobber an existing file unless --overwrite is passed.

Edit safety
  • No files outside the target recipe directory are read (beyond the recipe's own .py files) or written.
  • Existing tests/test_runnability.py is never silently overwritten. The user must explicitly opt in with --overwrite.
  • An existing tests/conftest.py is never overwritten, not even with --overwrite — the skill reports conftest_action: skipped and warns instead. A conftest it did not write may do something clobbering would break.
  • tests/ directory is created if missing (mkdir -p equivalent). No other directory or file is added.
  • Ruff-clean by construction — the generated file passes ruff check and ruff format --check under the root config.

Show full SKILL.md (672 more words)Show less

Rules for the Agent

  1. Always use the script — never hand-write tests/test_runnability.py yourself. The skill exists to keep the boilerplate consistent across recipes.

  2. Ask for the recipe directory if the user hasn't given one. Recipe roots live under core/python/<name>/, contrib/python/<name>/, or plugins/<vertical>/<solution>/.

  3. Always start with --dry-run unless the user has explicitly said "apply", "generate it", "just do it", or equivalent. Show them what would land before writing.

  4. Report only what matters. Render a compact 3-column Markdown table (Rule / Status / Details) summarising the action plus the detections. Do NOT dump the raw JSON or the raw generated Python. Include the generated file's content as a fenced code block below the table so the user can review before deciding.

  5. If action is refused_overwrite, tell the user the file already exists and offer to re-run with --overwrite. Don't do it silently.

  6. If action is error, surface the message verbatim and stop. Common cases: no agent.py found (suggest --agent-file), parse error in agent.py.

  7. Offer to apply after a dry-run. Do NOT paste the raw command as a copy-and-paste snippet for the user; ask something like "Want me to write this file?" and if they agree, run apply yourself.

  8. After apply mode succeeds, remind the user to run the test locally to confirm it passes:

    cd <RECIPE_DIR> && uv run pytest tests/test_runnability.py -v
  9. Do not commit any changes. Show the diff or file contents; let the user commit.


Input

FieldRequiredDescription
--recipe-dirYesPath to the recipe root (e.g. core/python/cross-session-memory, contrib/python/my-recipe, plugins/retail/store-ops).
--dry-runNoPrint the JSON report (with the generated content in test_content) without writing any file.
--overwriteNoOverwrite an existing tests/test_runnability.py. Default: refuse and exit 1.
--agent-fileNoOverride auto-detection of the entry-point file. Path is relative to --recipe-dir (or absolute). Use when the recipe uses a non-standard layout (rare — <2% of recipes).

Run

Dry-run (start here)
bash
uv run --no-project python3 .agents/skills/generate-python-runnability-test/scripts/generate_runnability_test.py \
  --recipe-dir <RECIPE_DIR> --dry-run

Output on stdout: JSON with agent_file, module_name, detections, import_support, conftest_path, conftest_action (would_write / wrote / skipped / null), test_content, action (would_write / refused_overwrite / error), message, and warnings (a list — surface every entry to the user). Exit code 0.

Note: no --with flags are needed — the script only uses Python's stdlib (ast, argparse, json, pathlib, dataclasses, os, sys, subprocess, textwrap). uv run --no-project python3 is used (rather than a bare python3) to guarantee a modern managed interpreter, consistent with the other Python recipe skills; the system python3 on macOS can still be an old version. Dry-runs remain cheap and side-effect-free.

Apply
bash
uv run --no-project python3 .agents/skills/generate-python-runnability-test/scripts/generate_runnability_test.py \
  --recipe-dir <RECIPE_DIR>

Writes <RECIPE_DIR>/tests/test_runnability.py. Refuses if the file exists (exit 1).

Apply with overwrite
bash
uv run --no-project python3 .agents/skills/generate-python-runnability-test/scripts/generate_runnability_test.py \
  --recipe-dir <RECIPE_DIR> --overwrite
Override the entry-point file (rare)
bash
uv run --no-project python3 .agents/skills/generate-python-runnability-test/scripts/generate_runnability_test.py \
  --recipe-dir <RECIPE_DIR> --agent-file some/other/entry.py --dry-run

Path is relative to --recipe-dir or absolute. The generated import uses the module path derived from the relative location (e.g. some/other/entry.py → import some.other.entry).


Respond

Do not dump raw JSON. Render a compact table summarising the action and the detections, then include the generated file's content as a fenced code block below.

Table shape
RuleStatusDetails
  • Rule — a short label for what's being reported: agent-file, module, detections, write. Use backticks for clarity.
  • Status — ok / would_write / wrote / refused_overwrite / error. No emoji unless the user has asked.
  • Details — compact prose. For detections, list only what was found (e.g. "root_agent, app, needs vertexai patch + GCP project env + INTEGRATION_TEST env"). Don't list what was NOT found.
After the table
  • Show the generated test_content as a fenced Python code block so the user can review it before deciding.
Closing action
  • would_write (dry-run) — offer to apply yourself. Do NOT paste the raw command. Ask "Want me to write this file?" If the user agrees, run the apply command yourself and render the resulting report as another compact confirmation. If they decline, stop.

  • refused_overwrite — tell the user the file already exists and offer to re-run with --overwrite. Do NOT overwrite silently. If they agree, run with --overwrite.

  • error — surface the message verbatim and stop. Do not attempt to work around it.

  • wrote (apply) — end with:

    Next steps:
      cd <RECIPE_DIR> && uv run pytest tests/test_runnability.py -v
      git diff                                                          # review before committing

Then stop. Do not commit. Do not run any further tools. End your turn.

© google, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 3 other files (scripts) in .agents/skills/generate-python-runnability-test of google/adk-recipes.

  • SKILL.md
  • scripts/generate_runnability_test.py
  • tests/conftest.py
  • tests/test_generate_runnability_test.py

Open the folder on GitHubat commit fa9bdde

Compare with similar skills

Python Recipe Runnability Test Generator next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Python Recipe Runnability Test Generator compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Python Recipe Runnability Test Generator this skillgoogle/adk-recipes10k—~3.3kAutomated safety check: PassApache-2.0
Adk Verify Snippetsgoogle/adk-python22k—~1.4kAutomated safety check: PassApache-2.0
Hermetic Python Unit TestsdimensionalOS/dimos4.6k—~1.4kAutomated safety check: PassCustom licence
Test Coverage Reviewareed1192/finance-news-aggregator149—~2.6kAutomated safety check: PassMIT
Py Package Checkipea/geobr959—~1.4kAutomated safety check: NotesNone
Zizkadb TestZIZKA-AI-SL/ZizkaDB124—~358Automated safety check: PassCustom licence

Similar skills

  • Adk Verify Snippets

    google/adk-python

    Official

    Checks that every Python code block in a Markdown file actually compiles and runs, by extracting each block to a temporary file, executing it in an isolated subprocess, and writing a pass/fail…

    22k GitHub stars~1.4k tokensUpdated today
    Testing & QAAuto-check passed
  • Hermetic Python Unit Tests

    dimensionalOS/dimos

    Rules for writing, fixing and reviewing pytest unit tests that are hermetic: behavior-focused, deterministic, isolated and cheap to run.

    4.6k GitHub stars~1.4k tokensUpdated today
    Testing & QAAuto-check passed
  • Test Coverage Review

    areed1192/finance-news-aggregator

    Audit, plan, write, and verify unit tests for Python projects using pytest.

    149 GitHub stars~2.6k tokensUpdated 5 mo ago
    Testing & QAAuto-check passed
  • Run the Python package release gate for geobr — sync the locked environment, run the offline and network test suites, build the distribution, and review the source against the Python conventions.

    959 GitHub stars~1.4k tokensUpdated 10 days ago
    Testing & QAAuto-check: notes
  • Zizkadb Test

    ZIZKA-AI-SL/ZizkaDB

    Run the full ZizkaDB test suite across all layers — lint, Python unit tests, SDK tests, MCP tests, TypeScript tests, and dashboard build verification.

    124 GitHub stars~358 tokensUpdated yesterday
    Testing & QAAuto-check passed
  • Testing Livekit Agents

    livekit-examples/agent-starter-python

    Writes turn-level tests for a LiveKit agent in the user's normal test suite: pytest (Python) or Vitest (Node.js).

    264 GitHub starsUsed in 1 repo~1.9k tokens
    Testing & QAAuto-check passed

More from google/adk-recipes

All 14 skills in this repo
  • Retail Product Search Agent

    google/adk-recipes

    Official

    Builds a retail product search agent on Google Cloud, from catalog ingestion into BigQuery and Vector Search to ADK scaffolding, evaluation and Cloud Run deployment.

    10k GitHub stars~3k tokensUpdated 2 days ago
    Auto-check passed
  • Align Recipe pyproject.toml

    google/adk-recipes

    Official

    Brings a Python recipe's pyproject.toml in line with the repo's CI rules, either as a read-only dry run or by rewriting the file while keeping comments.

    10k GitHub stars~4.6k tokensUpdated 2 days ago
    Auto-check passed
  • Retail Virtual Try-On Agent

    google/adk-recipes

    Official

    Sets up a virtual try-on agent on Google Cloud that generates image and catwalk-video try-ons with Gemini, from first setup through local testing.

    10k GitHub stars~3.5k tokensUpdated 2 days ago
    Auto-check passed
  • Scaffold Python ADK Recipe

    google/adk-recipes

    Official

    Creates a new Python recipe for the ADK recipes repository by running a scaffold script that copies template files, after confirming the output directory and recipe name.

    10k GitHub stars~931 tokensUpdated 2 days ago
    Auto-check passed
  • Official

    Reviews a GitHub pull request and drafts a small set of inline comments in a human reviewing voice, each checkable from the line it points at, then posts them after approval.

    10k GitHub stars~8.4k tokensUpdated 2 days ago
    Auto-check passed
  • Official

    Makes an existing Python recipe deployable: generates the serving files a container needs (Dockerfile, .dockerignore, fastapiapp.py, apputils/a2a.py, apputils/services.py…

    10k GitHub stars~6.9k tokensUpdated 2 days ago
    Auto-check: notes

Works with

Categories

Questions about Python Recipe Runnability Test Generator

What does Python Recipe Runnability Test Generator do?

Generates a minimal tests/test_runnability.py for a Python agent recipe that imports the agent module and checks root_agent, adding only the mocks and env vars it needs. The generated test is deliberately small: it imports the recipe's agent module and asserts that `root_agent` is not None, and `app` too if the module defines one.py` while skipping virtualenvs, build output, caches, `node_modules` and tests, and writes one file per run.

When should I use Python Recipe Runnability Test Generator?

Python Recipe Runnability Test Generator fits situations like: adding the required runnability test to a new Python recipe; fixing a CI failure about a missing tests/test_runnability.py; previewing which mocks and environment variables a recipe's import needs.

How do I install Python Recipe Runnability Test Generator in Claude Code?

Run `npx skills add google/adk-recipes --skill generate-python-runnability-test -a claude-code`. Or copy the skill folder (.agents/skills/generate-python-runnability-test in google/adk-recipes) into .claude/skills/generate-python-runnability-test in your project. Claude Code loads it when a task matches its description.

How do I install Python Recipe Runnability Test Generator in Codex?

Run `npx skills add google/adk-recipes --skill generate-python-runnability-test -a codex`. Or copy the skill folder (.agents/skills/generate-python-runnability-test in google/adk-recipes) into .agents/skills/generate-python-runnability-test in your project. Codex loads it when a task matches its description.

Can I use Python Recipe Runnability Test Generator in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add google/adk-recipes --skill generate-python-runnability-test -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/generate-python-runnability-test, .gemini/skills/generate-python-runnability-test, .github/skills/generate-python-runnability-test and .opencode/skills/generate-python-runnability-test in your project.

What does Python Recipe Runnability Test Generator need to run?

Going by SKILL.md and its folder, Python Recipe Runnability Test Generator needs Python for the scripts in its folder and the command-line tools its instructions call (uv, ruff and git). Our summary lists: Python, to run the generator script; A Python agent recipe with an agent.py file.

Does Python Recipe Runnability Test Generator access the network?

SKILL.md contains no URLs. Its commands use uv and git, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Python Recipe Runnability Test Generator safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Python Recipe Runnability Test Generator use?

Python Recipe Runnability Test Generator is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Python Recipe Runnability Test Generator use?

About 3.3k tokens (SKILL.md is roughly 13k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Python Recipe Runnability Test Generator?

Skills that share tags, products or a category with Python Recipe Runnability Test Generator: Adk Verify Snippets (google/adk-python, 22k stars), Hermetic Python Unit Tests (dimensionalOS/dimos, 4.6k stars), Test Coverage Review (areed1192/finance-news-aggregator, 149 stars) and Py Package Check (ipea/geobr, 959 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Python Recipe Runnability Test Generator?

google (a GitHub organization, an official publisher) maintains it in google/adk-recipes, which has 10,419 GitHub stars. The repository holds 14 skills in this directory. The repository was last updated on October 5, 2026.

Source: google/adk-recipes on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.