xtr-http-client-contracts 4.0.2__py3-none-any.whl

xtr_http_client_contracts/testing/test_http_server.py

@@ -0,0 +1,213 @@
+"""A disposable HTTP server a client implementation can be tested against."""
+
+from __future__ import annotations
+
+import asyncio
+import threading
+from typing import TYPE_CHECKING, ClassVar, Final, cast, final
+
+from ._fixture_request import read_request
+from ._fixture_routes import respond
+
+if TYPE_CHECKING:
+    from types import TracebackType
+    from typing import Self
+
+__all__ = ["TestHttpServer"]
+
+_HOST: Final = "127.0.0.1"
+
+#: Ask the operating system for a free port, so two suites running at once never collide.
+_ANY_FREE_PORT: Final = 0
+
+
+@final
+class TestHttpServer:
+    """The server the conformance suite points a client at.
+
+    It runs on an event loop of its own, in a background thread, because the client under test
+    owns the loop its own code runs on: a client that stops pumping its loop — which is exactly
+    what a timeout test provokes — must not stop the server that is meant to keep answering it.
+
+    ``start()`` returns once the port is listening, and both ``start()`` and ``stop()`` may be
+    called again at any point, so one instance can live for a whole test session::
+
+        @pytest.fixture(scope="session")
+        def http_server() -> Iterator[TestHttpServer]:
+            with TestHttpServer() as server:
+                yield server
+
+    Unless a port is named, the server listens on whichever free port the operating system
+    hands out, which :attr:`port` and :attr:`base_uri` report once :meth:`start` has returned.
+    A restarted server may be given a different one.
+
+    What each route answers is described in ``_fixture_routes``; what the echoing ones report
+    about the request is described in ``_fixture_request``.
+    """
+
+    __test__: ClassVar[bool] = False  # a library class, not a pytest test case
+
+    __slots__ = (
+        "_bound_port",
+        "_failure",
+        "_host",
+        "_loop",
+        "_port",
+        "_ready",
+        "_stop",
+        "_thread",
+    )
+
+    def __init__(self, host: str = _HOST, port: int = _ANY_FREE_PORT) -> None:
+        """Bind nothing yet: the socket is opened by :meth:`start`."""
+        self._host = host
+        self._port = port
+        self._bound_port: int | None = None
+        self._ready = threading.Event()
+        self._thread: threading.Thread | None = None
+        self._loop: asyncio.AbstractEventLoop | None = None
+        self._stop: asyncio.Event | None = None
+        self._failure: BaseException | None = None
+
+    @property
+    def host(self) -> str:
+        """The address the server listens on."""
+        return self._host
+
+    @property
+    def port(self) -> int:
+        """The port the server listens on.
+
+        Raises:
+            RuntimeError: When the server was asked for any free port and has not been
+                started, so no port has been chosen yet.
+        """
+        if self._bound_port is not None:
+            return self._bound_port
+        if self._port == _ANY_FREE_PORT:
+            raise RuntimeError(
+                "The server listens on a free port chosen by start(); start it first."
+            )
+        return self._port
+
+    @property
+    def base_uri(self) -> str:
+        """The origin a client should send its requests to."""
+        return f"http://{self._host}:{self.port}"
+
+    def start(self) -> None:
+        """Listen, and return once the port accepts connections.
+
+        Starting an already-running server does nothing, so a fixture may start it defensively.
+        Whatever stopped the thread from listening — a port already taken, most often — is
+        raised here rather than left to make every later request fail obscurely.
+        """
+        if self._thread is not None:
+            return
+        self._failure = None
+        self._ready.clear()
+        thread = threading.Thread(target=self._run, name="xtr-fixture-http-server", daemon=True)
+        self._thread = thread
+        thread.start()
+        _ = self._ready.wait()
+        failure = self._failure
+        if failure is not None:
+            self._thread = None
+            self._failure = None
+            raise failure
+
+    def stop(self) -> None:
+        """Close the port and everything still connected to it.
+
+        Stopping a server that is not running does nothing, and a stopped server can be started
+        again; a route still writing when this is called is cut off rather than waited for.
+        """
+        thread, loop, stop = self._thread, self._loop, self._stop
+        self._thread = None
+        self._loop = None
+        self._stop = None
+        if thread is None:
+            return
+        if loop is not None and stop is not None:
+            _ = loop.call_soon_threadsafe(stop.set)
+        thread.join()
+
+    def __enter__(self) -> Self:
+        """Start, for a test that wants the server for the length of a block."""
+        self.start()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        """Stop, whatever the block did."""
+        del exc, exc_type, traceback
+        self.stop()
+
+    def _run(self) -> None:
+        """The background thread: one event loop, used for nothing else."""
+        try:
+            asyncio.run(self._serve())
+        except BaseException as failure:  # noqa: BLE001 - re-raised by start()
+            self._failure = failure
+        finally:
+            self._ready.set()
+
+    async def _serve(self) -> None:
+        self._loop = asyncio.get_running_loop()
+        stop = asyncio.Event()
+        self._stop = stop
+        server = await asyncio.start_server(self._handle, self._host, self._port)
+        bound = cast("tuple[object, ...]", server.sockets[0].getsockname())
+        self._bound_port = cast("int", bound[1])
+        self._ready.set()
+        try:
+            _ = await stop.wait()
+        finally:
+            # Order matters: everything connected goes before the listener does. A connection
+            # that attaches after a server has been closed makes the standard library wake
+            # waiters it already dropped, and the socket cleanup that was underneath dies with
+            # it — leaving the socket open. Nothing can attach once no accept is in flight.
+            await _end_everything_still_serving()
+            server.close()
+            await server.wait_closed()
+
+    async def _handle(self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None:
+        """Answer one request and close, as every response promises in its headers."""
+        try:
+            request = await read_request(reader, writer, self._host)
+            if request is not None:
+                await respond(request, writer)
+            writer.close()
+            await writer.wait_closed()
+        except (OSError, EOFError):
+            pass  # the client hung up mid-exchange, which several routes exist to provoke
+        finally:
+            # However the exchange ended — cut short by a cancelled route included — the socket
+            # may not outlive the handler, or the loop is closed with it still open. Aborting
+            # an already-closed transport does nothing, so the orderly path above still wins.
+            writer.transport.abort()
+
+
+async def _end_everything_still_serving() -> None:
+    """Cancel every other task on this loop, wait for it, and let its socket close.
+
+    This is what ``asyncio.run`` would do on the way out, done here instead while the loop can
+    still run, because the runner drops what it cancels with its sockets still open.
+
+    The two turns of the loop around the cancelling are both load-bearing. Before: a connection
+    accepted in the same breath as the shutdown has a task that has not run at all yet, holding
+    the accepted socket and nothing that could close it; one turn lets it reach the transport,
+    which cancelling then closes. After: losing a connection is a callback, and the sockets the
+    cancelled tasks just abandoned are still waiting for it.
+    """
+    await asyncio.sleep(0)
+    current = asyncio.current_task()
+    serving = [task for task in asyncio.all_tasks() if task is not current]
+    for task in serving:
+        _ = task.cancel()
+    _ = await asyncio.gather(*serving, return_exceptions=True)
+    await asyncio.sleep(0)

xtr_http_client_contracts-4.0.2.dist-info/METADATA

@@ -0,0 +1,271 @@
+Metadata-Version: 2.4
+Name: xtr-http-client-contracts
+Version: 4.0.2
+Summary: The async HTTP client contract alone: a request call, a response read on demand, typed options and the errors they raise.
+Keywords: http,http-client,contracts,interface,protocol,asyncio
+Author: Xterr
+Author-email: Xterr <me@xterr.dev>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+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
+Classifier: Typing :: Typed
+Requires-Dist: typing-extensions>=4.4
+Requires-Dist: xtr-http-message-contracts>=4.0,<5
+Requires-Dist: anyio>=4.0 ; extra == 'testing'
+Requires-Dist: pytest>=8 ; extra == 'testing'
+Requires-Dist: xtr-http-message>=4.0,<5 ; extra == 'testing'
+Requires-Python: >=3.11
+Provides-Extra: testing
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+# xtr-http-client-contracts
+
+**The async HTTP client contract, and nothing else — so a library that calls out installs no backend.**
+
+<img alt="python 3.11+" src="https://img.shields.io/badge/python-%E2%89%A5%203.11-3776AB?logo=python&logoColor=white">
+<img alt="asyncio" src="https://img.shields.io/badge/asyncio-native-1f6feb">
+<img alt="typed" src="https://img.shields.io/badge/typed-ty%20%2B%20basedpyright-1f6feb">
+<img alt="license MIT" src="https://img.shields.io/badge/license-MIT-blue">
+
+</div>
+
+---
+
+## Why?
+
+A library that sends an HTTP request should not choose what sends it. It takes the client
+interface, asks for a method and a URL, and leaves connection pooling, redirects and TLS to
+whatever the application wired behind it.
+
+That needs the *seam*, not a client. This package is that seam: the client interface, the
+response interface, the typed request options, the errors they raise, and a conformance suite
+any implementation runs against itself.
+
+## Install
+
+```sh
+uv add xtr-http-client-contracts
+uv add --dev "xtr-http-client-contracts[testing]"   # + what the conformance suite runs on
+```
+
+Requires Python 3.11+. The only runtime dependency beyond `typing-extensions` is
+[xtr-http-message-contracts](../xtr-http-message-contracts): a client response is an HTTP
+response before it is anything else.
+
+## What a caller depends on
+
+```python
+from xtr_http_client_contracts import HttpClientInterface
+
+
+async def paid_orders(client: HttpClientInterface) -> dict[str, object]:
+    response = await client.request("GET", "https://api.example.com/orders", query={"paid": "1"})
+    async with response:
+        return await response.to_array()
+```
+
+`HttpClientInterface` is a `@runtime_checkable` `Protocol` with three members:
+
+| Member | Answers |
+|---|---|
+| `await request(method, url, **options)` | an `HttpResponseInterface`, once the status line and the headers are in |
+| `await send_request(request, **options)` | the same, for a [message request](../xtr-http-message-contracts) that already knows its own method, URI, headers and body |
+| `with_options(**options)` | another client of the same type, whose defaults are these options over this one's |
+
+Neither call raises because of the status: a 404 or a 503 is an answer and comes back as a
+response. What they do raise is `TransportError` when nothing answered,
+`TransportTimeoutError` when nothing answered in time, and `InvalidArgumentError` for a
+method, a URL or an option that is refused before anything is sent.
+
+`send_request` says what wins when a request and the options both have an opinion: the request
+is authoritative. A relative URI is resolved against `base_uri`, `query` is merged into the
+URI, a header from `headers` is sent only under a name the request does not carry,
+`auth_basic` and `auth_bearer` apply only without an `Authorization` of the request's own, and
+`body` or `json` alongside a request that already carries a body is refused, word for word:
+
+```
+Define either the request body or the "body" or "json" option, setting both is not supported.
+```
+
+Several requests run at once by being made from tasks of one task group; nothing in the
+contract is per client state a caller has to serialize.
+
+## The response
+
+`HttpResponseInterface` extends the message `ResponseInterface`, so the status code, the reason
+phrase, the protocol version, the headers, `get_body()` and the `with_*` copies are the message
+contract's — code typed against the plain response interface takes one of these as it is, and
+`isinstance` is what reveals the extras:
+
+```python
+from xtr_http_client_contracts import HttpResponseInterface
+from xtr_http_message_contracts import ResponseInterface
+
+
+def log(response: ResponseInterface) -> None:
+    print(response.get_status_code())
+    if isinstance(response, HttpResponseInterface):
+        print(response.get_info("total_time"))
+```
+
+What a client adds on top of a message response:
+
+| Member | Is |
+|---|---|
+| `await get_content(throw=True)` | every byte of the body, waiting for the rest of it to arrive |
+| `await to_array(throw=True)` | that body decoded as a JSON object |
+| `get_info(key=None)` | what the transfer knows about itself, never waiting and never raising |
+| `await cancel()` | the transfer abandoned, and what it held let go of |
+| `async with response:` | a block that owns the transfer and closes the body on the way out |
+
+`throw` is the one switch: left on, an unsuccessful status is raised by reading the body —
+`RedirectionError`, `ClientError`, `ServerError` — rather than returned. `throw=False` hands
+the body over whatever the status says, which is how a 4xx carrying an explanation is read.
+
+`get_info()` always answers these entries: `canceled`, `error`, `http_code` (`0` before a
+status arrived), `http_method`, `redirect_count`, `redirect_url`, `response_headers` (the raw
+status and header lines of every hop), `start_time`, `total_time`, `url` and `user_data`.
+`primary_ip` and `retry_count` are there when they are known. Because it neither waits nor
+raises, it is readable while the transfer is still going on.
+
+## Request options
+
+`RequestOptions` is a `total=False` `TypedDict`, so every option is checked where it is
+written and an option left out is one nobody asked about — the client fills it in from its own
+defaults, which start at `OPTIONS_DEFAULTS`.
+
+```python
+from xtr_http_client_contracts import OPTIONS_DEFAULTS, RequestOptions
+
+defaults: RequestOptions = {**OPTIONS_DEFAULTS, "timeout": 5, "max_redirects": 0}
+```
+
+| Option | Says |
+|---|---|
+| `auth_basic`, `auth_bearer` | the credentials to send; both at once is refused |
+| `query` | parameters merged into the URL, winning over one of the same name already there |
+| `headers` | the headers to send, one value or several per name |
+| `body`, `json` | what to send — bytes, text, a mapping as a form, an async iterable produced as it goes; or a value encoded as JSON. Both at once is refused |
+| `user_data` | anything to find again under the `user_data` entry of `get_info()`; never read |
+| `max_redirects` | how many hops to follow; zero or less answers with the 3xx |
+| `http_version` | `"1.0"`, `"1.1"`, `"2"` or `"2.0"`; `None` leaves it to the connection |
+| `base_uri` | what a relative URL resolves against. A sequence of them is for a client that retries, which moves along it |
+| `timeout` | how long the transfer may go quiet for. `None` is 60 seconds, not "no limit" |
+| `max_duration`, `max_connect_duration` | limits on the whole request and on connecting. Zero *is* "no limit" |
+| `resolve` | host to address, instead of asking a resolver — what pins a request to an address already checked |
+| `proxy` | the proxy to go through, as a URL |
+| `verify_peer`, `verify_host`, `cafile`, `capath`, `local_cert`, `local_pk`, `passphrase` | how the peer is checked, and what is presented to it |
+| `max_retries` | how many further attempts a client that retries may make |
+| `extra` | options a client may ignore where it has no use for them — `use_persistent_connections`, `trace_content` |
+
+A name the contract does not list is refused rather than quietly obeyed, with
+`InvalidArgumentError`:
+
+```
+Unsupported option "timout" passed to "HttpxHttpClient", did you mean "timeout"?
+```
+
+That refusal is the point of naming them: an option spelled wrong cannot pass for one that was
+obeyed. `extra` is the escape hatch for what one client understands and another has no use
+for, so entries in it may be ignored.
+
+## Errors
+
+Everything derives from `HttpClientError`, and the shape of the tree is the question a caller
+asks: was there an answer at all, and was it the one wanted?
+
+| Error | Raised when |
+|---|---|
+| `HttpClientError` | the root; nothing raises it directly |
+| `TransportError` | no answer came — a refused connection, a broken transfer, a cancelled response |
+| `TransportTimeoutError` | no answer came in time; a `TransportError` |
+| `HttpError` | there is an answer and it is not a success |
+| `RedirectionError` | a 3xx read with `throw`, once `max_redirects` was reached |
+| `ClientError` | a 4xx read with `throw` |
+| `ServerError` | a 5xx read with `throw` |
+| `DecodingError` | the body is not what it was read as |
+| `JsonError` | the body is not the JSON object it was read as; a `DecodingError` |
+| `InvalidArgumentError` | the request is one the client refuses to make, before anything is sent |
+
+The message of an `HttpError` names the code and the URL — `HTTP 404 returned for "<url>".` —
+or quotes the status line the server sent, and takes the `title` and `detail` of the body when
+that body is a JSON error document.
+
+## The conformance suite
+
+`xtr_http_client_contracts.testing` is how an implementation proves it is one. It ships in
+`src` rather than in `tests` because it is run by other packages; install it with the
+`testing` extra, which brings an async backend, the runner the suite is written for, and a
+message request implementation.
+
+Subclass `HttpClientTestCase` and return the client under test:
+
+```python
+# tests/integration/test_my_http_client.py
+from xtr_http_client_contracts import HttpClientInterface
+from xtr_http_client_contracts.testing import HttpClientTestCase
+
+from my_package import MyHttpClient
+
+
+class TestMyHttpClient(HttpClientTestCase):
+    def create_client(self) -> HttpClientInterface:
+        return MyHttpClient()
+```
+
+That is the whole of it: the suite starts `TestHttpServer` once for the session on a free port,
+points every test at it through `self.base_uri` and `self.port`, and runs the contract as
+behaviour — the status that is an answer, the body that is
+kept and can be read twice, the redirect chain that drops credentials when it leaves the host
+and gets them back when it returns, the timeouts, the proxy settings read from the
+environment, the `resolve` pin, the options `send_request` fills in, and the refusals quoted
+above. A client that passes is one a caller can hold through the interface alone.
+
+`create_client` is called per test, freshly: a test may cancel a transfer or exhaust a pool, so
+no two tests share a client. A client that cannot honour part of the contract yet says which
+tests it skips and why, rather than quietly not running them:
+
+```python
+from collections.abc import Mapping
+from typing import ClassVar
+
+
+class TestMyHttpClient(HttpClientTestCase):
+    skipped_tests: ClassVar[Mapping[str, str]] = {
+        "test_ipv6_resolve": "no IPv6 in this environment",
+    }
+```
+
+A parametrized test is named there without its parameter. `TestHttpServer(host=..., port=...)`
+is usable on its own — as a context manager, or with `start()` and `stop()` — for a test that
+needs a second server of its own. Leave `port` out and it listens on whichever free port the
+operating system gives it, which `server.port` and `server.base_uri` report once it has started;
+two suites running at once never collide.
+
+## Development
+
+Developed in the [python-xtr](https://github.com/xterr/python-xtr) monorepo, under
+`packages/xtr-http-client-contracts`; run the commands below from there. The
+`python-xtr-http-client-contracts` repository is a read-only copy, so send issues and pull
+requests to the monorepo.
+
+```sh
+uv sync --all-extras
+uv run ruff check && uv run ruff format --check && uv run basedpyright && uv run ty check && uv run pytest
+```
+
+[xtr-http-client](../xtr-http-client) is the implementation, and runs this suite against each
+of its clients.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

xtr_http_client_contracts-4.0.2.dist-info/RECORD

@@ -0,0 +1,27 @@
+xtr_http_client_contracts/__init__.py,sha256=AKyp64z4nKyMrYZqI97yJBB0eGKC_Rfu34elhvyary8,1414
+xtr_http_client_contracts/exception/__init__.py,sha256=rbcAbtSQsNP_-mSh4MUZ_-poFnumMWqHcgA0hy8Gu8w,1466
+xtr_http_client_contracts/exception/client_error.py,sha256=LEJGmaGlzniMUeQLNEacQd8D6wpC4DoDc4W-2nbifSo,473
+xtr_http_client_contracts/exception/decoding_error.py,sha256=9IcqdBK4CaSpVD1Bf-HxKu_amsZufaA-b0NJKdgpZMM,1034
+xtr_http_client_contracts/exception/http_client_error.py,sha256=KGSG22G0x4T3GNc3UzRYpLHjbfGBUXvaPZY1HuD-uzI,870
+xtr_http_client_contracts/exception/http_error.py,sha256=lNJOZ51Hsr4WQnvSGpWRfdCfvZhbBnEt-Lk3sMGeGyU,2058
+xtr_http_client_contracts/exception/invalid_argument_error.py,sha256=RiJNYu8GQJcCY4xK-mwPXPDysovcnmAAdcUwK_mZPMw,1092
+xtr_http_client_contracts/exception/json_error.py,sha256=dYljsXDoUbq6lb5wRmBOC4NIOt3HO66z9agGg3YjXj4,607
+xtr_http_client_contracts/exception/redirection_error.py,sha256=js7OQ0yYFaUtYM1FkJxuNi_6-xwvbR-Q9lF8hglTjzE,735
+xtr_http_client_contracts/exception/server_error.py,sha256=jHPpelWFDRyrUMUxVIoyjuUZ4dxXCZHSWKN6ABJgRtk,423
+xtr_http_client_contracts/exception/transport_error.py,sha256=7vW5i8sN7T9run_JRO1fllnk251HsQtzRUzFQcW0w2o,1046
+xtr_http_client_contracts/exception/transport_timeout_error.py,sha256=bU9mXh2oAeSfcZzkypJhFjZxKsKrivTlmqOOeq1G8TA,991
+xtr_http_client_contracts/http_client_interface.py,sha256=WtFPjSTgVCdnT33rpGW4iK3eWWnd9DJKTZEMvKGHSkk,4417
+xtr_http_client_contracts/http_response_interface.py,sha256=1dn_S51-8syoA9uWWgRsPFAJomshKBRIMbZoLS0y3PY,5757
+xtr_http_client_contracts/options_defaults.py,sha256=ONXeI96HPKTrxSKfd_FxYMOCPg6914MoRNJGWBOMT9Q,2617
+xtr_http_client_contracts/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xtr_http_client_contracts/request_options.py,sha256=8CaYajdmdgA50-QP2e1jECObbUoe-fXMPlgMnv5whLg,5184
+xtr_http_client_contracts/testing/__init__.py,sha256=FrExbAxW8mo521ilwfDWA2tvYuohgIC11v3f5lAR5Ck,422
+xtr_http_client_contracts/testing/_fixture_request.py,sha256=zQVELOmLjcbLLFXDqoLyUMytsEIeey8vPrymqN3N7pk,7200
+xtr_http_client_contracts/testing/_fixture_response.py,sha256=D7r40k3Rcel3Yk7SnFT7Ufugn6DRgHrJ0IMwR8xDvpY,2855
+xtr_http_client_contracts/testing/_fixture_routes.py,sha256=KcfLYr-SJkXcQXxM1KY7vITrDMT8tPfumX9RCUWP2Kg,12936
+xtr_http_client_contracts/testing/http_client_test_case.py,sha256=PWrgpmT1OgSFwxqncsNwMZ-xIYUbBU72a9y_GFhFcHw,42346
+xtr_http_client_contracts/testing/test_http_server.py,sha256=HkPDlSTM-9cQr3-3ZQ3aUQ9XwPD3qk1x4DQnJaoWjxE,8301
+xtr_http_client_contracts-4.0.2.dist-info/licenses/LICENSE,sha256=HjmMt8uWRU2yv_ijhX_mqelIvKdeCgg-QlhxyxrwQ3c,1106
+xtr_http_client_contracts-4.0.2.dist-info/WHEEL,sha256=9IUYslYuG_asT4WlWvfk_K76nveuLvSTKDoLeL0cV-Q,80
+xtr_http_client_contracts-4.0.2.dist-info/METADATA,sha256=Nnnb_Rt_qw0qeu75SsDvC0CLj7x5Tr6VBWQJaYTJHYc,12573
+xtr_http_client_contracts-4.0.2.dist-info/RECORD,,

xtr_http_client_contracts-4.0.2.dist-info/WHEEL

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

xtr_http_client_contracts-4.0.2.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 xterr
+Copyright (c) 2018-present Fabien Potencier
+
+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.