# Supported in Python

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

**What the marks mean.**

- **Supported:** Niro recognised every way of using it that the test code tries.

- **Partly:** Niro recognised some of those ways, or recognised one only in part.

- **Not yet:** Niro did not recognise it in the test code.

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](https://help.niroai.dev/cli/coverage-audit-and-consent/)).

## 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")](http://svc:port%22).get(%22/relative%22)) 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](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](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 |