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).
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 |