Jongo
One language for the whole web app. Jongo is a full-stack Python web framework in the spirit of Django: ORM, migrations, auth, sessions, CSRF protection and an admin site. The difference is that your frontend is Python too. Components render on the server for a fast first paint, then compile to JavaScript and come alive in the browser. They call your server code with a plain await.
There's no template language, no separate JS project and no build step. It has zero dependencies.
from jongo import Jongo, component, db, server, state
from jongo.html import *
app = Jongo(__name__, title="Todos", database="db.sqlite3")
class Todo(db.Model): # a database table
title = db.Text(max_length=200)
done = db.Bool(default=False)
@server # a server function, callable from the browser
def add_todo(title: str) -> dict:
return Todo.create(title=title).to_dict()
@component # UI: Python here, JavaScript in the browser
def TodoList(todos):
items = state(todos)
draft = state("")
async def add(event):
todo = await add_todo(draft.value) # runs on the server
items.value = items.value + [todo]
draft.value = ""
return div(
form(
input_(value=draft.value, on_input=lambda e: draft.set(e.target.value)),
button("Add"),
on_submit=add,
),
ul([li(t["title"], key=t["id"]) for t in items.value]),
)
@app.page("/") # route + view + UI, together
def home():
return TodoList(todos=Todo.all())
jongo dev # → http://localhost:8000, reloads when you save
Documentation
- The guide — the long version: the request model, routing, components, every hook, server functions, the ORM, migrations, PostgreSQL, channels, auth, security, testing, deployment, exactly what compiles to the browser, a troubleshooting table, form schemas, rate limits and sessions, OpenAPI and the MCP server.
- Patterns — sixteen complete, runnable apps: CRUD, auth, search as you type, pagination, optimistic UI, live chat, a live dashboard, modals with server validation, master-detail, uploads, background work, testing, deployment, shared validation, agent tools, sessions and rate limits.
- Benchmarks — against Django and FastAPI, with the harness and the caveats.
- The docs site is itself a Jongo app:
jongo dev docs/docs_site.py --port 8790.
Why
In Django, one feature is spread across models.py, urls.py, views.py, a template, a form class and usually some JavaScript. In Jongo it's one idea in one place:
| Concern | Django | Jongo |
|---|---|---|
| URL | urls.py |
@app.page("/todos/<id>") |
| View | views.py |
the decorated function |
| Template | .html + template language |
Python functions: div(h1(title)) |
| Interactivity | separate JavaScript | the same component, compiled |
| AJAX endpoint | view + URL + fetch + JSON |
@server function, called with await |
| Input validation | form classes | type hints (title: str, todo: Todo) |
| Migrations | makemigrations + files |
jongo migrate diffs models against the DB |
Quick start
pip install jongo # Python 3.10+
jongo new mysite
cd mysite
jongo dev
The example app lives in examples/todo/app.py. It's a polished todo list with a detail page and a focus timer, all in one file.
Pages and routing
@app.page("/posts/<id>", title="Post")
def post(request, id: int, preview: bool = False): # `id: int` makes the route only match numbers
...
- Path parameters use
<name>or<converter:name>, with the convertersstr int float slug path uuid. An annotation likeid: intpicks the converter for you. - Arguments are filled by name.
requestis the current request, path parameters come from the URL, and anything else is read from the query string and type-checked: aboolacceptstrue/false,1/0,on/off,yes/no, andlist[int]collects a repeated key (?ids=1&ids=2). A value that doesn't fit is a 400 (J211). - A page returns UI,
Page(ui, title=..., status=..., head=[...]), or aResponse, such asredirect("/login"). - Plain handlers:
@app.get,@app.postand@app.route(path, methods=[...])return aResponse, HTMLstr, JSON-abledict/list, or UI. - Layouts:
@app.layoutwraps every page in a component. When a link switches pages, the layout's state survives. - Errors: raise
NotFound("..."),Forbidden()orHTTPError(status, message), and customise the page with@app.errorhandler(404). - Access control:
login_required=Trueandadmin_required=Truework on pages and routes. An anonymous visitor is redirected tologin_url(/loginby default) with?next=; that page is yours to write (see Auth and admin).
Same-origin links are handled by the client-side router. It fetches the next page as JSON and patches the DOM, with no full reload. Opt out with a(..., data_reload=True).
Components
@component
def Card(title, children, tone="plain"):
open_ = state(True)
return section(
h2(title, on_click=lambda e: open_.set(not open_.value)),
open_.value and div(children),
class_=["card", {"card-warning": tone == "warning"}],
style={"padding": 16, "border_radius": 12},
)
Elements come from from jongo.html import *.
- Children: positional arguments are children, which can be strings, elements, lists or
None. - Attributes: keyword arguments become attributes.
class_accepts a string, list or{name: condition}dict.styletakes a dict. Snake_case becomes kebab-case, and numbers getpx.on_click,on_input,on_submit… attach event handlers. Submit handlers callpreventDefault()for you.aria_label,data_id→aria-label,data-id.
- Name clashes: Python builtins get a trailing underscore:
input_,del_,map_. - Other helpers:
key=for list items,raw(html)for trusted markup,h("my-element")for custom tags.
Hooks and browser helpers:
state(initial) |
reactive value. Set .value, or call .set(v) / .update(fn), to re-render |
effect(fn, deps=None) |
runs in the browser after render; deps=[] runs it once; return a cleanup function |
ref() |
pass as ref= to get the DOM node in .current |
navigate(url) / refresh() |
client-side navigation / re-run the current page |
form_values(event) |
dict of a form's fields |
js.window, js.localStorage, js.fetch… |
browser globals; e.prevent_default() maps to preventDefault() |
Python that runs in the browser
The compiler supports most everyday Python:
- functions (default,
*args, keyword-only and**kwargsparameters),lambda, closures andnonlocal if/elif/else,for/whileloops withelse,try/except/finally,raise- list/dict/set comprehensions, generator expressions, the walrus operator, unpacking
- f-strings with format specs,
%formatting andstr.format async/await
It keeps Python semantics:
- Empty lists are falsy.
[1] + [2]concatenates.xs[-1]indexes from the end.-7 // 2 == -4.==compares structures.- A missing dict key raises
KeyError.
The common methods of str, list, dict and set work, as do the math, random, json and time modules. A test suite runs the same functions in Python and in Node and requires identical results.
Anything that can't run in a browser is a compile error with a hint, reported at startup:
- classes
with- imports inside functions
- server-only modules
- touching a database model directly
One deliberate improvement: closures created in a for loop capture each item, so button(on_click=lambda e: remove(todo)) in a loop does what you mean.
Server functions
@server
def rename(request, todo: Todo, title: str) -> dict: # `todo: Todo` loads the row, 404 if missing
if request.user is None:
raise HTTPError(401, "Log in first")
todo.title = title
todo.save()
return todo.to_dict()
- In a component, call it with
await rename(todo_id, "New title"). Keyword arguments work too. - Arguments are validated against the type hints before your code runs. Supported hints:
str,int,float,bool,list[...],tuple[...],set[...],dict[...],Optionaland unions,Literal, dataclasses, models, aforms.Schema, and (sent as strings)date,datetime,time,UUID,Decimal,bytes(base64) andEnum. Any other annotation is refused when the function is defined (J405); useAnyto take any JSON. - Return values can be JSON-able data or UI elements (rendered in the browser), or a
redirect(url)that navigates: a path on this site or anhttp(s)URL (ajavascript:target is refused). - Failures raise
ServerErrorin the browser, with.status,.typeand field.errors. - Options:
@server(login_required=True),@server(admin_required=True),@server(refresh=True)to re-run the page loader after each call, and@server(rate_limit="5/minute")to cap one caller (429 over the limit). - Security: every call is CSRF-protected. Only functions you decorate are exposed.
Forms: one set of rules, enforced twice
Validation usually exists twice, in JavaScript for speed and on the server for safety, and the copies drift. Here there is one definition, because the browser runs compiled Python:
from jongo import forms
Signup = forms.Schema(
"Signup",
email=forms.Email(),
seats=forms.Int(min=1, max=50, default=1),
password=forms.Text(min_length=8, secret=True),
confirm=forms.Text(same_as="password", secret=True),
)
@server
def sign_up(request, data: Signup) -> dict: # validated first; `data` is the cleaned dict
return Account.create(email=data["email"], seats=data["seats"]).to_dict()
@component
def SignupForm():
errors = state({})
async def submit(event):
values = form_values(event)
found = forms.validate(Signup, values) # in the browser: the same function, compiled
errors.set(found)
if not found:
try:
await sign_up(values) # on the server: the same rules again
except ServerError as exc:
errors.set(exc.errors or {})
return form([forms.Field(schema=Signup, name=n, error=errors.value.get(n), key=n) for n in Signup],
button("Create account"), on_submit=submit)
- One definition. The schema is data, inlined into the bundle;
forms.validateis Python the compiler turns into JavaScript. Messages are rendered once, in Python, and patterns are rewritten to syntax both regex engines read the same way, or refused when the schema is defined. - The server never trusts the browser. A
@serverparameter annotated with a schema is validated again and arrives cleaned: typed, stripped, and holding only the fields the schema declares. - From a model:
forms.Schema.from_model(Invite)readsmax_length,choicesand types from the table. Pick fields withonly=[...]orexclude=[...];is_admin,is_staff,is_superuserandpasswordare left out unlessonly=names them. - Checked, not asserted: a test runs every rule against a table of awkward values in CPython and in the compiled bundle under Node, and requires identical answers.
Real-time
Push from a server function straight into a mounted component. Declare the channel, and the declaring function authorises each subscription — an undeclared channel cannot be subscribed to at all, the same rule that keeps undecorated functions off the RPC boundary.
@app.channel("room:<int:id>")
def room(request, id):
return id in request.session.get("rooms", [])
@server
def post(request, room: int, text: str) -> dict:
message = Message.create(room_id=room, text=text).to_dict()
broadcast(f"room:{room}", message) # -> every subscribed browser
return message
@component
def Chat(room):
messages = state([])
live(f"room:{room}", lambda message: messages.set([*messages.value, message]))
return ul([li(m["text"], key=m["id"]) for m in messages.value])
live() is a hook like state() and effect(): the subscription opens when the component
mounts, moves when the channel changes, and closes when it unmounts. One SSE connection per
tab carries every channel the page asked for, and reconnects with backoff if it drops.
- It is a live feed, not a queue: a browser that reconnects sees what happens next, not what it missed, and a connection that falls more than 100 messages behind sheds its oldest.
- The hub is per process. With one worker and threads (the default
jongo run) a broadcast reaches every connection. Across multiple worker processes, each worker only reaches its own connections — put a shared bus in front if you need that. - Each streaming connection holds a worker thread, so raise
--threadsfor a chatty app. - A tab may listen to at most
MAX_CHANNELS(20) channels, with names of at mostMAX_CHANNEL_LENGTH(200) characters (both in thejongo.livemodule). The one stream counts everylive()on the page together, so give a list one channel and put the row id in the message, rather than a channel per row; past the limit the stream is refused (403,J210).
Styles
from jongo import css, global_css
s = css(
card={"padding": 16, "border_radius": 12, ":hover": {"background": "#fafafa"},
"& h2": {"margin": 0}, "@media (max-width: 600px)": {"padding": 8}},
)
div(h2("Hi"), class_=s.card) # class="card-3f9a1c"
Class names are scoped. All stylesheets are served together from /_jongo/app.css.
Database
class Author(db.Model):
name = db.Text(max_length=100, unique=True)
class Book(db.Model):
title = db.Text(max_length=200)
author = db.ForeignKey(Author, related_name="books")
published = db.Date(null=True)
tags = db.JSON(default=list)
class Meta:
ordering = ["-published"]
Book.filter(author__name__icontains="le guin", published__gte=date(1970, 1, 1)).exclude(tags=[])[:10]
Book.filter(db.Q(title__startswith="The") | db.Q(tags__contains="classic")).count()
author.books.create(title="The Dispossessed")
with db.transaction():
...
- Fields:
Text Int Float Bool DateTime Date JSON ForeignKey. - Lookups:
exact iexact contains icontains startswith endswith gt gte lt lte in isnull ne, plus relation traversal with__. - Migrations have no files.
jongo migratecompares your models to the live schema.- It creates tables, adds columns and indexes, and changes a column when its type changes.
- It only drops columns when you pass
--allow-destructive. jongo migrate --planshows the SQL first.jongo devapplies the safe changes automatically.
SQLite or PostgreSQL
SQLite is the default and needs no setup. Point the same models at PostgreSQL with a URL:
app = Jongo(__name__, database="postgres://user:pw@localhost/app")
# or: JONGO_DATABASE=postgres://user:pw@localhost/app
pip install "jongo[postgres]" # adds the psycopg driver; the core stays dependency-free
Nothing else changes — the same models, queries, migrations and tests run on both, and the test suite is run against both. The backends differ only where the database does:
| SQLite | PostgreSQL | |
|---|---|---|
| Changing a column | rebuilds the table | ALTER TABLE … ALTER COLUMN |
| Dropping a column | rebuilds when the column is referenced | drops in place |
Case-sensitive contains |
GLOB |
LIKE |
Case-insensitive icontains |
LIKE |
ILIKE |
| New row ids | AUTOINCREMENT |
identity column, kept in step with explicit ids |
Both store the same representations — datetimes and dates as ISO-8601 text, booleans as
integers, JSON as text — so a model behaves identically on either one. That is a deliberate
trade for consistency: it means no value changes meaning when you move an app from SQLite to
PostgreSQL, at the cost of not using timestamptz/jsonb natively.
Auth and admin
from jongo.auth import User, authenticate, login, logout
app.admin() # generated admin at /admin
- Users:
User.create_user(username, password, **fields)for sign-up (it hashes the password; neverUser.create(password=...), whichsave()refuses withJ304), thenauthenticate(username, password, request),login(request, user)andlogout(request).request.useris available in pages, routes and server functions. - The sign-in page is yours.
login_requiredredirects tologin_url(/loginby default) with?next=; define that page, and after signing in redirect tonextonly ifis_local_url(next)(from jongo import is_local_url), so a link can't send your users to another site. Pattern 02 is a complete one. - Passwords use PBKDF2-SHA256. Changing a password signs out the user's other sessions.
- Password guessing is throttled with no configuration: after 10 wrong passwords for a username in 5 minutes,
authenticate()stops checking and answers 429. - Sign-ins are revocable. Each
login()is a row on the server:auth.sessions(user)lists them,auth.revoke_session(id, user=user)signs one browser out,auth.revoke_sessions(user)signs out everywhere, andlogout()kills the cookie on the server, not just in the browser.jongo sessionsdoes the same from the command line. - The admin site lists, searches, sorts, creates, edits and deletes rows for every model, with forms built from your field types. Create the first account with
jongo createadmin.
Sessions, CSRF, security
- Sessions are HMAC-signed cookies:
request.session["cart"] = [...]. SetJONGO_SECRET_KEYin production. In dev, a key is generated into.jongo/secret. - Rate limits:
rate_limit="5/minute"on@server,@app.pageor@app.routecaps one caller: every request counts against the client address and, when someone is signed in, against that user too, and either being over refuses it.ratelimit.check(request, "3/hour", "reset", key=email)for your own key. Counters are per process. - Channel guards fail closed: a guard must return
Trueto allow a subscription; returning nothing refuses it. - CSRF: unsafe requests need a token. Browser code sends it automatically. Classic HTML forms need
input_(type="hidden", name="csrf_token", value=request.csrf_token). Cross-originOriginheaders are rejected. - Host header:
jongo devanswers requests addressed tolocalhostor an IP address and refuses other host names (400,J214), which stops DNS rebinding;Jongo(allowed_hosts=["myapp.example.com"])lists more names (".example.com"takes subdomains too), and turns the check on in production. - Framing: pages carry
X-Frame-Options: SAMEORIGIN(andframe-ancestors 'self'when there's no CSP);Jongo(frame_options="DENY")is stricter andframe_options=Noneopts out. - Request limits: bodies up to
Request.max_body_size(16 MB) and forms up toRequest.max_form_fields/Request.max_form_parts(1000 each); more is a 413 (J212) before anything is parsed. - Redirects:
is_local_url(url)is true only for a path on this site; check user-supplied redirect targets with it. - Escaping: text is always HTML-escaped.
raw()is the explicit escape hatch. - Data sent to the browser: props are converted to JSON.
User.to_dict()never includes password hashes.
Testing
TestClient uses the database the app is configured with, so the app fixture gives every
test a fresh in-memory one instead of db.sqlite3. Put it in conftest.py next to app.py
(jongo new writes the same fixture into tests/conftest.py):
import pytest
from jongo import db
import app as todo_module
@pytest.fixture
def app():
db.configure(":memory:") # a new, empty database for each test
db.migrate() # with every model's table
yield todo_module.app
db.close_connections()
Then, in a test file that does from app import add_todo:
def test_add(app):
client = app.test_client()
assert client.get("/").status == 200 # the status code, as an int
todo = client.rpc(add_todo, "Write tests") # full HTTP round trip, CSRF included
assert todo["title"] == "Write tests" # a refused call raises jongo.ServerError
assert client.navigate("/")["title"] == "Todos"
AI coding agents
The author of a web app is increasingly a model, and a model needs what a new colleague needs: the map of the app in one document it can load at once, and a feedback loop whose output it can act on. Jongo generates both from the running code, so neither can go stale:
jongo context # the rules of the framework, then this app's map: models, server
# functions with their signatures, pages, components, channels
jongo context -o AGENTS.md # write it for the agent jongo context --json # as data
jongo check --json # compile every component, resolve every server function's type
# hints, plan migrations; problems as {kind, message, file, line, hint}
When something goes wrong, every error says which one it is: a stable code (J302), a hint,
and the file and line, on the dev error page, in server-call errors, in jongo check and in
every CLI message.
jongo explain J302 # what the code means, why it happens, how to fix it (--list for all)
jongo doctor --json # one health report: the app loads, components compile, database
# reachable, pending migrations, production settings; exit 1 on failure
jongo status --json # a running server: recent requests and errors (code, traceback,
# request id), per-route counters, channels, likely N+1 queries
Across 19 scripted broken apps, 0.5.0 attaches a stable code and a fix hint to every failure (0.4.0: no codes, hints for 3) — the method and the full table are in benchmarks/diagnostics/RESULTS.md.
The app is a set of tools. jongo mcp serves the app to an agent over the Model Context
Protocol: the reports above as tools, plus one tool per @server function, with input schemas
generated from the type hints. A tool call passes through the same checks as a call from the
browser, and a failure comes back with its Jongo code and hint.
claude mcp add myapp -- jongo mcp # stdio: nothing to add to the app
jongo openapi -o openapi.json # the same contract as an OpenAPI 3.1 document
app.mcp(tools=[add_todo, list_todos]) # or serve it from the running app, at POST /_jongo/mcp
The HTTP endpoint exists only if you mount it, answers this machine only under jongo dev,
and needs Authorization: Bearer $JONGO_MCP_TOKEN in production.
jongo new writes an AGENTS.md for the project (the convention Codex, Cursor and most
agents read) and a CLAUDE.md that imports it, so Claude Code knows the rules the moment it
opens the folder. The reasons this shape suits agents are the reasons it suits people: one
language, one file, type-checked boundaries, and compile errors at start-up instead of
surprises in a browser. From Python: jongo.describe(app), jongo.context(app),
jongo.doctor(app), jongo.status(app), jongo.explain(code), jongo.openapi(app) and
jongo.json_schema(hint).
CLI
| Command | |
|---|---|
jongo new NAME |
create a project |
jongo dev [app.py] [--port] |
dev server: auto-reload, live browser reload, error overlay, debug pages |
jongo run [--host --port --migrate] |
production server (threaded) |
jongo migrate [--plan] [--allow-destructive] |
sync the schema |
jongo createadmin |
create an admin user |
jongo routes |
list routes |
jongo shell |
Python shell with your models |
jongo build |
compile components and report errors (good for CI) |
jongo check [--json] |
compile, resolve server-function hints, plan migrations; problems as data |
jongo context [--json] [-o FILE] |
describe the app for an AI coding tool |
jongo doctor [--json] [--production] |
health report on the app, database, settings and environment |
jongo explain CODE |
explain an error code and its fix (--list for all) |
jongo status [--url URL] [--json] |
what a running server is doing: requests, errors, routes, channels |
jongo openapi [-o FILE] |
the OpenAPI 3.1 document, generated from the type hints |
jongo mcp [--list] [--read-only] [--user NAME] |
serve the app to a coding agent over MCP (stdio) |
jongo sessions [--user NAME] [--revoke ID] [--revoke-user NAME] |
list or revoke sign-ins |
With --json, a command prints JSON even when it fails: {"ok": false, "error": {"code", "message", "hint", "file", "line"}}, exit 1.
Deployment
app is a standard WSGI application:
JONGO_SECRET_KEY=... gunicorn app:app # or: jongo run --port 8000 --migrate
Run jongo doctor --production first: it fails on a weak secret key or dev mode left on, and
warns when the key only lives in .jongo/secret (set JONGO_SECRET_KEY instead). /_jongo/status is never open in production; set JONGO_STATUS_TOKEN to read it
with jongo status --url ... --token ..., or sign in as an admin.
How it works
request ─▶ route ─▶ page function ─▶ UI tree ─┬─▶ rendered to HTML on the server ─▶ fast first paint
└─▶ serialised as JSON ──────────────▶ browser hydrates it
with components compiled
@component (Python source) ──ast──▶ JavaScript ──▶ /_jongo/app.js from the same Python
@server call in browser ──POST /_jongo/rpc/<id> (CSRF, JSON, type-checked)──▶ your function
jongo/compiler/turns Python ASTs into JavaScript. Free names resolve against the live Python objects, so the compiler knows whetheradd_todois a server function, a component, a helper or a constant.jongo/compiler/pyrt.jsprovides Python semantics in the browser.jongo/compiler/dom.jsis the virtual DOM, hooks, keyed diffing, hydration and router, in about 700 lines with no dependencies.jongo/vdom.pyis the same tree model on the server.
Developing Jongo
python3 -m venv .venv && .venv/bin/pip install -e . pytest
.venv/bin/python -m pytest # needs `node` for the compiler parity tests
cd examples/todo && ../../.venv/bin/jongo dev
Status
Version 0.7 (see CHANGELOG.md). Known limits:
- Rate limits and the login throttle count in each process's memory: exact with one worker, per worker with several, cleared by a restart.
- Form schemas validate flat fields (no nested objects or lists).
- The MCP server offers tools and resources over stdio and plain JSON-over-HTTP; it doesn't push (no server-sent stream, no prompts, no sampling).
- No WebSockets: real-time channels run over server-sent events, and the hub is per process.
- No classes in browser code.
- Components re-render their subtree without memoisation.
x__ne=v/.exclude(field=v)also match rows where the column isNULL(matching Python'sNone != v, not SQL's three-valued logic).- Browser (post-hydration) code inherits JavaScript's value model, so a few things differ from CPython (the server is always correct): integers past 2⁵³ lose precision and
str(2.0)shows"2"(one number type — format explicitly, e.g.f"{x:.2f}"); a dict keyed by ints iterates string keys, and integer-like keys iterate in ascending order rather than insertion order;isinstance(5, float)is true; generator expressions are evaluated eagerly, soany()/all()don't stop early. Do exact numeric/big-integer work in a@serverfunction. - The first argument to
Jongo()should be__name__(or passroot=): the database file,.jongo/secretandstatic/are found next to that module.
Bug reports and ideas are welcome.
License
Jongo is Copyright © 2026 Joshua Harty, and is licensed under the GNU Affero General Public License v3.0 or later (AGPL-3.0-or-later) — see LICENSE. You are free to use, study, share and modify it, but any modified version you distribute or make available to users over a network must also be released, in full source form, under the AGPL. This keeps Jongo open and prevents it from being folded into closed, proprietary products. Versions 0.1.0–0.2.2 were released under the MIT License and remain available under those terms.
Metadata
Release files for jongo 0.7.0
For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.
Source distribution (sdist)
| File | Size | Uploaded | Provenance | Actions |
|---|---|---|---|---|
| jongo-0.7.0.tar.gz | 402.8 kB | With provenance | Details for jongo-0.7.0.tar.gz |
Built distribution (wheel)
| File | Interpreter | ABI | Platform | Actions Reset |
|---|---|---|---|---|
| jongo-0.7.0-py3-none-any.whl | Python 3 | none | any | Details for jongo-0.7.0-py3-none-any.whl |
Total release size: 687.4 kB
Release files / jongo-0.7.0.tar.gz
| Download URL | jongo-0.7.0.tar.gz |
|---|---|
| Size | 402.8 kB |
| Tags | Source |
|
SHA-256 checksum How to use checksums |
e6cd070eff3d2dc6ae9252307f92411b73e463f0bece94e454bbb3c8712a4da2
|
|
BLAKE2b-256 checksum How to use checksums |
16cf98ad56e533bfe5910f4b85e9430c46cb8ccda201412f05d1accbbc4a45cd
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
Yes |
| Uploaded via |
twine/7.0.0 CPython/3.13.14
|
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 GitHub Actions, verified by PyPI on Nov 21, 2026.
Transparency logRelease files / jongo-0.7.0-py3-none-any.whl
| Download URL | jongo-0.7.0-py3-none-any.whl |
|---|---|
| Size | 284.7 kB |
| Tags | Python 3 |
|
SHA-256 checksum How to use checksums |
c6b9d03ec7ddf2579a75c54b6de0c30de4ead1389c533d1226ae1f8384598263
|
|
BLAKE2b-256 checksum How to use checksums |
3b414f3216e79375cb53a6155b94a8e3ee24946b54e9eeea3fd9c1bb0151eeb6
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
Yes |
| Uploaded via |
twine/7.0.0 CPython/3.13.14
|
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 GitHub Actions, verified by PyPI on Nov 21, 2026.
Transparency logSecurity for jongo 0.7.0
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
Both files in this release have been uploaded with provenance metadata.
Attestation for jongo-0.7.0.tar.gz
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Nov 21, 2026.
Transparency logA 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.