Your specs say what
your code should do.
Quelltest proves it.
Quelltest reads your Python docstrings, Pydantic models, and PySpark schemas — extracts every testable requirement — generates verified pytest tests that actually prove each one. Two-phase verification before anything touches disk. No LLM key required.
$ quell check src/ --fix --no-llm
scanning 3 spec sources...
─────────────────────────────────────
process_payment MUST_RAISE ✓ verified
process_payment MUST_RETURN ✓ verified
PaymentRequest BOUNDARY ✓ verified
PaymentRequest ENUM_VALID ✓ verified
payment_schema NOT_NULL ✓ verified
payment_schema TYPE_CHECK ✓ verified
─────────────────────────────────────
6 tests written → tests/test_payments.py
Score: 100% (6/6 covered)
Your code never left your machine.
$ ▋
Spec sources
Three places where requirements already live in your codebase.
Python Docstrings
Google · NumPy · Sphinx style
Raises: ValueError: If amount is <= 0.
Pydantic Models
Field validators · Literal types
amount: float = Field(gt=0, le=10_000)
PySpark Schemas
StructType · StructField
StructField("amount", DoubleType(), nullable=False)
How it works
From spec to verified test in seconds.
Read specs from three sources
Quelltest scans Python docstrings (Raises:, Returns:, Args: sections), Pydantic models (Field validators, Literal type annotations), and PySpark StructType definitions — all via AST, no imports, no test execution.
[docstring] MUST_RAISE ValueError: amount <= 0
[pydantic] BOUNDARY amount: gt=0, le=10000
[pydantic] ENUM_VALID currency: USD|EUR|GBP
[pyspark] NOT_NULL amount must not be null
[pyspark] TYPE_CHECK payment_schema structure
Find gaps — no test execution needed
An AST-based coverage checker scans your test files and marks each requirement as covered or uncovered. Static, fast, no pytest run required at scan time.
5 gap(s) found.
Run --fix to generate tests.
Verify before writing — the moat
Every generated test must PASS on correct code AND FAIL on violated code. Quelltest injects targeted violations per constraint kind — comments out the raise, weakens the Field bound, flips nullable — then runs both phases in subprocess isolation.
✓ phase 2: fails on violated code
→ proven. safe to write.
Write with libcst. Always restore.
Tests are injected using libcst — a lossless concrete syntax tree. Comments, spacing, and formatting are preserved. Source is backed up first and always restored in a finally block, no matter what.
✓ tests/test_payments.py +6 tests
report: .quell/report.json
Your code never left your machine.
Design principle
Rule-based first.
LLM as last resort.
Most test generation tools send your code to an LLM and hope for the best. Quelltest inverts this. Every constraint kind has a deterministic rule-based generator — no network call, no hallucinations, no API key. The rule engine covers ~75% of real requirements. LLM handles the rest — only if you configure one.
CLI
One tool, a few commands.
quell scan src/
Find untested guard clauses (if/raise patterns). No docstrings needed.
quell scan src/ --fix
Generate and verify failing tests for every untested guard clause.
quell check src/ --no-llm
Scan docstrings + Pydantic models for requirement gaps.
quell check src/ --fix --no-llm
Generate and verify tests for every uncovered requirement.
quell pr <PR_NUMBER> --comment
Post a coverage gap report as a PR comment.
quell install --pr
Write the GitHub Actions workflow to your repo in one command.
Privacy-safe feedback loop
Every run generates a diagnostic report.
After every --fix run, Quelltest writes .quell/report.json— a privacy-safe file recording where the rule engine succeeded, what it skipped, and which argument types it couldn't stub. No source code. Safe to share.
{
"quell_version": "0.6.9",
"written": 6,
"fails_on_correct": 0,
"doesnt_catch_violation": 0,
"spec_sources": ["docstring", "pydantic", "pyspark"],
"_note": "No source code. Safe to share."
}
GitHub Integration
Every pull request reviewed automatically.
Quelltest scans every changed Python file for untested guard clauses — if/raise patterns, try/except/raise, assert — and posts inline diff annotations and a PR comment. No docstrings needed. Purely AST-based.
GitHub Action
Per-repo · one YAML file · inline annotations
Add to any repo in under a minute. The action runs on every PR, emits inline diff warnings, and posts an idempotent summary comment.
# .github/workflows/quell.yml
uses: shashank7109/quelltest_lib@main
with:
target: '.'
post-comment: 'true'
fail-on-gaps: 'false'
✓ Inline diff annotations per guard clause
✓ PR comment with gap table
✓ Optional merge block with fail-on-gaps
GitHub App
Org-wide · zero per-repo config · self-hosted
Install once at the organisation level. Every repo gets automatic PR reviews with no YAML to add or maintain. Runs the same AST scanner against files fetched via the GitHub Contents API — no clone needed.
# Deploy the FastAPI webhook server
pip install quelltest fastapi uvicorn PyJWT
uvicorn quell.github.app:app \
--host 0.0.0.0 --port $PORT
✓ One install covers all repos in the org
✓ No repository clone — uses GitHub API
✓ Idempotent PR comment per push
🟡 Quell — Guard Clause Scan
3 untested guard clauses found — 40% covered (2/5)
Fix locally: quell scan . --fix
Pricing
Free to start. Scale when you need to.
Rule-based generation is free forever. LLM fallback and CI features are Pro.
Hobby
- 500 requirements / month
- 1 API key
- Rule-based generation — no LLM key needed
- Docstring, Pydantic & PySpark scanning
- Diagnostic report (.quell/report.json)
- Community support
Pro
- Unlimited requirements
- 5 API keys
- LLM fallback (Claude & GPT-4)
- Unlimited projects
- PR comment reports
- Usage analytics dashboard
- Email support
Team
- Everything in Pro
- Unlimited API keys
- 10 team seats
- SSO / SAML
- Priority support + SLA
Loading pricing for your region…