This page lists the Python libraries, frameworks and build tools Niro was tested against, and whether it recognised each one.

What the marks mean.

The test code is made up for the purpose: one small service per library, with the names invented. So "supported" means Niro recognised it there. It is good evidence, but it is not a promise about every codebase. If Niro misses something in your code, the coverage audit reports the gap on its own (see Coverage audit).

Web frameworks and HTTP servers (the routes your code serves)

22 supported, 4 partly, 6 not yet.

Name Status Ways of using it that were tested
aiohttp supported yes: class X(web.View) with async post(), web.view(path, X)
yes: app.router.add_post(path, handler)
yes: routes = web.RouteTableDef(); @routes.get(path)
yes: app.add_routes([web.get(path, handler)])
apiflask not yet no: APIFlask app with @app.get(path) (Flask subclass)
AWS SAM template.yaml supported yes: AWS::Serverless::Function with Events Type: Api (REST API) Properties Path and Method; Handler module.function under CodeUri names the handler
yes: AWS::Serverless::Function with Events Type: HttpApi Properties Path and Method (ANY, greedy {proxy+})
Azure Functions (Python v1 programming model) supported yes: <FunctionName>/function.json with a httpTrigger binding (route, methods) beside init.py; no route means the folder name, no methods means every verb; host.json routePrefix in front
Azure Functions (Python v2 programming model) supported yes: @app.route(route="x/{id}", methods=[...]) on a func.FunctionApp in function_app.py, served under the host.json routePrefix (default api); no methods means every verb
yes: bp = func.Blueprint(); @bp.route(route=...) in another file, app.register_functions(bp)
yes: @app.route() with no route: the route is the @app.function_name name, else the Python function's name
blacksheep supported yes: from blacksheep import get; @get(path)
yes: @app.router.post(path)
bottle supported yes: app = Bottle(); @app.get(path)
yes: from bottle import route; @route(path) on the default app
yes: app.mount(prefix, sub_app) with routes on the sub-app
chalice supported yes: @app.route(path, methods=[...]) on a Chalice app
cherrypy partly no: @cherrypy.expose methods, path from cherrypy.tree.mount(obj, prefix)
yes: MethodDispatcher with GET/POST methods on an exposed class
connexion not yet no: routes in openapi.yaml, operationId names the Python function, app.add_api(spec, base_path)
django supported yes: path(route, View.as_view()) with get/post methods
yes: path("prefix/", include("app.urls"))
yes: urlpatterns = [path("route/<int:pk>/", view)]
yes: re_path(r"^regex$", view)
django-ninja partly partly: api = NinjaAPI(); @api.get(path), mounted with path("prefix/", api.urls)
no: Router() with @router.post, api.add_router(prefix, router)
djangorestframework supported yes: @action(detail=True, methods=["post"]) on a ViewSet
yes: @api_view(["GET"]) function view
yes: class X(APIView) with post(), path(route, X.as_view())
yes: DefaultRouter().register(prefix, ViewSet) + include(router.urls)
emmett not yet no: @app.route(path) on Emmett
falcon supported yes: resource class with on_get/on_post, app.add_route(path, Resource())
fastapi partly yes: app.add_api_route(path, fn, methods=[...])
no: @app.api_route(path, methods=["GET", "PUT"])
yes: @app.get(path) on FastAPI()
partly: APIRouter() routes, app.include_router(router, prefix=...)
yes: APIRouter(prefix="/x") carrying its own prefix
no: @app.websocket(path)
flask supported yes: app.add_url_rule(path, view_func=fn)
yes: Blueprint routes, app.register_blueprint(bp, url_prefix=...)
yes: MethodView subclass, add_url_rule(path, view_func=X.as_view(name))
yes: @app.route(path, methods=["GET", "POST"])
yes: @app.get / @app.delete with a <int:id> converter
flask-restful supported yes: Api(app, prefix).add_resource(Resource, url) with get/delete methods
flask-restx supported yes: @ns.route(path) on a Resource class, api.add_namespace(ns, path=...)
flask-smorest supported yes: flask_smorest Blueprint(url_prefix) @blp.route on a MethodView
hug not yet no: @hug.get(path)
litestar partly yes: class X(Controller) with path and @get/@post methods
yes: standalone @get(path) handler in route_handlers
partly: Router(path=..., route_handlers=[...])
pyramid not yet no: config.add_route(name, pattern) + config.add_view(fn, route_name=...)
no: config.add_route(name, pattern) + @view_config(route_name=...)
quart supported yes: Quart Blueprint(url_prefix=...) with @bp.post
yes: @app.route(path, methods=[...]) on Quart
responder not yet no: @api.route(path) on responder.API
robyn supported yes: @app.get(path) on Robyn
yes: SubRouter(file, prefix=...) + app.include_router
sanic supported yes: @app.get(path) on Sanic
yes: Blueprint(name, url_prefix=...) @bp.route, app.blueprint(bp)
yes: HTTPMethodView subclass, app.add_route(View.as_view(), path)
Serverless Framework serverless.yml supported yes: functions.<name>.handler file.function with events httpApi ('GET /path' or method+path) or http (REST, path without a leading slash)
starlette supported yes: Mount(prefix, routes=[Route("/", HTTPEndpoint subclass)])
yes: routes = [Route(path, fn, methods=[...])]; Starlette(routes=routes)
strawberry-graphql supported yes: app.include_router(GraphQLRouter(schema), prefix="/graphql")
tornado supported yes: tornado.web.Application([(r"/x/([0-9]+)", Handler)]) with get/post methods
yes: tornado.web.url(pattern, Handler, name=...) in the Application list
Vercel Functions (Python runtime, /api directory) supported yes: api/<name>.py defining class handler(BaseHTTPRequestHandler); path from the file, verbs from its do_GET/do_POST methods
yes: api/orders/[order_id].py: a bracketed file name is a dynamic path segment
yes: api/index.py exporting a Flask or FastAPI app, with a vercel.json rewrite sending every path to it; the app's own routes are the endpoints

The language's own HTTP server

3 supported, 0 partly, 2 not yet.

Name Status Ways of using it that were tested
asyncio streams (stdlib) not yet no: asyncio.start_server(handler, host, port) raw TCP listener
http.server (stdlib) supported yes: BaseHTTPRequestHandler subclass dispatching through a dict of paths and getattr
yes: do_GET comparing self.path == "/x"
yes: do_DELETE testing self.path in ("/x", "/x/")
yes: do_GET with urlparse(self.path).path.startswith("/x/")
yes: SimpleHTTPRequestHandler subclass adding one API path
yes: do_POST reading urlparse(self.path).path into a local, then ==
socketserver (stdlib) not yet no: socketserver.TCPServer + StreamRequestHandler line protocol
wsgiref (stdlib) supported yes: WSGI callable dispatching on environ["PATH_INFO"], served by wsgiref.make_server
xmlrpc.server / xmlrpc.client (stdlib) supported yes: SimpleXMLRPCServer.register_function(fn, "dotted.name")
yes: SimpleXMLRPCServer.register_instance(obj)

HTTP client libraries (the calls your code makes to other services)

10 supported, 3 partly, 2 not yet.

Name Status Ways of using it that were tested
aiohttp supported yes: aiohttp.ClientSession(base_url=...) + relative path
yes: async with ClientSession() as s: async with s.get(url) as resp
yes: session = ClientSession(); await session.post(url)
gql supported yes: gql Client(transport=RequestsHTTPTransport(url=...)).execute(query)
grequests supported yes: grequests.get(url) mapped with grequests.map
httpcore partly yes: httpcore.request("GET", url)
partly: with httpcore.ConnectionPool() as pool: pool.request(verb, url)
httplib2 supported yes: httplib2.Http().request(url, "GET")
httpx partly yes: async with httpx.AsyncClient() as c: await c.patch(url)
partly: httpx.AsyncClient(base_url=SETTING) + relative path
partly: with httpx.Client() as c: c.post(url)
yes: httpx.Client(base_url="http://svc:port").get("/relative")
yes: httpx.get(f"http://{HOST}:{PORT}/path") from settings constants
yes: httpx.get(url) module function
yes: httpx.request("POST", url)
niquests supported yes: niquests.get(url)
yes: with niquests.Session() as s: s.post(url)
pycurl supported yes: pycurl.Curl(); c.setopt(c.URL, url); c.perform()
requests supported yes: requests.get(BASE + "/path/" + str(id))
yes: base URL from os.environ.get("X_URL", default) then requests.get(f"{BASE}/path")
yes: base URL from os.getenv("X_URL", default)
yes: requests.post(f"{CONST_BASE}/path")
yes: requests.get("http://svc:port/path")
yes: requests.request("DELETE", url)
yes: s = requests.Session(); s.put(url)
yes: with requests.Session() as s: s.get(url)
requests-futures supported yes: FuturesSession().get(url).result()
tornado partly yes: await AsyncHTTPClient().fetch(url)
yes: AsyncHTTPClient().fetch(url, method="POST", body=...)
yes: HTTPClient().fetch(url)
partly: fetch(HTTPRequest(url, method="GET"))
treq supported yes: treq.get(url) / treq.post(url) (Twisted)
uplink not yet no: uplink Consumer subclass with @get("/path") methods, base_url at construction
urllib3 supported yes: urllib3.PoolManager().request("GET", url)
yes: urllib3.request("POST", url) (urllib3 2.x helper)
zeep not yet no: zeep.Client(wsdl_url).service.Operation(...)

The language's own HTTP client

3 supported, 0 partly, 2 not yet.

Name Status Ways of using it that were tested
asyncio streams (stdlib) not yet no: asyncio.open_connection(host, port) raw TCP client
http.client (stdlib) supported yes: http.client.HTTPConnection(host, port).request(verb, path)
yes: HTTPConnection("host:port") then request(verb, path)
yes: http.client.HTTPSConnection(host, port).request(verb, path)
socket (stdlib) not yet no: socket.create_connection((host, port)) raw TCP
urllib.request (stdlib) supported yes: urllib.request.Request(url, method="DELETE") passed to urlopen
yes: Request(url, data=..., method="POST") passed to urlopen
yes: urlopen(f"{BASE}/path") imported by name
yes: urllib.request.urlopen("http://host/path")
xmlrpc.client (stdlib) supported yes: xmlrpc.client.ServerProxy(url).dotted.method(...)
yes: with ServerProxy(url) as proxy: proxy.method(...)

gRPC

0 supported, 2 partly, 0 not yet.

Name Status Ways of using it that were tested
betterproto + grpclib partly partly: grpclib Channel + betterproto InventoryStub(channel).lookup(req) awaited
yes: class X(<S>Base) from a betterproto module, snake_case async methods, grpclib Server([X()])
grpcio partly yes: grpc.aio.server() + async servicer methods, add_<S>Servicer_to_server
yes: async with grpc.aio.insecure_channel(t) as ch: await <S>Stub(ch).M(req)
yes: stub held in a typed attribute (stub: <S>Stub), called later (declared_type)
yes: channel.unary_unary("/pkg.S/M") called directly (literal_path)
yes: class X(<mod>pb2_grpc.<S>Servicer) + add<S>Servicer_to_server (grpcio-servicer)
yes: server-streaming RPC method yielding replies on the servicer
yes: stub.M.future(req) on a target from the environment
yes: for update in stub.M(req) (server streaming)
yes: <mod>_pb2_grpc.<S>Stub(grpc.insecure_channel(t)).M(req) (factory/constructor)
no: stub.M.with_call(req) over grpc.secure_channel
no: server.add_generic_rpc_handlers((grpc.method_handlers_generic_handler("pkg.S", {...}),)) written by hand
no: grpc.intercept_channel(channel, interceptor) then stub calls
no: Connect protocol client (connect-python, early adoption)

Databases and data stores

21 supported, 2 partly, 11 not yet.

Name Status Ways of using it that were tested
aiosqlite supported yes: async with aiosqlite.connect(...) as db: db.execute(sql)
asyncpg supported yes: await asyncpg.connect(dsn) then conn.fetch(sql)
yes: create_pool + pool.acquire() + conn.execute(sql)
beanie supported yes: Document subclass with Settings.name, await Model.find_one(...)
boto3 (DynamoDB) supported yes: boto3.client("dynamodb").query(TableName=...)
yes: boto3.resource("dynamodb").Table("x").get_item/put_item
boto3 (S3) supported yes: s3.put_object(Bucket=..., Key=...)
yes: s3.upload_file(path, bucket, key)
cassandra-driver supported yes: Cluster().connect(ks).execute(cql), prepare + execute
clickhouse-connect supported yes: clickhouse_connect client.query(sql) / client.insert(table, rows)
django (ORM) supported yes: Model.objects.create(...) (table from the model name)
yes: Model.objects.filter(...) with Meta.db_table
yes: Model.objects.raw(sql)
yes: django.db.connection.cursor().execute(sql)
duckdb supported yes: duckdb.connect(path).execute(sql)
elasticsearch supported yes: Elasticsearch(url).index(index=...) / search(index=...)
google-cloud-firestore supported yes: firestore.Client().collection("x").document(id).get/set
influxdb-client not yet no: write_api.write(bucket=...), query_api.query(flux)
mongoengine not yet no: Document with meta collection, Model.objects(...)
motor not yet no: AsyncIOMotorClient db.coll.find_one awaited
mysqlclient (MySQLdb) supported yes: MySQLdb.connect(...).cursor().execute(sql)
neo4j supported yes: driver.session().run(cypher) / driver.execute_query(cypher)
opensearch-py not yet no: OpenSearch(hosts).index/search(index=...)
oracledb not yet no: oracledb.connect(...).cursor().execute(sql)
peewee supported yes: Model.create(...) / Model.update(...).execute()
yes: Model.select().where(...) with Meta.table_name
pony not yet no: class X(db.Entity) with select(x for x in X)
psycopg (3) supported yes: psycopg.AsyncConnection + cursor.execute(sql)
yes: psycopg.connect(...).execute(sql) shortcut
psycopg2 supported yes: psycopg2.connect(dsn).cursor().execute("SELECT ... FROM t")
yes: with conn.cursor() as cur: cur.executemany(sql, rows)
yes: cur.execute(SQL_CONSTANT, params) with the SQL in a module constant
pymemcache supported yes: pymemcache Client.get/set(key)
pymongo not yet no: MongoClient()[db].coll.find_one(...) (attribute access)
no: db.get_collection("x").insert_one(...)
no: db["x"].update_one(...) (subscript access)
pymysql supported yes: pymysql.connect(...); with conn.cursor() as c: c.execute(sql)
pynamodb not yet no: pynamodb Model with Meta.table_name, Model.get(key) / save()
pyodbc supported yes: pyodbc.connect(conn_str).cursor().execute(sql)
redis (redis-py) partly yes: redis.asyncio.Redis().get(key) awaited
yes: r.hset(...), client.lpush(...)
yes: pipe = r.pipeline(); pipe.set(...); pipe.execute()
partly: redis.Redis(host).set/get(key)
snowflake-connector-python not yet no: snowflake.connector.connect(...).cursor().execute(sql)
sqlalchemy partly no: AsyncSession.execute(select(Model)) awaited
no: Core Table("t", metadata) + conn.execute(insert(table))
no: session.execute(select(Model).where(...))
yes: session.add(Model(...)) with tablename
no: session.query(Model).filter(...).first() (legacy)
yes: conn.execute(text("SELECT ... FROM t"))
sqlite3 (stdlib) supported yes: sqlite3.connect(path).execute(sql)
yes: conn.cursor().execute(sql) / executescript
yes: with sqlite3.connect(path) as conn: conn.executemany(sql, rows)
sqlmodel not yet no: SQLModel Session.add(Model(...))
no: SQLModel Session.exec(select(Model))
supabase not yet no: supabase.table("x").select("*").execute()
tortoise-orm supported yes: await Model.create(...) with Meta.table
yes: await Model.filter(...).all()

Messaging and events (queues, topics, streams)

11 supported, 17 partly, 3 not yet.

Name Status Ways of using it that were tested
aio-pika partly no: channel.default_exchange.publish(Message, routing_key="q")
partly: queue = await channel.declare_queue("q"); await queue.consume(cb)
partly: async with queue.iterator() as it: async for message in it
aiokafka supported yes: AIOKafkaConsumer("topic", ...); async for msg in consumer
yes: AIOKafkaProducer.send_and_wait("topic", value)
arq partly partly: await redis.enqueue_job("function_name", ...)
no: class WorkerSettings: functions = [fn]
azure-servicebus partly yes: client.get_queue_receiver(queue_name=...).receive_messages()
no: client.get_queue_sender(queue_name=...).send_messages(...)
boto3 (EventBridge) partly partly: boto3.client("events").put_events(Entries=[{... EventBusName}])
boto3 (Kinesis) supported yes: boto3.client("kinesis").put_record(StreamName=...)
boto3 (SNS) supported yes: boto3.client("sns").publish(TopicArn=...)
boto3 (SQS) supported yes: sqs.receive_message(QueueUrl=...) polling loop
yes: sqs.send_message(QueueUrl=CONST, MessageBody=...)
celery partly yes: @app.task(name="x") on a Celery app
no: app.signature("task").apply_async(...)
no: app.signature("task").delay(...)
yes: app.send_task("task.name", args=[...])
yes: @shared_task
confluent-kafka supported yes: Consumer(conf).subscribe([TOPIC_CONST]) then poll
yes: Producer(conf).produce("topic", value=...)
django (signals) supported yes: @receiver(post_save, sender=Model) (in-process signal)
dramatiq partly yes: @dramatiq.actor(queue_name=...)
no: broker.enqueue(dramatiq.Message(actor_name=..., queue_name=...))
faststream partly yes: async with KafkaBroker(...) as broker: await broker.publish(msg, topic=...)
partly: @broker.publisher("topic") on a subscriber
yes: @broker.subscriber("topic")
faust-streaming not yet no: @app.agent(app.topic("x"))
google-cloud-pubsub partly partly: PublisherClient().publish(topic_path(project, topic), data)
no: SubscriberClient().subscribe(subscription_path(project, sub), callback)
huey supported yes: @huey.task() / @huey.periodic_task(crontab(...))
kafka-python partly yes: KafkaConsumer("topic", bootstrap_servers=...)
yes: KafkaConsumer(...).subscribe(["topic"])
yes: KafkaProducer.send(TOPIC_CONSTANT, ...)
partly: KafkaProducer(...).send("topic", value)
kombu partly no: ConsumerMixin.get_consumers returning Consumer(queues=[Queue("q")])
partly: kombu Producer(channel, exchange).publish(body, routing_key="q")
multiprocessing (stdlib) not yet no: multiprocessing.Queue between processes of one program (not cross-service)
no: BaseManager(address=(host, port)) serving a queue; client manager.connect() + get_queue().put
nameko partly no: nameko standalone event_dispatcher(config)(service, event, payload)
partly: @event_handler("service", "event")
partly: @rpc method on a nameko service class
no: ClusterRpcProxy(config) as rpc: rpc.service.method(...)
nats-py supported yes: js = nc.jetstream(); await js.publish(subject, data)
yes: await js.subscribe(subject, durable=...)
yes: nc = await nats.connect(url); await nc.publish(subject, data)
yes: await nc.subscribe(subject, cb=handler)
paho-mqtt partly no: paho.mqtt.publish.single(topic, payload, hostname=...)
yes: client.subscribe("topic") with on_message callback
pika supported yes: channel.basic_consume(queue="q", on_message_callback=cb)
yes: channel.basic_publish(exchange="", routing_key="q", body=...)
pulsar-client supported yes: client.create_producer(topic).send(data)
yes: client.subscribe(topic, subscription_name=...)
python-socketio partly partly: socketio.AsyncClient().emit("event", data)
partly: await sio.emit("event", data) on the server
yes: @sio.on("event") handler
pyzmq not yet no: ctx.socket(zmq.PULL).bind("tcp://*:port")
no: ctx.socket(zmq.PUSH).connect("tcp://host:port").send_json(...)
redis (pub/sub, streams) partly yes: r.publish("channel", message)
yes: pubsub = r.pubsub(); pubsub.subscribe("channel")
partly: r.xadd("stream", fields)
no: r.xgroup_create + r.xreadgroup(group, consumer, {"stream": ">"})
rq partly partly: Queue("q", connection=Redis()).enqueue("module.fn", ...)
no: Worker([Queue("q")]).work()
stomp.py supported yes: stomp.Connection(...).send(destination="/queue/x", body=...)
yes: conn.subscribe(destination="/queue/x", id=...) with a ConnectionListener
taskiq partly partly: AsyncKicker(task_name="x", broker=b, labels={}).kiq(...)
no: @broker.task(task_name="x")
websockets partly no: async with websockets.connect("ws://svc:port/") as ws: await ws.send(...)
partly: websockets.serve(handler, host, port)

Build tools and package managers

14 supported, 0 partly, 0 not yet.

Name Status Ways of using it that were tested
Bazel (rules_python) supported yes: MODULE.bazel, py_binary and py_library targets, deps by label //libs/shop_common
conda (environment.yml) supported yes: environment.yml per module, no pyproject, setup.py or requirements.txt
Flit (flit_core) supported yes: flit_core backend, module named after the project, flat layout (package folder at the top, no src/)
Hatch (hatchling) supported yes: hatchling backend, wheel packages list, a service run with python -m <package> (src/<pkg>/main.py) and a hatch env script
maturin (PyO3) supported yes: pyproject build-backend maturin with python-source = "python", Cargo.toml in the same folder, Rust src/lib.rs
Pants supported yes: pants.toml source root /src/python, BUILD files with python_sources() and pex_binary targets, 3rdparty requirements
PDM supported yes: pdm-backend, file:// path dependency with ${PROJECT_ROOT}, [tool.pdm.scripts], main.py service
pip (requirements.txt only) supported yes: requirements.txt with an -e ../shop-common line, scripts importing sibling files by bare module name (from handlers import ...)
Pipenv supported yes: Pipfile with an editable path dependency; one service started by app.py, one by worker.py
Poetry supported yes: [tool.poetry] with packages from src, path dependency on ../shop-common (develop = true), [tool.poetry.scripts]; second service started by app.py
setuptools (pyproject build-system + setup.cfg) supported yes: pyproject.toml holds only [build-system]; name, packages and console scripts live in setup.cfg
setuptools (setup.cfg) supported yes: metadata and [options.entry_points] console_scripts in setup.cfg, setup.py is a two-line shim
setuptools (setup.py) supported yes: setup.py with find_packages and console_scripts entry_points; library without entry_points
yes: a source module named setup.py inside a package (def setup(registry)), not a packaging script
uv (workspace) supported yes: root pyproject with [tool.uv.workspace] members globs and [tool.uv.sources] workspace = true; root holds no code

Project and folder layouts

7 supported, 0 partly, 0 not yet.

Name Status Ways of using it that were tested
Django supported yes: Django project (manage.py, settings package, apps orders and billing), a reusable Django app as a library, a second service
Jupyter supported yes: an analysis/ folder of .ipynb notebooks (with its own requirements.txt) next to the packages
none (loose scripts) supported yes: a scripts/ folder of executable .py files with no build file, beside packaged services
pytest / unittest supported yes: tests/ with conftest.py, tests inside the package, *_test.py beside code, and a top-level integration-tests project with its own pyproject
setuptools (PEP 420 namespace) supported yes: three distributions share the namespace acme with no acme/init.py
setuptools (PEP 621 pyproject) supported yes: [project] + [project.scripts] + [tool.setuptools.packages.find] where=["src"], two packages in one distribution
setuptools (PEP 621) supported yes: a source package literally named build/ (not ignored) in one module, and a gitignored build/ output in another
yes: services run with python -m: one main.py at the folder top, one inside the package (invoice_worker/main.py)
yes: build/lib copy, .egg-info, dist/, .tox, venv/ with pyvenv.cfg, .venv, vendor/, third_party/ copy, protoc output under generated/
yes: services/
, libs/* and tools/* each with its own pyproject, no workspace file, no compose
yes: a developer tool with its own pyproject and console script nested inside a service folder
yes: service code in a package folder: Flask app at shop/app.py, FastAPI app at app/main.py with app/routers/ (the python-mono shape), no console script
yes: two libraries side by side: shop-common in src layout, pricing-rules in flat layout