@niroai/niro 0.17.0 → 0.18.0

package/docs/supported-python.md

@@ -0,0 +1,224 @@
+# Supported in Python
+
+<!-- GENERATED by scripts/gen-supported-docs.js. Do not edit by hand: run the script again. -->
+<!-- source: catalog/python.json; catalog/python.structure.json -->
+<!-- measured: coverage corpus 1bb4ebb, niro-local 2b30d4fd -->
+
+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-and-consent.md](coverage-audit-and-consent.md)).
+<!-- source: niro-coverage-corpus README.md ("Synthetic test code ... All names are made up"); catalog status merged pairs one to one with measured found -->
+
+## 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)<br>yes: app.router.add_post(path, handler)<br>yes: routes = web.RouteTableDef(); @routes.get(path)<br>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<br>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<br>yes: bp = func.Blueprint(); @bp.route(route=...) in another file, app.register_functions(bp)<br>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)<br>yes: @app.router.post(path) |
+| bottle | supported | yes: app = Bottle(); @app.get(path)<br>yes: from bottle import route; @route(path) on the default app<br>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)<br>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<br>yes: path("prefix/", include("app.urls"))<br>yes: urlpatterns = [path("route/<int:pk>/", view)]<br>yes: re_path(r"^regex$", view) |
+| django-ninja | partly | partly: api = NinjaAPI(); @api.get(path), mounted with path("prefix/", api.urls)<br>no: Router() with @router.post, api.add_router(prefix, router) |
+| djangorestframework | supported | yes: @action(detail=True, methods=["post"]) on a ViewSet<br>yes: @api_view(["GET"]) function view<br>yes: class X(APIView) with post(), path(route, X.as_view())<br>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=[...])<br>no: @app.api_route(path, methods=["GET", "PUT"])<br>yes: @app.get(path) on FastAPI()<br>partly: APIRouter() routes, app.include_router(router, prefix=...)<br>yes: APIRouter(prefix="/x") carrying its own prefix<br>no: @app.websocket(path) |
+| flask | supported | yes: app.add_url_rule(path, view_func=fn)<br>yes: Blueprint routes, app.register_blueprint(bp, url_prefix=...)<br>yes: MethodView subclass, add_url_rule(path, view_func=X.as_view(name))<br>yes: @app.route(path, methods=["GET", "POST"])<br>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<br>yes: standalone @get(path) handler in route_handlers<br>partly: Router(path=..., route_handlers=[...]) |
+| pyramid | not yet | no: config.add_route(name, pattern) + config.add_view(fn, route_name=...)<br>no: config.add_route(name, pattern) + @view_config(route_name=...) |
+| quart | supported | yes: Quart Blueprint(url_prefix=...) with @bp.post<br>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<br>yes: SubRouter(__file__, prefix=...) + app.include_router |
+| sanic | supported | yes: @app.get(path) on Sanic<br>yes: Blueprint(name, url_prefix=...) @bp.route, app.blueprint(bp)<br>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)])<br>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<br>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<br>yes: api/orders/[order_id].py: a bracketed file name is a dynamic path segment<br>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<br>yes: do_GET comparing self.path == "/x"<br>yes: do_DELETE testing self.path in ("/x", "/x/")<br>yes: do_GET with urlparse(self.path).path.startswith("/x/")<br>yes: SimpleHTTPRequestHandler subclass adding one API path<br>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")<br>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<br>yes: async with ClientSession() as s: async with s.get(url) as resp<br>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)<br>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)<br>partly: httpx.AsyncClient(base_url=SETTING) + relative path<br>partly: with httpx.Client() as c: c.post(url)<br>yes: httpx.Client(base_url="http://svc:port").get("/relative")<br>yes: httpx.get(f"http://{HOST}:{PORT}/path") from settings constants<br>yes: httpx.get(url) module function<br>yes: httpx.request("POST", url) |
+| niquests | supported | yes: niquests.get(url)<br>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))<br>yes: base URL from os.environ.get("X_URL", default) then requests.get(f"{BASE}/path")<br>yes: base URL from os.getenv("X_URL", default)<br>yes: requests.post(f"{CONST_BASE}/path")<br>yes: requests.get("http://svc:port/path")<br>yes: requests.request("DELETE", url)<br>yes: s = requests.Session(); s.put(url)<br>yes: with requests.Session() as s: s.get(url) |
+| requests-futures | supported | yes: FuturesSession().get(url).result() |
+| tornado | partly | yes: await AsyncHTTPClient().fetch(url)<br>yes: AsyncHTTPClient().fetch(url, method="POST", body=...)<br>yes: HTTPClient().fetch(url)<br>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)<br>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)<br>yes: HTTPConnection("host:port") then request(verb, path)<br>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<br>yes: Request(url, data=..., method="POST") passed to urlopen<br>yes: urlopen(f"{BASE}/path") imported by name<br>yes: urllib.request.urlopen("http://host/path") |
+| xmlrpc.client (stdlib) | supported | yes: xmlrpc.client.ServerProxy(url).dotted.method(...)<br>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<br>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<br>yes: async with grpc.aio.insecure_channel(t) as ch: await <S>Stub(ch).M(req)<br>yes: stub held in a typed attribute (stub: <S>Stub), called later (declared_type)<br>yes: channel.unary_unary("/pkg.S/M") called directly (literal_path)<br>yes: class X(<mod>_pb2_grpc.<S>Servicer) + add_<S>Servicer_to_server (grpcio-servicer)<br>yes: server-streaming RPC method yielding replies on the servicer<br>yes: stub.M.future(req) on a target from the environment<br>yes: for update in stub.M(req) (server streaming)<br>yes: <mod>_pb2_grpc.<S>Stub(grpc.insecure_channel(t)).M(req) (factory/constructor)<br>no: stub.M.with_call(req) over grpc.secure_channel<br>no: server.add_generic_rpc_handlers((grpc.method_handlers_generic_handler("pkg.S", {...}),)) written by hand<br>no: grpc.intercept_channel(channel, interceptor) then stub calls<br>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)<br>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=...)<br>yes: boto3.resource("dynamodb").Table("x").get_item/put_item |
+| boto3 (S3) | supported | yes: s3.put_object(Bucket=..., Key=...)<br>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)<br>yes: Model.objects.filter(...) with Meta.db_table<br>yes: Model.objects.raw(sql)<br>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()<br>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)<br>yes: psycopg.connect(...).execute(sql) shortcut |
+| psycopg2 | supported | yes: psycopg2.connect(dsn).cursor().execute("SELECT ... FROM t")<br>yes: with conn.cursor() as cur: cur.executemany(sql, rows)<br>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)<br>no: db.get_collection("x").insert_one(...)<br>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<br>yes: r.hset(...), client.lpush(...)<br>yes: pipe = r.pipeline(); pipe.set(...); pipe.execute()<br>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<br>no: Core Table("t", metadata) + conn.execute(insert(table))<br>no: session.execute(select(Model).where(...))<br>yes: session.add(Model(...)) with __tablename__<br>no: session.query(Model).filter(...).first() (legacy)<br>yes: conn.execute(text("SELECT ... FROM t")) |
+| sqlite3 (stdlib) | supported | yes: sqlite3.connect(path).execute(sql)<br>yes: conn.cursor().execute(sql) / executescript<br>yes: with sqlite3.connect(path) as conn: conn.executemany(sql, rows) |
+| sqlmodel | not yet | no: SQLModel Session.add(Model(...))<br>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<br>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")<br>partly: queue = await channel.declare_queue("q"); await queue.consume(cb)<br>partly: async with queue.iterator() as it: async for message in it |
+| aiokafka | supported | yes: AIOKafkaConsumer("topic", ...); async for msg in consumer<br>yes: AIOKafkaProducer.send_and_wait("topic", value) |
+| arq | partly | partly: await redis.enqueue_job("function_name", ...)<br>no: class WorkerSettings: functions = [fn] |
+| azure-servicebus | partly | yes: client.get_queue_receiver(queue_name=...).receive_messages()<br>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<br>yes: sqs.send_message(QueueUrl=CONST, MessageBody=...) |
+| celery | partly | yes: @app.task(name="x") on a Celery app<br>no: app.signature("task").apply_async(...)<br>no: app.signature("task").delay(...)<br>yes: app.send_task("task.name", args=[...])<br>yes: @shared_task |
+| confluent-kafka | supported | yes: Consumer(conf).subscribe([TOPIC_CONST]) then poll<br>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=...)<br>no: broker.enqueue(dramatiq.Message(actor_name=..., queue_name=...)) |
+| faststream | partly | yes: async with KafkaBroker(...) as broker: await broker.publish(msg, topic=...)<br>partly: @broker.publisher("topic") on a subscriber<br>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)<br>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=...)<br>yes: KafkaConsumer(...).subscribe(["topic"])<br>yes: KafkaProducer.send(TOPIC_CONSTANT, ...)<br>partly: KafkaProducer(...).send("topic", value) |
+| kombu | partly | no: ConsumerMixin.get_consumers returning Consumer(queues=[Queue("q")])<br>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)<br>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)<br>partly: @event_handler("service", "event")<br>partly: @rpc method on a nameko service class<br>no: ClusterRpcProxy(config) as rpc: rpc.service.method(...) |
+| nats-py | supported | yes: js = nc.jetstream(); await js.publish(subject, data)<br>yes: await js.subscribe(subject, durable=...)<br>yes: nc = await nats.connect(url); await nc.publish(subject, data)<br>yes: await nc.subscribe(subject, cb=handler) |
+| paho-mqtt | partly | no: paho.mqtt.publish.single(topic, payload, hostname=...)<br>yes: client.subscribe("topic") with on_message callback |
+| pika | supported | yes: channel.basic_consume(queue="q", on_message_callback=cb)<br>yes: channel.basic_publish(exchange="", routing_key="q", body=...) |
+| pulsar-client | supported | yes: client.create_producer(topic).send(data)<br>yes: client.subscribe(topic, subscription_name=...) |
+| python-socketio | partly | partly: socketio.AsyncClient().emit("event", data)<br>partly: await sio.emit("event", data) on the server<br>yes: @sio.on("event") handler |
+| pyzmq | not yet | no: ctx.socket(zmq.PULL).bind("tcp://*:port")<br>no: ctx.socket(zmq.PUSH).connect("tcp://host:port").send_json(...) |
+| redis (pub/sub, streams) | partly | yes: r.publish("channel", message)<br>yes: pubsub = r.pubsub(); pubsub.subscribe("channel")<br>partly: r.xadd("stream", fields)<br>no: r.xgroup_create + r.xreadgroup(group, consumer, {"stream": ">"}) |
+| rq | partly | partly: Queue("q", connection=Redis()).enqueue("module.fn", ...)<br>no: Worker([Queue("q")]).work() |
+| stomp.py | supported | yes: stomp.Connection(...).send(destination="/queue/x", body=...)<br>yes: conn.subscribe(destination="/queue/x", id=...) with a ConnectionListener |
+| taskiq | partly | partly: AsyncKicker(task_name="x", broker=b, labels={}).kiq(...)<br>no: @broker.task(task_name="x") |
+| websockets | partly | no: async with websockets.connect("ws://svc:port/") as ws: await ws.send(...)<br>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<br>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<br>yes: services run with python -m: one __main__.py at the folder top, one inside the package (invoice_worker/__main__.py)<br>yes: build/lib copy, *.egg-info, dist/, .tox, venv/ with pyvenv.cfg, .venv, vendor/, third_party/ copy, protoc output under generated/<br>yes: services/*, libs/* and tools/* each with its own pyproject, no workspace file, no compose<br>yes: a developer tool with its own pyproject and console script nested inside a service folder<br>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<br>yes: two libraries side by side: shop-common in src layout, pricing-rules in flat layout |

package/docs/supported-ruby.md

@@ -0,0 +1,162 @@
+# Supported in Ruby
+
+<!-- GENERATED by scripts/gen-supported-docs.js. Do not edit by hand: run the script again. -->
+<!-- source: catalog/ruby.json; catalog/ruby.structure.json -->
+<!-- measured: coverage corpus 1bb4ebb, niro-local 2b30d4fd -->
+
+This page lists the Ruby 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-and-consent.md](coverage-audit-and-consent.md)).
+<!-- source: niro-coverage-corpus README.md ("Synthetic test code ... All names are made up"); catalog status merged pairs one to one with measured found -->
+
+## Web frameworks and HTTP servers (the routes your code serves)
+
+5 supported, 3 partly, 3 not yet.
+
+| Name | Status | Ways of using it that were tested |
+|---|---|---|
+| AWS SAM template.yaml | supported | yes: AWS::Serverless::Function (Runtime ruby3.3, Handler file.method under CodeUri) with Events Type HttpApi or Api Path and Method |
+| cuba | not yet | no: Cuba.define do on get, "vendors" do ... end end |
+| grape | partly | partly: resource :shipments with version "v1", using: :path and prefix :api |
+| hanami | supported | yes: class Routes < Hanami::Routes with get "/stores", to: "stores.index" and scope |
+| padrino | not yet | no: App.controllers :reviews do get :index ... post :create, map: "/reviews" end |
+| rails | partly | yes: get "/orders", to: "orders#index" in config/routes.rb<br>yes: get "orders/:id" written without a leading slash<br>yes: get "/legacy/orders" => "orders#legacy"<br>no: resources :carts, only: [...] expands to the REST routes<br>yes: namespace :admin do get "reports" ... end prefixes /admin<br>yes: scope path: "/v1" do ... end<br>yes: match "/checkout", to: ..., via: [:get, :post]<br>yes: root "home#index" |
+| roda | not yet | no: route do \|r\| r.on "wishlists" do r.get true ... end; r.is "health" ... end |
+| Serverless Framework serverless.yml | supported | yes: functions.<name>.handler file.method with events httpApi or http |
+| sinatra | supported | yes: top-level get "/tickets" do ... end in a classic app<br>yes: class X < Sinatra::Base with get/delete blocks |
+| sinatra-contrib | partly | partly: namespace "/api" do get "/status" end (Sinatra::Namespace) |
+| Vercel Functions (Ruby runtime, /api directory) | supported | yes: api/<name>.rb defining Handler = Proc.new do \|request, response\|: the file path is the route, every verb<br>yes: api/<name>.rb defining class Handler < WEBrick::HTTPServlet::AbstractServlet with do_GET/do_POST: verbs from the do_ methods<br>yes: api/wishlists/[id].rb: a bracketed file name is a dynamic path segment |
+
+## The language's own HTTP server
+
+0 supported, 1 partly, 2 not yet.
+
+| Name | Status | Ways of using it that were tested |
+|---|---|---|
+| drb | not yet | no: DRb.start_service("druby://host:port", front_object) |
+| rack | not yet | no: def call(env) branching on env["PATH_INFO"] and env["REQUEST_METHOD"]<br>no: Rack::Request#get? and #path_info == "/gift-cards"<br>no: map "/admin/ping" do run lambda end in config.ru or Rack::Builder |
+| webrick | partly | no: server.mount_proc "/receipts" do \|req, res\| ... end<br>yes: server.mount "/refunds", RefundServlet where the servlet defines do_GET / do_POST |
+
+## HTTP client libraries (the calls your code makes to other services)
+
+2 supported, 7 partly, 1 not yet.
+
+| Name | Status | Ways of using it that were tested |
+|---|---|---|
+| activeresource | not yet | no: class X < ActiveResource::Base; self.site = base; X.find(:all) is GET /products.json |
+| excon | partly | yes: Excon.get(absolute url)<br>partly: Excon.new(base).get(path: "/receipts")<br>no: conn.request(method: :post, path: ...) |
+| faraday | partly | no: Faraday.new(url: base) then conn.get(relative path)<br>partly: conn.post(path) do \|req\| req.body = ... end<br>yes: Faraday.get(absolute url)<br>partly: Faraday.new(ENV.fetch("RODA_URL")) with the value in docker-compose<br>no: conn.run_request(:delete, path, body, headers) |
+| http (http.rb) | partly | yes: HTTP.get(url)<br>yes: HTTP.auth(token).post(url, json: ...)<br>no: HTTP.persistent(base) do \|http\| http.get(path) end |
+| httparty | partly | yes: HTTParty.get(absolute url)<br>no: include HTTParty; base_uri "..."; self.class.get(path) |
+| httpclient | supported | yes: HTTPClient.new.get(url) and .post(url, body) |
+| httpx | supported | yes: HTTPX.get(url) and HTTPX.post(url, json:) |
+| rest-client | partly | yes: RestClient.get(url) and RestClient.post(url, payload, headers)<br>yes: RestClient::Resource.new(base)["vendors"].get<br>no: RestClient::Request.execute(method: :delete, url: ...) |
+| several (main project) | partly | partly: main calls a server in each framework through a different client form |
+| typhoeus | partly | yes: Typhoeus.get(url)<br>no: Typhoeus::Request.new(url, method: :post).run<br>no: hydra.queue(Typhoeus::Request.new(url)); hydra.run |
+
+## The language's own HTTP client
+
+0 supported, 2 partly, 1 not yet.
+
+| Name | Status | Ways of using it that were tested |
+|---|---|---|
+| drb | not yet | no: DRbObject.new_with_uri("druby://host:port").method(args) |
+| net/http | partly | yes: Net::HTTP.get(URI(url))<br>yes: Net::HTTP.get_response(URI.parse(url))<br>yes: Net::HTTP.post(URI(url), body, headers) and post_form<br>no: Net::HTTP.start(host, port) do \|http\| http.get(path) end<br>no: http.request(Net::HTTP::Delete.new(path)) and Net::HTTP::Post.new(uri) |
+| open-uri | partly | yes: URI.open(url).read<br>partly: URI(url).open { } and URI.parse(url).read |
+
+## gRPC
+
+0 supported, 2 partly, 0 not yet.
+
+| Name | Status | Ways of using it that were tested |
+|---|---|---|
+| grpc | partly | yes: class X < Pkg::S::Service with snake_case methods, GRPC::RpcServer#handle(X)<br>no: Pkg::S::Stub.new(addr, creds) then stub.place_order(req)<br>yes: stub.list_orders(req) returns an enumerator<br>no: stub.place_order(req, return_op: true).execute<br>no: GRPC::ClientStub#request_response("/pkg.S/M", req, marshal, unmarshal) |
+| gruf | partly | yes: class X < Gruf::Controllers::Base; bind Pkg::S::Service; def place_order<br>no: Gruf::Client.new(service: Pkg::S, options: { hostname: }) then client.call(:PlaceOrder, ...) |
+
+## Databases and data stores
+
+8 supported, 2 partly, 8 not yet.
+
+| Name | Status | Ways of using it that were tested |
+|---|---|---|
+| activerecord | partly | yes: Order.where(...) on a model with self.table_name<br>yes: Order.create!(attrs) and order.update!(...)<br>yes: model without table_name: Coupon reads table coupons<br>no: ActiveRecord::Base.connection.execute(raw SQL)<br>yes: Order.find_by_sql("SELECT ...") |
+| aws-sdk-dynamodb | not yet | no: Aws::DynamoDB::Client#put_item(table_name:) and query |
+| aws-sdk-s3 | not yet | no: Aws::S3::Client#put_object(bucket:) and get_object<br>no: Aws::S3::Resource.new.bucket(name).object(key).put(body:) |
+| dalli | supported | yes: Dalli::Client.new(servers).set(key, value, ttl) |
+| dynamoid | supported | yes: include Dynamoid::Document; table name: :wishes; Wish.where(...).all |
+| elasticsearch (elasticsearch-ruby) | not yet | no: Elasticsearch::Client#index(index:) and search(index:) |
+| File, FileUtils (core) | supported | yes: File.write(path, data), File.read(path), FileUtils.mkdir_p |
+| mongo | not yet | no: client[:ratings].insert_one / find |
+| mongoid | supported | yes: include Mongoid::Document; store_in collection: ...; Review.where / create! |
+| mysql2 | supported | yes: Mysql2::Client.new(...).query(sql) and prepare(sql).execute |
+| pg | supported | yes: PG.connect(...).exec(sql) and exec_params(sql, params) |
+| rails (ActiveSupport cache) | not yet | no: Rails.cache.fetch(key, expires_in:) { } and Rails.cache.delete(key) |
+| redis (redis-rb) | supported | yes: Redis.new(url:); redis.set / get / lpush |
+| redis-client | not yet | no: RedisClient.config(...).new_client.call("SET", key, value) |
+| searchkick | not yet | no: class Product < ApplicationRecord; searchkick; end; Product.search(text) |
+| sequel | partly | partly: DB[:invoices].where(...).all and DB[:invoices].insert(...)<br>yes: class Invoice < Sequel::Model(:invoices); Invoice.where(...)<br>no: DB.run(raw SQL) |
+| several (main project) | not yet | no: main writes tables, queues and topics that services read |
+| sqlite3 | supported | yes: SQLite3::Database.new(path).execute(sql) |
+
+## Messaging and events (queues, topics, streams)
+
+5 supported, 7 partly, 9 not yet.
+
+| Name | Status | Ways of using it that were tested |
+|---|---|---|
+| actioncable | not yet | no: ActionCable.server.broadcast("orders_channel", data) and stream_from "orders_channel" |
+| activejob | not yet | no: Job.perform_later(args) and Job.set(wait:).perform_later<br>no: class X < ApplicationJob; queue_as :shipping; def perform |
+| activesupport (Notifications) | not yet | no: ActiveSupport::Notifications.instrument("order.placed") and subscribe("order.placed") |
+| aws-sdk-sns | supported | yes: Aws::SNS::Client#publish(topic_arn:, message:) |
+| aws-sdk-sqs | partly | partly: Aws::SQS::Client#send_message(queue_url:) and receive_message |
+| bunny | partly | no: channel.topic("orders").publish(body, routing_key:)<br>yes: channel.default_exchange.publish(body, routing_key: queue)<br>partly: channel.queue("invoice-requests").subscribe { \|d, p, body\| } |
+| delayed_job | not yet | no: Delayed::Job.enqueue(job, queue:) and Object.delay.method(args) |
+| google-cloud-pubsub | partly | partly: pubsub.topic(name).publish(data) and subscription(name).listen { } |
+| karafka | partly | partly: routes.draw { topic :loyalty_events { consumer X } } with X#consume<br>yes: Karafka.producer.produce_async(topic:, payload:) |
+| nats-pure | not yet | no: NATS.connect(url); nats.publish(subject, data); nats.subscribe(subject) { } |
+| rdkafka | supported | yes: producer.produce(topic: "payments", payload:) and consumer.subscribe("payments-settled") |
+| redis (redis-rb) | supported | yes: redis.publish(channel, msg) and redis.subscribe(channel) { \|on\| on.message { } } |
+| resque | not yet | no: Resque.enqueue(JobClass, args) with @queue and self.perform |
+| ruby-kafka | supported | yes: kafka.deliver_message(value, topic:) and consumer.subscribe + each_message |
+| rufus-scheduler | supported | yes: scheduler.every "10m" do ... end and scheduler.cron "0 3 * * *" |
+| shoryuken | partly | partly: include Shoryuken::Worker; shoryuken_options queue: ...; Worker.perform_async(body) |
+| sidekiq | partly | partly: include Sidekiq::Job (the name since 6.3) with perform<br>partly: include Sidekiq::Worker with perform<br>no: Job.perform_async(args) and perform_in(seconds, args)<br>no: Job.set(queue: "critical").perform_async(args)<br>no: Sidekiq::Client.push("class" => "Job", "queue" => ...) |
+| sneakers | partly | partly: include Sneakers::Worker; from_queue "q"; def work(msg) |
+| sucker_punch | not yet | no: include SuckerPunch::Job; Job.perform_async(args) |
+| waterdrop | not yet | no: WaterDrop::Producer.new { }.produce_sync(topic:, payload:) |
+| wisper | not yet | no: include Wisper::Publisher; broadcast(:order_placed, ...); flow.subscribe(listener) / on(:event) |
+
+## Build tools and package managers
+
+6 supported, 1 partly, 0 not yet.
+
+| Name | Status | Ways of using it that were tested |
+|---|---|---|
+| bundler | supported | yes: Gemfile plus config.ru Sinatra app, lib/, spec/, gems installed into vendor/bundle |
+| bundler (appraisal) | supported | yes: gemfiles/*.gemfile variants generated by Appraisal beside the real Gemfile |
+| bundler (path gems) | supported | yes: gems/* libraries and apps/* that load them through `gem "x", path: "../../gems/x"` |
+| none (plain Ruby) | supported | yes: plain scripts: bin/*.rb load lib/*.rb with require_relative; no Gemfile |
+| rake | supported | yes: a task project: Rakefile and lib/tasks/*.rake, no Gemfile |
+| rubygems (gemspec executables) | partly | partly: a command-line gem: exe/shopctl named in spec.executables, Thor CLI in lib/ |
+| rubygems (gemspec) + bundler | supported | yes: a library gem: .gemspec, Gemfile with `gemspec`, lib/<name>/, spec/, sig/ RBS, pkg/ and doc/ output |
+
+## Project and folder layouts
+
+8 supported, 0 partly, 0 not yet.
+
+| Name | Status | Ways of using it that were tested |
+|---|---|---|
+| bundler (several apps) | supported | yes: services/orders (Rack), services/billing (Rails) and libs/shop_events (gem), each with its own Gemfile |
+| hanami 2 | supported | yes: a Hanami 2 app with slices/admin and slices/main beside app/ |
+| packwerk / packs-rails | supported | yes: one Rails app split into packs/<name>/ (package.yml, app/), all deployed together |
+| rails | supported | yes: a Rails app: bin/rails, app/, lib/, test/ (Minitest), db/schema.rb (generated), public/assets (compiled), tmp/, log/ |
+| rails engines | supported | yes: a host Rails app with engines/billing (an isolated engine gem with its own test/dummy app) |
+| RSpec, Minitest, Cucumber | supported | yes: a library with spec/ (RSpec), test/ (Minitest) and features/ (Cucumber step definitions and support) |
+| sorbet + tapioca | supported | yes: typed code with generated sorbet/rbi/gems and sorbet/rbi/dsl, and RBS signatures in sig/ |
+| zeitwerk (no Rails) | supported | yes: a Rack app whose lib/ is autoloaded by Zeitwerk: constants are used with no require |

package/docs/supported-rust.md

@@ -0,0 +1,150 @@
+# Supported in Rust
+
+<!-- GENERATED by scripts/gen-supported-docs.js. Do not edit by hand: run the script again. -->
+<!-- source: catalog/rust.json; catalog/rust.structure.json -->
+<!-- measured: coverage corpus 1bb4ebb, niro-local 2b30d4fd -->
+
+This page lists the Rust 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-and-consent.md](coverage-audit-and-consent.md)).
+<!-- source: niro-coverage-corpus README.md ("Synthetic test code ... All names are made up"); catalog status merged pairs one to one with measured found -->
+
+The test catalog also holds 4 look-alike cases for Rust: code that Niro must NOT take for a route, a call or a store. They test that Niro ignores the look-alike, so they are left out of this page and its counts.
+<!-- source: catalog/rust.json and catalog/rust.structure.json, rows marked as traps (scripts/gen-supported-docs.js isTrap) -->
+
+## Web frameworks and HTTP servers (the routes your code serves)
+
+10 supported, 0 partly, 4 not yet.
+
+| Name | Status | Ways of using it that were tested |
+|---|---|---|
+| actix-web | supported | yes: #[get("/path")] attribute on an async fn, registered with App::service<br>yes: #[route(path, method = "PUT", method = "PATCH")]<br>yes: web::scope(prefix).route(path, web::get().to(handler))<br>yes: web::resource(path).route(web::post().to(handler))<br>yes: App::new().route(path, web::get().to(handler)) |
+| axum | supported | yes: Router::new().route(path, get(h).post(h2))<br>yes: second verb chained on the method router: get(h).post(h2)<br>yes: Router::nest(prefix, sub_router()) from another module<br>yes: Router::merge(other_router()) built by a helper function |
+| gotham | not yet | no: build_simple_router(\|route\| route.get(path).to(h)) |
+| hyper | not yet | no: service_fn(route) with match (req.method(), req.uri().path()) arms |
+| iron | supported | yes: router.get(path, handler, route_id) |
+| ntex | supported | yes: #[web::get(path)] attribute<br>yes: App::new().route(path, web::delete().to(h)) |
+| poem | supported | yes: Route::new().at(path, get(h).post(h2)) with #[handler] fns |
+| poem-openapi | not yet | no: #[oai(path, method)] inside #[OpenApi] impl, nested under a prefix |
+| rocket | supported | yes: #[get("/x/<id>")] attribute, mounted with routes![] under a prefix<br>yes: #[route(PUT, uri = "...")]<br>yes: #[post(path, data = "<body>")] |
+| salvo | supported | yes: Router::with_path(p).get(h).post(h2).push(Router::with_path("<id>").get(h3)) |
+| tide | supported | yes: app.at(path).get(h).post(h2) |
+| tiny_http | not yet | no: for request in server.incoming_requests() with match on (method, url) |
+| utoipa | supported | yes: #[utoipa::path(get, path = ...)] on an axum handler |
+| warp | supported | yes: warp::path!("x" / u32).and(warp::get()).and_then(h)<br>yes: warp::path("x").and(warp::post()).and(body).and_then(h) |
+
+## The language's own HTTP server
+
+0 supported, 0 partly, 1 not yet.
+
+| Name | Status | Ways of using it that were tested |
+|---|---|---|
+| std::net::TcpListener | not yet | no: TcpListener::bind + match on the request line string "GET /path HTTP/1.1" |
+
+## HTTP client libraries (the calls your code makes to other services)
+
+5 supported, 2 partly, 0 not yet.
+
+| Name | Status | Ways of using it that were tested |
+|---|---|---|
+| attohttpc | supported | yes: attohttpc::get(url).send() |
+| awc | supported | yes: awc::Client::default().get(url).send() |
+| hyper | partly | no: hyper_util legacy Client; Request::builder().method(..).uri(url); client.request(req)<br>yes: client.get(Uri::from_static(url)) |
+| isahc | supported | yes: isahc::get(url)<br>yes: HttpClient::new()?.post_async(url, body) |
+| reqwest | partly | yes: let client = Client::new(); client.get(literal_url).send().await<br>yes: reqwest::Client::new().post(url).json(&body).send()<br>yes: reqwest::get(url) module function<br>no: client.request(Method::DELETE, format!("{}/x/{}", CONST_BASE, id)) on a ClientBuilder-built client<br>no: base URL from std::env::var with a literal fallback, joined with format!<br>yes: reqwest::blocking::Client::new().get(url).send()<br>no: client held in a struct field, base URL passed to new(), call in a method |
+| surf | supported | yes: surf::get(url).recv_string()<br>yes: surf::Client::new().get(url) |
+| ureq | supported | yes: ureq::get(url).call()<br>yes: ureq::post(url).send_json(..)<br>yes: let agent = AgentBuilder::new().build(); agent.get(url).call() |
+
+## The language's own HTTP client
+
+0 supported, 0 partly, 1 not yet.
+
+| Name | Status | Ways of using it that were tested |
+|---|---|---|
+| std::net::TcpStream | not yet | no: TcpStream::connect(host) then write_all(b"GET /path HTTP/1.1...") |
+
+## gRPC
+
+1 supported, 1 partly, 0 not yet.
+
+| Name | Status | Ways of using it that were tested |
+|---|---|---|
+| grpcio | supported | yes: server, form implements: impl <S> for T with RpcContext and UnarySink, create_<s>(impl) registration |
+| tonic | partly | yes: server, form implements: #[tonic::async_trait] impl <S> for T, trait imported from pb::<s>_server<br>yes: tonic::include_proto!("pkg") names the proto package used in the wire path<br>yes: registration: Server::builder().add_service(<S>Server::new(impl))<br>no: client, form factory: <S>Client::connect(literal_url) then client.<rpc>(Request::new(..))<br>no: client, form constructor: Channel::from_static(url).connect(); <S>Client::new(channel)<br>yes: client, form factory with an address from std::env::var |
+
+## Databases and data stores
+
+8 supported, 4 partly, 8 not yet.
+
+| Name | Status | Ways of using it that were tested |
+|---|---|---|
+| aws-sdk-dynamodb | supported | yes: client.put_item().table_name(t).item(..).send() |
+| aws-sdk-s3 | supported | yes: client.put_object().bucket(b).key(k).send() |
+| deadpool-postgres | supported | yes: let client = pool.get().await?; client.query(sql, &[]) |
+| diesel | partly | no: table DSL: invoices::table.filter(col.eq(x)).load::<T>(conn)<br>no: diesel::insert_into(table).values(&x).execute(conn)<br>yes: raw SQL: diesel::sql_query(sql).load(conn) |
+| elasticsearch | not yet | no: client.index(IndexParts::IndexId(index, id)) / search(SearchParts::Index(&[index])) |
+| memcache | not yet | no: memcache::connect(url); client.set(key, v, ttl) |
+| mongodb | not yet | no: client.database(db).collection(name) then insert_one / find / delete_many |
+| mysql_async | supported | yes: conn.query_drop(sql) and conn.exec_first(sql, params) |
+| postgres | supported | yes: postgres::Client::connect(..) then client.query(sql, &[]) |
+| qdrant-client | not yet | no: client.upsert_points(UpsertPointsBuilder::new(collection, points)) |
+| redis | not yet | no: con.set(key, v) / con.get(key) through redis::AsyncCommands<br>no: redis::cmd("HSET").arg(key)...query_async(&mut con) |
+| rocksdb | not yet | no: DB::open_default(path); db.put(k, v); db.get(k) |
+| rusqlite | supported | yes: conn.execute(sql, params![..]) |
+| scylla | supported | yes: session.query_unpaged(cql, values) and session.prepare(cql) |
+| sea-orm | partly | no: Entity::find().all(db) with #[sea_orm(table_name = ...)] on the model<br>no: ActiveModel { .. }.insert(db)<br>yes: db.query_all(Statement::from_string(backend, sql)) |
+| sled | not yet | no: sled::open(path) then db.open_tree(name).insert(k, v) |
+| sqlx | partly | yes: sqlx::query_as::<_, T>(sql).bind(x).fetch_one(pool)<br>partly: sqlx::query!(sql, args).execute(pool)<br>yes: sqlx::query_scalar(sql).fetch_one(pool)<br>yes: query(sql).execute(&mut *tx) inside pool.begin()<br>yes: shared table: main writes orders that services/sqlx reads |
+| surrealdb | not yet | no: db.select(table) and db.query(surql) |
+| tiberius | supported | yes: client.query(sql, &[&p]) on SQL Server |
+| tokio-postgres | partly | yes: client.query(sql, &[]) on a connected Client<br>no: let stmt = client.prepare(sql); client.execute(&stmt, ..) |
+
+## Messaging and events (queues, topics, streams)
+
+6 supported, 4 partly, 5 not yet.
+
+| Name | Status | Ways of using it that were tested |
+|---|---|---|
+| apalis | not yet | no: storage.push(Job); WorkerBuilder::new(name).backend(storage).build_fn(handler) |
+| async-nats | partly | no: client.subscribe(subject) then .next()<br>no: client.publish(subject, payload)<br>no: client.request(subject, payload)<br>yes: async_nats::jetstream::new(client).publish(subject, payload)<br>partly: shared subject: main publishes shipments.created |
+| aws-sdk-sns | supported | yes: client.publish().topic_arn(arn).message(m).send() |
+| aws-sdk-sqs | partly | yes: client.send_message().queue_url(url).message_body(b).send()<br>no: client.receive_message().queue_url(url) in a polling loop<br>partly: shared SQS queue URL: main sends to refunds |
+| crossbeam-channel | supported | yes: in-process: crossbeam_channel::unbounded(); s.send(x); r.recv() |
+| google-cloud-pubsub | not yet | no: client.topic(name).new_publisher(None).publish(msg) |
+| lapin | partly | no: channel.basic_publish(exchange, routing_key, ..)<br>no: channel.basic_consume(queue, consumer_tag, ..) then stream<br>partly: shared queue: main publishes to the default exchange with routing key invoice-emails |
+| pulsar | partly | partly: pulsar.producer().with_topic(t).build(); producer.send(..)<br>yes: pulsar.consumer().with_topic(t).with_subscription(s).build() |
+| rdkafka | supported | yes: FutureProducer.send(FutureRecord::to(topic).payload(..), timeout)<br>yes: BaseProducer.send(BaseRecord::to(topic))<br>yes: StreamConsumer.subscribe(&[topic]); consumer.recv()<br>yes: shared topic: main produces orders.placed that services/rdkafka consumes |
+| redis | not yet | no: con.publish(channel, msg)<br>no: client.get_async_pubsub(); pubsub.subscribe(channel); on_message() |
+| rumqttc | supported | yes: AsyncClient.subscribe(topic, qos) / publish(topic, qos, retain, payload)<br>yes: client.subscribe(topic, qos)<br>yes: shared MQTT topic: main publishes warehouse/temperature |
+| std::sync::mpsc | supported | yes: built-in in-process: std::sync::mpsc::channel(); tx.send(x); for x in rx |
+| tokio-cron-scheduler | not yet | no: JobScheduler::new(); sched.add(Job::new(cron, closure)) |
+| tokio::sync | supported | yes: in-process: tokio::sync::mpsc::channel(); tx.send(x).await; rx.recv().await<br>yes: in-process: tokio::sync::broadcast::channel(); tx.send(x) |
+| zmq | not yet | no: ctx.socket(zmq::PUB).bind(..).send(msg); SUB set_subscribe(prefix) |
+
+## Build tools and package managers
+
+3 supported, 0 partly, 0 not yet.
+
+| Name | Status | Ways of using it that were tested |
+|---|---|---|
+| Bazel rules_rust | supported | yes: MODULE.bazel + BUILD.bazel with rust_binary and rust_library, no Cargo.toml |
+| Cargo | supported | yes: one package with src/main.rs, src/<mod>.rs, tests/ and inline #[cfg(test)] tests |
+| Cargo workspace | supported | yes: virtual manifest with members listed by path; two binaries depend on a library by path<br>yes: members by glob (crates/*), exclude, default-members<br>yes: [workspace.package] and [workspace.dependencies] with a path dependency inherited by `x.workspace = true`<br>yes: a proc-macro crate ([lib] proc-macro = true) used by a service through a derive |
+
+## Project and folder layouts
+
+5 supported, 0 partly, 0 not yet.
+
+| Name | Status | Ways of using it that were tested |
+|---|---|---|
+| Cargo | supported | yes: one package with src/lib.rs, src/main.rs, src/bin/*.rs, examples/ and benches/<br>yes: build output target/ beside Cargo.toml with no .gitignore<br>yes: sibling crates with no workspace, path dependencies, one renamed with package = |
+| Cargo + cc | supported | yes: build.rs compiles native/*.c with the cc crate; a CMakeLists.txt sits beside Cargo.toml |
+| Cargo build script | supported | yes: build.rs writes code to OUT_DIR, included with include!(concat!(env!("OUT_DIR"), ..)); target/ listed in .gitignore |
+| cargo vendor | supported | yes: vendor/ holding third-party crates, wired by .cargo/config.toml [source.vendored-sources] |
+| Tauri | supported | yes: a web front end (package.json, src/) with the Rust backend in src-tauri/ (Cargo.toml, tauri.conf.json) |