matchapi 0.1.0__py3-none-any.whl

matchapi/__init__.py

@@ -0,0 +1,306 @@
+"""matchapi: an HTTP service is one function, and `match` replaces the router.
+
+async def handle(req):
+    match req.route:
+        case "GET", "ping":
+            return "pong"
+        case "GET", "users", user_id:
+            return {"id": int(user_id)}
+        case _:
+            return 404
+
+$ matchapi app
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import importlib
+import inspect
+import json
+import logging
+import os
+import sys
+from collections.abc import AsyncIterable, Awaitable, Callable, Iterable, Mapping
+from http import HTTPStatus
+from typing import Any
+from urllib.parse import parse_qsl
+
+__all__ = ["App", "HTTPError", "Request", "Response", "app", "main", "respond"]
+
+TEXT = "text/plain; charset=utf-8"
+JSON = "application/json"
+OCTETS = "application/octet-stream"
+BODYLESS = frozenset(range(100, 200)) | {204, 304}  # the statuses HTTP forbids a body for
+log = logging.getLogger("matchapi")
+
+
+def _phrase(status: int) -> str:
+    try:
+        return HTTPStatus(status).phrase
+    except ValueError:
+        return ""
+
+
+def _headers(headers: Mapping[str, str] | None) -> dict[str, str]:
+    """Lower-case names; a value HTTP cannot carry fails here, inside the handler's error handling."""
+    lowered = {}
+    for key, value in (headers or {}).items():
+        try:
+            key.encode("latin-1"), value.encode("latin-1")
+        except UnicodeEncodeError as error:
+            raise ValueError(f"header {key!r}: {value!r} is not latin-1; percent-encode it") from error
+        lowered[key.lower()] = value
+    return lowered
+
+
+def _json(value: object) -> bytes:
+    return json.dumps(value, separators=(",", ":"), ensure_ascii=False).encode()
+
+
+class HTTPError(Exception):
+    """Raised anywhere in the handler; becomes a JSON `{"detail": ...}` response with the status."""
+
+    def __init__(self, status: int, detail: str | None = None) -> None:
+        self.status = status
+        self.detail = _phrase(status) if detail is None else detail
+        super().__init__(f"{status} {self.detail}")
+
+
+class Request:
+    """The request as plain data: no transport underneath, so a test builds one by hand."""
+
+    __slots__ = ("body", "headers", "method", "path", "query")
+
+    def __init__(
+        self,
+        method: str,
+        path: str,
+        *,
+        query: str | Mapping[str, str] = "",
+        headers: Mapping[str, str] | None = None,
+        body: bytes = b"",
+    ) -> None:
+        self.method = method.upper()
+        self.path = path
+        self.query = dict(parse_qsl(query, keep_blank_values=True)) if isinstance(query, str) else dict(query)
+        self.headers = {key.lower(): value for key, value in (headers or {}).items()}
+        self.body = body
+
+    @property
+    def route(self) -> tuple[str, ...]:
+        """`(method, *segments)`, the subject of the handler's `match`: `/users/42` is `("GET", "users", "42")`."""
+        return (self.method, *(segment for segment in self.path.split("/") if segment))
+
+    def json(self) -> Any:
+        try:
+            return json.loads(self.body)
+        except ValueError as error:
+            raise HTTPError(400, f"invalid JSON body: {error}") from error
+
+
+class Response:
+    """The response as plain data; a `str` body is text, an iterable or async iterable of `bytes` streams."""
+
+    def __init__(
+        self,
+        status: int = 200,
+        body: bytes | str | Iterable[bytes] | AsyncIterable[bytes] = b"",
+        headers: Mapping[str, str] | None = None,
+    ) -> None:
+        self.status = status
+        self.headers = _headers(headers)
+        if isinstance(body, str):
+            body = body.encode()
+            self.headers.setdefault("content-type", TEXT)
+        if isinstance(body, bytes) and status not in BODYLESS:
+            self.headers.setdefault("content-length", str(len(body)))
+        self.body: bytes | Iterable[bytes] | AsyncIterable[bytes] = body
+
+
+def _status(value: int) -> int:
+    if not 100 <= value <= 999:
+        raise ValueError(f"{value} is not an HTTP status: a status is a three-digit number")
+    return value
+
+
+def respond(value: object) -> Response:
+    """The rules that turn a handler's return value into a response."""
+    match value:
+        case Response():
+            _status(value.status)
+            return value
+        case None:
+            return Response(204)
+        case int() if type(value) is int:
+            return Response(_status(value)) if value in BODYLESS else Response(_status(value), _phrase(value))
+        case str():
+            return Response(200, value)
+        case bytes():
+            return Response(200, value, {"content-type": OCTETS})
+        case dict() | list():
+            return Response(200, _json(value), {"content-type": JSON})
+        case (int() as status, body) if type(status) is int:
+            return _with_status(status, body)
+        case (int() as status, body, Mapping() as extra) if type(status) is int:
+            return _with_status(status, body, extra)
+    raise TypeError(
+        f"cannot turn {type(value).__name__} into a response: return a dict, list, str, bytes, int status, None, "
+        "a (status, body) or (status, body, headers) tuple, or a Response"
+    )
+
+
+def _with_status(status: int, body: object, extra: Mapping[str, str] | None = None) -> Response:
+    inner = respond(body)  # copied, so a Response shared between requests is not changed
+    response = Response(_status(status), inner.body, inner.headers)
+    response.headers.update(_headers(extra))
+    return response
+
+
+def _failed(req: Request, error: BaseException) -> Response:
+    if isinstance(error, HTTPError):
+        if error.status in BODYLESS:
+            return Response(error.status)
+        return Response(error.status, _json({"detail": error.detail}), {"content-type": JSON})
+    log.error("%s %s failed", req.method, req.path, exc_info=error)
+    return Response(500, "Internal Server Error")
+
+
+class App:
+    """The handler as an ASGI application."""
+
+    def __init__(self, handler: Callable[[Request], Any]) -> None:
+        self.handler = handler
+        # True once a call has returned an awaitable: the next call then skips the thread pool
+        self._async = inspect.iscoroutinefunction(handler) or None
+
+    async def _respond(self, req: Request) -> Response:
+        try:
+            result = self.handler(req) if self._async else await asyncio.to_thread(self.handler, req)
+            if inspect.isawaitable(result):
+                self._async = True
+                result = await result
+            return respond(result)
+        except Exception as error:
+            return _failed(req, error)
+
+    async def __call__(
+        self, scope: Mapping[str, Any], receive: Callable[[], Awaitable[Any]], send: Callable[[Any], Awaitable[None]]
+    ) -> None:
+        match scope["type"]:
+            case "lifespan":
+                while (await receive())["type"] != "lifespan.shutdown":
+                    await send({"type": "lifespan.startup.complete"})
+                await send({"type": "lifespan.shutdown.complete"})
+            case "http":
+                body = bytearray()
+                while True:
+                    message = await receive()
+                    if message["type"] == "http.disconnect":
+                        return  # nobody is listening: the handler does not run on a truncated body
+                    body += message.get("body", b"")
+                    if not message.get("more_body"):
+                        break
+                req = Request(
+                    scope["method"],
+                    scope["path"],
+                    query=scope.get("query_string", b"").decode("latin-1"),
+                    headers={key.decode("latin-1"): value.decode("latin-1") for key, value in scope.get("headers", [])},
+                    body=bytes(body),
+                )
+                response = await self._respond(req)
+                headers = [(key.encode("latin-1"), value.encode("latin-1")) for key, value in response.headers.items()]
+                await send({"type": "http.response.start", "status": response.status, "headers": headers})
+                if isinstance(response.body, bytes):
+                    await send({"type": "http.response.body", "body": response.body})
+                elif isinstance(response.body, AsyncIterable):
+                    async for chunk in response.body:
+                        await send({"type": "http.response.body", "body": chunk, "more_body": True})
+                    await send({"type": "http.response.body", "body": b""})
+                else:
+                    for chunk in response.body:
+                        await send({"type": "http.response.body", "body": chunk, "more_body": True})
+                    await send({"type": "http.response.body", "body": b""})
+            case "websocket":
+                await send({"type": "websocket.close"})
+
+
+def app(handler: Callable[[Request], Any]) -> App:
+    """Wrap the handler for a server of your own: `app = matchapi.app(handle)`, then `uvicorn asgi:app`."""
+    return App(handler)
+
+
+def _load(target: str) -> Callable[[Request], Any]:
+    module_name, _, attribute = target.partition(":")
+    if not module_name:
+        raise SystemExit(
+            f"{target!r}: the target is module or module:function, e.g. `matchapi app` or `matchapi app:handle`"
+        )
+    try:
+        module = importlib.import_module(module_name)
+    except ModuleNotFoundError as error:
+        if error.name != module_name and not module_name.startswith(f"{error.name}."):
+            raise  # the module was found; something it imports was not, and that is the user's traceback
+        hint = f"; drop the .py: `matchapi {module_name[:-3]}`" if module_name.endswith(".py") else ""
+        raise SystemExit(f"{error}{hint}") from error
+    if attribute:
+        if not hasattr(module, attribute):
+            raise SystemExit(f"{module_name} has no `{attribute}`")
+    elif hasattr(module, "handle"):
+        attribute = "handle"
+    else:
+        public = [
+            name
+            for name, value in vars(module).items()
+            if not name.startswith("_") and inspect.isfunction(value) and value.__module__ == module.__name__
+        ]
+        if not public:
+            raise SystemExit(f"{module_name} has no public function to serve")
+        if len(public) > 1:
+            raise SystemExit(
+                f"{module_name} has no `handle` and several public functions: {', '.join(public)}; "
+                f"run `matchapi {module_name}:<function>`"
+            )
+        attribute = public[0]
+    handler: Callable[[Request], Any] = getattr(module, attribute)
+    if not callable(handler):
+        raise SystemExit(f"{module_name}: `{attribute}` is not callable")
+    return handler
+
+
+def _factory() -> App:
+    """The import string of `--workers` and `--reload`: every worker process loads the handler itself."""
+    return app(_load(os.environ["MATCHAPI_TARGET"]))
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(
+        prog="matchapi", description="Serve a module whose function `handle(req)` is the HTTP service."
+    )
+    parser.add_argument(
+        "target", help="the module, or module:function; without a function, `handle` or the only public one"
+    )
+    parser.add_argument("--host", default="127.0.0.1")
+    parser.add_argument("--port", type=int, default=8000)
+    parser.add_argument("--workers", type=int, help="processes; the handler is loaded in each of them")
+    parser.add_argument("--reload", action="store_true", help="restart on a code change")
+    args = parser.parse_args(argv)
+    if (cwd := os.getcwd()) not in sys.path:
+        sys.path.insert(0, cwd)
+    handler = _load(args.target)  # fail here, with the message, rather than in a worker
+
+    import uvicorn
+
+    if args.workers or args.reload:
+        os.environ["MATCHAPI_TARGET"] = args.target
+        uvicorn.run(
+            f"{__name__}:_factory",
+            host=args.host,
+            port=args.port,
+            workers=args.workers,
+            reload=args.reload,
+            factory=True,
+        )
+    else:
+        uvicorn.run(app(handler), host=args.host, port=args.port)

matchapi/__main__.py

@@ -0,0 +1,3 @@
+from matchapi import main
+
+main()

matchapi-0.1.0.dist-info/METADATA

@@ -0,0 +1,331 @@
+Metadata-Version: 2.5
+Name: matchapi
+Version: 0.1.0
+Summary: An HTTP service is one function: match replaces the router
+Project-URL: Homepage, https://github.com/troyan-dy/matchapi
+Project-URL: Repository, https://github.com/troyan-dy/matchapi
+Project-URL: Issues, https://github.com/troyan-dy/matchapi/issues
+Project-URL: Changelog, https://github.com/troyan-dy/matchapi/blob/master/CHANGELOG.md
+Author: Dmitriy Troyan
+License-Expression: MIT
+License-File: LICENSE
+Keywords: asgi,framework,http,match,microservice,pattern-matching,web,webhook
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: uvicorn>=0.30
+Description-Content-Type: text/markdown
+
+# matchapi
+
+[![PyPI](https://img.shields.io/pypi/v/matchapi)](https://pypi.org/project/matchapi/)
+[![Python](https://img.shields.io/pypi/pyversions/matchapi)](https://pypi.org/project/matchapi/)
+[![CI](https://github.com/troyan-dy/matchapi/actions/workflows/ci.yml/badge.svg)](https://github.com/troyan-dy/matchapi/actions/workflows/ci.yml)
+[![License](https://img.shields.io/pypi/l/matchapi)](LICENSE)
+
+An HTTP service is one function. `match` replaces the router.
+
+```python
+# app.py
+async def handle(req):
+    match req.route:
+        case "GET", "ping":
+            return "pong"
+        case "GET", "users", user_id:
+            return {"id": int(user_id), "name": "ann"}
+        case "POST", "users":
+            body = req.json()
+            return 201, {"id": 7, "name": body["name"]}
+        case _:
+            return 404
+```
+
+```console
+$ pip install matchapi
+$ matchapi app
+INFO:     Started server process [62579]
+INFO:     Waiting for application startup.
+INFO:     Application startup complete.
+INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+```
+
+```console
+$ curl localhost:8000/ping
+pong
+$ curl localhost:8000/users/42
+{"id":42,"name":"ann"}
+$ curl -i -X POST localhost:8000/users -d '{"name": "bob"}'
+HTTP/1.1 201 Created
+date: Mon, 12 Oct 2026 00:10:08 GMT
+server: uvicorn
+content-type: application/json
+content-length: 21
+
+{"id":7,"name":"bob"}
+$ curl -i localhost:8000/nothing
+HTTP/1.1 404 Not Found
+date: Mon, 12 Oct 2026 00:10:08 GMT
+server: uvicorn
+content-type: text/plain; charset=utf-8
+content-length: 9
+
+Not Found
+```
+
+No decorators, no route table, no schema classes, no dependency markers. The file above does not even import
+`matchapi`: it is a Python function that takes a request and returns a value, and it can be called like one.
+
+- [Why](#why)
+- [The model](#the-model)
+  - [One function](#one-function)
+  - [`req.route` is the subject of `match`](#reqroute-is-the-subject-of-match)
+  - [The request is plain data](#the-request-is-plain-data)
+  - [The return value is the response](#the-return-value-is-the-response)
+  - [Errors](#errors)
+  - [Sync or async, the same way](#sync-or-async-the-same-way)
+- [Running](#running)
+- [Testing](#testing)
+- [Recipes](#recipes)
+- [What matchapi does not do](#what-matchapi-does-not-do)
+- [Design notes](#design-notes)
+- [Development](#development)
+
+## Why
+
+Every Python web framework, from Flask to FastAPI, is a router with a decorator in front of it and a growing set of
+concepts behind it: path templates, parameter sources, dependency markers, routers, middleware stacks, response
+models. A service with three endpoints pays for all of it.
+
+Python has had structural pattern matching since 3.10. A `match` over `(method, *segments)` is a router already:
+it binds path parameters, it falls through to a default, it nests, and the language, not a library, defines how it
+reads. matchapi is what is left of a framework once the router is gone: a `Request`, a `Response`, the rules that
+turn a return value into one, and a command that serves a module.
+
+## The model
+
+### One function
+
+The service is a function that takes a `Request` and returns something. That is the whole contract. A function is
+easy to test, easy to compose, easy to move: two services in one process are a function that calls two others.
+
+### `req.route` is the subject of `match`
+
+`req.route` is a tuple of the method followed by the non-empty path segments: `GET /users/42` is
+`("GET", "users", "42")`, and `GET /` is `("GET",)`. A flat tuple matches without nesting:
+
+```python
+match req.route:
+    case "GET", "users", user_id:  # binds the segment
+        ...
+    case "GET" | "HEAD", "health":  # several methods
+        ...
+    case _, "api", *rest:  # a prefix: delegate the rest
+        return api(req, rest)
+    case _:
+        return 404
+```
+
+Segments are strings, so a numeric id is `int(user_id)` in the handler; a `ValueError` there is a 500, so raise
+`HTTPError(400)` yourself when the input is the client's fault. `req.method` and `req.path` stay available as
+strings for the cases where a plain comparison reads better.
+
+### The request is plain data
+
+| Attribute | Type | Example for `POST /users/42?q=x` |
+|---|---|---|
+| `method` | `str`, upper case | `"POST"` |
+| `path` | `str` | `"/users/42"` |
+| `route` | `tuple[str, ...]` | `("POST", "users", "42")` |
+| `query` | `dict[str, str]`, last value wins | `{"q": "x"}` |
+| `headers` | `dict[str, str]`, lower-case names | `{"content-type": "application/json"}` |
+| `body` | `bytes`, read in full before the call | `b'{"name": "bob"}'` |
+| `json()` | the body as JSON; a broken body is a 400 | `{"name": "bob"}` |
+
+There is no `scope` or stream underneath: the body is read before the handler runs, so a sync handler needs no
+`await`. `Request("POST", "/users", body=b"...")`
+builds one by hand, which is how a test calls the handler; `query` takes the raw string or a dict.
+
+### The return value is the response
+
+| Return | Response |
+|---|---|
+| `dict` or `list` | 200, `application/json` |
+| `str` | 200, `text/plain; charset=utf-8` |
+| `bytes` | 200, `application/octet-stream` |
+| `int` (not `bool`) | that status, the standard phrase as text: `return 404` is `Not Found`; 1xx, 204 and 304 have no body |
+| `None` | 204, no body |
+| `(status, body)` | the body as above with that status: `return 201, {"id": 7}` |
+| `(status, body, headers)` | the same with extra headers: `return 302, None, {"location": "/"}` |
+| `Response(status, body, headers)` | as given; a `str` body is text, an iterable or async iterable of `bytes` streams |
+
+Anything else, a status outside 100-999 or a header value outside latin-1 is a 500 with the reason in the log.
+JSON is compact and keeps non-ASCII text as is: exactly what
+`json.dumps(value, separators=(",", ":"), ensure_ascii=False)` gives. A `Response` passed in a tuple is copied,
+so a module-level `NOT_FOUND = Response(404, "no")` is safe to reuse.
+
+### Errors
+
+`HTTPError(status, detail=None)` raised anywhere in the handler becomes a JSON response
+`{"detail": "..."}` with that status; `detail` defaults to the standard phrase. `req.json()` raises it as a 400.
+
+Any other exception is a 500 with the body `Internal Server Error`; the traceback goes to the `matchapi` logger
+together with the method and path. Nothing of the exception reaches the client.
+
+### Sync or async, the same way
+
+`def handle(req)` and `async def handle(req)` are both fine. A sync handler runs in a thread pool, an async one in
+the event loop; both are served by the same uvicorn. The kind of handler is read from the result of a call, not
+from the function, so a `functools.partial`, a callable object or a compiled function all work, and a sync
+function that returns a coroutine from some branches is awaited on those.
+
+## Running
+
+```console
+$ matchapi app                      # app.py in the working directory, its function `handle`
+$ matchapi app:serve                # another function
+$ matchapi api.users                # a module in a package
+$ matchapi app --host 0.0.0.0 --port 80 --workers 4
+$ matchapi app --reload             # development
+$ python -m matchapi app            # the same command
+```
+
+Without `:function`, the command takes `handle`, and if there is none, the only public function the module defines.
+The server is uvicorn, the one dependency of the package. `--workers` and `--reload` make every process load the
+module itself.
+
+For a server of your own, `matchapi.app(handle)` is an ASGI application:
+
+```python
+# asgi.py
+import matchapi
+from app import handle
+
+app = matchapi.app(handle)
+```
+
+```console
+$ uvicorn asgi:app
+$ granian --interface asgi asgi:app
+```
+
+## Testing
+
+The handler is a function and `Request` is a constructor, so a test needs no client and no server:
+
+```python
+import asyncio
+
+from matchapi import Request
+
+from app import handle
+
+
+def test_user() -> None:
+    assert asyncio.run(handle(Request("GET", "/users/42"))) == {"id": 42, "name": "ann"}
+
+
+def test_create() -> None:
+    result = asyncio.run(handle(Request("POST", "/users", body=b'{"name": "bob"}')))
+    assert result == (201, {"id": 7, "name": "bob"})
+
+
+def test_unknown() -> None:
+    assert asyncio.run(handle(Request("DELETE", "/users/42"))) == 404
+```
+
+With `pytest-asyncio` the tests are `async def` and await the handler directly. When the headers or the status
+line matter, `matchapi.respond(value)` turns a return value into the `Response` the server would send.
+
+## Recipes
+
+**Authorization** is a line before the `match`:
+
+```python
+async def handle(req):
+    if req.headers.get("authorization") != f"Bearer {TOKEN}":
+        return 401
+    match req.route:
+        ...
+```
+
+**Two services in one process** are two functions and a prefix:
+
+```python
+async def handle(req):
+    match req.route:
+        case _, "users", *rest:
+            return await users(req, rest)
+        case _, "orders", *rest:
+            return await orders(req, rest)
+        case _:
+            return 404
+```
+
+**Validation** is whatever you like; a dataclass is enough for a simple body:
+
+```python
+from dataclasses import dataclass
+
+from matchapi import HTTPError
+
+
+@dataclass
+class NewUser:
+    name: str
+    age: int = 0
+
+
+async def handle(req):
+    match req.route:
+        case "POST", "users":
+            try:
+                user = NewUser(**req.json())
+            except TypeError as error:
+                raise HTTPError(400, str(error)) from error
+            return 201, {"name": user.name}
+```
+
+**A redirect, a custom content type, a stream:**
+
+```python
+return 302, None, {"location": "/login"}
+return Response(200, "<h1>hi</h1>", {"content-type": "text/html"})
+return Response(200, (chunk for chunk in lines()))
+```
+
+## What matchapi does not do
+
+No router or decorators, no middleware stack, no parameter conversion from type hints, no OpenAPI, no cookies or
+sessions, no templates, no static files, no websockets, no streaming request bodies, no WSGI. Each of these is
+either a few lines in the handler or a job for an ASGI middleware wrapped around `matchapi.app(handle)`.
+
+The line is deliberate. The framework fits in one file of about 300 lines that reads in half an hour, and the
+handler stays a function that works without it.
+
+## Design notes
+
+The decisions and the alternatives that were rejected are in [docs/design.md](docs/design.md): why the router
+went instead of the signature magic, why there is a command rather than an `app = ...` line, why the body is read
+before the call, why there is only ASGI, and why there is no compiled core.
+
+## Development
+
+```console
+$ uv sync
+$ uv run pytest --cov
+$ uv run ruff check . && uv run ruff format --check . && uv run mypy
+```
+
+Coverage is kept at 100%. A pull request bumps the version in `pyproject.toml` and adds a `CHANGELOG.md` entry;
+a merge into `master` publishes that version to PyPI and tags it.

matchapi-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+matchapi/__init__.py,sha256=4x8kouFApWkvKaqZ6qNs4spkQ0B0lP9n9NuHp_1v-EI,12213
+matchapi/__main__.py,sha256=qukUn1fbAwg4IBxehKxx_tqJfAq5vyylgnRuKuXV2fY,34
+matchapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+matchapi-0.1.0.dist-info/METADATA,sha256=kfF_XJKX4iC3ZYyDOPhM6JqgL3EYRoQ1dnVD2gJu7Yg,12137
+matchapi-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+matchapi-0.1.0.dist-info/entry_points.txt,sha256=KvkgH0Bj32cT_j41aVrrU8Eo2hcPdWNq41Ui3aGSSt8,43
+matchapi-0.1.0.dist-info/licenses/LICENSE,sha256=kYDh-xs92donPCS9wWWttVjpfOUekM4zXqYqnYTykI0,1071
+matchapi-0.1.0.dist-info/RECORD,,

matchapi-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

matchapi-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+matchapi = matchapi:main

matchapi-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dmitriy Troyan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.