claude-all-hands 1.0.0 → 1.0.2

package/.claude/envoy/.venv/lib/python3.9/site-packages/websockets/sync/utils.py

@@ -1,45 +0,0 @@
-from __future__ import annotations
-
-import time
-
-
-__all__ = ["Deadline"]
-
-
-class Deadline:
-    """
-    Manage timeouts across multiple steps.
-
-    Args:
-        timeout: Time available in seconds or :obj:`None` if there is no limit.
-
-    """
-
-    def __init__(self, timeout: float | None) -> None:
-        self.deadline: float | None
-        if timeout is None:
-            self.deadline = None
-        else:
-            self.deadline = time.monotonic() + timeout
-
-    def timeout(self, *, raise_if_elapsed: bool = True) -> float | None:
-        """
-        Calculate a timeout from a deadline.
-
-        Args:
-            raise_if_elapsed: Whether to raise :exc:`TimeoutError`
-                if the deadline lapsed.
-
-        Raises:
-            TimeoutError: If the deadline lapsed.
-
-        Returns:
-            Time left in seconds or :obj:`None` if there is no limit.
-
-        """
-        if self.deadline is None:
-            return None
-        timeout = self.deadline - time.monotonic()
-        if raise_if_elapsed and timeout <= 0:
-            raise TimeoutError("timed out")
-        return timeout

package/.claude/envoy/.venv/lib/python3.9/site-packages/websockets/typing.py

@@ -1,74 +0,0 @@
-from __future__ import annotations
-
-import http
-import logging
-from typing import TYPE_CHECKING, Any, NewType, Optional, Sequence, Union
-
-
-__all__ = [
-    "Data",
-    "LoggerLike",
-    "StatusLike",
-    "Origin",
-    "Subprotocol",
-    "ExtensionName",
-    "ExtensionParameter",
-]
-
-
-# Public types used in the signature of public APIs
-
-# Change to str | bytes when dropping Python < 3.10.
-Data = Union[str, bytes]
-"""Types supported in a WebSocket message:
-:class:`str` for a Text_ frame, :class:`bytes` for a Binary_.
-
-.. _Text: https://datatracker.ietf.org/doc/html/rfc6455#section-5.6
-.. _Binary : https://datatracker.ietf.org/doc/html/rfc6455#section-5.6
-
-"""
-
-
-# Change to logging.Logger | ... when dropping Python < 3.10.
-if TYPE_CHECKING:
-    LoggerLike = Union[logging.Logger, logging.LoggerAdapter[Any]]
-    """Types accepted where a :class:`~logging.Logger` is expected."""
-else:  # remove this branch when dropping support for Python < 3.11
-    LoggerLike = Union[logging.Logger, logging.LoggerAdapter]
-    """Types accepted where a :class:`~logging.Logger` is expected."""
-
-
-# Change to http.HTTPStatus | int when dropping Python < 3.10.
-StatusLike = Union[http.HTTPStatus, int]
-"""
-Types accepted where an :class:`~http.HTTPStatus` is expected."""
-
-
-Origin = NewType("Origin", str)
-"""Value of a ``Origin`` header."""
-
-
-Subprotocol = NewType("Subprotocol", str)
-"""Subprotocol in a ``Sec-WebSocket-Protocol`` header."""
-
-
-ExtensionName = NewType("ExtensionName", str)
-"""Name of a WebSocket extension."""
-
-# Change to tuple[str, str | None] when dropping Python < 3.10.
-ExtensionParameter = tuple[str, Optional[str]]
-"""Parameter of a WebSocket extension."""
-
-
-# Private types
-
-ExtensionHeader = tuple[ExtensionName, Sequence[ExtensionParameter]]
-"""Extension in a ``Sec-WebSocket-Extensions`` header."""
-
-
-ConnectionOption = NewType("ConnectionOption", str)
-"""Connection option in a ``Connection`` header."""
-
-
-UpgradeProtocol = NewType("UpgradeProtocol", str)
-"""Upgrade protocol in an ``Upgrade`` header."""

package/.claude/envoy/.venv/lib/python3.9/site-packages/websockets/uri.py

@@ -1,225 +0,0 @@
-from __future__ import annotations
-
-import dataclasses
-import urllib.parse
-import urllib.request
-
-from .exceptions import InvalidProxy, InvalidURI
-
-
-__all__ = ["parse_uri", "WebSocketURI"]
-
-
-# All characters from the gen-delims and sub-delims sets in RFC 3987.
-DELIMS = ":/?#[]@!$&'()*+,;="
-
-
-@dataclasses.dataclass
-class WebSocketURI:
-    """
-    WebSocket URI.
-
-    Attributes:
-        secure: :obj:`True` for a ``wss`` URI, :obj:`False` for a ``ws`` URI.
-        host: Normalized to lower case.
-        port: Always set even if it's the default.
-        path: May be empty.
-        query: May be empty if the URI doesn't include a query component.
-        username: Available when the URI contains `User Information`_.
-        password: Available when the URI contains `User Information`_.
-
-    .. _User Information: https://datatracker.ietf.org/doc/html/rfc3986#section-3.2.1
-
-    """
-
-    secure: bool
-    host: str
-    port: int
-    path: str
-    query: str
-    username: str | None = None
-    password: str | None = None
-
-    @property
-    def resource_name(self) -> str:
-        if self.path:
-            resource_name = self.path
-        else:
-            resource_name = "/"
-        if self.query:
-            resource_name += "?" + self.query
-        return resource_name
-
-    @property
-    def user_info(self) -> tuple[str, str] | None:
-        if self.username is None:
-            return None
-        assert self.password is not None
-        return (self.username, self.password)
-
-
-def parse_uri(uri: str) -> WebSocketURI:
-    """
-    Parse and validate a WebSocket URI.
-
-    Args:
-        uri: WebSocket URI.
-
-    Returns:
-        Parsed WebSocket URI.
-
-    Raises:
-        InvalidURI: If ``uri`` isn't a valid WebSocket URI.
-
-    """
-    parsed = urllib.parse.urlparse(uri)
-    if parsed.scheme not in ["ws", "wss"]:
-        raise InvalidURI(uri, "scheme isn't ws or wss")
-    if parsed.hostname is None:
-        raise InvalidURI(uri, "hostname isn't provided")
-    if parsed.fragment != "":
-        raise InvalidURI(uri, "fragment identifier is meaningless")
-
-    secure = parsed.scheme == "wss"
-    host = parsed.hostname
-    port = parsed.port or (443 if secure else 80)
-    path = parsed.path
-    query = parsed.query
-    username = parsed.username
-    password = parsed.password
-    # urllib.parse.urlparse accepts URLs with a username but without a
-    # password. This doesn't make sense for HTTP Basic Auth credentials.
-    if username is not None and password is None:
-        raise InvalidURI(uri, "username provided without password")
-
-    try:
-        uri.encode("ascii")
-    except UnicodeEncodeError:
-        # Input contains non-ASCII characters.
-        # It must be an IRI. Convert it to a URI.
-        host = host.encode("idna").decode()
-        path = urllib.parse.quote(path, safe=DELIMS)
-        query = urllib.parse.quote(query, safe=DELIMS)
-        if username is not None:
-            assert password is not None
-            username = urllib.parse.quote(username, safe=DELIMS)
-            password = urllib.parse.quote(password, safe=DELIMS)
-
-    return WebSocketURI(secure, host, port, path, query, username, password)
-
-
-@dataclasses.dataclass
-class Proxy:
-    """
-    Proxy.
-
-    Attributes:
-        scheme: ``"socks5h"``, ``"socks5"``, ``"socks4a"``, ``"socks4"``,
-            ``"https"``, or ``"http"``.
-        host: Normalized to lower case.
-        port: Always set even if it's the default.
-        username: Available when the proxy address contains `User Information`_.
-        password: Available when the proxy address contains `User Information`_.
-
-    .. _User Information: https://datatracker.ietf.org/doc/html/rfc3986#section-3.2.1
-
-    """
-
-    scheme: str
-    host: str
-    port: int
-    username: str | None = None
-    password: str | None = None
-
-    @property
-    def user_info(self) -> tuple[str, str] | None:
-        if self.username is None:
-            return None
-        assert self.password is not None
-        return (self.username, self.password)
-
-
-def parse_proxy(proxy: str) -> Proxy:
-    """
-    Parse and validate a proxy.
-
-    Args:
-        proxy: proxy.
-
-    Returns:
-        Parsed proxy.
-
-    Raises:
-        InvalidProxy: If ``proxy`` isn't a valid proxy.
-
-    """
-    parsed = urllib.parse.urlparse(proxy)
-    if parsed.scheme not in ["socks5h", "socks5", "socks4a", "socks4", "https", "http"]:
-        raise InvalidProxy(proxy, f"scheme {parsed.scheme} isn't supported")
-    if parsed.hostname is None:
-        raise InvalidProxy(proxy, "hostname isn't provided")
-    if parsed.path not in ["", "/"]:
-        raise InvalidProxy(proxy, "path is meaningless")
-    if parsed.query != "":
-        raise InvalidProxy(proxy, "query is meaningless")
-    if parsed.fragment != "":
-        raise InvalidProxy(proxy, "fragment is meaningless")
-
-    scheme = parsed.scheme
-    host = parsed.hostname
-    port = parsed.port or (443 if parsed.scheme == "https" else 80)
-    username = parsed.username
-    password = parsed.password
-    # urllib.parse.urlparse accepts URLs with a username but without a
-    # password. This doesn't make sense for HTTP Basic Auth credentials.
-    if username is not None and password is None:
-        raise InvalidProxy(proxy, "username provided without password")
-
-    try:
-        proxy.encode("ascii")
-    except UnicodeEncodeError:
-        # Input contains non-ASCII characters.
-        # It must be an IRI. Convert it to a URI.
-        host = host.encode("idna").decode()
-        if username is not None:
-            assert password is not None
-            username = urllib.parse.quote(username, safe=DELIMS)
-            password = urllib.parse.quote(password, safe=DELIMS)
-
-    return Proxy(scheme, host, port, username, password)
-
-
-def get_proxy(uri: WebSocketURI) -> str | None:
-    """
-    Return the proxy to use for connecting to the given WebSocket URI, if any.
-
-    """
-    if urllib.request.proxy_bypass(f"{uri.host}:{uri.port}"):
-        return None
-
-    # According to the _Proxy Usage_ section of RFC 6455, use a SOCKS5 proxy if
-    # available, else favor the proxy for HTTPS connections over the proxy for
-    # HTTP connections.
-
-    # The priority of a proxy for WebSocket connections is unspecified. We give
-    # it the highest priority. This makes it easy to configure a specific proxy
-    # for websockets.
-
-    # getproxies() may return SOCKS proxies as {"socks": "http://host:port"} or
-    # as {"https": "socks5h://host:port"} depending on whether they're declared
-    # in the operating system or in environment variables.
-
-    proxies = urllib.request.getproxies()
-    if uri.secure:
-        schemes = ["wss", "socks", "https"]
-    else:
-        schemes = ["ws", "socks", "https", "http"]
-
-    for scheme in schemes:
-        proxy = proxies.get(scheme)
-        if proxy is not None:
-            if scheme == "socks" and proxy.startswith("http://"):
-                proxy = "socks5h://" + proxy[7:]
-            return proxy
-    else:
-        return None

package/.claude/envoy/.venv/lib/python3.9/site-packages/websockets/utils.py

@@ -1,51 +0,0 @@
-from __future__ import annotations
-
-import base64
-import hashlib
-import secrets
-import sys
-
-
-__all__ = ["accept_key", "apply_mask"]
-
-
-GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
-
-
-def generate_key() -> str:
-    """
-    Generate a random key for the Sec-WebSocket-Key header.
-
-    """
-    key = secrets.token_bytes(16)
-    return base64.b64encode(key).decode()
-
-
-def accept_key(key: str) -> str:
-    """
-    Compute the value of the Sec-WebSocket-Accept header.
-
-    Args:
-        key: Value of the Sec-WebSocket-Key header.
-
-    """
-    sha1 = hashlib.sha1((key + GUID).encode()).digest()
-    return base64.b64encode(sha1).decode()
-
-
-def apply_mask(data: bytes, mask: bytes) -> bytes:
-    """
-    Apply masking to the data of a WebSocket message.
-
-    Args:
-        data: Data to mask.
-        mask: 4-bytes mask.
-
-    """
-    if len(mask) != 4:
-        raise ValueError("mask must contain 4 bytes")
-
-    data_int = int.from_bytes(data, sys.byteorder)
-    mask_repeated = mask * (len(data) // 4) + mask[: len(data) % 4]
-    mask_int = int.from_bytes(mask_repeated, sys.byteorder)
-    return (data_int ^ mask_int).to_bytes(len(data), sys.byteorder)

package/.claude/envoy/.venv/lib/python3.9/site-packages/websockets/version.py

@@ -1,92 +0,0 @@
-from __future__ import annotations
-
-import importlib.metadata
-
-
-__all__ = ["tag", "version", "commit"]
-
-
-# ========= =========== ===================
-#           release     development
-# ========= =========== ===================
-# tag       X.Y         X.Y (upcoming)
-# version   X.Y         X.Y.dev1+g5678cde
-# commit    X.Y         5678cde
-# ========= =========== ===================
-
-
-# When tagging a release, set `released = True`.
-# After tagging a release, set `released = False` and increment `tag`.
-
-released = True
-
-tag = version = commit = "15.0.1"
-
-
-if not released:  # pragma: no cover
-    import pathlib
-    import re
-    import subprocess
-
-    def get_version(tag: str) -> str:
-        # Since setup.py executes the contents of src/websockets/version.py,
-        # __file__ can point to either of these two files.
-        file_path = pathlib.Path(__file__)
-        root_dir = file_path.parents[0 if file_path.name == "setup.py" else 2]
-
-        # Read version from package metadata if it is installed.
-        try:
-            version = importlib.metadata.version("websockets")
-        except ImportError:
-            pass
-        else:
-            # Check that this file belongs to the installed package.
-            files = importlib.metadata.files("websockets")
-            if files:
-                version_files = [f for f in files if f.name == file_path.name]
-                if version_files:
-                    version_file = version_files[0]
-                    if version_file.locate() == file_path:
-                        return version
-
-        # Read version from git if available.
-        try:
-            description = subprocess.run(
-                ["git", "describe", "--dirty", "--tags", "--long"],
-                capture_output=True,
-                cwd=root_dir,
-                timeout=1,
-                check=True,
-                text=True,
-            ).stdout.strip()
-        # subprocess.run raises FileNotFoundError if git isn't on $PATH.
-        except (
-            FileNotFoundError,
-            subprocess.CalledProcessError,
-            subprocess.TimeoutExpired,
-        ):
-            pass
-        else:
-            description_re = r"[0-9.]+-([0-9]+)-(g[0-9a-f]{7,}(?:-dirty)?)"
-            match = re.fullmatch(description_re, description)
-            if match is None:
-                raise ValueError(f"Unexpected git description: {description}")
-            distance, remainder = match.groups()
-            remainder = remainder.replace("-", ".")  # required by PEP 440
-            return f"{tag}.dev{distance}+{remainder}"
-
-        # Avoid crashing if the development version cannot be determined.
-        return f"{tag}.dev0+gunknown"
-
-    version = get_version(tag)
-
-    def get_commit(tag: str, version: str) -> str:
-        # Extract commit from version, falling back to tag if not available.
-        version_re = r"[0-9.]+\.dev[0-9]+\+g([0-9a-f]{7,}|unknown)(?:\.dirty)?"
-        match = re.fullmatch(version_re, version)
-        if match is None:
-            raise ValueError(f"Unexpected version: {version}")
-        (commit,) = match.groups()
-        return tag if commit == "unknown" else commit
-
-    commit = get_commit(tag, version)

package/.claude/envoy/.venv/lib/python3.9/site-packages/websockets-15.0.1.dist-info/INSTALLER

@@ -1 +0,0 @@
-pip

package/.claude/envoy/.venv/lib/python3.9/site-packages/websockets-15.0.1.dist-info/LICENSE

@@ -1,24 +0,0 @@
-Copyright (c) Aymeric Augustin and contributors
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright notice,
-      this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright notice,
-      this list of conditions and the following disclaimer in the documentation
-      and/or other materials provided with the distribution.
-    * Neither the name of the copyright holder nor the names of its contributors
-      may be used to endorse or promote products derived from this software
-      without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/.claude/envoy/.venv/lib/python3.9/site-packages/websockets-15.0.1.dist-info/METADATA

@@ -1,179 +0,0 @@
-Metadata-Version: 2.2
-Name: websockets
-Version: 15.0.1
-Summary: An implementation of the WebSocket Protocol (RFC 6455 & 7692)
-Author-email: Aymeric Augustin <aymeric.augustin@m4x.org>
-License: BSD-3-Clause
-Project-URL: Homepage, https://github.com/python-websockets/websockets
-Project-URL: Changelog, https://websockets.readthedocs.io/en/stable/project/changelog.html
-Project-URL: Documentation, https://websockets.readthedocs.io/
-Project-URL: Funding, https://tidelift.com/subscription/pkg/pypi-websockets?utm_source=pypi-websockets&utm_medium=referral&utm_campaign=readme
-Project-URL: Tracker, https://github.com/python-websockets/websockets/issues
-Keywords: WebSocket
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Web Environment
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.9
-Description-Content-Type: text/x-rst
-License-File: LICENSE
-Dynamic: description
-Dynamic: description-content-type
-
-.. image:: logo/horizontal.svg
-   :width: 480px
-   :alt: websockets
-
-|licence| |version| |pyversions| |tests| |docs| |openssf|
-
-.. |licence| image:: https://img.shields.io/pypi/l/websockets.svg
-    :target: https://pypi.python.org/pypi/websockets
-
-.. |version| image:: https://img.shields.io/pypi/v/websockets.svg
-    :target: https://pypi.python.org/pypi/websockets
-
-.. |pyversions| image:: https://img.shields.io/pypi/pyversions/websockets.svg
-    :target: https://pypi.python.org/pypi/websockets
-
-.. |tests| image:: https://img.shields.io/github/checks-status/python-websockets/websockets/main?label=tests
-   :target: https://github.com/python-websockets/websockets/actions/workflows/tests.yml
-
-.. |docs| image:: https://img.shields.io/readthedocs/websockets.svg
-   :target: https://websockets.readthedocs.io/
-
-.. |openssf| image:: https://bestpractices.coreinfrastructure.org/projects/6475/badge
-   :target: https://bestpractices.coreinfrastructure.org/projects/6475
-
-What is ``websockets``?
------------------------
-
-websockets is a library for building WebSocket_ servers and clients in Python
-with a focus on correctness, simplicity, robustness, and performance.
-
-.. _WebSocket: https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API
-
-Built on top of ``asyncio``, Python's standard asynchronous I/O framework, the
-default implementation provides an elegant coroutine-based API.
-
-An implementation on top of ``threading`` and a Sans-I/O implementation are also
-available.
-
-`Documentation is available on Read the Docs. <https://websockets.readthedocs.io/>`_
-
-.. copy-pasted because GitHub doesn't support the include directive
-
-Here's an echo server with the ``asyncio`` API:
-
-.. code:: python
-
-    #!/usr/bin/env python
-
-    import asyncio
-    from websockets.asyncio.server import serve
-
-    async def echo(websocket):
-        async for message in websocket:
-            await websocket.send(message)
-
-    async def main():
-        async with serve(echo, "localhost", 8765) as server:
-            await server.serve_forever()
-
-    asyncio.run(main())
-
-Here's how a client sends and receives messages with the ``threading`` API:
-
-.. code:: python
-
-    #!/usr/bin/env python
-
-    from websockets.sync.client import connect
-
-    def hello():
-        with connect("ws://localhost:8765") as websocket:
-            websocket.send("Hello world!")
-            message = websocket.recv()
-            print(f"Received: {message}")
-
-    hello()
-
-
-Does that look good?
-
-`Get started with the tutorial! <https://websockets.readthedocs.io/en/stable/intro/index.html>`_
-
-Why should I use ``websockets``?
---------------------------------
-
-The development of ``websockets`` is shaped by four principles:
-
-1. **Correctness**: ``websockets`` is heavily tested for compliance with
-   :rfc:`6455`. Continuous integration fails under 100% branch coverage.
-
-2. **Simplicity**: all you need to understand is ``msg = await ws.recv()`` and
-   ``await ws.send(msg)``. ``websockets`` takes care of managing connections
-   so you can focus on your application.
-
-3. **Robustness**: ``websockets`` is built for production. For example, it was
-   the only library to `handle backpressure correctly`_ before the issue
-   became widely known in the Python community.
-
-4. **Performance**: memory usage is optimized and configurable. A C extension
-   accelerates expensive operations. It's pre-compiled for Linux, macOS and
-   Windows and packaged in the wheel format for each system and Python version.
-
-Documentation is a first class concern in the project. Head over to `Read the
-Docs`_ and see for yourself.
-
-.. _Read the Docs: https://websockets.readthedocs.io/
-.. _handle backpressure correctly: https://vorpus.org/blog/some-thoughts-on-asynchronous-api-design-in-a-post-asyncawait-world/#websocket-servers
-
-Why shouldn't I use ``websockets``?
------------------------------------
-
-* If you prefer callbacks over coroutines: ``websockets`` was created to
-  provide the best coroutine-based API to manage WebSocket connections in
-  Python. Pick another library for a callback-based API.
-
-* If you're looking for a mixed HTTP / WebSocket library: ``websockets`` aims
-  at being an excellent implementation of :rfc:`6455`: The WebSocket Protocol
-  and :rfc:`7692`: Compression Extensions for WebSocket. Its support for HTTP
-  is minimal — just enough for an HTTP health check.
-
-  If you want to do both in the same server, look at HTTP + WebSocket servers
-  that build on top of ``websockets`` to support WebSocket connections, like
-  uvicorn_ or Sanic_.
-
-.. _uvicorn: https://www.uvicorn.org/
-.. _Sanic: https://sanic.dev/en/
-
-What else?
-----------
-
-Bug reports, patches and suggestions are welcome!
-
-To report a security vulnerability, please use the `Tidelift security
-contact`_. Tidelift will coordinate the fix and disclosure.
-
-.. _Tidelift security contact: https://tidelift.com/security
-
-For anything else, please open an issue_ or send a `pull request`_.
-
-.. _issue: https://github.com/python-websockets/websockets/issues/new
-.. _pull request: https://github.com/python-websockets/websockets/compare/
-
-Participants must uphold the `Contributor Covenant code of conduct`_.
-
-.. _Contributor Covenant code of conduct: https://github.com/python-websockets/websockets/blob/main/CODE_OF_CONDUCT.md
-
-``websockets`` is released under the `BSD license`_.
-
-.. _BSD license: https://github.com/python-websockets/websockets/blob/main/LICENSE