Initial public upload from Projekte/CodingAgent (part 3)

hai-mcp-pr7/.venv/lib/python3.13/site-packages/httpx-0.28.1.dist-info/INSTALLER

@@ -0,0 +1 @@
+uv

hai-mcp-pr7/.venv/lib/python3.13/site-packages/httpx-0.28.1.dist-info/METADATA

@@ -0,0 +1,203 @@
+Metadata-Version: 2.3
+Name: httpx
+Version: 0.28.1
+Summary: The next generation HTTP client.
+Project-URL: Changelog, https://github.com/encode/httpx/blob/master/CHANGELOG.md
+Project-URL: Documentation, https://www.python-httpx.org
+Project-URL: Homepage, https://github.com/encode/httpx
+Project-URL: Source, https://github.com/encode/httpx
+Author-email: Tom Christie <tom@tomchristie.com>
+License: BSD-3-Clause
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Web Environment
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: Trio
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.8
+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: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.8
+Requires-Dist: anyio
+Requires-Dist: certifi
+Requires-Dist: httpcore==1.*
+Requires-Dist: idna
+Provides-Extra: brotli
+Requires-Dist: brotli; (platform_python_implementation == 'CPython') and extra == 'brotli'
+Requires-Dist: brotlicffi; (platform_python_implementation != 'CPython') and extra == 'brotli'
+Provides-Extra: cli
+Requires-Dist: click==8.*; extra == 'cli'
+Requires-Dist: pygments==2.*; extra == 'cli'
+Requires-Dist: rich<14,>=10; extra == 'cli'
+Provides-Extra: http2
+Requires-Dist: h2<5,>=3; extra == 'http2'
+Provides-Extra: socks
+Requires-Dist: socksio==1.*; extra == 'socks'
+Provides-Extra: zstd
+Requires-Dist: zstandard>=0.18.0; extra == 'zstd'
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <a href="https://www.python-httpx.org/"><img width="350" height="208" src="https://raw.githubusercontent.com/encode/httpx/master/docs/img/butterfly.png" alt='HTTPX'></a>
+</p>
+
+<p align="center"><strong>HTTPX</strong> <em>- A next-generation HTTP client for Python.</em></p>
+
+<p align="center">
+<a href="https://github.com/encode/httpx/actions">
+    <img src="https://github.com/encode/httpx/workflows/Test%20Suite/badge.svg" alt="Test Suite">
+</a>
+<a href="https://pypi.org/project/httpx/">
+    <img src="https://badge.fury.io/py/httpx.svg" alt="Package version">
+</a>
+</p>
+
+HTTPX is a fully featured HTTP client library for Python 3. It includes **an integrated command line client**, has support for both **HTTP/1.1 and HTTP/2**, and provides both **sync and async APIs**.
+
+---
+
+Install HTTPX using pip:
+
+```shell
+$ pip install httpx
+```
+
+Now, let's get started:
+
+```pycon
+>>> import httpx
+>>> r = httpx.get('https://www.example.org/')
+>>> r
+<Response [200 OK]>
+>>> r.status_code
+200
+>>> r.headers['content-type']
+'text/html; charset=UTF-8'
+>>> r.text
+'<!doctype html>\n<html>\n<head>\n<title>Example Domain</title>...'
+```
+
+Or, using the command-line client.
+
+```shell
+$ pip install 'httpx[cli]'  # The command line client is an optional dependency.
+```
+
+Which now allows us to use HTTPX directly from the command-line...
+
+<p align="center">
+  <img width="700" src="https://raw.githubusercontent.com/encode/httpx/master/docs/img/httpx-help.png" alt='httpx --help'>
+</p>
+
+Sending a request...
+
+<p align="center">
+  <img width="700" src="https://raw.githubusercontent.com/encode/httpx/master/docs/img/httpx-request.png" alt='httpx http://httpbin.org/json'>
+</p>
+
+## Features
+
+HTTPX builds on the well-established usability of `requests`, and gives you:
+
+* A broadly [requests-compatible API](https://www.python-httpx.org/compatibility/).
+* An integrated command-line client.
+* HTTP/1.1 [and HTTP/2 support](https://www.python-httpx.org/http2/).
+* Standard synchronous interface, but with [async support if you need it](https://www.python-httpx.org/async/).
+* Ability to make requests directly to [WSGI applications](https://www.python-httpx.org/advanced/transports/#wsgi-transport) or [ASGI applications](https://www.python-httpx.org/advanced/transports/#asgi-transport).
+* Strict timeouts everywhere.
+* Fully type annotated.
+* 100% test coverage.
+
+Plus all the standard features of `requests`...
+
+* International Domains and URLs
+* Keep-Alive & Connection Pooling
+* Sessions with Cookie Persistence
+* Browser-style SSL Verification
+* Basic/Digest Authentication
+* Elegant Key/Value Cookies
+* Automatic Decompression
+* Automatic Content Decoding
+* Unicode Response Bodies
+* Multipart File Uploads
+* HTTP(S) Proxy Support
+* Connection Timeouts
+* Streaming Downloads
+* .netrc Support
+* Chunked Requests
+
+## Installation
+
+Install with pip:
+
+```shell
+$ pip install httpx
+```
+
+Or, to include the optional HTTP/2 support, use:
+
+```shell
+$ pip install httpx[http2]
+```
+
+HTTPX requires Python 3.8+.
+
+## Documentation
+
+Project documentation is available at [https://www.python-httpx.org/](https://www.python-httpx.org/).
+
+For a run-through of all the basics, head over to the [QuickStart](https://www.python-httpx.org/quickstart/).
+
+For more advanced topics, see the [Advanced Usage](https://www.python-httpx.org/advanced/) section, the [async support](https://www.python-httpx.org/async/) section, or the [HTTP/2](https://www.python-httpx.org/http2/) section.
+
+The [Developer Interface](https://www.python-httpx.org/api/) provides a comprehensive API reference.
+
+To find out about tools that integrate with HTTPX, see [Third Party Packages](https://www.python-httpx.org/third_party_packages/).
+
+## Contribute
+
+If you want to contribute with HTTPX check out the [Contributing Guide](https://www.python-httpx.org/contributing/) to learn how to start.
+
+## Dependencies
+
+The HTTPX project relies on these excellent libraries:
+
+* `httpcore` - The underlying transport implementation for `httpx`.
+  * `h11` - HTTP/1.1 support.
+* `certifi` - SSL certificates.
+* `idna` - Internationalized domain name support.
+* `sniffio` - Async library autodetection.
+
+As well as these optional installs:
+
+* `h2` - HTTP/2 support. *(Optional, with `httpx[http2]`)*
+* `socksio` - SOCKS proxy support. *(Optional, with `httpx[socks]`)*
+* `rich` - Rich terminal support. *(Optional, with `httpx[cli]`)*
+* `click` - Command line client support. *(Optional, with `httpx[cli]`)*
+* `brotli` or `brotlicffi` - Decoding for "brotli" compressed responses. *(Optional, with `httpx[brotli]`)*
+* `zstandard` - Decoding for "zstd" compressed responses. *(Optional, with `httpx[zstd]`)*
+
+A huge amount of credit is due to `requests` for the API layout that
+much of this work follows, as well as to `urllib3` for plenty of design
+inspiration around the lower-level networking details.
+
+---
+
+<p align="center"><i>HTTPX is <a href="https://github.com/encode/httpx/blob/master/LICENSE.md">BSD licensed</a> code.<br/>Designed & crafted with care.</i><br/>&mdash; 🦋 &mdash;</p>
+
+## Release Information
+
+### Fixed
+
+* Reintroduced supposedly-private `URLTypes` shortcut. (#2673)
+
+
+---
+
+[Full changelog](https://github.com/encode/httpx/blob/master/CHANGELOG.md)

hai-mcp-pr7/.venv/lib/python3.13/site-packages/httpx-0.28.1.dist-info/RECORD

@@ -0,0 +1,32 @@
+../../../bin/httpx,sha256=gRFPb2PaCCSO98wCExsi-S88-5nu5up_dYRMrTqXxpA,334
+httpx-0.28.1.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+httpx-0.28.1.dist-info/METADATA,sha256=_rubD48-gNV8gZnDBPNcQzboWB0dGNeYPJJ2a4J5OyU,7052
+httpx-0.28.1.dist-info/RECORD,,
+httpx-0.28.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+httpx-0.28.1.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+httpx-0.28.1.dist-info/entry_points.txt,sha256=2lVkdQmxLA1pNMgSN2eV89o90HCZezhmNwsy6ryKDSA,37
+httpx-0.28.1.dist-info/licenses/LICENSE.md,sha256=TsWdVE8StfU5o6cW_TIaxYzNgDC0ZSIfLIgCAM3yjY0,1508
+httpx/__init__.py,sha256=CsaZe6yZj0rHg6322AWKWHGTMVr9txgEfD5P3_Rrz60,2171
+httpx/__version__.py,sha256=LoUyYeOXTieGzuP_64UL0wxdtxjuu_QbOvE7NOg-IqU,108
+httpx/_api.py,sha256=r_Zgs4jIpcPJLqK5dbbSayqo_iVMKFaxZCd-oOHxLEs,11743
+httpx/_auth.py,sha256=Yr3QwaUSK17rGYx-7j-FdicFIzz4Y9FFV-1F4-7RXX4,11891
+httpx/_client.py,sha256=xD-UG67-WMkeltAAOeGGj-cZ2RRTAm19sWRxlFY7_40,65714
+httpx/_config.py,sha256=pPp2U-wicfcKsF-KYRE1LYdt3e6ERGeIoXZ8Gjo3LWc,8547
+httpx/_content.py,sha256=LGGzrJTR3OvN4Mb1GVVNLXkXJH-6oKlwAttO9p5w_yg,8161
+httpx/_decoders.py,sha256=p0dX8I0NEHexs3UGp4SsZutiMhsXrrWl6-GnqVb0iKM,12041
+httpx/_exceptions.py,sha256=bxW7fxzgVMAdNTbwT0Vnq04gJDW1_gI_GFiQPuMyjL0,8527
+httpx/_main.py,sha256=Cg9GMabiTT_swaDfUgIRitSwxLRMSwUDOm7LdSGqlA4,15626
+httpx/_models.py,sha256=4__Guyv1gLxuZChwim8kfQNiIOcJ9acreFOSurvZfms,44700
+httpx/_multipart.py,sha256=KOHEZZl6oohg9mPaKyyu345qq1rJLg35TUG3YAzXB3Y,9843
+httpx/_status_codes.py,sha256=DYn-2ufBgMeXy5s8x3_TB7wjAuAAMewTakPrm5rXEsc,5639
+httpx/_transports/__init__.py,sha256=GbUoBSAOp7z-l-9j5YhMhR3DMIcn6FVLhj072O3Nnno,275
+httpx/_transports/asgi.py,sha256=HRfiDYMPt4wQH2gFgHZg4c-i3sblo6bL5GTqcET-xz8,5501
+httpx/_transports/base.py,sha256=kZS_VMbViYfF570pogUCJ1bulz-ybfL51Pqs9yktebU,2523
+httpx/_transports/default.py,sha256=AzeaRUyVwCccTyyNJexDf0n1dFfzzydpdIQgvw7PLnk,13983
+httpx/_transports/mock.py,sha256=PTo0d567RITXxGrki6kN7_67wwAxfwiMDcuXJiZCjEo,1232
+httpx/_transports/wsgi.py,sha256=NcPX3Xap_EwCFZWO_OaSyQNuInCYx1QMNbO8GAei6jY,4825
+httpx/_types.py,sha256=Jyh41GQq7AOev8IOWKDAg7zCbvHAfufmW5g_PiTtErY,2965
+httpx/_urlparse.py,sha256=ZAmH47ONfkxrrj-PPYhGeiHjb6AjKCS-ANWIN4OL_KY,18546
+httpx/_urls.py,sha256=dX99VR1DSOHpgo9Aq7PzYO4FKdxqKjwyNp8grf8dHN0,21550
+httpx/_utils.py,sha256=_TVeqAKvxJkKHdz7dFeb4s0LZqQXgeFkXSgfiHBK_1o,8285
+httpx/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0

hai-mcp-pr7/.venv/lib/python3.13/site-packages/httpx-0.28.1.dist-info/WHEEL

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

hai-mcp-pr7/.venv/lib/python3.13/site-packages/httpx-0.28.1.dist-info/entry_points.txt

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

hai-mcp-pr7/.venv/lib/python3.13/site-packages/httpx-0.28.1.dist-info/licenses/LICENSE.md

@@ -0,0 +1,12 @@
+Copyright © 2019, [Encode OSS Ltd](https://www.encode.io/).
+All rights reserved.
+
+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.

hai-mcp-pr7/.venv/lib/python3.13/site-packages/httpx/_urlparse.py

@@ -0,0 +1,527 @@
+"""
+An implementation of `urlparse` that provides URL validation and normalization
+as described by RFC3986.
+
+We rely on this implementation rather than the one in Python's stdlib, because:
+
+* It provides more complete URL validation.
+* It properly differentiates between an empty querystring and an absent querystring,
+  to distinguish URLs with a trailing '?'.
+* It handles scheme, hostname, port, and path normalization.
+* It supports IDNA hostnames, normalizing them to their encoded form.
+* The API supports passing individual components, as well as the complete URL string.
+
+Previously we relied on the excellent `rfc3986` package to handle URL parsing and
+validation, but this module provides a simpler alternative, with less indirection
+required.
+"""
+
+from __future__ import annotations
+
+import ipaddress
+import re
+import typing
+
+import idna
+
+from ._exceptions import InvalidURL
+
+MAX_URL_LENGTH = 65536
+
+# https://datatracker.ietf.org/doc/html/rfc3986.html#section-2.3
+UNRESERVED_CHARACTERS = (
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~"
+)
+SUB_DELIMS = "!$&'()*+,;="
+
+PERCENT_ENCODED_REGEX = re.compile("%[A-Fa-f0-9]{2}")
+
+# https://url.spec.whatwg.org/#percent-encoded-bytes
+
+# The fragment percent-encode set is the C0 control percent-encode set
+# and U+0020 SPACE, U+0022 ("), U+003C (<), U+003E (>), and U+0060 (`).
+FRAG_SAFE = "".join(
+    [chr(i) for i in range(0x20, 0x7F) if i not in (0x20, 0x22, 0x3C, 0x3E, 0x60)]
+)
+
+# The query percent-encode set is the C0 control percent-encode set
+# and U+0020 SPACE, U+0022 ("), U+0023 (#), U+003C (<), and U+003E (>).
+QUERY_SAFE = "".join(
+    [chr(i) for i in range(0x20, 0x7F) if i not in (0x20, 0x22, 0x23, 0x3C, 0x3E)]
+)
+
+# The path percent-encode set is the query percent-encode set
+# and U+003F (?), U+0060 (`), U+007B ({), and U+007D (}).
+PATH_SAFE = "".join(
+    [
+        chr(i)
+        for i in range(0x20, 0x7F)
+        if i not in (0x20, 0x22, 0x23, 0x3C, 0x3E) + (0x3F, 0x60, 0x7B, 0x7D)
+    ]
+)
+
+# The userinfo percent-encode set is the path percent-encode set
+# and U+002F (/), U+003A (:), U+003B (;), U+003D (=), U+0040 (@),
+# U+005B ([) to U+005E (^), inclusive, and U+007C (|).
+USERNAME_SAFE = "".join(
+    [
+        chr(i)
+        for i in range(0x20, 0x7F)
+        if i
+        not in (0x20, 0x22, 0x23, 0x3C, 0x3E)
+        + (0x3F, 0x60, 0x7B, 0x7D)
+        + (0x2F, 0x3A, 0x3B, 0x3D, 0x40, 0x5B, 0x5C, 0x5D, 0x5E, 0x7C)
+    ]
+)
+PASSWORD_SAFE = "".join(
+    [
+        chr(i)
+        for i in range(0x20, 0x7F)
+        if i
+        not in (0x20, 0x22, 0x23, 0x3C, 0x3E)
+        + (0x3F, 0x60, 0x7B, 0x7D)
+        + (0x2F, 0x3A, 0x3B, 0x3D, 0x40, 0x5B, 0x5C, 0x5D, 0x5E, 0x7C)
+    ]
+)
+# Note... The terminology 'userinfo' percent-encode set in the WHATWG document
+# is used for the username and password quoting. For the joint userinfo component
+# we remove U+003A (:) from the safe set.
+USERINFO_SAFE = "".join(
+    [
+        chr(i)
+        for i in range(0x20, 0x7F)
+        if i
+        not in (0x20, 0x22, 0x23, 0x3C, 0x3E)
+        + (0x3F, 0x60, 0x7B, 0x7D)
+        + (0x2F, 0x3B, 0x3D, 0x40, 0x5B, 0x5C, 0x5D, 0x5E, 0x7C)
+    ]
+)
+
+
+# {scheme}:      (optional)
+# //{authority}  (optional)
+# {path}
+# ?{query}       (optional)
+# #{fragment}    (optional)
+URL_REGEX = re.compile(
+    (
+        r"(?:(?P<scheme>{scheme}):)?"
+        r"(?://(?P<authority>{authority}))?"
+        r"(?P<path>{path})"
+        r"(?:\?(?P<query>{query}))?"
+        r"(?:#(?P<fragment>{fragment}))?"
+    ).format(
+        scheme="([a-zA-Z][a-zA-Z0-9+.-]*)?",
+        authority="[^/?#]*",
+        path="[^?#]*",
+        query="[^#]*",
+        fragment=".*",
+    )
+)
+
+# {userinfo}@    (optional)
+# {host}
+# :{port}        (optional)
+AUTHORITY_REGEX = re.compile(
+    (
+        r"(?:(?P<userinfo>{userinfo})@)?" r"(?P<host>{host})" r":?(?P<port>{port})?"
+    ).format(
+        userinfo=".*",  # Any character sequence.
+        host="(\\[.*\\]|[^:@]*)",  # Either any character sequence excluding ':' or '@',
+        # or an IPv6 address enclosed within square brackets.
+        port=".*",  # Any character sequence.
+    )
+)
+
+
+# If we call urlparse with an individual component, then we need to regex
+# validate that component individually.
+# Note that we're duplicating the same strings as above. Shock! Horror!!
+COMPONENT_REGEX = {
+    "scheme": re.compile("([a-zA-Z][a-zA-Z0-9+.-]*)?"),
+    "authority": re.compile("[^/?#]*"),
+    "path": re.compile("[^?#]*"),
+    "query": re.compile("[^#]*"),
+    "fragment": re.compile(".*"),
+    "userinfo": re.compile("[^@]*"),
+    "host": re.compile("(\\[.*\\]|[^:]*)"),
+    "port": re.compile(".*"),
+}
+
+
+# We use these simple regexs as a first pass before handing off to
+# the stdlib 'ipaddress' module for IP address validation.
+IPv4_STYLE_HOSTNAME = re.compile(r"^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$")
+IPv6_STYLE_HOSTNAME = re.compile(r"^\[.*\]$")
+
+
+class ParseResult(typing.NamedTuple):
+    scheme: str
+    userinfo: str
+    host: str
+    port: int | None
+    path: str
+    query: str | None
+    fragment: str | None
+
+    @property
+    def authority(self) -> str:
+        return "".join(
+            [
+                f"{self.userinfo}@" if self.userinfo else "",
+                f"[{self.host}]" if ":" in self.host else self.host,
+                f":{self.port}" if self.port is not None else "",
+            ]
+        )
+
+    @property
+    def netloc(self) -> str:
+        return "".join(
+            [
+                f"[{self.host}]" if ":" in self.host else self.host,
+                f":{self.port}" if self.port is not None else "",
+            ]
+        )
+
+    def copy_with(self, **kwargs: str | None) -> ParseResult:
+        if not kwargs:
+            return self
+
+        defaults = {
+            "scheme": self.scheme,
+            "authority": self.authority,
+            "path": self.path,
+            "query": self.query,
+            "fragment": self.fragment,
+        }
+        defaults.update(kwargs)
+        return urlparse("", **defaults)
+
+    def __str__(self) -> str:
+        authority = self.authority
+        return "".join(
+            [
+                f"{self.scheme}:" if self.scheme else "",
+                f"//{authority}" if authority else "",
+                self.path,
+                f"?{self.query}" if self.query is not None else "",
+                f"#{self.fragment}" if self.fragment is not None else "",
+            ]
+        )
+
+
+def urlparse(url: str = "", **kwargs: str | None) -> ParseResult:
+    # Initial basic checks on allowable URLs.
+    # ---------------------------------------
+
+    # Hard limit the maximum allowable URL length.
+    if len(url) > MAX_URL_LENGTH:
+        raise InvalidURL("URL too long")
+
+    # If a URL includes any ASCII control characters including \t, \r, \n,
+    # then treat it as invalid.
+    if any(char.isascii() and not char.isprintable() for char in url):
+        char = next(char for char in url if char.isascii() and not char.isprintable())
+        idx = url.find(char)
+        error = (
+            f"Invalid non-printable ASCII character in URL, {char!r} at position {idx}."
+        )
+        raise InvalidURL(error)
+
+    # Some keyword arguments require special handling.
+    # ------------------------------------------------
+
+    # Coerce "port" to a string, if it is provided as an integer.
+    if "port" in kwargs:
+        port = kwargs["port"]
+        kwargs["port"] = str(port) if isinstance(port, int) else port
+
+    # Replace "netloc" with "host and "port".
+    if "netloc" in kwargs:
+        netloc = kwargs.pop("netloc") or ""
+        kwargs["host"], _, kwargs["port"] = netloc.partition(":")
+
+    # Replace "username" and/or "password" with "userinfo".
+    if "username" in kwargs or "password" in kwargs:
+        username = quote(kwargs.pop("username", "") or "", safe=USERNAME_SAFE)
+        password = quote(kwargs.pop("password", "") or "", safe=PASSWORD_SAFE)
+        kwargs["userinfo"] = f"{username}:{password}" if password else username
+
+    # Replace "raw_path" with "path" and "query".
+    if "raw_path" in kwargs:
+        raw_path = kwargs.pop("raw_path") or ""
+        kwargs["path"], seperator, kwargs["query"] = raw_path.partition("?")
+        if not seperator:
+            kwargs["query"] = None
+
+    # Ensure that IPv6 "host" addresses are always escaped with "[...]".
+    if "host" in kwargs:
+        host = kwargs.get("host") or ""
+        if ":" in host and not (host.startswith("[") and host.endswith("]")):
+            kwargs["host"] = f"[{host}]"
+
+    # If any keyword arguments are provided, ensure they are valid.
+    # -------------------------------------------------------------
+
+    for key, value in kwargs.items():
+        if value is not None:
+            if len(value) > MAX_URL_LENGTH:
+                raise InvalidURL(f"URL component '{key}' too long")
+
+            # If a component includes any ASCII control characters including \t, \r, \n,
+            # then treat it as invalid.
+            if any(char.isascii() and not char.isprintable() for char in value):
+                char = next(
+                    char for char in value if char.isascii() and not char.isprintable()
+                )
+                idx = value.find(char)
+                error = (
+                    f"Invalid non-printable ASCII character in URL {key} component, "
+                    f"{char!r} at position {idx}."
+                )
+                raise InvalidURL(error)
+
+            # Ensure that keyword arguments match as a valid regex.
+            if not COMPONENT_REGEX[key].fullmatch(value):
+                raise InvalidURL(f"Invalid URL component '{key}'")
+
+    # The URL_REGEX will always match, but may have empty components.
+    url_match = URL_REGEX.match(url)
+    assert url_match is not None
+    url_dict = url_match.groupdict()
+
+    # * 'scheme', 'authority', and 'path' may be empty strings.
+    # * 'query' may be 'None', indicating no trailing "?" portion.
+    #   Any string including the empty string, indicates a trailing "?".
+    # * 'fragment' may be 'None', indicating no trailing "#" portion.
+    #   Any string including the empty string, indicates a trailing "#".
+    scheme = kwargs.get("scheme", url_dict["scheme"]) or ""
+    authority = kwargs.get("authority", url_dict["authority"]) or ""
+    path = kwargs.get("path", url_dict["path"]) or ""
+    query = kwargs.get("query", url_dict["query"])
+    frag = kwargs.get("fragment", url_dict["fragment"])
+
+    # The AUTHORITY_REGEX will always match, but may have empty components.
+    authority_match = AUTHORITY_REGEX.match(authority)
+    assert authority_match is not None
+    authority_dict = authority_match.groupdict()
+
+    # * 'userinfo' and 'host' may be empty strings.
+    # * 'port' may be 'None'.
+    userinfo = kwargs.get("userinfo", authority_dict["userinfo"]) or ""
+    host = kwargs.get("host", authority_dict["host"]) or ""
+    port = kwargs.get("port", authority_dict["port"])
+
+    # Normalize and validate each component.
+    # We end up with a parsed representation of the URL,
+    # with components that are plain ASCII bytestrings.
+    parsed_scheme: str = scheme.lower()
+    parsed_userinfo: str = quote(userinfo, safe=USERINFO_SAFE)
+    parsed_host: str = encode_host(host)
+    parsed_port: int | None = normalize_port(port, scheme)
+
+    has_scheme = parsed_scheme != ""
+    has_authority = (
+        parsed_userinfo != "" or parsed_host != "" or parsed_port is not None
+    )
+    validate_path(path, has_scheme=has_scheme, has_authority=has_authority)
+    if has_scheme or has_authority:
+        path = normalize_path(path)
+
+    parsed_path: str = quote(path, safe=PATH_SAFE)
+    parsed_query: str | None = None if query is None else quote(query, safe=QUERY_SAFE)
+    parsed_frag: str | None = None if frag is None else quote(frag, safe=FRAG_SAFE)
+
+    # The parsed ASCII bytestrings are our canonical form.
+    # All properties of the URL are derived from these.
+    return ParseResult(
+        parsed_scheme,
+        parsed_userinfo,
+        parsed_host,
+        parsed_port,
+        parsed_path,
+        parsed_query,
+        parsed_frag,
+    )
+
+
+def encode_host(host: str) -> str:
+    if not host:
+        return ""
+
+    elif IPv4_STYLE_HOSTNAME.match(host):
+        # Validate IPv4 hostnames like #.#.#.#
+        #
+        # From https://datatracker.ietf.org/doc/html/rfc3986/#section-3.2.2
+        #
+        # IPv4address = dec-octet "." dec-octet "." dec-octet "." dec-octet
+        try:
+            ipaddress.IPv4Address(host)
+        except ipaddress.AddressValueError:
+            raise InvalidURL(f"Invalid IPv4 address: {host!r}")
+        return host
+
+    elif IPv6_STYLE_HOSTNAME.match(host):
+        # Validate IPv6 hostnames like [...]
+        #
+        # From https://datatracker.ietf.org/doc/html/rfc3986/#section-3.2.2
+        #
+        # "A host identified by an Internet Protocol literal address, version 6
+        # [RFC3513] or later, is distinguished by enclosing the IP literal
+        # within square brackets ("[" and "]").  This is the only place where
+        # square bracket characters are allowed in the URI syntax."
+        try:
+            ipaddress.IPv6Address(host[1:-1])
+        except ipaddress.AddressValueError:
+            raise InvalidURL(f"Invalid IPv6 address: {host!r}")
+        return host[1:-1]
+
+    elif host.isascii():
+        # Regular ASCII hostnames
+        #
+        # From https://datatracker.ietf.org/doc/html/rfc3986/#section-3.2.2
+        #
+        # reg-name    = *( unreserved / pct-encoded / sub-delims )
+        WHATWG_SAFE = '"`{}%|\\'
+        return quote(host.lower(), safe=SUB_DELIMS + WHATWG_SAFE)
+
+    # IDNA hostnames
+    try:
+        return idna.encode(host.lower()).decode("ascii")
+    except idna.IDNAError:
+        raise InvalidURL(f"Invalid IDNA hostname: {host!r}")
+
+
+def normalize_port(port: str | int | None, scheme: str) -> int | None:
+    # From https://tools.ietf.org/html/rfc3986#section-3.2.3
+    #
+    # "A scheme may define a default port.  For example, the "http" scheme
+    # defines a default port of "80", corresponding to its reserved TCP
+    # port number.  The type of port designated by the port number (e.g.,
+    # TCP, UDP, SCTP) is defined by the URI scheme.  URI producers and
+    # normalizers should omit the port component and its ":" delimiter if
+    # port is empty or if its value would be the same as that of the
+    # scheme's default."
+    if port is None or port == "":
+        return None
+
+    try:
+        port_as_int = int(port)
+    except ValueError:
+        raise InvalidURL(f"Invalid port: {port!r}")
+
+    # See https://url.spec.whatwg.org/#url-miscellaneous
+    default_port = {"ftp": 21, "http": 80, "https": 443, "ws": 80, "wss": 443}.get(
+        scheme
+    )
+    if port_as_int == default_port:
+        return None
+    return port_as_int
+
+
+def validate_path(path: str, has_scheme: bool, has_authority: bool) -> None:
+    """
+    Path validation rules that depend on if the URL contains
+    a scheme or authority component.
+
+    See https://datatracker.ietf.org/doc/html/rfc3986.html#section-3.3
+    """
+    if has_authority:
+        # If a URI contains an authority component, then the path component
+        # must either be empty or begin with a slash ("/") character."
+        if path and not path.startswith("/"):
+            raise InvalidURL("For absolute URLs, path must be empty or begin with '/'")
+
+    if not has_scheme and not has_authority:
+        # If a URI does not contain an authority component, then the path cannot begin
+        # with two slash characters ("//").
+        if path.startswith("//"):
+            raise InvalidURL("Relative URLs cannot have a path starting with '//'")
+
+        # In addition, a URI reference (Section 4.1) may be a relative-path reference,
+        # in which case the first path segment cannot contain a colon (":") character.
+        if path.startswith(":"):
+            raise InvalidURL("Relative URLs cannot have a path starting with ':'")
+
+
+def normalize_path(path: str) -> str:
+    """
+    Drop "." and ".." segments from a URL path.
+
+    For example:
+
+        normalize_path("/path/./to/somewhere/..") == "/path/to"
+    """
+    # Fast return when no '.' characters in the path.
+    if "." not in path:
+        return path
+
+    components = path.split("/")
+
+    # Fast return when no '.' or '..' components in the path.
+    if "." not in components and ".." not in components:
+        return path
+
+    # https://datatracker.ietf.org/doc/html/rfc3986#section-5.2.4
+    output: list[str] = []
+    for component in components:
+        if component == ".":
+            pass
+        elif component == "..":
+            if output and output != [""]:
+                output.pop()
+        else:
+            output.append(component)
+    return "/".join(output)
+
+
+def PERCENT(string: str) -> str:
+    return "".join([f"%{byte:02X}" for byte in string.encode("utf-8")])
+
+
+def percent_encoded(string: str, safe: str) -> str:
+    """
+    Use percent-encoding to quote a string.
+    """
+    NON_ESCAPED_CHARS = UNRESERVED_CHARACTERS + safe
+
+    # Fast path for strings that don't need escaping.
+    if not string.rstrip(NON_ESCAPED_CHARS):
+        return string
+
+    return "".join(
+        [char if char in NON_ESCAPED_CHARS else PERCENT(char) for char in string]
+    )
+
+
+def quote(string: str, safe: str) -> str:
+    """
+    Use percent-encoding to quote a string, omitting existing '%xx' escape sequences.
+
+    See: https://www.rfc-editor.org/rfc/rfc3986#section-2.1
+
+    * `string`: The string to be percent-escaped.
+    * `safe`: A string containing characters that may be treated as safe, and do not
+        need to be escaped. Unreserved characters are always treated as safe.
+        See: https://www.rfc-editor.org/rfc/rfc3986#section-2.3
+    """
+    parts = []
+    current_position = 0
+    for match in re.finditer(PERCENT_ENCODED_REGEX, string):
+        start_position, end_position = match.start(), match.end()
+        matched_text = match.group(0)
+        # Add any text up to the '%xx' escape sequence.
+        if start_position != current_position:
+            leading_text = string[current_position:start_position]
+            parts.append(percent_encoded(leading_text, safe=safe))
+
+        # Add the '%xx' escape sequence.
+        parts.append(matched_text)
+        current_position = end_position
+
+    # Add any text after the final '%xx' escape sequence.
+    if current_position != len(string):
+        trailing_text = string[current_position:]
+        parts.append(percent_encoded(trailing_text, safe=safe))
+
+    return "".join(parts)

hai-mcp-pr7/.venv/lib/python3.13/site-packages/httpx/_urls.py

@@ -0,0 +1,641 @@
+from __future__ import annotations
+
+import typing
+from urllib.parse import parse_qs, unquote, urlencode
+
+import idna
+
+from ._types import QueryParamTypes
+from ._urlparse import urlparse
+from ._utils import primitive_value_to_str
+
+__all__ = ["URL", "QueryParams"]
+
+
+class URL:
+    """
+    url = httpx.URL("HTTPS://jo%40email.com:a%20secret@müller.de:1234/pa%20th?search=ab#anchorlink")
+
+    assert url.scheme == "https"
+    assert url.username == "jo@email.com"
+    assert url.password == "a secret"
+    assert url.userinfo == b"jo%40email.com:a%20secret"
+    assert url.host == "müller.de"
+    assert url.raw_host == b"xn--mller-kva.de"
+    assert url.port == 1234
+    assert url.netloc == b"xn--mller-kva.de:1234"
+    assert url.path == "/pa th"
+    assert url.query == b"?search=ab"
+    assert url.raw_path == b"/pa%20th?search=ab"
+    assert url.fragment == "anchorlink"
+
+    The components of a URL are broken down like this:
+
+       https://jo%40email.com:a%20secret@müller.de:1234/pa%20th?search=ab#anchorlink
+    [scheme]   [  username  ] [password] [ host ][port][ path ] [ query ] [fragment]
+               [       userinfo        ] [   netloc   ][    raw_path    ]
+
+    Note that:
+
+    * `url.scheme` is normalized to always be lowercased.
+
+    * `url.host` is normalized to always be lowercased. Internationalized domain
+      names are represented in unicode, without IDNA encoding applied. For instance:
+
+      url = httpx.URL("http://中国.icom.museum")
+      assert url.host == "中国.icom.museum"
+      url = httpx.URL("http://xn--fiqs8s.icom.museum")
+      assert url.host == "中国.icom.museum"
+
+    * `url.raw_host` is normalized to always be lowercased, and is IDNA encoded.
+
+      url = httpx.URL("http://中国.icom.museum")
+      assert url.raw_host == b"xn--fiqs8s.icom.museum"
+      url = httpx.URL("http://xn--fiqs8s.icom.museum")
+      assert url.raw_host == b"xn--fiqs8s.icom.museum"
+
+    * `url.port` is either None or an integer. URLs that include the default port for
+      "http", "https", "ws", "wss", and "ftp" schemes have their port
+      normalized to `None`.
+
+      assert httpx.URL("http://example.com") == httpx.URL("http://example.com:80")
+      assert httpx.URL("http://example.com").port is None
+      assert httpx.URL("http://example.com:80").port is None
+
+    * `url.userinfo` is raw bytes, without URL escaping. Usually you'll want to work
+      with `url.username` and `url.password` instead, which handle the URL escaping.
+
+    * `url.raw_path` is raw bytes of both the path and query, without URL escaping.
+      This portion is used as the target when constructing HTTP requests. Usually you'll
+      want to work with `url.path` instead.
+
+    * `url.query` is raw bytes, without URL escaping. A URL query string portion can
+      only be properly URL escaped when decoding the parameter names and values
+      themselves.
+    """
+
+    def __init__(self, url: URL | str = "", **kwargs: typing.Any) -> None:
+        if kwargs:
+            allowed = {
+                "scheme": str,
+                "username": str,
+                "password": str,
+                "userinfo": bytes,
+                "host": str,
+                "port": int,
+                "netloc": bytes,
+                "path": str,
+                "query": bytes,
+                "raw_path": bytes,
+                "fragment": str,
+                "params": object,
+            }
+
+            # Perform type checking for all supported keyword arguments.
+            for key, value in kwargs.items():
+                if key not in allowed:
+                    message = f"{key!r} is an invalid keyword argument for URL()"
+                    raise TypeError(message)
+                if value is not None and not isinstance(value, allowed[key]):
+                    expected = allowed[key].__name__
+                    seen = type(value).__name__
+                    message = f"Argument {key!r} must be {expected} but got {seen}"
+                    raise TypeError(message)
+                if isinstance(value, bytes):
+                    kwargs[key] = value.decode("ascii")
+
+            if "params" in kwargs:
+                # Replace any "params" keyword with the raw "query" instead.
+                #
+                # Ensure that empty params use `kwargs["query"] = None` rather
+                # than `kwargs["query"] = ""`, so that generated URLs do not
+                # include an empty trailing "?".
+                params = kwargs.pop("params")
+                kwargs["query"] = None if not params else str(QueryParams(params))
+
+        if isinstance(url, str):
+            self._uri_reference = urlparse(url, **kwargs)
+        elif isinstance(url, URL):
+            self._uri_reference = url._uri_reference.copy_with(**kwargs)
+        else:
+            raise TypeError(
+                "Invalid type for url.  Expected str or httpx.URL,"
+                f" got {type(url)}: {url!r}"
+            )
+
+    @property
+    def scheme(self) -> str:
+        """
+        The URL scheme, such as "http", "https".
+        Always normalised to lowercase.
+        """
+        return self._uri_reference.scheme
+
+    @property
+    def raw_scheme(self) -> bytes:
+        """
+        The raw bytes representation of the URL scheme, such as b"http", b"https".
+        Always normalised to lowercase.
+        """
+        return self._uri_reference.scheme.encode("ascii")
+
+    @property
+    def userinfo(self) -> bytes:
+        """
+        The URL userinfo as a raw bytestring.
+        For example: b"jo%40email.com:a%20secret".
+        """
+        return self._uri_reference.userinfo.encode("ascii")
+
+    @property
+    def username(self) -> str:
+        """
+        The URL username as a string, with URL decoding applied.
+        For example: "jo@email.com"
+        """
+        userinfo = self._uri_reference.userinfo
+        return unquote(userinfo.partition(":")[0])
+
+    @property
+    def password(self) -> str:
+        """
+        The URL password as a string, with URL decoding applied.
+        For example: "a secret"
+        """
+        userinfo = self._uri_reference.userinfo
+        return unquote(userinfo.partition(":")[2])
+
+    @property
+    def host(self) -> str:
+        """
+        The URL host as a string.
+        Always normalized to lowercase, with IDNA hosts decoded into unicode.
+
+        Examples:
+
+        url = httpx.URL("http://www.EXAMPLE.org")
+        assert url.host == "www.example.org"
+
+        url = httpx.URL("http://中国.icom.museum")
+        assert url.host == "中国.icom.museum"
+
+        url = httpx.URL("http://xn--fiqs8s.icom.museum")
+        assert url.host == "中国.icom.museum"
+
+        url = httpx.URL("https://[::ffff:192.168.0.1]")
+        assert url.host == "::ffff:192.168.0.1"
+        """
+        host: str = self._uri_reference.host
+
+        if host.startswith("xn--"):
+            host = idna.decode(host)
+
+        return host
+
+    @property
+    def raw_host(self) -> bytes:
+        """
+        The raw bytes representation of the URL host.
+        Always normalized to lowercase, and IDNA encoded.
+
+        Examples:
+
+        url = httpx.URL("http://www.EXAMPLE.org")
+        assert url.raw_host == b"www.example.org"
+
+        url = httpx.URL("http://中国.icom.museum")
+        assert url.raw_host == b"xn--fiqs8s.icom.museum"
+
+        url = httpx.URL("http://xn--fiqs8s.icom.museum")
+        assert url.raw_host == b"xn--fiqs8s.icom.museum"
+
+        url = httpx.URL("https://[::ffff:192.168.0.1]")
+        assert url.raw_host == b"::ffff:192.168.0.1"
+        """
+        return self._uri_reference.host.encode("ascii")
+
+    @property
+    def port(self) -> int | None:
+        """
+        The URL port as an integer.
+
+        Note that the URL class performs port normalization as per the WHATWG spec.
+        Default ports for "http", "https", "ws", "wss", and "ftp" schemes are always
+        treated as `None`.
+
+        For example:
+
+        assert httpx.URL("http://www.example.com") == httpx.URL("http://www.example.com:80")
+        assert httpx.URL("http://www.example.com:80").port is None
+        """
+        return self._uri_reference.port
+
+    @property
+    def netloc(self) -> bytes:
+        """
+        Either `<host>` or `<host>:<port>` as bytes.
+        Always normalized to lowercase, and IDNA encoded.
+
+        This property may be used for generating the value of a request
+        "Host" header.
+        """
+        return self._uri_reference.netloc.encode("ascii")
+
+    @property
+    def path(self) -> str:
+        """
+        The URL path as a string. Excluding the query string, and URL decoded.
+
+        For example:
+
+        url = httpx.URL("https://example.com/pa%20th")
+        assert url.path == "/pa th"
+        """
+        path = self._uri_reference.path or "/"
+        return unquote(path)
+
+    @property
+    def query(self) -> bytes:
+        """
+        The URL query string, as raw bytes, excluding the leading b"?".
+
+        This is necessarily a bytewise interface, because we cannot
+        perform URL decoding of this representation until we've parsed
+        the keys and values into a QueryParams instance.
+
+        For example:
+
+        url = httpx.URL("https://example.com/?filter=some%20search%20terms")
+        assert url.query == b"filter=some%20search%20terms"
+        """
+        query = self._uri_reference.query or ""
+        return query.encode("ascii")
+
+    @property
+    def params(self) -> QueryParams:
+        """
+        The URL query parameters, neatly parsed and packaged into an immutable
+        multidict representation.
+        """
+        return QueryParams(self._uri_reference.query)
+
+    @property
+    def raw_path(self) -> bytes:
+        """
+        The complete URL path and query string as raw bytes.
+        Used as the target when constructing HTTP requests.
+
+        For example:
+
+        GET /users?search=some%20text HTTP/1.1
+        Host: www.example.org
+        Connection: close
+        """
+        path = self._uri_reference.path or "/"
+        if self._uri_reference.query is not None:
+            path += "?" + self._uri_reference.query
+        return path.encode("ascii")
+
+    @property
+    def fragment(self) -> str:
+        """
+        The URL fragments, as used in HTML anchors.
+        As a string, without the leading '#'.
+        """
+        return unquote(self._uri_reference.fragment or "")
+
+    @property
+    def is_absolute_url(self) -> bool:
+        """
+        Return `True` for absolute URLs such as 'http://example.com/path',
+        and `False` for relative URLs such as '/path'.
+        """
+        # We don't use `.is_absolute` from `rfc3986` because it treats
+        # URLs with a fragment portion as not absolute.
+        # What we actually care about is if the URL provides
+        # a scheme and hostname to which connections should be made.
+        return bool(self._uri_reference.scheme and self._uri_reference.host)
+
+    @property
+    def is_relative_url(self) -> bool:
+        """
+        Return `False` for absolute URLs such as 'http://example.com/path',
+        and `True` for relative URLs such as '/path'.
+        """
+        return not self.is_absolute_url
+
+    def copy_with(self, **kwargs: typing.Any) -> URL:
+        """
+        Copy this URL, returning a new URL with some components altered.
+        Accepts the same set of parameters as the components that are made
+        available via properties on the `URL` class.
+
+        For example:
+
+        url = httpx.URL("https://www.example.com").copy_with(
+            username="jo@gmail.com", password="a secret"
+        )
+        assert url == "https://jo%40email.com:a%20secret@www.example.com"
+        """
+        return URL(self, **kwargs)
+
+    def copy_set_param(self, key: str, value: typing.Any = None) -> URL:
+        return self.copy_with(params=self.params.set(key, value))
+
+    def copy_add_param(self, key: str, value: typing.Any = None) -> URL:
+        return self.copy_with(params=self.params.add(key, value))
+
+    def copy_remove_param(self, key: str) -> URL:
+        return self.copy_with(params=self.params.remove(key))
+
+    def copy_merge_params(self, params: QueryParamTypes) -> URL:
+        return self.copy_with(params=self.params.merge(params))
+
+    def join(self, url: URL | str) -> URL:
+        """
+        Return an absolute URL, using this URL as the base.
+
+        Eg.
+
+        url = httpx.URL("https://www.example.com/test")
+        url = url.join("/new/path")
+        assert url == "https://www.example.com/new/path"
+        """
+        from urllib.parse import urljoin
+
+        return URL(urljoin(str(self), str(URL(url))))
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+    def __eq__(self, other: typing.Any) -> bool:
+        return isinstance(other, (URL, str)) and str(self) == str(URL(other))
+
+    def __str__(self) -> str:
+        return str(self._uri_reference)
+
+    def __repr__(self) -> str:
+        scheme, userinfo, host, port, path, query, fragment = self._uri_reference
+
+        if ":" in userinfo:
+            # Mask any password component.
+            userinfo = f'{userinfo.split(":")[0]}:[secure]'
+
+        authority = "".join(
+            [
+                f"{userinfo}@" if userinfo else "",
+                f"[{host}]" if ":" in host else host,
+                f":{port}" if port is not None else "",
+            ]
+        )
+        url = "".join(
+            [
+                f"{self.scheme}:" if scheme else "",
+                f"//{authority}" if authority else "",
+                path,
+                f"?{query}" if query is not None else "",
+                f"#{fragment}" if fragment is not None else "",
+            ]
+        )
+
+        return f"{self.__class__.__name__}({url!r})"
+
+    @property
+    def raw(self) -> tuple[bytes, bytes, int, bytes]:  # pragma: nocover
+        import collections
+        import warnings
+
+        warnings.warn("URL.raw is deprecated.")
+        RawURL = collections.namedtuple(
+            "RawURL", ["raw_scheme", "raw_host", "port", "raw_path"]
+        )
+        return RawURL(
+            raw_scheme=self.raw_scheme,
+            raw_host=self.raw_host,
+            port=self.port,
+            raw_path=self.raw_path,
+        )
+
+
+class QueryParams(typing.Mapping[str, str]):
+    """
+    URL query parameters, as a multi-dict.
+    """
+
+    def __init__(self, *args: QueryParamTypes | None, **kwargs: typing.Any) -> None:
+        assert len(args) < 2, "Too many arguments."
+        assert not (args and kwargs), "Cannot mix named and unnamed arguments."
+
+        value = args[0] if args else kwargs
+
+        if value is None or isinstance(value, (str, bytes)):
+            value = value.decode("ascii") if isinstance(value, bytes) else value
+            self._dict = parse_qs(value, keep_blank_values=True)
+        elif isinstance(value, QueryParams):
+            self._dict = {k: list(v) for k, v in value._dict.items()}
+        else:
+            dict_value: dict[typing.Any, list[typing.Any]] = {}
+            if isinstance(value, (list, tuple)):
+                # Convert list inputs like:
+                #     [("a", "123"), ("a", "456"), ("b", "789")]
+                # To a dict representation, like:
+                #     {"a": ["123", "456"], "b": ["789"]}
+                for item in value:
+                    dict_value.setdefault(item[0], []).append(item[1])
+            else:
+                # Convert dict inputs like:
+                #    {"a": "123", "b": ["456", "789"]}
+                # To dict inputs where values are always lists, like:
+                #    {"a": ["123"], "b": ["456", "789"]}
+                dict_value = {
+                    k: list(v) if isinstance(v, (list, tuple)) else [v]
+                    for k, v in value.items()
+                }
+
+            # Ensure that keys and values are neatly coerced to strings.
+            # We coerce values `True` and `False` to JSON-like "true" and "false"
+            # representations, and coerce `None` values to the empty string.
+            self._dict = {
+                str(k): [primitive_value_to_str(item) for item in v]
+                for k, v in dict_value.items()
+            }
+
+    def keys(self) -> typing.KeysView[str]:
+        """
+        Return all the keys in the query params.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123&a=456&b=789")
+        assert list(q.keys()) == ["a", "b"]
+        """
+        return self._dict.keys()
+
+    def values(self) -> typing.ValuesView[str]:
+        """
+        Return all the values in the query params. If a key occurs more than once
+        only the first item for that key is returned.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123&a=456&b=789")
+        assert list(q.values()) == ["123", "789"]
+        """
+        return {k: v[0] for k, v in self._dict.items()}.values()
+
+    def items(self) -> typing.ItemsView[str, str]:
+        """
+        Return all items in the query params. If a key occurs more than once
+        only the first item for that key is returned.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123&a=456&b=789")
+        assert list(q.items()) == [("a", "123"), ("b", "789")]
+        """
+        return {k: v[0] for k, v in self._dict.items()}.items()
+
+    def multi_items(self) -> list[tuple[str, str]]:
+        """
+        Return all items in the query params. Allow duplicate keys to occur.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123&a=456&b=789")
+        assert list(q.multi_items()) == [("a", "123"), ("a", "456"), ("b", "789")]
+        """
+        multi_items: list[tuple[str, str]] = []
+        for k, v in self._dict.items():
+            multi_items.extend([(k, i) for i in v])
+        return multi_items
+
+    def get(self, key: typing.Any, default: typing.Any = None) -> typing.Any:
+        """
+        Get a value from the query param for a given key. If the key occurs
+        more than once, then only the first value is returned.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123&a=456&b=789")
+        assert q.get("a") == "123"
+        """
+        if key in self._dict:
+            return self._dict[str(key)][0]
+        return default
+
+    def get_list(self, key: str) -> list[str]:
+        """
+        Get all values from the query param for a given key.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123&a=456&b=789")
+        assert q.get_list("a") == ["123", "456"]
+        """
+        return list(self._dict.get(str(key), []))
+
+    def set(self, key: str, value: typing.Any = None) -> QueryParams:
+        """
+        Return a new QueryParams instance, setting the value of a key.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123")
+        q = q.set("a", "456")
+        assert q == httpx.QueryParams("a=456")
+        """
+        q = QueryParams()
+        q._dict = dict(self._dict)
+        q._dict[str(key)] = [primitive_value_to_str(value)]
+        return q
+
+    def add(self, key: str, value: typing.Any = None) -> QueryParams:
+        """
+        Return a new QueryParams instance, setting or appending the value of a key.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123")
+        q = q.add("a", "456")
+        assert q == httpx.QueryParams("a=123&a=456")
+        """
+        q = QueryParams()
+        q._dict = dict(self._dict)
+        q._dict[str(key)] = q.get_list(key) + [primitive_value_to_str(value)]
+        return q
+
+    def remove(self, key: str) -> QueryParams:
+        """
+        Return a new QueryParams instance, removing the value of a key.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123")
+        q = q.remove("a")
+        assert q == httpx.QueryParams("")
+        """
+        q = QueryParams()
+        q._dict = dict(self._dict)
+        q._dict.pop(str(key), None)
+        return q
+
+    def merge(self, params: QueryParamTypes | None = None) -> QueryParams:
+        """
+        Return a new QueryParams instance, updated with.
+
+        Usage:
+
+        q = httpx.QueryParams("a=123")
+        q = q.merge({"b": "456"})
+        assert q == httpx.QueryParams("a=123&b=456")
+
+        q = httpx.QueryParams("a=123")
+        q = q.merge({"a": "456", "b": "789"})
+        assert q == httpx.QueryParams("a=456&b=789")
+        """
+        q = QueryParams(params)
+        q._dict = {**self._dict, **q._dict}
+        return q
+
+    def __getitem__(self, key: typing.Any) -> str:
+        return self._dict[key][0]
+
+    def __contains__(self, key: typing.Any) -> bool:
+        return key in self._dict
+
+    def __iter__(self) -> typing.Iterator[typing.Any]:
+        return iter(self.keys())
+
+    def __len__(self) -> int:
+        return len(self._dict)
+
+    def __bool__(self) -> bool:
+        return bool(self._dict)
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+    def __eq__(self, other: typing.Any) -> bool:
+        if not isinstance(other, self.__class__):
+            return False
+        return sorted(self.multi_items()) == sorted(other.multi_items())
+
+    def __str__(self) -> str:
+        return urlencode(self.multi_items())
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        query_string = str(self)
+        return f"{class_name}({query_string!r})"
+
+    def update(self, params: QueryParamTypes | None = None) -> None:
+        raise RuntimeError(
+            "QueryParams are immutable since 0.18.0. "
+            "Use `q = q.merge(...)` to create an updated copy."
+        )
+
+    def __setitem__(self, key: str, value: str) -> None:
+        raise RuntimeError(
+            "QueryParams are immutable since 0.18.0. "
+            "Use `q = q.set(key, value)` to create an updated copy."
+        )

hai-mcp-pr7/.venv/lib/python3.13/site-packages/httpx/_utils.py

@@ -0,0 +1,242 @@
+from __future__ import annotations
+
+import ipaddress
+import os
+import re
+import typing
+from urllib.request import getproxies
+
+from ._types import PrimitiveData
+
+if typing.TYPE_CHECKING:  # pragma: no cover
+    from ._urls import URL
+
+
+def primitive_value_to_str(value: PrimitiveData) -> str:
+    """
+    Coerce a primitive data type into a string value.
+
+    Note that we prefer JSON-style 'true'/'false' for boolean values here.
+    """
+    if value is True:
+        return "true"
+    elif value is False:
+        return "false"
+    elif value is None:
+        return ""
+    return str(value)
+
+
+def get_environment_proxies() -> dict[str, str | None]:
+    """Gets proxy information from the environment"""
+
+    # urllib.request.getproxies() falls back on System
+    # Registry and Config for proxies on Windows and macOS.
+    # We don't want to propagate non-HTTP proxies into
+    # our configuration such as 'TRAVIS_APT_PROXY'.
+    proxy_info = getproxies()
+    mounts: dict[str, str | None] = {}
+
+    for scheme in ("http", "https", "all"):
+        if proxy_info.get(scheme):
+            hostname = proxy_info[scheme]
+            mounts[f"{scheme}://"] = (
+                hostname if "://" in hostname else f"http://{hostname}"
+            )
+
+    no_proxy_hosts = [host.strip() for host in proxy_info.get("no", "").split(",")]
+    for hostname in no_proxy_hosts:
+        # See https://curl.haxx.se/libcurl/c/CURLOPT_NOPROXY.html for details
+        # on how names in `NO_PROXY` are handled.
+        if hostname == "*":
+            # If NO_PROXY=* is used or if "*" occurs as any one of the comma
+            # separated hostnames, then we should just bypass any information
+            # from HTTP_PROXY, HTTPS_PROXY, ALL_PROXY, and always ignore
+            # proxies.
+            return {}
+        elif hostname:
+            # NO_PROXY=.google.com is marked as "all://*.google.com,
+            #   which disables "www.google.com" but not "google.com"
+            # NO_PROXY=google.com is marked as "all://*google.com,
+            #   which disables "www.google.com" and "google.com".
+            #   (But not "wwwgoogle.com")
+            # NO_PROXY can include domains, IPv6, IPv4 addresses and "localhost"
+            #   NO_PROXY=example.com,::1,localhost,192.168.0.0/16
+            if "://" in hostname:
+                mounts[hostname] = None
+            elif is_ipv4_hostname(hostname):
+                mounts[f"all://{hostname}"] = None
+            elif is_ipv6_hostname(hostname):
+                mounts[f"all://[{hostname}]"] = None
+            elif hostname.lower() == "localhost":
+                mounts[f"all://{hostname}"] = None
+            else:
+                mounts[f"all://*{hostname}"] = None
+
+    return mounts
+
+
+def to_bytes(value: str | bytes, encoding: str = "utf-8") -> bytes:
+    return value.encode(encoding) if isinstance(value, str) else value
+
+
+def to_str(value: str | bytes, encoding: str = "utf-8") -> str:
+    return value if isinstance(value, str) else value.decode(encoding)
+
+
+def to_bytes_or_str(value: str, match_type_of: typing.AnyStr) -> typing.AnyStr:
+    return value if isinstance(match_type_of, str) else value.encode()
+
+
+def unquote(value: str) -> str:
+    return value[1:-1] if value[0] == value[-1] == '"' else value
+
+
+def peek_filelike_length(stream: typing.Any) -> int | None:
+    """
+    Given a file-like stream object, return its length in number of bytes
+    without reading it into memory.
+    """
+    try:
+        # Is it an actual file?
+        fd = stream.fileno()
+        # Yup, seems to be an actual file.
+        length = os.fstat(fd).st_size
+    except (AttributeError, OSError):
+        # No... Maybe it's something that supports random access, like `io.BytesIO`?
+        try:
+            # Assuming so, go to end of stream to figure out its length,
+            # then put it back in place.
+            offset = stream.tell()
+            length = stream.seek(0, os.SEEK_END)
+            stream.seek(offset)
+        except (AttributeError, OSError):
+            # Not even that? Sorry, we're doomed...
+            return None
+
+    return length
+
+
+class URLPattern:
+    """
+    A utility class currently used for making lookups against proxy keys...
+
+    # Wildcard matching...
+    >>> pattern = URLPattern("all://")
+    >>> pattern.matches(httpx.URL("http://example.com"))
+    True
+
+    # Witch scheme matching...
+    >>> pattern = URLPattern("https://")
+    >>> pattern.matches(httpx.URL("https://example.com"))
+    True
+    >>> pattern.matches(httpx.URL("http://example.com"))
+    False
+
+    # With domain matching...
+    >>> pattern = URLPattern("https://example.com")
+    >>> pattern.matches(httpx.URL("https://example.com"))
+    True
+    >>> pattern.matches(httpx.URL("http://example.com"))
+    False
+    >>> pattern.matches(httpx.URL("https://other.com"))
+    False
+
+    # Wildcard scheme, with domain matching...
+    >>> pattern = URLPattern("all://example.com")
+    >>> pattern.matches(httpx.URL("https://example.com"))
+    True
+    >>> pattern.matches(httpx.URL("http://example.com"))
+    True
+    >>> pattern.matches(httpx.URL("https://other.com"))
+    False
+
+    # With port matching...
+    >>> pattern = URLPattern("https://example.com:1234")
+    >>> pattern.matches(httpx.URL("https://example.com:1234"))
+    True
+    >>> pattern.matches(httpx.URL("https://example.com"))
+    False
+    """
+
+    def __init__(self, pattern: str) -> None:
+        from ._urls import URL
+
+        if pattern and ":" not in pattern:
+            raise ValueError(
+                f"Proxy keys should use proper URL forms rather "
+                f"than plain scheme strings. "
+                f'Instead of "{pattern}", use "{pattern}://"'
+            )
+
+        url = URL(pattern)
+        self.pattern = pattern
+        self.scheme = "" if url.scheme == "all" else url.scheme
+        self.host = "" if url.host == "*" else url.host
+        self.port = url.port
+        if not url.host or url.host == "*":
+            self.host_regex: typing.Pattern[str] | None = None
+        elif url.host.startswith("*."):
+            # *.example.com should match "www.example.com", but not "example.com"
+            domain = re.escape(url.host[2:])
+            self.host_regex = re.compile(f"^.+\\.{domain}$")
+        elif url.host.startswith("*"):
+            # *example.com should match "www.example.com" and "example.com"
+            domain = re.escape(url.host[1:])
+            self.host_regex = re.compile(f"^(.+\\.)?{domain}$")
+        else:
+            # example.com should match "example.com" but not "www.example.com"
+            domain = re.escape(url.host)
+            self.host_regex = re.compile(f"^{domain}$")
+
+    def matches(self, other: URL) -> bool:
+        if self.scheme and self.scheme != other.scheme:
+            return False
+        if (
+            self.host
+            and self.host_regex is not None
+            and not self.host_regex.match(other.host)
+        ):
+            return False
+        if self.port is not None and self.port != other.port:
+            return False
+        return True
+
+    @property
+    def priority(self) -> tuple[int, int, int]:
+        """
+        The priority allows URLPattern instances to be sortable, so that
+        we can match from most specific to least specific.
+        """
+        # URLs with a port should take priority over URLs without a port.
+        port_priority = 0 if self.port is not None else 1
+        # Longer hostnames should match first.
+        host_priority = -len(self.host)
+        # Longer schemes should match first.
+        scheme_priority = -len(self.scheme)
+        return (port_priority, host_priority, scheme_priority)
+
+    def __hash__(self) -> int:
+        return hash(self.pattern)
+
+    def __lt__(self, other: URLPattern) -> bool:
+        return self.priority < other.priority
+
+    def __eq__(self, other: typing.Any) -> bool:
+        return isinstance(other, URLPattern) and self.pattern == other.pattern
+
+
+def is_ipv4_hostname(hostname: str) -> bool:
+    try:
+        ipaddress.IPv4Address(hostname.split("/")[0])
+    except Exception:
+        return False
+    return True
+
+
+def is_ipv6_hostname(hostname: str) -> bool:
+    try:
+        ipaddress.IPv6Address(hostname.split("/")[0])
+    except Exception:
+        return False
+    return True

hai-mcp-pr7/.venv/lib/python3.13/site-packages/httpx_sse-0.4.3.dist-info/INSTALLER

@@ -0,0 +1 @@
+uv

hai-mcp-pr7/.venv/lib/python3.13/site-packages/httpx_sse-0.4.3.dist-info/METADATA

@@ -0,0 +1,351 @@
+Metadata-Version: 2.4
+Name: httpx-sse
+Version: 0.4.3
+Summary: Consume Server-Sent Event (SSE) messages with HTTPX.
+Author-email: Florimond Manca <florimond.manca@protonmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/florimondmanca/httpx-sse
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# httpx-sse
+
+[![Build Status](https://dev.azure.com/florimondmanca/public/_apis/build/status/florimondmanca.httpx-sse?branchName=master)](https://dev.azure.com/florimondmanca/public/_build?definitionId=19)
+[![Coverage](https://codecov.io/gh/florimondmanca/httpx-sse/branch/master/graph/badge.svg)](https://codecov.io/gh/florimondmanca/httpx-sse)
+[![Package version](https://badge.fury.io/py/httpx-sse.svg)](https://pypi.org/project/httpx-sse)
+
+Consume [Server-Sent Event (SSE)](https://html.spec.whatwg.org/multipage/server-sent-events.html#server-sent-events) messages with [HTTPX](https://www.python-httpx.org).
+
+**Table of contents**
+
+- [Installation](#installation)
+- [Quickstart](#quickstart)
+- [How-To](#how-to)
+- [API Reference](#api-reference)
+
+## Installation
+
+**NOTE**: This is beta software. Please be sure to pin your dependencies.
+
+```bash
+pip install httpx-sse=="0.4.*"
+```
+
+## Quickstart
+
+`httpx-sse` provides the [`connect_sse`](#connect_sse) and [`aconnect_sse`](#aconnect_sse) helpers for connecting to an SSE endpoint. The resulting [`EventSource`](#eventsource) object exposes the [`.iter_sse()`](#iter_sse) and [`.aiter_sse()`](#aiter_sse) methods to iterate over the server-sent events.
+
+Example usage:
+
+```python
+import httpx
+from httpx_sse import connect_sse
+
+with httpx.Client() as client:
+    with connect_sse(client, "GET", "http://localhost:8000/sse") as event_source:
+        for sse in event_source.iter_sse():
+            print(sse.event, sse.data, sse.id, sse.retry)
+```
+
+You can try this against this example Starlette server ([credit](https://sysid.github.io/sse/)):
+
+```python
+# Requirements: pip install uvicorn starlette sse-starlette
+import asyncio
+import uvicorn
+from starlette.applications import Starlette
+from starlette.routing import Route
+from sse_starlette.sse import EventSourceResponse
+
+async def numbers(minimum, maximum):
+    for i in range(minimum, maximum + 1):
+        await asyncio.sleep(0.9)
+        yield {"data": i}
+
+async def sse(request):
+    generator = numbers(1, 5)
+    return EventSourceResponse(generator)
+
+routes = [
+    Route("/sse", endpoint=sse)
+]
+
+app = Starlette(routes=routes)
+
+if __name__ == "__main__":
+    uvicorn.run(app)
+```
+
+## How-To
+
+### Calling into Python web apps
+
+You can [call into Python web apps](https://www.python-httpx.org/async/#calling-into-python-web-apps) with HTTPX and `httpx-sse` to test SSE endpoints directly.
+
+Here's an example of calling into a Starlette ASGI app...
+
+```python
+import asyncio
+
+import httpx
+from httpx_sse import aconnect_sse
+from sse_starlette.sse import EventSourceResponse
+from starlette.applications import Starlette
+from starlette.routing import Route
+
+async def auth_events(request):
+    async def events():
+        yield {
+            "event": "login",
+            "data": '{"user_id": "4135"}',
+        }
+
+    return EventSourceResponse(events())
+
+app = Starlette(routes=[Route("/sse/auth/", endpoint=auth_events)])
+
+async def main():
+    async with httpx.AsyncClient(transport=httpx.ASGITransport(app)) as client:
+        async with aconnect_sse(
+            client, "GET", "http://localhost:8000/sse/auth/"
+        ) as event_source:
+            events = [sse async for sse in event_source.aiter_sse()]
+            (sse,) = events
+            assert sse.event == "login"
+            assert sse.json() == {"user_id": "4135"}
+
+asyncio.run(main())
+```
+
+### Handling reconnections
+
+_(Advanced)_
+
+`SSETransport` and `AsyncSSETransport` don't have reconnection built-in. This is because how to perform retries is generally dependent on your use case. As a result, if the connection breaks while attempting to read from the server, you will get an `httpx.ReadError` from `iter_sse()` (or `aiter_sse()`).
+
+However, `httpx-sse` does allow implementing reconnection by using the `Last-Event-ID` and reconnection time (in milliseconds), exposed as `sse.id` and `sse.retry` respectively.
+
+Here's how you might achieve this using [`stamina`](https://github.com/hynek/stamina)...
+
+```python
+import time
+from typing import Iterator
+
+import httpx
+from httpx_sse import connect_sse, ServerSentEvent
+from stamina import retry
+
+def iter_sse_retrying(client, method, url):
+    last_event_id = ""
+    reconnection_delay = 0.0
+
+    # `stamina` will apply jitter and exponential backoff on top of
+    # the `retry` reconnection delay sent by the server.
+    @retry(on=httpx.ReadError)
+    def _iter_sse():
+        nonlocal last_event_id, reconnection_delay
+
+        time.sleep(reconnection_delay)
+
+        headers = {"Accept": "text/event-stream"}
+
+        if last_event_id:
+            headers["Last-Event-ID"] = last_event_id
+
+        with connect_sse(client, method, url, headers=headers) as event_source:
+            for sse in event_source.iter_sse():
+                last_event_id = sse.id
+
+                if sse.retry is not None:
+                    reconnection_delay = sse.retry / 1000
+
+                yield sse
+
+    return _iter_sse()
+```
+
+Usage:
+
+```python
+with httpx.Client() as client:
+    for sse in iter_sse_retrying(client, "GET", "http://localhost:8000/sse"):
+        print(sse.event, sse.data)
+```
+
+## API Reference
+
+### `connect_sse`
+
+```python
+def connect_sse(
+    client: httpx.Client,
+    method: str,
+    url: Union[str, httpx.URL],
+    **kwargs,
+) -> ContextManager[EventSource]
+```
+
+Connect to an SSE endpoint and return an [`EventSource`](#eventsource) context manager.
+
+This sets `Cache-Control: no-store` on the request, as per the SSE spec, as well as `Accept: text/event-stream`.
+
+If the response `Content-Type` is not `text/event-stream`, this will raise an [`SSEError`](#sseerror).
+
+### `aconnect_sse`
+
+```python
+async def aconnect_sse(
+    client: httpx.AsyncClient,
+    method: str,
+    url: Union[str, httpx.URL],
+    **kwargs,
+) -> AsyncContextManager[EventSource]
+```
+
+An async equivalent to [`connect_sse`](#connect_sse).
+
+### `EventSource`
+
+```python
+def __init__(response: httpx.Response)
+```
+
+Helper for working with an SSE response.
+
+#### `response`
+
+The underlying [`httpx.Response`](https://www.python-httpx.org/api/#response).
+
+You may use this to perform more operations and checks on the response, such as checking for HTTP status errors:
+
+```python
+with connect_sse(...) as event_source:
+    event_source.response.raise_for_status()
+
+    for sse in event_source.iter_sse():
+        ...
+```
+
+#### `iter_sse`
+
+```python
+def iter_sse() -> Iterator[ServerSentEvent]
+```
+
+Decode the response content and yield corresponding [`ServerSentEvent`](#serversentevent).
+
+Example usage:
+
+```python
+for sse in event_source.iter_sse():
+    ...
+```
+
+#### `aiter_sse`
+
+```python
+async def iter_sse() -> AsyncIterator[ServerSentEvent]
+```
+
+An async equivalent to `iter_sse`.
+
+### `ServerSentEvent`
+
+Represents a server-sent event.
+
+* `event: str` - Defaults to `"message"`.
+* `data: str` - Defaults to `""`.
+* `id: str` - Defaults to `""`.
+* `retry: str | None` - Defaults to `None`.
+
+Methods:
+
+* `json() -> Any` - Returns `sse.data` decoded as JSON.
+
+### `SSEError`
+
+An error that occurred while making a request to an SSE endpoint.
+
+Parents:
+
+* `httpx.TransportError`
+
+## License
+
+MIT
+
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+
+## 0.4.3 - 2025-10-10
+
+### Fixed
+
+* Fix performance issue introduced by the improved line parsing from release 0.4.2. (Pull #40)
+
+## 0.4.2 - 2025-10-07
+
+### Fixed
+
+* Fix incorrect newline parsing that was not compliant with SSE spec. (Pull #37)
+
+## 0.4.1 - 2025-06-24
+
+### Fixed
+
+* Always close the response async generator in `aiter_sse()`. (Pull #30)
+
+## 0.4.0 - 2023-12-22
+
+### Removed
+
+* Dropped Python 3.7 support, as it has reached EOL. (Pull #21)
+
+### Added
+
+* Add official support for Python 3.12. (Pull #21)
+
+### Fixed
+
+* Allow `Content-Type` that contain but are not strictly `text/event-stream`. (Pull #22 by @dbuades)
+* Improve error message when `Content-Type` is missing. (Pull #20 by @jamesbraza)
+
+## 0.3.1 - 2023-06-01
+
+### Added
+
+* Add `__repr__()` for `ServerSentEvent` model, which may help with debugging and other tasks. (Pull #16)
+
+## 0.3.0 - 2023-04-27
+
+### Changed
+
+* Raising an `SSEError` if the response content type is not `text/event-stream` is now performed as part of `iter_sse()` / `aiter_sse()`, instead of `connect_sse()` / `aconnect_sse()`. This allows inspecting the response before iterating on server-sent events, such as checking for error responses. (Pull #12)
+
+## 0.2.0 - 2023-03-27
+
+### Changed
+
+* `connect_sse()` and `aconnect_sse()` now require a `method` argument: `connect_sse(client, "GET", "https://example.org")`. This provides support for SSE requests with HTTP verbs other than `GET`. (Pull #7)
+
+## 0.1.0 - 2023-02-05
+
+_Initial release_
+
+### Added
+
+* Add `connect_sse`, `aconnect_sse()`, `ServerSentEvent` and `SSEError`.

hai-mcp-pr7/.venv/lib/python3.13/site-packages/httpx_sse-0.4.3.dist-info/RECORD

@@ -0,0 +1,13 @@
+httpx_sse-0.4.3.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+httpx_sse-0.4.3.dist-info/METADATA,sha256=1MbYBO5axG6bO2WVwnq4riunz7X2kseLFv9GPkvRqB4,9671
+httpx_sse-0.4.3.dist-info/RECORD,,
+httpx_sse-0.4.3.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+httpx_sse-0.4.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+httpx_sse-0.4.3.dist-info/licenses/LICENSE,sha256=vuxn5O6Dp68m8kK-2Zh6qGPW0t-3dhBqojYMQYfzGQE,1072
+httpx_sse-0.4.3.dist-info/top_level.txt,sha256=hbK3kwBH9d-rEZQvJ6yBawdDylIKfJ8fh0CM4EVNs04,10
+httpx_sse/__init__.py,sha256=G-F8jpJLo4eJwKvKt6ejTQYPhBHgmksZTNuaQySRAjc,282
+httpx_sse/_api.py,sha256=D7pfkajmdHlms75OV8HpdOrOEr5NbWQlDwMfSFcJ8FU,2919
+httpx_sse/_decoders.py,sha256=na1XyVBiCLbRE8tg0o713U5Gz-m9fBxYPfSMmu_xns8,4005
+httpx_sse/_exceptions.py,sha256=sFZBUT1xIM1DvYQ6ckpzrhBG9d8VffFSZFMIEhv1N58,62
+httpx_sse/_models.py,sha256=4WwGeBEGMR2nbROTZ7PyVlu7chmWg7tbkJyXyd5DTx0,1221
+httpx_sse/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0

hai-mcp-pr7/.venv/lib/python3.13/site-packages/httpx_sse-0.4.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

hai-mcp-pr7/.venv/lib/python3.13/site-packages/httpx_sse-0.4.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Florimond Manca
+
+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.

hai-mcp-pr7/.venv/lib/python3.13/site-packages/httpx_sse-0.4.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+httpx_sse

hai-mcp-pr7/.venv/lib/python3.13/site-packages/httpx_sse/__init__.py

@@ -0,0 +1,14 @@
+from ._api import EventSource, aconnect_sse, connect_sse
+from ._exceptions import SSEError
+from ._models import ServerSentEvent
+
+__version__ = "0.4.3"
+
+__all__ = [
+    "__version__",
+    "EventSource",
+    "connect_sse",
+    "aconnect_sse",
+    "ServerSentEvent",
+    "SSEError",
+]

hai-mcp-pr7/.venv/lib/python3.13/site-packages/httpx_sse/_api.py

@@ -0,0 +1,93 @@
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager, contextmanager
+from typing import Any, AsyncIterator, Iterator, cast
+
+import httpx
+
+from ._decoders import SSEDecoder, SSELineDecoder
+from ._exceptions import SSEError
+from ._models import ServerSentEvent
+
+
+class EventSource:
+    def __init__(self, response: httpx.Response) -> None:
+        self._response = response
+
+    def _check_content_type(self) -> None:
+        content_type = self._response.headers.get("content-type", "").partition(";")[0]
+        if "text/event-stream" not in content_type:
+            raise SSEError(
+                "Expected response header Content-Type to contain 'text/event-stream', "
+                f"got {content_type!r}"
+            )
+
+    @property
+    def response(self) -> httpx.Response:
+        return self._response
+
+    def iter_sse(self) -> Iterator[ServerSentEvent]:
+        self._check_content_type()
+        decoder = SSEDecoder()
+        for line in _iter_sse_lines(self._response):
+            line = line.rstrip("\n")
+            sse = decoder.decode(line)
+            if sse is not None:
+                yield sse
+
+    async def aiter_sse(self) -> AsyncGenerator[ServerSentEvent, None]:
+        self._check_content_type()
+        decoder = SSEDecoder()
+        lines = cast(AsyncGenerator[str, None], _aiter_sse_lines(self._response))
+        try:
+            async for line in lines:
+                line = line.rstrip("\n")
+                sse = decoder.decode(line)
+                if sse is not None:
+                    yield sse
+        finally:
+            await lines.aclose()
+
+
+@contextmanager
+def connect_sse(
+    client: httpx.Client, method: str, url: str, **kwargs: Any
+) -> Iterator[EventSource]:
+    headers = kwargs.pop("headers", {})
+    headers["Accept"] = "text/event-stream"
+    headers["Cache-Control"] = "no-store"
+
+    with client.stream(method, url, headers=headers, **kwargs) as response:
+        yield EventSource(response)
+
+
+@asynccontextmanager
+async def aconnect_sse(
+    client: httpx.AsyncClient,
+    method: str,
+    url: str,
+    **kwargs: Any,
+) -> AsyncIterator[EventSource]:
+    headers = kwargs.pop("headers", {})
+    headers["Accept"] = "text/event-stream"
+    headers["Cache-Control"] = "no-store"
+
+    async with client.stream(method, url, headers=headers, **kwargs) as response:
+        yield EventSource(response)
+
+
+async def _aiter_sse_lines(response: httpx.Response) -> AsyncIterator[str]:
+    decoder = SSELineDecoder()
+    async for text in response.aiter_text():
+        for line in decoder.decode(text):
+            yield line
+    for line in decoder.flush():
+        yield line
+
+
+def _iter_sse_lines(response: httpx.Response) -> Iterator[str]:
+    decoder = SSELineDecoder()
+    for text in response.iter_text():
+        for line in decoder.decode(text):
+            yield line
+    for line in decoder.flush():
+        yield line

hai-mcp-pr7/.venv/lib/python3.13/site-packages/httpx_sse/_decoders.py

@@ -0,0 +1,139 @@
+from typing import List, Optional
+
+from ._models import ServerSentEvent
+
+
+def _splitlines_sse(text: str) -> List[str]:
+    """Split text on \r\n, \r, or \n only."""
+    if not text:
+        return []
+
+    if "\r" not in text:
+        lines = text.split("\n")
+    else:
+        normalized = text.replace("\r\n", "\n").replace("\r", "\n")
+        lines = normalized.split("\n")
+
+    if text[-1] in "\r\n":
+        lines.pop()
+
+    return lines
+
+
+class SSELineDecoder:
+    """
+    Handles incrementally reading lines from text.
+
+    Mostly a copy of httpx._decoders.LineDecoder, but as per SSE spec, only \r\n, \r,
+    and \n are treated as newlines, which differs from the behavior of splitlines()
+    used by httpx._decoders.LineDecoder.
+    """
+
+    def __init__(self) -> None:
+        self.buffer: list[str] = []
+        self.trailing_cr: bool = False
+
+    def decode(self, text: str) -> list[str]:
+        # We always push a trailing `\r` into the next decode iteration.
+        if self.trailing_cr:
+            text = "\r" + text
+            self.trailing_cr = False
+        if text.endswith("\r"):
+            self.trailing_cr = True
+            text = text[:-1]
+
+        if not text:
+            # NOTE: the edge case input of empty text doesn't occur in practice,
+            # because other httpx internals filter out this value
+            return []  # pragma: no cover
+
+        trailing_newline = text[-1] in "\n\r"
+        lines = _splitlines_sse(text)
+
+        if len(lines) == 1 and not trailing_newline:
+            # No new lines, buffer the input and continue.
+            self.buffer.append(lines[0])
+            return []
+
+        if self.buffer:
+            # Include any existing buffer in the first portion of the
+            # splitlines result.
+            lines = ["".join(self.buffer) + lines[0]] + lines[1:]
+            self.buffer = []
+
+        if not trailing_newline:
+            # If the last segment of splitlines is not newline terminated,
+            # then drop it from our output and start a new buffer.
+            self.buffer = [lines.pop()]
+
+        return lines
+
+    def flush(self) -> list[str]:
+        if not self.buffer and not self.trailing_cr:
+            return []
+
+        lines = ["".join(self.buffer)]
+        self.buffer = []
+        self.trailing_cr = False
+        return lines
+
+
+class SSEDecoder:
+    def __init__(self) -> None:
+        self._event = ""
+        self._data: List[str] = []
+        self._last_event_id = ""
+        self._retry: Optional[int] = None
+
+    def decode(self, line: str) -> Optional[ServerSentEvent]:
+        # See: https://html.spec.whatwg.org/multipage/server-sent-events.html#event-stream-interpretation  # noqa: E501
+
+        if not line:
+            if (
+                not self._event
+                and not self._data
+                and not self._last_event_id
+                and self._retry is None
+            ):
+                return None
+
+            sse = ServerSentEvent(
+                event=self._event,
+                data="\n".join(self._data),
+                id=self._last_event_id,
+                retry=self._retry,
+            )
+
+            # NOTE: as per the SSE spec, do not reset last_event_id.
+            self._event = ""
+            self._data = []
+            self._retry = None
+
+            return sse
+
+        if line.startswith(":"):
+            return None
+
+        fieldname, _, value = line.partition(":")
+
+        if value.startswith(" "):
+            value = value[1:]
+
+        if fieldname == "event":
+            self._event = value
+        elif fieldname == "data":
+            self._data.append(value)
+        elif fieldname == "id":
+            if "\0" in value:
+                pass
+            else:
+                self._last_event_id = value
+        elif fieldname == "retry":
+            try:
+                self._retry = int(value)
+            except (TypeError, ValueError):
+                pass
+        else:
+            pass  # Field is ignored.
+
+        return None

hai-mcp-pr7/.venv/lib/python3.13/site-packages/httpx_sse/_exceptions.py

@@ -0,0 +1,5 @@
+import httpx
+
+
+class SSEError(httpx.TransportError):
+    pass

hai-mcp-pr7/.venv/lib/python3.13/site-packages/httpx_sse/_models.py

@@ -0,0 +1,54 @@
+import json
+from typing import Any, Optional
+
+
+class ServerSentEvent:
+    def __init__(
+        self,
+        event: Optional[str] = None,
+        data: Optional[str] = None,
+        id: Optional[str] = None,
+        retry: Optional[int] = None,
+    ) -> None:
+        if not event:
+            event = "message"
+
+        if data is None:
+            data = ""
+
+        if id is None:
+            id = ""
+
+        self._event = event
+        self._data = data
+        self._id = id
+        self._retry = retry
+
+    @property
+    def event(self) -> str:
+        return self._event
+
+    @property
+    def data(self) -> str:
+        return self._data
+
+    @property
+    def id(self) -> str:
+        return self._id
+
+    @property
+    def retry(self) -> Optional[int]:
+        return self._retry
+
+    def json(self) -> Any:
+        return json.loads(self.data)
+
+    def __repr__(self) -> str:
+        pieces = [f"event={self.event!r}"]
+        if self.data != "":
+            pieces.append(f"data={self.data!r}")
+        if self.id != "":
+            pieces.append(f"id={self.id!r}")
+        if self.retry is not None:
+            pieces.append(f"retry={self.retry!r}")
+        return f"ServerSentEvent({', '.join(pieces)})"

hai-mcp-pr7/.venv/lib/python3.13/site-packages/idna-3.18.dist-info/INSTALLER

@@ -0,0 +1 @@
+uv

hai-mcp-pr7/.venv/lib/python3.13/site-packages/idna-3.18.dist-info/METADATA

@@ -0,0 +1,155 @@
+Metadata-Version: 2.4
+Name: idna
+Version: 3.18
+Summary: Internationalized Domain Names in Applications (IDNA)
+Author-email: Kim Davies <kim+pypi@gumleaf.org>
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-Expression: BSD-3-Clause
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Internet :: Name Service (DNS)
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+License-File: LICENSE.md
+Requires-Dist: ruff >= 0.6.2 ; extra == "all"
+Requires-Dist: mypy >= 1.11.2 ; extra == "all"
+Requires-Dist: pytest >= 8.3.2 ; extra == "all"
+Project-URL: Changelog, https://github.com/kjd/idna/blob/master/HISTORY.md
+Project-URL: Issue tracker, https://github.com/kjd/idna/issues
+Project-URL: Source, https://github.com/kjd/idna
+Provides-Extra: all
+
+# Internationalized Domain Names in Applications (IDNA)
+
+Support for [Internationalized Domain Names in Applications
+(IDNA)](https://tools.ietf.org/html/rfc5891) and [Unicode IDNA
+Compatibility Processing](https://unicode.org/reports/tr46/). It
+supersedes the standard library's `encodings.idna`, which only
+implements the 2003 specification, offering broader script coverage and
+limiting domains with known security vulnerabilities.
+
+## Usage
+
+Package may be installed from [PyPI](https://pypi.org/project/idna/) via
+the typical methods (e.g. `python3 -m pip install idna`)
+
+For typical usage, the `encode` and `decode` functions will take a
+domain name argument and perform a conversion to ASCII-compatible encoding
+(known as A-labels), or to Unicode strings (known as U-labels)
+respectively.
+
+```pycon
+>>> import idna
+>>> idna.encode('ドメイン.テスト')
+b'xn--eckwd4c7c.xn--zckzah'
+>>> print(idna.decode('xn--eckwd4c7c.xn--zckzah'))
+ドメイン.テスト
+```
+
+Conversions can be applied at a per-label basis using the `ulabel` or
+`alabel` functions for specialized use cases.
+
+
+### Compatibility Mapping (UTS #46)
+
+This library provides support for [Unicode IDNA Compatibility
+Processing](https://unicode.org/reports/tr46/) which normalizes input from
+different potential ways a user may input a domain prior to performing the IDNA
+conversion operations. This functionality, known as a
+[mapping](https://tools.ietf.org/html/rfc5895), is considered by the
+specification to be a local user-interface issue distinct from IDNA
+conversion functionality.
+
+For example, "Königsgäßchen" is not a permissible label as capital letters
+are not allowed. UTS 46 will convert this into lower case prior to applying
+the IDNA conversion.
+
+```pycon
+>>> import idna
+>>> idna.encode('Königsgäßchen')
+...
+idna.core.InvalidCodepoint: Codepoint U+004B at position 1 of 'Königsgäßchen' not allowed
+>>> idna.encode('Königsgäßchen', uts46=True)
+b'xn--knigsgchen-b4a3dun'
+>>> idna.decode('xn--knigsgchen-b4a3dun')
+'königsgäßchen'
+```
+
+When performing a decode operation for display purposes, `decode()`
+accepts a `display=True` argument that leaves any `xn--` label that
+fails to decode unchanged. This is useful for user interface display
+where a domain is in use, the A-label form can be presented when it
+is not a valid IDN.
+
+
+## Exceptions
+
+All errors raised during conversion derive from the `idna.IDNAError`
+base class. The more specific exceptions are:
+
+* `idna.IDNABidiError` — raised when a label contains an illegal
+  combination of left-to-right and right-to-left characters.
+* `idna.InvalidCodepoint` — raised when a label contains a codepoint
+  that is INVALID for IDNA.
+* `idna.InvalidCodepointContext` — raised when a CONTEXTO or CONTEXTJ
+  codepoint appears in a position whose contextual requirements are
+  not satisfied.
+
+
+## Command-line tool
+
+The package supports command-line usage to convert domain names
+between their Unicode and ASCII-compatible forms. It can be run either
+as a module (`python3 -m idna`) or, once installed (such as with `uv
+tool` or `pipx`), via the `idna` script:
+
+```bash
+$ uv tool install idna
+$ idna xn--e1afmkfd.xn--p1ai
+пример.рф
+$ idna пример.рф
+xn--e1afmkfd.xn--p1ai
+```
+
+Mode can be specified with `-e`/`--encode` or `-d`/`--decode`, otherwise
+it will be chosen automatically based on the first input. Multiple
+domains can be supplied either as arguments or through standard input.
+UTS #46 mapping is applied by default, which lets the tool accept
+inputs that aren't strictly valid IDNA 2008 by normalising them first,
+pass `--strict` to disable UTS #46.
+
+Conversion failures are reported on stderr together with the
+offending input; processing continues with the remaining domains and
+the tool exits with a non-zero status if any conversion failed.
+
+
+## Additional Notes
+
+* **Version support**. This library supports Python 3.9 and higher.
+  As this library serves as a low-level toolkit for a variety of
+  applications, we strive to support all versions of Python that are
+  not beyond end-of-life.
+
+* **Emoji**. It is an occasional request to support emoji domains in
+  this library. Encoding of symbols like emoji is expressly prohibited by
+  the IDNA technical standard, and emoji domains are broadly phased
+  out across the domain industry due to associated security risks.
+
+* **Regenerating lookup tables**. The IDNA and UTS 46 functionality
+  relies upon pre-calculated lookup tables, generated using the
+  `idna-data` script in [`tools/`](tools/README.md).
+

hai-mcp-pr7/.venv/lib/python3.13/site-packages/idna-3.18.dist-info/RECORD

@@ -0,0 +1,19 @@
+../../../bin/idna,sha256=DpM3F7tbov4G3PhMS4ABNVg-eKZCeW0DaKSiYqKvqyU,337
+idna-3.18.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+idna-3.18.dist-info/METADATA,sha256=Rt_m5axGLQ9oDs2avPZugptqIzSCS02eOXmzETXK8oE,6119
+idna-3.18.dist-info/RECORD,,
+idna-3.18.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+idna-3.18.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+idna-3.18.dist-info/entry_points.txt,sha256=7H3nGOHap3jnLE5e7q7Ywr9Vq8axB7WIj5-C_4N2vhw,38
+idna-3.18.dist-info/licenses/LICENSE.md,sha256=GppPDj1HmickDd1ZqRN6ZqtKD539yMphiMwL_YUYfwQ,1541
+idna/__init__.py,sha256=MPqNDLZbXqGaNdXxAFhiqFPKEQXju2jNQhCey6-5eJM,868
+idna/__main__.py,sha256=4JMK66Wj4uLZTKbF-sT3LAxOsr6buig77PmOkJCRRxw,83
+idna/cli.py,sha256=swqJLMNc8Uzs60KziNpbWnHuqlG3WRQwJSbo4n8xDAo,4139
+idna/codec.py,sha256=JRbo-f7pEkLdWeiH89Z72UR4VBYhvKDFrQBeNX6sRDE,5040
+idna/compat.py,sha256=AepA39ceRHxkfHP41-FvKW5Ki-f4PfUZ90RUMlCNdmo,1353
+idna/core.py,sha256=SfOr1xO3PoE0RDYx7bMciAnjiyjJPbPw_93AB5IUYOw,24685
+idna/idnadata.py,sha256=Af-mo8WBmkhAK6TyXKOQH88OX0mQNDKtdL7UWtQpppk,44862
+idna/intranges.py,sha256=g49scLSkqJtAhLmOODa7hVHriSjmb60tiTsEoocJdBI,1851
+idna/package_data.py,sha256=TeI94EqAFAFaXfBJwsOPUMLn2969uirPa-DaeaceAyU,21
+idna/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+idna/uts46data.py,sha256=jujNz5QqWMcJf-XYLv4X1jBvb5FlI0t6-e1mILsgbPk,234325

hai-mcp-pr7/.venv/lib/python3.13/site-packages/idna-3.18.dist-info/WHEEL

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

hai-mcp-pr7/.venv/lib/python3.13/site-packages/idna-3.18.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+idna=idna.cli:main
+

hai-mcp-pr7/.venv/lib/python3.13/site-packages/idna-3.18.dist-info/licenses/LICENSE.md

@@ -0,0 +1,31 @@
+BSD 3-Clause License
+
+Copyright (c) 2013-2026, Kim Davies and contributors.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+2. 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.
+
+3. 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.

hai-mcp-pr7/.venv/lib/python3.13/site-packages/idna/__init__.py

@@ -0,0 +1,45 @@
+from .core import (
+    IDNABidiError,
+    IDNAError,
+    InvalidCodepoint,
+    InvalidCodepointContext,
+    alabel,
+    check_bidi,
+    check_hyphen_ok,
+    check_initial_combiner,
+    check_label,
+    check_nfc,
+    decode,
+    encode,
+    ulabel,
+    uts46_remap,
+    valid_contextj,
+    valid_contexto,
+    valid_label_length,
+    valid_string_length,
+)
+from .intranges import intranges_contain
+from .package_data import __version__
+
+__all__ = [
+    "__version__",
+    "IDNABidiError",
+    "IDNAError",
+    "InvalidCodepoint",
+    "InvalidCodepointContext",
+    "alabel",
+    "check_bidi",
+    "check_hyphen_ok",
+    "check_initial_combiner",
+    "check_label",
+    "check_nfc",
+    "decode",
+    "encode",
+    "intranges_contain",
+    "ulabel",
+    "uts46_remap",
+    "valid_contextj",
+    "valid_contexto",
+    "valid_label_length",
+    "valid_string_length",
+]

hai-mcp-pr7/.venv/lib/python3.13/site-packages/idna/__main__.py

@@ -0,0 +1,6 @@
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

hai-mcp-pr7/.venv/lib/python3.13/site-packages/idna/cli.py

@@ -0,0 +1,128 @@
+"""Command-line interface for the :mod:`idna` package.
+
+Invoked via ``python -m idna``. See :func:`main` for the entry point.
+"""
+
+import argparse
+import sys
+from collections.abc import Iterable
+from itertools import chain
+from typing import IO, Optional
+
+from . import IDNAError, decode, encode
+from .core import _alabel_prefix, _unicode_dots_re
+from .package_data import __version__
+
+
+def _looks_like_alabel(s: str) -> bool:
+    """Return True if any label in ``s`` carries the ``xn--`` ACE prefix."""
+    prefix = _alabel_prefix.decode("ascii")
+    return any(label.lower().startswith(prefix) for label in _unicode_dots_re.split(s))
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="python -m idna",
+        description=(
+            "Convert a domain name between its Unicode (U-label) and "
+            "ASCII-compatible (A-label) forms. With no mode flag, the "
+            "direction is chosen from the first input — if it contains "
+            "an xn-- label the stream is decoded, otherwise it is "
+            "encoded — and the same mode is applied to every remaining "
+            "input. UTS #46 mapping is applied by default; pass "
+            "--strict to disable it. When no domains are given on the "
+            "command line and stdin is piped, one domain per line is "
+            "read from stdin."
+        ),
+    )
+    mode = parser.add_mutually_exclusive_group()
+    mode.add_argument(
+        "-e",
+        "--encode",
+        dest="mode",
+        action="store_const",
+        const="encode",
+        help="Encode the input to its ASCII A-label form.",
+    )
+    mode.add_argument(
+        "-d",
+        "--decode",
+        dest="mode",
+        action="store_const",
+        const="decode",
+        help="Decode the input from its ASCII A-label form.",
+    )
+    parser.add_argument(
+        "--strict",
+        action="store_true",
+        help="Disable the default UTS #46 mapping and apply IDNA 2008 rules verbatim.",
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"idna {__version__}",
+    )
+    parser.add_argument(
+        "domain",
+        nargs="*",
+        help="One or more domain names to convert. Omit to read from stdin.",
+    )
+    return parser
+
+
+def _iter_stdin(stream: IO[str]) -> Iterable[str]:
+    """Yield non-empty stripped lines from ``stream``, ignoring blanks."""
+    for line in stream:
+        stripped = line.strip()
+        if stripped:
+            yield stripped
+
+
+def _convert_one(domain: str, mode: str, uts46: bool) -> bool:
+    """Convert ``domain`` and write the result; return ``False`` on failure."""
+    try:
+        if mode == "decode":
+            print(decode(domain, uts46=uts46))
+        else:
+            print(encode(domain, uts46=uts46).decode("ascii"))
+    except IDNAError as err:
+        print(f"idna: {mode} failed for {domain!r}: {err}", file=sys.stderr)
+        return False
+    return True
+
+
+def main(argv: Optional[list[str]] = None) -> int:
+    """Entry point for ``python -m idna``.
+
+    When more than one domain is supplied (via positional arguments or
+    piped stdin) and no mode flag is given, the first input determines
+    the direction and that mode is applied uniformly to the rest.
+
+    :param argv: Argument list excluding the program name. Defaults to
+        :data:`sys.argv` when ``None``.
+    :returns: ``0`` on success, ``1`` if any conversion fails.
+    """
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+    uts46 = not args.strict
+
+    if args.domain:
+        domains: Iterable[str] = args.domain
+    elif not sys.stdin.isatty():
+        domains = _iter_stdin(sys.stdin)
+    else:
+        parser.error("a domain argument is required when stdin is a terminal")
+
+    iterator = iter(domains)
+    first = next(iterator, None)
+    if first is None:
+        return 0
+
+    mode = args.mode or ("decode" if _looks_like_alabel(first) else "encode")
+
+    results = [_convert_one(domain, mode, uts46) for domain in chain([first], iterator)]
+    return 0 if all(results) else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

hai-mcp-pr7/.venv/lib/python3.13/site-packages/idna/codec.py

@@ -0,0 +1,159 @@
+import codecs
+from typing import Any, Optional
+
+from .core import IDNAError, _unicode_dots_re, alabel, decode, encode, ulabel
+
+
+class Codec(codecs.Codec):
+    """Stateless IDNA 2008 codec.
+
+    Implements the :class:`codecs.Codec` protocol so that the whole-domain
+    encoder (:func:`idna.encode`) and decoder (:func:`idna.decode`) are
+    accessible through the standard codec machinery as ``"idna2008"``.
+
+    Only the ``"strict"`` error handler is supported; any other handler
+    raises :exc:`~idna.IDNAError`.
+    """
+
+    def encode(self, data: str, errors: str = "strict") -> tuple[bytes, int]:  # ty: ignore[invalid-method-override]
+        if errors != "strict":
+            raise IDNAError(f'Unsupported error handling "{errors}"')
+
+        if not data:
+            return b"", 0
+
+        return encode(data), len(data)
+
+    def decode(self, data: bytes, errors: str = "strict") -> tuple[str, int]:  # ty: ignore[invalid-method-override]
+        if errors != "strict":
+            raise IDNAError(f'Unsupported error handling "{errors}"')
+
+        if not data:
+            return "", 0
+
+        return decode(data), len(data)
+
+
+class IncrementalEncoder(codecs.BufferedIncrementalEncoder):
+    """Incremental IDNA 2008 encoder.
+
+    Buffers a partial trailing label across calls until either the next
+    label separator is seen or ``final=True``, so that streamed input is
+    encoded one whole label at a time. Any of the four Unicode label
+    separators (``U+002E``, ``U+3002``, ``U+FF0E``, ``U+FF61``) ends a
+    label; the result always uses ``U+002E`` as the separator.
+
+    Only the ``"strict"`` error handler is supported.
+    """
+
+    def _buffer_encode(self, data: str, errors: str, final: bool) -> tuple[bytes, int]:  # ty: ignore[invalid-method-override]
+        if errors != "strict":
+            raise IDNAError(f'Unsupported error handling "{errors}"')
+
+        if not data:
+            return b"", 0
+
+        labels = _unicode_dots_re.split(data)
+        trailing_dot = b""
+        if labels:
+            if not labels[-1]:
+                trailing_dot = b"."
+                del labels[-1]
+            elif not final:
+                # Keep potentially unfinished label until the next call
+                del labels[-1]
+                if labels:
+                    trailing_dot = b"."
+
+        result = []
+        size = 0
+        for label in labels:
+            result.append(alabel(label))
+            if size:
+                size += 1
+            size += len(label)
+
+        # Join with U+002E
+        result_bytes = b".".join(result) + trailing_dot
+        size += len(trailing_dot)
+        return result_bytes, size
+
+
+class IncrementalDecoder(codecs.BufferedIncrementalDecoder):
+    """Incremental IDNA 2008 decoder.
+
+    Buffers a partial trailing label across calls until either the next
+    label separator is seen or ``final=True``, so that streamed input is
+    decoded one whole label at a time.
+
+    Only the ``"strict"`` error handler is supported.
+    """
+
+    def _buffer_decode(self, data: Any, errors: str, final: bool) -> tuple[str, int]:  # ty: ignore[invalid-method-override]
+        if errors != "strict":
+            raise IDNAError(f'Unsupported error handling "{errors}"')
+
+        if not data:
+            return ("", 0)
+
+        if not isinstance(data, str):
+            data = str(data, "ascii")
+
+        labels = _unicode_dots_re.split(data)
+        trailing_dot = ""
+        if labels:
+            if not labels[-1]:
+                trailing_dot = "."
+                del labels[-1]
+            elif not final:
+                # Keep potentially unfinished label until the next call
+                del labels[-1]
+                if labels:
+                    trailing_dot = "."
+
+        result = []
+        size = 0
+        for label in labels:
+            result.append(ulabel(label))
+            if size:
+                size += 1
+            size += len(label)
+
+        result_str = ".".join(result) + trailing_dot
+        size += len(trailing_dot)
+        return (result_str, size)
+
+
+class StreamWriter(Codec, codecs.StreamWriter):
+    pass
+
+
+class StreamReader(Codec, codecs.StreamReader):
+    pass
+
+
+def search_function(name: str) -> Optional[codecs.CodecInfo]:
+    """Codec search function registered with :mod:`codecs`.
+
+    Returns a :class:`codecs.CodecInfo` for the ``"idna2008"`` codec name
+    so that ``str.encode("idna2008")`` and ``bytes.decode("idna2008")``
+    invoke the IDNA 2008 codec defined in this module.
+
+    :param name: The codec name being looked up.
+    :returns: A :class:`codecs.CodecInfo` instance if ``name`` is
+        ``"idna2008"``, otherwise ``None``.
+    """
+    if name != "idna2008":
+        return None
+    return codecs.CodecInfo(
+        name=name,
+        encode=Codec().encode,
+        decode=Codec().decode,  # type: ignore
+        incrementalencoder=IncrementalEncoder,
+        incrementaldecoder=IncrementalDecoder,
+        streamwriter=StreamWriter,
+        streamreader=StreamReader,
+    )
+
+
+codecs.register(search_function)

hai-mcp-pr7/.venv/lib/python3.13/site-packages/idna/compat.py

@@ -0,0 +1,41 @@
+from typing import Any, Union
+
+from .core import decode, encode
+
+
+def ToASCII(label: str) -> bytes:
+    """Compatibility shim for :rfc:`3490` ``ToASCII``.
+
+    Delegates to :func:`idna.encode` (IDNA 2008). Provided to ease porting
+    of code written against the legacy :mod:`encodings.idna` API; new code
+    should call :func:`idna.encode` directly.
+
+    :param label: The label or domain to encode.
+    :returns: The encoded form as ASCII :class:`bytes`.
+    """
+    return encode(label)
+
+
+def ToUnicode(label: Union[bytes, bytearray]) -> str:
+    """Compatibility shim for :rfc:`3490` ``ToUnicode``.
+
+    Delegates to :func:`idna.decode` (IDNA 2008). Provided to ease porting
+    of code written against the legacy :mod:`encodings.idna` API; new code
+    should call :func:`idna.decode` directly.
+
+    :param label: The label or domain to decode.
+    :returns: The decoded Unicode form.
+    """
+    return decode(label)
+
+
+def nameprep(s: Any) -> None:
+    """Stub for :rfc:`3491` Nameprep, which is not used by IDNA 2008.
+
+    IDNA 2008 (:rfc:`5891`) replaces Nameprep with the per-codepoint
+    validity classes from :rfc:`5892`; this function exists only to
+    return a clear error if legacy code attempts to call it.
+
+    :raises NotImplementedError: Always.
+    """
+    raise NotImplementedError("IDNA 2008 does not utilise nameprep protocol")

hai-mcp-pr7/.venv/lib/python3.13/site-packages/idna/core.py

@@ -0,0 +1,648 @@
+import bisect
+import re
+import unicodedata
+import warnings
+from typing import Optional, Union
+
+from . import idnadata
+from .intranges import intranges_contain
+
+_virama_combining_class = 9
+_alabel_prefix = b"xn--"
+_max_input_length = 1024
+_unicode_dots_re = re.compile("[\u002e\u3002\uff0e\uff61]")
+
+
+# Bidi category sets from RFC 5893, hoisted out of the per-codepoint loop
+_bidi_rtl_first = frozenset({"R", "AL"})
+_bidi_rtl_categories = frozenset({"R", "AL", "AN"})
+_bidi_rtl_allowed = frozenset({"R", "AL", "AN", "EN", "ES", "CS", "ET", "ON", "BN", "NSM"})
+_bidi_rtl_valid_ending = frozenset({"R", "AL", "EN", "AN"})
+_bidi_rtl_numeric = frozenset({"AN", "EN"})
+_bidi_ltr_allowed = frozenset({"L", "EN", "ES", "CS", "ET", "ON", "BN", "NSM"})
+_bidi_ltr_valid_ending = frozenset({"L", "EN"})
+_bidi_joiner_l_or_d = frozenset({"L", "D"})
+_bidi_joiner_r_or_d = frozenset({"R", "D"})
+
+
+def _joining_type(cp: int) -> Optional[str]:
+    for jt, ranges in idnadata.joining_types.items():
+        if intranges_contain(cp, ranges):
+            return jt
+    return None
+
+
+class IDNAError(UnicodeError):
+    """Base exception for all IDNA-encoding related problems"""
+
+
+class IDNABidiError(IDNAError):
+    """Exception when bidirectional requirements are not satisfied"""
+
+
+class InvalidCodepoint(IDNAError):
+    """Exception when a disallowed or unallocated codepoint is used"""
+
+
+class InvalidCodepointContext(IDNAError):
+    """Exception when the codepoint is not valid in the context it is used"""
+
+
+def _combining_class(cp: int) -> int:
+    v = unicodedata.combining(chr(cp))
+    if v == 0 and not unicodedata.name(chr(cp)):
+        raise ValueError("Unknown character in unicodedata")
+    return v
+
+
+def _is_script(cp: str, script: str) -> bool:
+    return intranges_contain(ord(cp), idnadata.scripts[script])
+
+
+def _punycode(s: str) -> bytes:
+    return s.encode("punycode")
+
+
+def _unot(s: int) -> str:
+    return f"U+{s:04X}"
+
+
+def valid_label_length(label: Union[bytes, str]) -> bool:
+    """Check that a label does not exceed the maximum permitted length.
+
+    Per :rfc:`1035` (and :rfc:`5891` §4.2.4) a DNS label must not exceed
+    63 octets. The argument may be either a :class:`str` (a U-label, where
+    length is measured in characters) or :class:`bytes` (an A-label, where
+    length is measured in octets).
+
+    :param label: The label to check.
+    :returns: ``True`` if the label is within the length limit, otherwise
+        ``False``.
+    """
+    return len(label) <= 63
+
+
+def valid_string_length(domain: Union[bytes, str], trailing_dot: bool) -> bool:
+    """Check that a full domain name does not exceed the maximum length.
+
+    Per :rfc:`1035`, a domain name is limited to 253 octets when no trailing
+    dot is present, or 254 octets when one is included.
+
+    :param domain: The full (possibly multi-label) domain name.
+    :param trailing_dot: ``True`` if ``domain`` includes a trailing ``.``.
+    :returns: ``True`` if the domain is within the length limit, otherwise
+        ``False``.
+    """
+    return len(domain) <= (254 if trailing_dot else 253)
+
+
+def check_bidi(label: str, check_ltr: bool = False) -> bool:
+    """Validate the Bidi Rule from :rfc:`5893` for a single label.
+
+    The Bidi Rule constrains how bidirectional characters (Hebrew, Arabic,
+    etc.) may appear within a label. By default the check is only applied
+    when the label contains at least one right-to-left character (Unicode
+    bidirectional categories ``R``, ``AL``, or ``AN``); set ``check_ltr``
+    to ``True`` to apply it to LTR-only labels as well.
+
+    :param label: The label to validate, as a Unicode string.
+    :param check_ltr: If ``True``, apply the rules even when the label
+        contains no RTL characters.
+    :returns: ``True`` if the label satisfies the Bidi Rule.
+    :raises IDNABidiError: If any of Bidi Rule conditions 1-6 are violated,
+        or if the directional category of a codepoint cannot be determined.
+    """
+    if len(label) > _max_input_length:
+        raise IDNAError("Label too long")
+    # Bidi rules should only be applied if string contains RTL characters
+    bidi_label = False
+    for idx, cp in enumerate(label, 1):
+        direction = unicodedata.bidirectional(cp)
+        if direction == "":
+            # String likely comes from a newer version of Unicode
+            raise IDNABidiError(f"Unknown directionality in label {label!r} at position {idx}")
+        if direction in _bidi_rtl_categories:
+            bidi_label = True
+    if not bidi_label and not check_ltr:
+        return True
+
+    # Bidi rule 1
+    direction = unicodedata.bidirectional(label[0])
+    if direction in _bidi_rtl_first:
+        rtl = True
+    elif direction == "L":
+        rtl = False
+    else:
+        raise IDNABidiError(f"First codepoint in label {label!r} must be directionality L, R or AL")
+
+    valid_ending = False
+    number_type: Optional[str] = None
+    for idx, cp in enumerate(label, 1):
+        direction = unicodedata.bidirectional(cp)
+
+        if rtl:
+            # Bidi rule 2
+            if direction not in _bidi_rtl_allowed:
+                raise IDNABidiError(f"Invalid direction for codepoint at position {idx} in a right-to-left label")
+            # Bidi rule 3
+            if direction in _bidi_rtl_valid_ending:
+                valid_ending = True
+            elif direction != "NSM":
+                valid_ending = False
+            # Bidi rule 4
+            if direction in _bidi_rtl_numeric:
+                if not number_type:
+                    number_type = direction
+                elif number_type != direction:
+                    raise IDNABidiError("Can not mix numeral types in a right-to-left label")
+        else:
+            # Bidi rule 5
+            if direction not in _bidi_ltr_allowed:
+                raise IDNABidiError(f"Invalid direction for codepoint at position {idx} in a left-to-right label")
+            # Bidi rule 6
+            if direction in _bidi_ltr_valid_ending:
+                valid_ending = True
+            elif direction != "NSM":
+                valid_ending = False
+
+    if not valid_ending:
+        raise IDNABidiError("Label ends with illegal codepoint directionality")
+
+    return True
+
+
+def check_initial_combiner(label: str) -> bool:
+    """Reject labels that begin with a combining mark.
+
+    Per :rfc:`5891` §4.2.3.2 a label must not start with a character of
+    Unicode general category ``M`` (Mark).
+
+    :param label: The label to check.
+    :returns: ``True`` if the first character is not a combining mark.
+    :raises IDNAError: If the label begins with a combining character.
+    """
+    if unicodedata.category(label[0])[0] == "M":
+        raise IDNAError("Label begins with an illegal combining character")
+    return True
+
+
+def check_hyphen_ok(label: str) -> bool:
+    """Validate the hyphen restrictions for a label.
+
+    Per :rfc:`5891` §4.2.3.1 a label must not start or end with a hyphen
+    (``U+002D``), and must not have hyphens in both the third and fourth
+    positions (the prefix reserved for A-labels).
+
+    :param label: The label to check.
+    :returns: ``True`` if the hyphen restrictions are satisfied.
+    :raises IDNAError: If any of the hyphen restrictions are violated.
+    """
+    if label[2:4] == "--":
+        raise IDNAError("Label has disallowed hyphens in 3rd and 4th position")
+    if label[0] == "-" or label[-1] == "-":
+        raise IDNAError("Label must not start or end with a hyphen")
+    return True
+
+
+def check_nfc(label: str) -> None:
+    """Require that a label is in Unicode Normalization Form C.
+
+    :param label: The label to check.
+    :raises IDNAError: If ``label`` differs from its NFC normalisation.
+    """
+    if len(label) > _max_input_length:
+        raise IDNAError("Label too long")
+    if unicodedata.normalize("NFC", label) != label:
+        raise IDNAError("Label must be in Normalization Form C")
+
+
+def valid_contextj(label: str, pos: int) -> bool:
+    """Validate the CONTEXTJ rules from :rfc:`5892` Appendix A.
+
+    These rules govern the contextual use of the joiner codepoints
+    ``U+200C`` (ZERO WIDTH NON-JOINER, Appendix A.1) and ``U+200D``
+    (ZERO WIDTH JOINER, Appendix A.2) within a label.
+
+    :param label: The label containing the codepoint.
+    :param pos: Index of the joiner codepoint within ``label``.
+    :returns: ``True`` if the codepoint at ``pos`` satisfies its CONTEXTJ
+        rule, ``False`` otherwise (including when the codepoint at
+        ``pos`` is not a recognised joiner).
+    :raises ValueError: If an adjacent codepoint has no Unicode name when
+        determining its combining class.
+    :raises IDNAError: If ``label`` exceeds the defensive input length limit.
+    """
+    if len(label) > _max_input_length:
+        raise IDNAError("Label too long")
+    cp_value = ord(label[pos])
+
+    if cp_value == 0x200C:
+        if pos > 0 and _combining_class(ord(label[pos - 1])) == _virama_combining_class:
+            return True
+
+        ok = False
+        for i in range(pos - 1, -1, -1):
+            joining_type = _joining_type(ord(label[i]))
+            if joining_type == "T":
+                continue
+            if joining_type in _bidi_joiner_l_or_d:
+                ok = True
+                break
+            break
+
+        if not ok:
+            return False
+
+        ok = False
+        for i in range(pos + 1, len(label)):
+            joining_type = _joining_type(ord(label[i]))
+            if joining_type == "T":
+                continue
+            if joining_type in _bidi_joiner_r_or_d:
+                ok = True
+                break
+            break
+        return ok
+
+    if cp_value == 0x200D:
+        return pos > 0 and _combining_class(ord(label[pos - 1])) == _virama_combining_class
+
+    return False
+
+
+def valid_contexto(label: str, pos: int, exception: bool = False) -> bool:
+    """Validate the CONTEXTO rules from :rfc:`5892` Appendix A.
+
+    Covers the contextual rules for codepoints such as MIDDLE DOT
+    (``U+00B7``), Greek lower numeral sign, Hebrew punctuation, Katakana
+    middle dot, and the Arabic-Indic / Extended Arabic-Indic digit ranges.
+
+    :param label: The label containing the codepoint.
+    :param pos: Index of the codepoint within ``label``.
+    :param exception: Reserved for forward compatibility; currently unused.
+    :returns: ``True`` if the codepoint at ``pos`` satisfies its CONTEXTO
+        rule, ``False`` otherwise (including when the codepoint is not a
+        recognised CONTEXTO codepoint).
+    :raises IDNAError: If ``label`` exceeds the defensive input length limit.
+    """
+    if len(label) > _max_input_length:
+        raise IDNAError("Label too long")
+    cp_value = ord(label[pos])
+
+    if cp_value == 0x00B7:
+        return 0 < pos < len(label) - 1 and ord(label[pos - 1]) == 0x006C and ord(label[pos + 1]) == 0x006C
+
+    if cp_value == 0x0375:
+        if pos < len(label) - 1 and len(label) > 1:
+            return _is_script(label[pos + 1], "Greek")
+        return False
+
+    if cp_value in {0x05F3, 0x05F4}:
+        if pos > 0:
+            return _is_script(label[pos - 1], "Hebrew")
+        return False
+
+    if cp_value == 0x30FB:
+        for cp in label:
+            if cp == "\u30fb":
+                continue
+            if _is_script(cp, "Hiragana") or _is_script(cp, "Katakana") or _is_script(cp, "Han"):
+                return True
+        return False
+
+    if 0x660 <= cp_value <= 0x669:
+        return not any(0x6F0 <= ord(cp) <= 0x06F9 for cp in label)
+
+    if 0x6F0 <= cp_value <= 0x6F9:
+        return not any(0x660 <= ord(cp) <= 0x0669 for cp in label)
+
+    return False
+
+
+def check_label(label: Union[str, bytes, bytearray]) -> None:
+    """Run the full set of IDNA 2008 validity checks on a single label.
+
+    Applies, in order: NFC normalisation (:func:`check_nfc`), hyphen
+    restrictions (:func:`check_hyphen_ok`), the no-leading-combiner rule
+    (:func:`check_initial_combiner`), per-codepoint validity (PVALID,
+    CONTEXTJ, CONTEXTO classes from :rfc:`5892`), and the Bidi Rule
+    (:func:`check_bidi`).
+
+    :param label: The label to validate. ``bytes`` or ``bytearray`` input
+        is decoded as UTF-8 first.
+    :raises IDNAError: If the label is empty or fails a structural rule.
+    :raises InvalidCodepoint: If the label contains a DISALLOWED or
+        UNASSIGNED codepoint.
+    :raises InvalidCodepointContext: If a CONTEXTJ or CONTEXTO codepoint
+        is not valid in its context.
+    :raises IDNABidiError: If the Bidi Rule is violated.
+    """
+    if len(label) > _max_input_length:
+        raise IDNAError("Label too long")
+    if isinstance(label, (bytes, bytearray)):
+        label = label.decode("utf-8")
+    if len(label) == 0:
+        raise IDNAError("Empty Label")
+
+    # Reject on domain length rather than label length so support some UTS 46
+    # use cases, still reducing processing of label contextual rules
+    if not valid_string_length(label, trailing_dot=True):
+        raise IDNAError("Label too long")
+
+    check_nfc(label)
+    check_hyphen_ok(label)
+    check_initial_combiner(label)
+
+    for pos, cp in enumerate(label):
+        cp_value = ord(cp)
+        if intranges_contain(cp_value, idnadata.codepoint_classes["PVALID"]):
+            continue
+        if intranges_contain(cp_value, idnadata.codepoint_classes["CONTEXTJ"]):
+            try:
+                if not valid_contextj(label, pos):
+                    raise InvalidCodepointContext(f"Joiner {_unot(cp_value)} not allowed at position {pos + 1} in {label!r}")
+            except ValueError as err:
+                raise IDNAError(
+                    f"Unknown codepoint adjacent to joiner {_unot(cp_value)} at position {pos + 1} in {label!r}"
+                ) from err
+        elif intranges_contain(cp_value, idnadata.codepoint_classes["CONTEXTO"]):
+            if not valid_contexto(label, pos):
+                raise InvalidCodepointContext(f"Codepoint {_unot(cp_value)} not allowed at position {pos + 1} in {label!r}")
+        else:
+            raise InvalidCodepoint(f"Codepoint {_unot(cp_value)} at position {pos + 1} of {label!r} not allowed")
+
+    check_bidi(label)
+
+
+def alabel(label: str) -> bytes:
+    """Convert a single U-label into its A-label form.
+
+    The result is the ASCII-Compatible Encoding (ACE) form per :rfc:`5891`
+    §4: the label is validated, Punycode-encoded, and prefixed with
+    ``xn--``. Pure ASCII labels that are already valid IDNA labels are
+    returned unchanged (as :class:`bytes`).
+
+    :param label: The label to convert, as a Unicode string.
+    :returns: The A-label as ASCII-encoded :class:`bytes`.
+    :raises IDNAError: If the label is invalid or the resulting A-label
+        exceeds 63 octets.
+    """
+    if len(label) > _max_input_length:
+        raise IDNAError("Label too long")
+    try:
+        label_bytes = label.encode("ascii")
+    except UnicodeEncodeError:
+        pass
+    else:
+        ulabel(label_bytes)
+        if not valid_label_length(label_bytes):
+            raise IDNAError("Label too long")
+        return label_bytes
+
+    check_label(label)
+    label_bytes = _alabel_prefix + _punycode(label)
+
+    if not valid_label_length(label_bytes):
+        raise IDNAError("Label too long")
+
+    return label_bytes
+
+
+def ulabel(label: Union[str, bytes, bytearray]) -> str:
+    """Convert a single A-label into its U-label form.
+
+    Performs the inverse of :func:`alabel`: an ``xn--``-prefixed label is
+    Punycode-decoded and validated. Labels that are already Unicode (or
+    plain ASCII without the ACE prefix) are validated and returned as a
+    Unicode string.
+
+    :param label: The label to convert. ``bytes`` or ``bytearray`` input
+        is treated as ASCII.
+    :returns: The U-label as a Unicode string.
+    :raises IDNAError: If the label is malformed or fails validation.
+    """
+    if len(label) > _max_input_length:
+        raise IDNAError("Label too long")
+    if not isinstance(label, (bytes, bytearray)):
+        try:
+            label_bytes = label.encode("ascii")
+        except UnicodeEncodeError:
+            check_label(label)
+            return label
+    else:
+        label_bytes = bytes(label)
+
+    label_bytes = label_bytes.lower()
+    if label_bytes.startswith(_alabel_prefix):
+        label_bytes = label_bytes[len(_alabel_prefix) :]
+        if not label_bytes:
+            raise IDNAError("Malformed A-label, no Punycode eligible content found")
+        if label_bytes.endswith(b"-"):
+            raise IDNAError("A-label must not end with a hyphen")
+    else:
+        check_label(label_bytes)
+        return label_bytes.decode("ascii")
+
+    try:
+        label = label_bytes.decode("punycode")
+    except UnicodeError as err:
+        raise IDNAError("Invalid A-label") from err
+    check_label(label)
+    return label
+
+
+def uts46_remap(domain: str, std3_rules: bool = True, transitional: bool = False) -> str:
+    """Apply the UTS #46 character mapping to a domain string.
+
+    Implements the mapping table from `UTS #46 §4
+    <https://www.unicode.org/reports/tr46/>`_: each character is kept,
+    replaced, or rejected based on its status (``V``, ``M``, ``D``, ``3``,
+    ``I``). The result is returned in Normalisation Form C.
+
+    :param domain: The full domain name to remap.
+    :param std3_rules: If ``True``, apply the stricter STD3 ASCII rules
+        (status ``3`` codepoints raise instead of being kept or mapped).
+    :param transitional: If ``True``, use transitional processing (status
+        ``D`` codepoints are mapped instead of kept). Transitional
+        processing has been removed from UTS #46 and this option is
+        retained only for backwards compatibility.
+    :returns: The remapped domain, in Normalisation Form C.
+    :raises InvalidCodepoint: If the domain contains a disallowed
+        codepoint under the chosen rules.
+    :raises IDNAError: If ``domain`` exceeds the defensive input length limit.
+    """
+    if len(domain) > _max_input_length:
+        raise IDNAError("Domain too long")
+    from .uts46data import uts46_replacements, uts46_starts, uts46_statuses
+
+    output = ""
+
+    for pos, char in enumerate(domain):
+        code_point = ord(char)
+        i = code_point if code_point < 256 else bisect.bisect_right(uts46_starts, code_point) - 1
+        status = chr(uts46_statuses[i])
+        replacement: Optional[str] = uts46_replacements[i]
+
+        # UTS #46 §4: V is always valid, D is deviation (kept unless transitional),
+        # 3 is disallowed-STD3 (kept unmapped if std3_rules is off and no mapping).
+        keep_as_is = (
+            status == "V" or (status == "D" and not transitional) or (status == "3" and not std3_rules and replacement is None)
+        )
+        # M is mapped, 3-with-replacement and transitional D fall through to the
+        # same replacement output path.
+        use_replacement = replacement is not None and (
+            status == "M" or (status == "3" and not std3_rules) or (status == "D" and transitional)
+        )
+
+        if keep_as_is:
+            output += char
+        elif use_replacement:
+            assert replacement is not None  # narrowed by use_replacement
+            output += replacement
+        elif status == "I":
+            continue
+        else:
+            raise InvalidCodepoint(f"Codepoint {_unot(code_point)} not allowed at position {pos + 1} in {domain!r}")
+
+    return unicodedata.normalize("NFC", output)
+
+
+def encode(
+    s: Union[str, bytes, bytearray],
+    strict: bool = False,
+    uts46: bool = False,
+    std3_rules: bool = False,
+    transitional: bool = False,
+) -> bytes:
+    """Encode a Unicode domain name into its ASCII (A-label) form.
+
+    Splits the input on label separators (only ``U+002E`` if ``strict`` is
+    set; otherwise also IDEOGRAPHIC FULL STOP ``U+3002``, FULLWIDTH FULL
+    STOP ``U+FF0E``, and HALFWIDTH IDEOGRAPHIC FULL STOP ``U+FF61``),
+    encodes each label with :func:`alabel`, and rejoins them with ``.``.
+    Optionally pre-processes the input through :func:`uts46_remap`.
+
+    :param s: The domain name to encode.
+    :param strict: If ``True``, only ``U+002E`` is recognised as a label
+        separator.
+    :param uts46: If ``True``, apply UTS #46 mapping before encoding.
+    :param std3_rules: Forwarded to :func:`uts46_remap` when ``uts46`` is
+        ``True``.
+    :param transitional: Forwarded to :func:`uts46_remap` when ``uts46``
+        is ``True``. Deprecated: emits a :class:`DeprecationWarning` and
+        will be removed in a future version.
+    :returns: The encoded domain as ASCII :class:`bytes`.
+    :raises IDNAError: If the domain is empty, contains an invalid label,
+        or exceeds the maximum domain length.
+    """
+    if transitional:
+        warnings.warn(
+            "Transitional processing has been removed from UTS #46. "
+            "The transitional argument will be removed in a future version.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+    if not isinstance(s, str):
+        try:
+            s = str(s, "ascii")
+        except (UnicodeDecodeError, TypeError) as err:
+            raise IDNAError("should pass a unicode string to the function rather than a byte string.") from err
+    if len(s) > _max_input_length:
+        raise IDNAError("Domain too long")
+    if uts46:
+        s = uts46_remap(s, std3_rules, transitional)
+
+    # Reject inputs that exceed the maximum DNS domain length up-front
+    # to avoid expensive computation on long inputs.
+    if not valid_string_length(s, trailing_dot=True):
+        raise IDNAError("Domain too long")
+
+    trailing_dot = False
+    result = []
+    labels = s.split(".") if strict else _unicode_dots_re.split(s)
+    if not labels or labels == [""]:
+        raise IDNAError("Empty domain")
+    if labels[-1] == "":
+        del labels[-1]
+        trailing_dot = True
+    for label in labels:
+        s = alabel(label)
+        if s:
+            result.append(s)
+        else:
+            raise IDNAError("Empty label")
+    if trailing_dot:
+        result.append(b"")
+    s = b".".join(result)
+    if not valid_string_length(s, trailing_dot):
+        raise IDNAError("Domain too long")
+    return s
+
+
+def decode(
+    s: Union[str, bytes, bytearray],
+    strict: bool = False,
+    uts46: bool = False,
+    std3_rules: bool = False,
+    display: bool = False,
+) -> str:
+    """Decode an A-label-encoded domain name back to Unicode.
+
+    Splits the input on label separators (see :func:`encode` for the
+    rules), decodes each label with :func:`ulabel`, and rejoins them
+    with ``.``. Optionally pre-processes the input through
+    :func:`uts46_remap`.
+
+    :param s: The domain name to decode.
+    :param strict: If ``True``, only ``U+002E`` is recognised as a label
+        separator.
+    :param uts46: If ``True``, apply UTS #46 mapping before decoding.
+    :param std3_rules: Forwarded to :func:`uts46_remap` when ``uts46`` is
+        ``True``.
+    :param display: If ``True``, any ``xn--`` label that fails IDNA
+        validation is passed through unchanged (lowercased) rather than
+        aborting the whole call. Intended for "decode for display"
+        consumers (e.g. URL libraries, HTTP clients) that want to show
+        the user the label as it appears on the wire when it cannot be
+        rendered as Unicode. Matches the per-label recovery prescribed
+        by UTS #46 §4 and the WHATWG URL "domain to Unicode" algorithm.
+    :returns: The decoded domain as a Unicode string.
+    :raises IDNAError: If the input is not valid ASCII, contains an
+        invalid label, or is empty.
+    """
+    if not isinstance(s, str):
+        try:
+            s = str(s, "ascii")
+        except (UnicodeDecodeError, TypeError) as err:
+            raise IDNAError("Invalid ASCII in A-label") from err
+    if len(s) > _max_input_length:
+        raise IDNAError("Domain too long")
+    if uts46:
+        s = uts46_remap(s, std3_rules, False)
+    # Reject inputs that exceed the maximum DNS domain length up-front
+    # to avoid expensive computation on long inputs.
+    if not valid_string_length(s, trailing_dot=True):
+        raise IDNAError("Domain too long")
+    trailing_dot = False
+    result = []
+    labels = s.split(".") if strict else _unicode_dots_re.split(s)
+    if not labels or labels == [""]:
+        raise IDNAError("Empty domain")
+    if not labels[-1]:
+        del labels[-1]
+        trailing_dot = True
+    for label in labels:
+        try:
+            u = ulabel(label)
+        except IDNAError:
+            if display and label[:4].lower() == "xn--":
+                u = label.lower()
+            else:
+                raise
+        if u:
+            result.append(u)
+        else:
+            raise IDNAError("Empty label")
+    if trailing_dot:
+        result.append("")
+    return ".".join(result)

hai-mcp-pr7/.venv/lib/python3.13/site-packages/idna/idnadata.py

@@ -0,0 +1,1897 @@
+# This file is automatically generated by tools/idna-data
+
+__version__ = "17.0.0"
+
+scripts = {
+    "Greek": (
+        0x37000000374,
+        0x37500000378,
+        0x37A0000037E,
+        0x37F00000380,
+        0x38400000385,
+        0x38600000387,
+        0x3880000038B,
+        0x38C0000038D,
+        0x38E000003A2,
+        0x3A3000003E2,
+        0x3F000000400,
+        0x1D2600001D2B,
+        0x1D5D00001D62,
+        0x1D6600001D6B,
+        0x1DBF00001DC0,
+        0x1F0000001F16,
+        0x1F1800001F1E,
+        0x1F2000001F46,
+        0x1F4800001F4E,
+        0x1F5000001F58,
+        0x1F5900001F5A,
+        0x1F5B00001F5C,
+        0x1F5D00001F5E,
+        0x1F5F00001F7E,
+        0x1F8000001FB5,
+        0x1FB600001FC5,
+        0x1FC600001FD4,
+        0x1FD600001FDC,
+        0x1FDD00001FF0,
+        0x1FF200001FF5,
+        0x1FF600001FFF,
+        0x212600002127,
+        0xAB650000AB66,
+        0x101400001018F,
+        0x101A0000101A1,
+        0x1D2000001D246,
+    ),
+    "Han": (
+        0x2E8000002E9A,
+        0x2E9B00002EF4,
+        0x2F0000002FD6,
+        0x300500003006,
+        0x300700003008,
+        0x30210000302A,
+        0x30380000303C,
+        0x340000004DC0,
+        0x4E000000A000,
+        0xF9000000FA6E,
+        0xFA700000FADA,
+        0x16FE200016FE4,
+        0x16FF000016FF7,
+        0x200000002A6E0,
+        0x2A7000002B81E,
+        0x2B8200002CEAE,
+        0x2CEB00002EBE1,
+        0x2EBF00002EE5E,
+        0x2F8000002FA1E,
+        0x300000003134B,
+        0x313500003347A,
+    ),
+    "Hebrew": (
+        0x591000005C8,
+        0x5D0000005EB,
+        0x5EF000005F5,
+        0xFB1D0000FB37,
+        0xFB380000FB3D,
+        0xFB3E0000FB3F,
+        0xFB400000FB42,
+        0xFB430000FB45,
+        0xFB460000FB50,
+    ),
+    "Hiragana": (
+        0x304100003097,
+        0x309D000030A0,
+        0x1B0010001B120,
+        0x1B1320001B133,
+        0x1B1500001B153,
+        0x1F2000001F201,
+    ),
+    "Katakana": (
+        0x30A1000030FB,
+        0x30FD00003100,
+        0x31F000003200,
+        0x32D0000032FF,
+        0x330000003358,
+        0xFF660000FF70,
+        0xFF710000FF9E,
+        0x1AFF00001AFF4,
+        0x1AFF50001AFFC,
+        0x1AFFD0001AFFF,
+        0x1B0000001B001,
+        0x1B1200001B123,
+        0x1B1550001B156,
+        0x1B1640001B168,
+    ),
+}
+
+
+joining_types = {
+    "C": (
+        0x64000000641,
+        0x7FA000007FB,
+        0x88300000886,
+        0x180A0000180B,
+        0x200D0000200E,
+    ),
+    "D": (
+        0x62000000621,
+        0x62600000627,
+        0x62800000629,
+        0x62A0000062F,
+        0x63300000640,
+        0x64100000648,
+        0x6490000064B,
+        0x66E00000670,
+        0x67800000688,
+        0x69A000006C0,
+        0x6C1000006C3,
+        0x6CC000006CD,
+        0x6CE000006CF,
+        0x6D0000006D2,
+        0x6FA000006FD,
+        0x6FF00000700,
+        0x71200000715,
+        0x71A0000071E,
+        0x71F00000728,
+        0x7290000072A,
+        0x72B0000072C,
+        0x72D0000072F,
+        0x74E00000759,
+        0x75C0000076B,
+        0x76D00000771,
+        0x77200000773,
+        0x77500000778,
+        0x77A00000780,
+        0x7CA000007EB,
+        0x84100000846,
+        0x84800000849,
+        0x84A00000854,
+        0x85500000856,
+        0x86000000861,
+        0x86200000866,
+        0x86800000869,
+        0x88600000887,
+        0x8890000088E,
+        0x88F00000890,
+        0x8A0000008AA,
+        0x8AF000008B1,
+        0x8B3000008B9,
+        0x8BA000008C9,
+        0x180700001808,
+        0x182000001879,
+        0x1887000018A9,
+        0x18AA000018AB,
+        0xA8400000A872,
+        0x10AC000010AC5,
+        0x10AD300010AD7,
+        0x10AD800010ADD,
+        0x10ADE00010AE1,
+        0x10AEB00010AEF,
+        0x10B8000010B81,
+        0x10B8200010B83,
+        0x10B8600010B89,
+        0x10B8A00010B8C,
+        0x10B8D00010B8E,
+        0x10B9000010B91,
+        0x10BAD00010BAF,
+        0x10D0100010D22,
+        0x10D2300010D24,
+        0x10EC300010EC5,
+        0x10EC600010EC8,
+        0x10F3000010F33,
+        0x10F3400010F45,
+        0x10F5100010F54,
+        0x10F7000010F74,
+        0x10F7600010F82,
+        0x10FB000010FB1,
+        0x10FB200010FB4,
+        0x10FB800010FB9,
+        0x10FBB00010FBD,
+        0x10FBE00010FC0,
+        0x10FC100010FC2,
+        0x10FC400010FC5,
+        0x10FCA00010FCB,
+        0x1E9000001E944,
+    ),
+    "L": (
+        0xA8720000A873,
+        0x10ACD00010ACE,
+        0x10AD700010AD8,
+        0x10D0000010D01,
+        0x10FCB00010FCC,
+    ),
+    "R": (
+        0x62200000626,
+        0x62700000628,
+        0x6290000062A,
+        0x62F00000633,
+        0x64800000649,
+        0x67100000674,
+        0x67500000678,
+        0x6880000069A,
+        0x6C0000006C1,
+        0x6C3000006CC,
+        0x6CD000006CE,
+        0x6CF000006D0,
+        0x6D2000006D4,
+        0x6D5000006D6,
+        0x6EE000006F0,
+        0x71000000711,
+        0x7150000071A,
+        0x71E0000071F,
+        0x72800000729,
+        0x72A0000072B,
+        0x72C0000072D,
+        0x72F00000730,
+        0x74D0000074E,
+        0x7590000075C,
+        0x76B0000076D,
+        0x77100000772,
+        0x77300000775,
+        0x7780000077A,
+        0x84000000841,
+        0x84600000848,
+        0x8490000084A,
+        0x85400000855,
+        0x85600000859,
+        0x86700000868,
+        0x8690000086B,
+        0x87000000883,
+        0x88E0000088F,
+        0x8AA000008AD,
+        0x8AE000008AF,
+        0x8B1000008B3,
+        0x8B9000008BA,
+        0x10AC500010AC6,
+        0x10AC700010AC8,
+        0x10AC900010ACB,
+        0x10ACE00010AD3,
+        0x10ADD00010ADE,
+        0x10AE100010AE2,
+        0x10AE400010AE5,
+        0x10AEF00010AF0,
+        0x10B8100010B82,
+        0x10B8300010B86,
+        0x10B8900010B8A,
+        0x10B8C00010B8D,
+        0x10B8E00010B90,
+        0x10B9100010B92,
+        0x10BA900010BAD,
+        0x10D2200010D23,
+        0x10EC200010EC3,
+        0x10F3300010F34,
+        0x10F5400010F55,
+        0x10F7400010F76,
+        0x10FB400010FB7,
+        0x10FB900010FBB,
+        0x10FBD00010FBE,
+        0x10FC200010FC4,
+        0x10FC900010FCA,
+    ),
+    "T": (
+        0xAD000000AE,
+        0x30000000370,
+        0x4830000048A,
+        0x591000005BE,
+        0x5BF000005C0,
+        0x5C1000005C3,
+        0x5C4000005C6,
+        0x5C7000005C8,
+        0x6100000061B,
+        0x61C0000061D,
+        0x64B00000660,
+        0x67000000671,
+        0x6D6000006DD,
+        0x6DF000006E5,
+        0x6E7000006E9,
+        0x6EA000006EE,
+        0x70F00000710,
+        0x71100000712,
+        0x7300000074B,
+        0x7A6000007B1,
+        0x7EB000007F4,
+        0x7FD000007FE,
+        0x8160000081A,
+        0x81B00000824,
+        0x82500000828,
+        0x8290000082E,
+        0x8590000085C,
+        0x897000008A0,
+        0x8CA000008E2,
+        0x8E300000903,
+        0x93A0000093B,
+        0x93C0000093D,
+        0x94100000949,
+        0x94D0000094E,
+        0x95100000958,
+        0x96200000964,
+        0x98100000982,
+        0x9BC000009BD,
+        0x9C1000009C5,
+        0x9CD000009CE,
+        0x9E2000009E4,
+        0x9FE000009FF,
+        0xA0100000A03,
+        0xA3C00000A3D,
+        0xA4100000A43,
+        0xA4700000A49,
+        0xA4B00000A4E,
+        0xA5100000A52,
+        0xA7000000A72,
+        0xA7500000A76,
+        0xA8100000A83,
+        0xABC00000ABD,
+        0xAC100000AC6,
+        0xAC700000AC9,
+        0xACD00000ACE,
+        0xAE200000AE4,
+        0xAFA00000B00,
+        0xB0100000B02,
+        0xB3C00000B3D,
+        0xB3F00000B40,
+        0xB4100000B45,
+        0xB4D00000B4E,
+        0xB5500000B57,
+        0xB6200000B64,
+        0xB8200000B83,
+        0xBC000000BC1,
+        0xBCD00000BCE,
+        0xC0000000C01,
+        0xC0400000C05,
+        0xC3C00000C3D,
+        0xC3E00000C41,
+        0xC4600000C49,
+        0xC4A00000C4E,
+        0xC5500000C57,
+        0xC6200000C64,
+        0xC8100000C82,
+        0xCBC00000CBD,
+        0xCBF00000CC0,
+        0xCC600000CC7,
+        0xCCC00000CCE,
+        0xCE200000CE4,
+        0xD0000000D02,
+        0xD3B00000D3D,
+        0xD4100000D45,
+        0xD4D00000D4E,
+        0xD6200000D64,
+        0xD8100000D82,
+        0xDCA00000DCB,
+        0xDD200000DD5,
+        0xDD600000DD7,
+        0xE3100000E32,
+        0xE3400000E3B,
+        0xE4700000E4F,
+        0xEB100000EB2,
+        0xEB400000EBD,
+        0xEC800000ECF,
+        0xF1800000F1A,
+        0xF3500000F36,
+        0xF3700000F38,
+        0xF3900000F3A,
+        0xF7100000F7F,
+        0xF8000000F85,
+        0xF8600000F88,
+        0xF8D00000F98,
+        0xF9900000FBD,
+        0xFC600000FC7,
+        0x102D00001031,
+        0x103200001038,
+        0x10390000103B,
+        0x103D0000103F,
+        0x10580000105A,
+        0x105E00001061,
+        0x107100001075,
+        0x108200001083,
+        0x108500001087,
+        0x108D0000108E,
+        0x109D0000109E,
+        0x135D00001360,
+        0x171200001715,
+        0x173200001734,
+        0x175200001754,
+        0x177200001774,
+        0x17B4000017B6,
+        0x17B7000017BE,
+        0x17C6000017C7,
+        0x17C9000017D4,
+        0x17DD000017DE,
+        0x180B0000180E,
+        0x180F00001810,
+        0x188500001887,
+        0x18A9000018AA,
+        0x192000001923,
+        0x192700001929,
+        0x193200001933,
+        0x19390000193C,
+        0x1A1700001A19,
+        0x1A1B00001A1C,
+        0x1A5600001A57,
+        0x1A5800001A5F,
+        0x1A6000001A61,
+        0x1A6200001A63,
+        0x1A6500001A6D,
+        0x1A7300001A7D,
+        0x1A7F00001A80,
+        0x1AB000001ADE,
+        0x1AE000001AEC,
+        0x1B0000001B04,
+        0x1B3400001B35,
+        0x1B3600001B3B,
+        0x1B3C00001B3D,
+        0x1B4200001B43,
+        0x1B6B00001B74,
+        0x1B8000001B82,
+        0x1BA200001BA6,
+        0x1BA800001BAA,
+        0x1BAB00001BAE,
+        0x1BE600001BE7,
+        0x1BE800001BEA,
+        0x1BED00001BEE,
+        0x1BEF00001BF2,
+        0x1C2C00001C34,
+        0x1C3600001C38,
+        0x1CD000001CD3,
+        0x1CD400001CE1,
+        0x1CE200001CE9,
+        0x1CED00001CEE,
+        0x1CF400001CF5,
+        0x1CF800001CFA,
+        0x1DC000001E00,
+        0x200B0000200C,
+        0x200E00002010,
+        0x202A0000202F,
+        0x206000002065,
+        0x206A00002070,
+        0x20D0000020F1,
+        0x2CEF00002CF2,
+        0x2D7F00002D80,
+        0x2DE000002E00,
+        0x302A0000302E,
+        0x30990000309B,
+        0xA66F0000A673,
+        0xA6740000A67E,
+        0xA69E0000A6A0,
+        0xA6F00000A6F2,
+        0xA8020000A803,
+        0xA8060000A807,
+        0xA80B0000A80C,
+        0xA8250000A827,
+        0xA82C0000A82D,
+        0xA8C40000A8C6,
+        0xA8E00000A8F2,
+        0xA8FF0000A900,
+        0xA9260000A92E,
+        0xA9470000A952,
+        0xA9800000A983,
+        0xA9B30000A9B4,
+        0xA9B60000A9BA,
+        0xA9BC0000A9BE,
+        0xA9E50000A9E6,
+        0xAA290000AA2F,
+        0xAA310000AA33,
+        0xAA350000AA37,
+        0xAA430000AA44,
+        0xAA4C0000AA4D,
+        0xAA7C0000AA7D,
+        0xAAB00000AAB1,
+        0xAAB20000AAB5,
+        0xAAB70000AAB9,
+        0xAABE0000AAC0,
+        0xAAC10000AAC2,
+        0xAAEC0000AAEE,
+        0xAAF60000AAF7,
+        0xABE50000ABE6,
+        0xABE80000ABE9,
+        0xABED0000ABEE,
+        0xFB1E0000FB1F,
+        0xFE000000FE10,
+        0xFE200000FE30,
+        0xFEFF0000FF00,
+        0xFFF90000FFFC,
+        0x101FD000101FE,
+        0x102E0000102E1,
+        0x103760001037B,
+        0x10A0100010A04,
+        0x10A0500010A07,
+        0x10A0C00010A10,
+        0x10A3800010A3B,
+        0x10A3F00010A40,
+        0x10AE500010AE7,
+        0x10D2400010D28,
+        0x10D6900010D6E,
+        0x10EAB00010EAD,
+        0x10EFA00010F00,
+        0x10F4600010F51,
+        0x10F8200010F86,
+        0x1100100011002,
+        0x1103800011047,
+        0x1107000011071,
+        0x1107300011075,
+        0x1107F00011082,
+        0x110B3000110B7,
+        0x110B9000110BB,
+        0x110C2000110C3,
+        0x1110000011103,
+        0x111270001112C,
+        0x1112D00011135,
+        0x1117300011174,
+        0x1118000011182,
+        0x111B6000111BF,
+        0x111C9000111CD,
+        0x111CF000111D0,
+        0x1122F00011232,
+        0x1123400011235,
+        0x1123600011238,
+        0x1123E0001123F,
+        0x1124100011242,
+        0x112DF000112E0,
+        0x112E3000112EB,
+        0x1130000011302,
+        0x1133B0001133D,
+        0x1134000011341,
+        0x113660001136D,
+        0x1137000011375,
+        0x113BB000113C1,
+        0x113CE000113CF,
+        0x113D0000113D1,
+        0x113D2000113D3,
+        0x113E1000113E3,
+        0x1143800011440,
+        0x1144200011445,
+        0x1144600011447,
+        0x1145E0001145F,
+        0x114B3000114B9,
+        0x114BA000114BB,
+        0x114BF000114C1,
+        0x114C2000114C4,
+        0x115B2000115B6,
+        0x115BC000115BE,
+        0x115BF000115C1,
+        0x115DC000115DE,
+        0x116330001163B,
+        0x1163D0001163E,
+        0x1163F00011641,
+        0x116AB000116AC,
+        0x116AD000116AE,
+        0x116B0000116B6,
+        0x116B7000116B8,
+        0x1171D0001171E,
+        0x1171F00011720,
+        0x1172200011726,
+        0x117270001172C,
+        0x1182F00011838,
+        0x118390001183B,
+        0x1193B0001193D,
+        0x1193E0001193F,
+        0x1194300011944,
+        0x119D4000119D8,
+        0x119DA000119DC,
+        0x119E0000119E1,
+        0x11A0100011A0B,
+        0x11A3300011A39,
+        0x11A3B00011A3F,
+        0x11A4700011A48,
+        0x11A5100011A57,
+        0x11A5900011A5C,
+        0x11A8A00011A97,
+        0x11A9800011A9A,
+        0x11B6000011B61,
+        0x11B6200011B65,
+        0x11B6600011B67,
+        0x11C3000011C37,
+        0x11C3800011C3E,
+        0x11C3F00011C40,
+        0x11C9200011CA8,
+        0x11CAA00011CB1,
+        0x11CB200011CB4,
+        0x11CB500011CB7,
+        0x11D3100011D37,
+        0x11D3A00011D3B,
+        0x11D3C00011D3E,
+        0x11D3F00011D46,
+        0x11D4700011D48,
+        0x11D9000011D92,
+        0x11D9500011D96,
+        0x11D9700011D98,
+        0x11EF300011EF5,
+        0x11F0000011F02,
+        0x11F3600011F3B,
+        0x11F4000011F41,
+        0x11F4200011F43,
+        0x11F5A00011F5B,
+        0x1343000013441,
+        0x1344700013456,
+        0x1611E0001612A,
+        0x1612D00016130,
+        0x16AF000016AF5,
+        0x16B3000016B37,
+        0x16F4F00016F50,
+        0x16F8F00016F93,
+        0x16FE400016FE5,
+        0x1BC9D0001BC9F,
+        0x1BCA00001BCA4,
+        0x1CF000001CF2E,
+        0x1CF300001CF47,
+        0x1D1670001D16A,
+        0x1D1730001D183,
+        0x1D1850001D18C,
+        0x1D1AA0001D1AE,
+        0x1D2420001D245,
+        0x1DA000001DA37,
+        0x1DA3B0001DA6D,
+        0x1DA750001DA76,
+        0x1DA840001DA85,
+        0x1DA9B0001DAA0,
+        0x1DAA10001DAB0,
+        0x1E0000001E007,
+        0x1E0080001E019,
+        0x1E01B0001E022,
+        0x1E0230001E025,
+        0x1E0260001E02B,
+        0x1E08F0001E090,
+        0x1E1300001E137,
+        0x1E2AE0001E2AF,
+        0x1E2EC0001E2F0,
+        0x1E4EC0001E4F0,
+        0x1E5EE0001E5F0,
+        0x1E6E30001E6E4,
+        0x1E6E60001E6E7,
+        0x1E6EE0001E6F0,
+        0x1E6F50001E6F6,
+        0x1E8D00001E8D7,
+        0x1E9440001E94C,
+        0xE0001000E0002,
+        0xE0020000E0080,
+        0xE0100000E01F0,
+    ),
+}
+
+
+codepoint_classes = {
+    "PVALID": (
+        0x2D0000002E,
+        0x300000003A,
+        0x610000007B,
+        0xDF000000F7,
+        0xF800000100,
+        0x10100000102,
+        0x10300000104,
+        0x10500000106,
+        0x10700000108,
+        0x1090000010A,
+        0x10B0000010C,
+        0x10D0000010E,
+        0x10F00000110,
+        0x11100000112,
+        0x11300000114,
+        0x11500000116,
+        0x11700000118,
+        0x1190000011A,
+        0x11B0000011C,
+        0x11D0000011E,
+        0x11F00000120,
+        0x12100000122,
+        0x12300000124,
+        0x12500000126,
+        0x12700000128,
+        0x1290000012A,
+        0x12B0000012C,
+        0x12D0000012E,
+        0x12F00000130,
+        0x13100000132,
+        0x13500000136,
+        0x13700000139,
+        0x13A0000013B,
+        0x13C0000013D,
+        0x13E0000013F,
+        0x14200000143,
+        0x14400000145,
+        0x14600000147,
+        0x14800000149,
+        0x14B0000014C,
+        0x14D0000014E,
+        0x14F00000150,
+        0x15100000152,
+        0x15300000154,
+        0x15500000156,
+        0x15700000158,
+        0x1590000015A,
+        0x15B0000015C,
+        0x15D0000015E,
+        0x15F00000160,
+        0x16100000162,
+        0x16300000164,
+        0x16500000166,
+        0x16700000168,
+        0x1690000016A,
+        0x16B0000016C,
+        0x16D0000016E,
+        0x16F00000170,
+        0x17100000172,
+        0x17300000174,
+        0x17500000176,
+        0x17700000178,
+        0x17A0000017B,
+        0x17C0000017D,
+        0x17E0000017F,
+        0x18000000181,
+        0x18300000184,
+        0x18500000186,
+        0x18800000189,
+        0x18C0000018E,
+        0x19200000193,
+        0x19500000196,
+        0x1990000019C,
+        0x19E0000019F,
+        0x1A1000001A2,
+        0x1A3000001A4,
+        0x1A5000001A6,
+        0x1A8000001A9,
+        0x1AA000001AC,
+        0x1AD000001AE,
+        0x1B0000001B1,
+        0x1B4000001B5,
+        0x1B6000001B7,
+        0x1B9000001BC,
+        0x1BD000001C4,
+        0x1CE000001CF,
+        0x1D0000001D1,
+        0x1D2000001D3,
+        0x1D4000001D5,
+        0x1D6000001D7,
+        0x1D8000001D9,
+        0x1DA000001DB,
+        0x1DC000001DE,
+        0x1DF000001E0,
+        0x1E1000001E2,
+        0x1E3000001E4,
+        0x1E5000001E6,
+        0x1E7000001E8,
+        0x1E9000001EA,
+        0x1EB000001EC,
+        0x1ED000001EE,
+        0x1EF000001F1,
+        0x1F5000001F6,
+        0x1F9000001FA,
+        0x1FB000001FC,
+        0x1FD000001FE,
+        0x1FF00000200,
+        0x20100000202,
+        0x20300000204,
+        0x20500000206,
+        0x20700000208,
+        0x2090000020A,
+        0x20B0000020C,
+        0x20D0000020E,
+        0x20F00000210,
+        0x21100000212,
+        0x21300000214,
+        0x21500000216,
+        0x21700000218,
+        0x2190000021A,
+        0x21B0000021C,
+        0x21D0000021E,
+        0x21F00000220,
+        0x22100000222,
+        0x22300000224,
+        0x22500000226,
+        0x22700000228,
+        0x2290000022A,
+        0x22B0000022C,
+        0x22D0000022E,
+        0x22F00000230,
+        0x23100000232,
+        0x2330000023A,
+        0x23C0000023D,
+        0x23F00000241,
+        0x24200000243,
+        0x24700000248,
+        0x2490000024A,
+        0x24B0000024C,
+        0x24D0000024E,
+        0x24F000002B0,
+        0x2B9000002C2,
+        0x2C6000002D2,
+        0x2EC000002ED,
+        0x2EE000002EF,
+        0x30000000340,
+        0x34200000343,
+        0x3460000034F,
+        0x35000000370,
+        0x37100000372,
+        0x37300000374,
+        0x37700000378,
+        0x37B0000037E,
+        0x39000000391,
+        0x3AC000003CF,
+        0x3D7000003D8,
+        0x3D9000003DA,
+        0x3DB000003DC,
+        0x3DD000003DE,
+        0x3DF000003E0,
+        0x3E1000003E2,
+        0x3E3000003E4,
+        0x3E5000003E6,
+        0x3E7000003E8,
+        0x3E9000003EA,
+        0x3EB000003EC,
+        0x3ED000003EE,
+        0x3EF000003F0,
+        0x3F3000003F4,
+        0x3F8000003F9,
+        0x3FB000003FD,
+        0x43000000460,
+        0x46100000462,
+        0x46300000464,
+        0x46500000466,
+        0x46700000468,
+        0x4690000046A,
+        0x46B0000046C,
+        0x46D0000046E,
+        0x46F00000470,
+        0x47100000472,
+        0x47300000474,
+        0x47500000476,
+        0x47700000478,
+        0x4790000047A,
+        0x47B0000047C,
+        0x47D0000047E,
+        0x47F00000480,
+        0x48100000482,
+        0x48300000488,
+        0x48B0000048C,
+        0x48D0000048E,
+        0x48F00000490,
+        0x49100000492,
+        0x49300000494,
+        0x49500000496,
+        0x49700000498,
+        0x4990000049A,
+        0x49B0000049C,
+        0x49D0000049E,
+        0x49F000004A0,
+        0x4A1000004A2,
+        0x4A3000004A4,
+        0x4A5000004A6,
+        0x4A7000004A8,
+        0x4A9000004AA,
+        0x4AB000004AC,
+        0x4AD000004AE,
+        0x4AF000004B0,
+        0x4B1000004B2,
+        0x4B3000004B4,
+        0x4B5000004B6,
+        0x4B7000004B8,
+        0x4B9000004BA,
+        0x4BB000004BC,
+        0x4BD000004BE,
+        0x4BF000004C0,
+        0x4C2000004C3,
+        0x4C4000004C5,
+        0x4C6000004C7,
+        0x4C8000004C9,
+        0x4CA000004CB,
+        0x4CC000004CD,
+        0x4CE000004D0,
+        0x4D1000004D2,
+        0x4D3000004D4,
+        0x4D5000004D6,
+        0x4D7000004D8,
+        0x4D9000004DA,
+        0x4DB000004DC,
+        0x4DD000004DE,
+        0x4DF000004E0,
+        0x4E1000004E2,
+        0x4E3000004E4,
+        0x4E5000004E6,
+        0x4E7000004E8,
+        0x4E9000004EA,
+        0x4EB000004EC,
+        0x4ED000004EE,
+        0x4EF000004F0,
+        0x4F1000004F2,
+        0x4F3000004F4,
+        0x4F5000004F6,
+        0x4F7000004F8,
+        0x4F9000004FA,
+        0x4FB000004FC,
+        0x4FD000004FE,
+        0x4FF00000500,
+        0x50100000502,
+        0x50300000504,
+        0x50500000506,
+        0x50700000508,
+        0x5090000050A,
+        0x50B0000050C,
+        0x50D0000050E,
+        0x50F00000510,
+        0x51100000512,
+        0x51300000514,
+        0x51500000516,
+        0x51700000518,
+        0x5190000051A,
+        0x51B0000051C,
+        0x51D0000051E,
+        0x51F00000520,
+        0x52100000522,
+        0x52300000524,
+        0x52500000526,
+        0x52700000528,
+        0x5290000052A,
+        0x52B0000052C,
+        0x52D0000052E,
+        0x52F00000530,
+        0x5590000055A,
+        0x56000000587,
+        0x58800000589,
+        0x591000005BE,
+        0x5BF000005C0,
+        0x5C1000005C3,
+        0x5C4000005C6,
+        0x5C7000005C8,
+        0x5D0000005EB,
+        0x5EF000005F3,
+        0x6100000061B,
+        0x62000000640,
+        0x64100000660,
+        0x66E00000675,
+        0x679000006D4,
+        0x6D5000006DD,
+        0x6DF000006E9,
+        0x6EA000006F0,
+        0x6FA00000700,
+        0x7100000074B,
+        0x74D000007B2,
+        0x7C0000007F6,
+        0x7FD000007FE,
+        0x8000000082E,
+        0x8400000085C,
+        0x8600000086B,
+        0x87000000888,
+        0x88900000890,
+        0x897000008E2,
+        0x8E300000958,
+        0x96000000964,
+        0x96600000970,
+        0x97100000984,
+        0x9850000098D,
+        0x98F00000991,
+        0x993000009A9,
+        0x9AA000009B1,
+        0x9B2000009B3,
+        0x9B6000009BA,
+        0x9BC000009C5,
+        0x9C7000009C9,
+        0x9CB000009CF,
+        0x9D7000009D8,
+        0x9E0000009E4,
+        0x9E6000009F2,
+        0x9FC000009FD,
+        0x9FE000009FF,
+        0xA0100000A04,
+        0xA0500000A0B,
+        0xA0F00000A11,
+        0xA1300000A29,
+        0xA2A00000A31,
+        0xA3200000A33,
+        0xA3500000A36,
+        0xA3800000A3A,
+        0xA3C00000A3D,
+        0xA3E00000A43,
+        0xA4700000A49,
+        0xA4B00000A4E,
+        0xA5100000A52,
+        0xA5C00000A5D,
+        0xA6600000A76,
+        0xA8100000A84,
+        0xA8500000A8E,
+        0xA8F00000A92,
+        0xA9300000AA9,
+        0xAAA00000AB1,
+        0xAB200000AB4,
+        0xAB500000ABA,
+        0xABC00000AC6,
+        0xAC700000ACA,
+        0xACB00000ACE,
+        0xAD000000AD1,
+        0xAE000000AE4,
+        0xAE600000AF0,
+        0xAF900000B00,
+        0xB0100000B04,
+        0xB0500000B0D,
+        0xB0F00000B11,
+        0xB1300000B29,
+        0xB2A00000B31,
+        0xB3200000B34,
+        0xB3500000B3A,
+        0xB3C00000B45,
+        0xB4700000B49,
+        0xB4B00000B4E,
+        0xB5500000B58,
+        0xB5F00000B64,
+        0xB6600000B70,
+        0xB7100000B72,
+        0xB8200000B84,
+        0xB8500000B8B,
+        0xB8E00000B91,
+        0xB9200000B96,
+        0xB9900000B9B,
+        0xB9C00000B9D,
+        0xB9E00000BA0,
+        0xBA300000BA5,
+        0xBA800000BAB,
+        0xBAE00000BBA,
+        0xBBE00000BC3,
+        0xBC600000BC9,
+        0xBCA00000BCE,
+        0xBD000000BD1,
+        0xBD700000BD8,
+        0xBE600000BF0,
+        0xC0000000C0D,
+        0xC0E00000C11,
+        0xC1200000C29,
+        0xC2A00000C3A,
+        0xC3C00000C45,
+        0xC4600000C49,
+        0xC4A00000C4E,
+        0xC5500000C57,
+        0xC5800000C5B,
+        0xC5C00000C5E,
+        0xC6000000C64,
+        0xC6600000C70,
+        0xC8000000C84,
+        0xC8500000C8D,
+        0xC8E00000C91,
+        0xC9200000CA9,
+        0xCAA00000CB4,
+        0xCB500000CBA,
+        0xCBC00000CC5,
+        0xCC600000CC9,
+        0xCCA00000CCE,
+        0xCD500000CD7,
+        0xCDC00000CDF,
+        0xCE000000CE4,
+        0xCE600000CF0,
+        0xCF100000CF4,
+        0xD0000000D0D,
+        0xD0E00000D11,
+        0xD1200000D45,
+        0xD4600000D49,
+        0xD4A00000D4F,
+        0xD5400000D58,
+        0xD5F00000D64,
+        0xD6600000D70,
+        0xD7A00000D80,
+        0xD8100000D84,
+        0xD8500000D97,
+        0xD9A00000DB2,
+        0xDB300000DBC,
+        0xDBD00000DBE,
+        0xDC000000DC7,
+        0xDCA00000DCB,
+        0xDCF00000DD5,
+        0xDD600000DD7,
+        0xDD800000DE0,
+        0xDE600000DF0,
+        0xDF200000DF4,
+        0xE0100000E33,
+        0xE3400000E3B,
+        0xE4000000E4F,
+        0xE5000000E5A,
+        0xE8100000E83,
+        0xE8400000E85,
+        0xE8600000E8B,
+        0xE8C00000EA4,
+        0xEA500000EA6,
+        0xEA700000EB3,
+        0xEB400000EBE,
+        0xEC000000EC5,
+        0xEC600000EC7,
+        0xEC800000ECF,
+        0xED000000EDA,
+        0xEDE00000EE0,
+        0xF0000000F01,
+        0xF0B00000F0C,
+        0xF1800000F1A,
+        0xF2000000F2A,
+        0xF3500000F36,
+        0xF3700000F38,
+        0xF3900000F3A,
+        0xF3E00000F43,
+        0xF4400000F48,
+        0xF4900000F4D,
+        0xF4E00000F52,
+        0xF5300000F57,
+        0xF5800000F5C,
+        0xF5D00000F69,
+        0xF6A00000F6D,
+        0xF7100000F73,
+        0xF7400000F75,
+        0xF7A00000F81,
+        0xF8200000F85,
+        0xF8600000F93,
+        0xF9400000F98,
+        0xF9900000F9D,
+        0xF9E00000FA2,
+        0xFA300000FA7,
+        0xFA800000FAC,
+        0xFAD00000FB9,
+        0xFBA00000FBD,
+        0xFC600000FC7,
+        0x10000000104A,
+        0x10500000109E,
+        0x10D0000010FB,
+        0x10FD00001100,
+        0x120000001249,
+        0x124A0000124E,
+        0x125000001257,
+        0x125800001259,
+        0x125A0000125E,
+        0x126000001289,
+        0x128A0000128E,
+        0x1290000012B1,
+        0x12B2000012B6,
+        0x12B8000012BF,
+        0x12C0000012C1,
+        0x12C2000012C6,
+        0x12C8000012D7,
+        0x12D800001311,
+        0x131200001316,
+        0x13180000135B,
+        0x135D00001360,
+        0x138000001390,
+        0x13A0000013F6,
+        0x14010000166D,
+        0x166F00001680,
+        0x16810000169B,
+        0x16A0000016EB,
+        0x16F1000016F9,
+        0x170000001716,
+        0x171F00001735,
+        0x174000001754,
+        0x17600000176D,
+        0x176E00001771,
+        0x177200001774,
+        0x1780000017B4,
+        0x17B6000017D4,
+        0x17D7000017D8,
+        0x17DC000017DE,
+        0x17E0000017EA,
+        0x18100000181A,
+        0x182000001879,
+        0x1880000018AB,
+        0x18B0000018F6,
+        0x19000000191F,
+        0x19200000192C,
+        0x19300000193C,
+        0x19460000196E,
+        0x197000001975,
+        0x1980000019AC,
+        0x19B0000019CA,
+        0x19D0000019DA,
+        0x1A0000001A1C,
+        0x1A2000001A5F,
+        0x1A6000001A7D,
+        0x1A7F00001A8A,
+        0x1A9000001A9A,
+        0x1AA700001AA8,
+        0x1AB000001ABE,
+        0x1ABF00001ADE,
+        0x1AE000001AEC,
+        0x1B0000001B4D,
+        0x1B5000001B5A,
+        0x1B6B00001B74,
+        0x1B8000001BF4,
+        0x1C0000001C38,
+        0x1C4000001C4A,
+        0x1C4D00001C7E,
+        0x1C8A00001C8B,
+        0x1CD000001CD3,
+        0x1CD400001CFB,
+        0x1D0000001D2C,
+        0x1D2F00001D30,
+        0x1D3B00001D3C,
+        0x1D4E00001D4F,
+        0x1D6B00001D78,
+        0x1D7900001D9B,
+        0x1DC000001E00,
+        0x1E0100001E02,
+        0x1E0300001E04,
+        0x1E0500001E06,
+        0x1E0700001E08,
+        0x1E0900001E0A,
+        0x1E0B00001E0C,
+        0x1E0D00001E0E,
+        0x1E0F00001E10,
+        0x1E1100001E12,
+        0x1E1300001E14,
+        0x1E1500001E16,
+        0x1E1700001E18,
+        0x1E1900001E1A,
+        0x1E1B00001E1C,
+        0x1E1D00001E1E,
+        0x1E1F00001E20,
+        0x1E2100001E22,
+        0x1E2300001E24,
+        0x1E2500001E26,
+        0x1E2700001E28,
+        0x1E2900001E2A,
+        0x1E2B00001E2C,
+        0x1E2D00001E2E,
+        0x1E2F00001E30,
+        0x1E3100001E32,
+        0x1E3300001E34,
+        0x1E3500001E36,
+        0x1E3700001E38,
+        0x1E3900001E3A,
+        0x1E3B00001E3C,
+        0x1E3D00001E3E,
+        0x1E3F00001E40,
+        0x1E4100001E42,
+        0x1E4300001E44,
+        0x1E4500001E46,
+        0x1E4700001E48,
+        0x1E4900001E4A,
+        0x1E4B00001E4C,
+        0x1E4D00001E4E,
+        0x1E4F00001E50,
+        0x1E5100001E52,
+        0x1E5300001E54,
+        0x1E5500001E56,
+        0x1E5700001E58,
+        0x1E5900001E5A,
+        0x1E5B00001E5C,
+        0x1E5D00001E5E,
+        0x1E5F00001E60,
+        0x1E6100001E62,
+        0x1E6300001E64,
+        0x1E6500001E66,
+        0x1E6700001E68,
+        0x1E6900001E6A,
+        0x1E6B00001E6C,
+        0x1E6D00001E6E,
+        0x1E6F00001E70,
+        0x1E7100001E72,
+        0x1E7300001E74,
+        0x1E7500001E76,
+        0x1E7700001E78,
+        0x1E7900001E7A,
+        0x1E7B00001E7C,
+        0x1E7D00001E7E,
+        0x1E7F00001E80,
+        0x1E8100001E82,
+        0x1E8300001E84,
+        0x1E8500001E86,
+        0x1E8700001E88,
+        0x1E8900001E8A,
+        0x1E8B00001E8C,
+        0x1E8D00001E8E,
+        0x1E8F00001E90,
+        0x1E9100001E92,
+        0x1E9300001E94,
+        0x1E9500001E9A,
+        0x1E9C00001E9E,
+        0x1E9F00001EA0,
+        0x1EA100001EA2,
+        0x1EA300001EA4,
+        0x1EA500001EA6,
+        0x1EA700001EA8,
+        0x1EA900001EAA,
+        0x1EAB00001EAC,
+        0x1EAD00001EAE,
+        0x1EAF00001EB0,
+        0x1EB100001EB2,
+        0x1EB300001EB4,
+        0x1EB500001EB6,
+        0x1EB700001EB8,
+        0x1EB900001EBA,
+        0x1EBB00001EBC,
+        0x1EBD00001EBE,
+        0x1EBF00001EC0,
+        0x1EC100001EC2,
+        0x1EC300001EC4,
+        0x1EC500001EC6,
+        0x1EC700001EC8,
+        0x1EC900001ECA,
+        0x1ECB00001ECC,
+        0x1ECD00001ECE,
+        0x1ECF00001ED0,
+        0x1ED100001ED2,
+        0x1ED300001ED4,
+        0x1ED500001ED6,
+        0x1ED700001ED8,
+        0x1ED900001EDA,
+        0x1EDB00001EDC,
+        0x1EDD00001EDE,
+        0x1EDF00001EE0,
+        0x1EE100001EE2,
+        0x1EE300001EE4,
+        0x1EE500001EE6,
+        0x1EE700001EE8,
+        0x1EE900001EEA,
+        0x1EEB00001EEC,
+        0x1EED00001EEE,
+        0x1EEF00001EF0,
+        0x1EF100001EF2,
+        0x1EF300001EF4,
+        0x1EF500001EF6,
+        0x1EF700001EF8,
+        0x1EF900001EFA,
+        0x1EFB00001EFC,
+        0x1EFD00001EFE,
+        0x1EFF00001F08,
+        0x1F1000001F16,
+        0x1F2000001F28,
+        0x1F3000001F38,
+        0x1F4000001F46,
+        0x1F5000001F58,
+        0x1F6000001F68,
+        0x1F7000001F71,
+        0x1F7200001F73,
+        0x1F7400001F75,
+        0x1F7600001F77,
+        0x1F7800001F79,
+        0x1F7A00001F7B,
+        0x1F7C00001F7D,
+        0x1FB000001FB2,
+        0x1FB600001FB7,
+        0x1FC600001FC7,
+        0x1FD000001FD3,
+        0x1FD600001FD8,
+        0x1FE000001FE3,
+        0x1FE400001FE8,
+        0x1FF600001FF7,
+        0x214E0000214F,
+        0x218400002185,
+        0x2C3000002C60,
+        0x2C6100002C62,
+        0x2C6500002C67,
+        0x2C6800002C69,
+        0x2C6A00002C6B,
+        0x2C6C00002C6D,
+        0x2C7100002C72,
+        0x2C7300002C75,
+        0x2C7600002C7C,
+        0x2C8100002C82,
+        0x2C8300002C84,
+        0x2C8500002C86,
+        0x2C8700002C88,
+        0x2C8900002C8A,
+        0x2C8B00002C8C,
+        0x2C8D00002C8E,
+        0x2C8F00002C90,
+        0x2C9100002C92,
+        0x2C9300002C94,
+        0x2C9500002C96,
+        0x2C9700002C98,
+        0x2C9900002C9A,
+        0x2C9B00002C9C,
+        0x2C9D00002C9E,
+        0x2C9F00002CA0,
+        0x2CA100002CA2,
+        0x2CA300002CA4,
+        0x2CA500002CA6,
+        0x2CA700002CA8,
+        0x2CA900002CAA,
+        0x2CAB00002CAC,
+        0x2CAD00002CAE,
+        0x2CAF00002CB0,
+        0x2CB100002CB2,
+        0x2CB300002CB4,
+        0x2CB500002CB6,
+        0x2CB700002CB8,
+        0x2CB900002CBA,
+        0x2CBB00002CBC,
+        0x2CBD00002CBE,
+        0x2CBF00002CC0,
+        0x2CC100002CC2,
+        0x2CC300002CC4,
+        0x2CC500002CC6,
+        0x2CC700002CC8,
+        0x2CC900002CCA,
+        0x2CCB00002CCC,
+        0x2CCD00002CCE,
+        0x2CCF00002CD0,
+        0x2CD100002CD2,
+        0x2CD300002CD4,
+        0x2CD500002CD6,
+        0x2CD700002CD8,
+        0x2CD900002CDA,
+        0x2CDB00002CDC,
+        0x2CDD00002CDE,
+        0x2CDF00002CE0,
+        0x2CE100002CE2,
+        0x2CE300002CE5,
+        0x2CEC00002CED,
+        0x2CEE00002CF2,
+        0x2CF300002CF4,
+        0x2D0000002D26,
+        0x2D2700002D28,
+        0x2D2D00002D2E,
+        0x2D3000002D68,
+        0x2D7F00002D97,
+        0x2DA000002DA7,
+        0x2DA800002DAF,
+        0x2DB000002DB7,
+        0x2DB800002DBF,
+        0x2DC000002DC7,
+        0x2DC800002DCF,
+        0x2DD000002DD7,
+        0x2DD800002DDF,
+        0x2DE000002E00,
+        0x2E2F00002E30,
+        0x300500003008,
+        0x302A0000302E,
+        0x303C0000303D,
+        0x304100003097,
+        0x30990000309B,
+        0x309D0000309F,
+        0x30A1000030FB,
+        0x30FC000030FF,
+        0x310500003130,
+        0x31A0000031C0,
+        0x31F000003200,
+        0x340000004DC0,
+        0x4E000000A48D,
+        0xA4D00000A4FE,
+        0xA5000000A60D,
+        0xA6100000A62C,
+        0xA6410000A642,
+        0xA6430000A644,
+        0xA6450000A646,
+        0xA6470000A648,
+        0xA6490000A64A,
+        0xA64B0000A64C,
+        0xA64D0000A64E,
+        0xA64F0000A650,
+        0xA6510000A652,
+        0xA6530000A654,
+        0xA6550000A656,
+        0xA6570000A658,
+        0xA6590000A65A,
+        0xA65B0000A65C,
+        0xA65D0000A65E,
+        0xA65F0000A660,
+        0xA6610000A662,
+        0xA6630000A664,
+        0xA6650000A666,
+        0xA6670000A668,
+        0xA6690000A66A,
+        0xA66B0000A66C,
+        0xA66D0000A670,
+        0xA6740000A67E,
+        0xA67F0000A680,
+        0xA6810000A682,
+        0xA6830000A684,
+        0xA6850000A686,
+        0xA6870000A688,
+        0xA6890000A68A,
+        0xA68B0000A68C,
+        0xA68D0000A68E,
+        0xA68F0000A690,
+        0xA6910000A692,
+        0xA6930000A694,
+        0xA6950000A696,
+        0xA6970000A698,
+        0xA6990000A69A,
+        0xA69B0000A69C,
+        0xA69E0000A6E6,
+        0xA6F00000A6F2,
+        0xA7170000A720,
+        0xA7230000A724,
+        0xA7250000A726,
+        0xA7270000A728,
+        0xA7290000A72A,
+        0xA72B0000A72C,
+        0xA72D0000A72E,
+        0xA72F0000A732,
+        0xA7330000A734,
+        0xA7350000A736,
+        0xA7370000A738,
+        0xA7390000A73A,
+        0xA73B0000A73C,
+        0xA73D0000A73E,
+        0xA73F0000A740,
+        0xA7410000A742,
+        0xA7430000A744,
+        0xA7450000A746,
+        0xA7470000A748,
+        0xA7490000A74A,
+        0xA74B0000A74C,
+        0xA74D0000A74E,
+        0xA74F0000A750,
+        0xA7510000A752,
+        0xA7530000A754,
+        0xA7550000A756,
+        0xA7570000A758,
+        0xA7590000A75A,
+        0xA75B0000A75C,
+        0xA75D0000A75E,
+        0xA75F0000A760,
+        0xA7610000A762,
+        0xA7630000A764,
+        0xA7650000A766,
+        0xA7670000A768,
+        0xA7690000A76A,
+        0xA76B0000A76C,
+        0xA76D0000A76E,
+        0xA76F0000A770,
+        0xA7710000A779,
+        0xA77A0000A77B,
+        0xA77C0000A77D,
+        0xA77F0000A780,
+        0xA7810000A782,
+        0xA7830000A784,
+        0xA7850000A786,
+        0xA7870000A789,
+        0xA78C0000A78D,
+        0xA78E0000A790,
+        0xA7910000A792,
+        0xA7930000A796,
+        0xA7970000A798,
+        0xA7990000A79A,
+        0xA79B0000A79C,
+        0xA79D0000A79E,
+        0xA79F0000A7A0,
+        0xA7A10000A7A2,
+        0xA7A30000A7A4,
+        0xA7A50000A7A6,
+        0xA7A70000A7A8,
+        0xA7A90000A7AA,
+        0xA7AF0000A7B0,
+        0xA7B50000A7B6,
+        0xA7B70000A7B8,
+        0xA7B90000A7BA,
+        0xA7BB0000A7BC,
+        0xA7BD0000A7BE,
+        0xA7BF0000A7C0,
+        0xA7C10000A7C2,
+        0xA7C30000A7C4,
+        0xA7C80000A7C9,
+        0xA7CA0000A7CB,
+        0xA7CD0000A7CE,
+        0xA7CF0000A7D0,
+        0xA7D10000A7D2,
+        0xA7D30000A7D4,
+        0xA7D50000A7D6,
+        0xA7D70000A7D8,
+        0xA7D90000A7DA,
+        0xA7DB0000A7DC,
+        0xA7F60000A7F8,
+        0xA7FA0000A828,
+        0xA82C0000A82D,
+        0xA8400000A874,
+        0xA8800000A8C6,
+        0xA8D00000A8DA,
+        0xA8E00000A8F8,
+        0xA8FB0000A8FC,
+        0xA8FD0000A92E,
+        0xA9300000A954,
+        0xA9800000A9C1,
+        0xA9CF0000A9DA,
+        0xA9E00000A9FF,
+        0xAA000000AA37,
+        0xAA400000AA4E,
+        0xAA500000AA5A,
+        0xAA600000AA77,
+        0xAA7A0000AAC3,
+        0xAADB0000AADE,
+        0xAAE00000AAF0,
+        0xAAF20000AAF7,
+        0xAB010000AB07,
+        0xAB090000AB0F,
+        0xAB110000AB17,
+        0xAB200000AB27,
+        0xAB280000AB2F,
+        0xAB300000AB5B,
+        0xAB600000AB69,
+        0xABC00000ABEB,
+        0xABEC0000ABEE,
+        0xABF00000ABFA,
+        0xAC000000D7A4,
+        0xFA0E0000FA10,
+        0xFA110000FA12,
+        0xFA130000FA15,
+        0xFA1F0000FA20,
+        0xFA210000FA22,
+        0xFA230000FA25,
+        0xFA270000FA2A,
+        0xFB1E0000FB1F,
+        0xFE200000FE30,
+        0xFE730000FE74,
+        0x100000001000C,
+        0x1000D00010027,
+        0x100280001003B,
+        0x1003C0001003E,
+        0x1003F0001004E,
+        0x100500001005E,
+        0x10080000100FB,
+        0x101FD000101FE,
+        0x102800001029D,
+        0x102A0000102D1,
+        0x102E0000102E1,
+        0x1030000010320,
+        0x1032D00010341,
+        0x103420001034A,
+        0x103500001037B,
+        0x103800001039E,
+        0x103A0000103C4,
+        0x103C8000103D0,
+        0x104280001049E,
+        0x104A0000104AA,
+        0x104D8000104FC,
+        0x1050000010528,
+        0x1053000010564,
+        0x10597000105A2,
+        0x105A3000105B2,
+        0x105B3000105BA,
+        0x105BB000105BD,
+        0x105C0000105F4,
+        0x1060000010737,
+        0x1074000010756,
+        0x1076000010768,
+        0x1078000010781,
+        0x1080000010806,
+        0x1080800010809,
+        0x1080A00010836,
+        0x1083700010839,
+        0x1083C0001083D,
+        0x1083F00010856,
+        0x1086000010877,
+        0x108800001089F,
+        0x108E0000108F3,
+        0x108F4000108F6,
+        0x1090000010916,
+        0x109200001093A,
+        0x109400001095A,
+        0x10980000109B8,
+        0x109BE000109C0,
+        0x10A0000010A04,
+        0x10A0500010A07,
+        0x10A0C00010A14,
+        0x10A1500010A18,
+        0x10A1900010A36,
+        0x10A3800010A3B,
+        0x10A3F00010A40,
+        0x10A6000010A7D,
+        0x10A8000010A9D,
+        0x10AC000010AC8,
+        0x10AC900010AE7,
+        0x10B0000010B36,
+        0x10B4000010B56,
+        0x10B6000010B73,
+        0x10B8000010B92,
+        0x10C0000010C49,
+        0x10CC000010CF3,
+        0x10D0000010D28,
+        0x10D3000010D3A,
+        0x10D4000010D50,
+        0x10D6900010D6E,
+        0x10D6F00010D86,
+        0x10E8000010EAA,
+        0x10EAB00010EAD,
+        0x10EB000010EB2,
+        0x10EC200010EC8,
+        0x10EFA00010F1D,
+        0x10F2700010F28,
+        0x10F3000010F51,
+        0x10F7000010F86,
+        0x10FB000010FC5,
+        0x10FE000010FF7,
+        0x1100000011047,
+        0x1106600011076,
+        0x1107F000110BB,
+        0x110C2000110C3,
+        0x110D0000110E9,
+        0x110F0000110FA,
+        0x1110000011135,
+        0x1113600011140,
+        0x1114400011148,
+        0x1115000011174,
+        0x1117600011177,
+        0x11180000111C5,
+        0x111C9000111CD,
+        0x111CE000111DB,
+        0x111DC000111DD,
+        0x1120000011212,
+        0x1121300011238,
+        0x1123E00011242,
+        0x1128000011287,
+        0x1128800011289,
+        0x1128A0001128E,
+        0x1128F0001129E,
+        0x1129F000112A9,
+        0x112B0000112EB,
+        0x112F0000112FA,
+        0x1130000011304,
+        0x113050001130D,
+        0x1130F00011311,
+        0x1131300011329,
+        0x1132A00011331,
+        0x1133200011334,
+        0x113350001133A,
+        0x1133B00011345,
+        0x1134700011349,
+        0x1134B0001134E,
+        0x1135000011351,
+        0x1135700011358,
+        0x1135D00011364,
+        0x113660001136D,
+        0x1137000011375,
+        0x113800001138A,
+        0x1138B0001138C,
+        0x1138E0001138F,
+        0x11390000113B6,
+        0x113B7000113C1,
+        0x113C2000113C3,
+        0x113C5000113C6,
+        0x113C7000113CB,
+        0x113CC000113D4,
+        0x113E1000113E3,
+        0x114000001144B,
+        0x114500001145A,
+        0x1145E00011462,
+        0x11480000114C6,
+        0x114C7000114C8,
+        0x114D0000114DA,
+        0x11580000115B6,
+        0x115B8000115C1,
+        0x115D8000115DE,
+        0x1160000011641,
+        0x1164400011645,
+        0x116500001165A,
+        0x11680000116B9,
+        0x116C0000116CA,
+        0x116D0000116E4,
+        0x117000001171B,
+        0x1171D0001172C,
+        0x117300001173A,
+        0x1174000011747,
+        0x118000001183B,
+        0x118C0000118EA,
+        0x118FF00011907,
+        0x119090001190A,
+        0x1190C00011914,
+        0x1191500011917,
+        0x1191800011936,
+        0x1193700011939,
+        0x1193B00011944,
+        0x119500001195A,
+        0x119A0000119A8,
+        0x119AA000119D8,
+        0x119DA000119E2,
+        0x119E3000119E5,
+        0x11A0000011A3F,
+        0x11A4700011A48,
+        0x11A5000011A9A,
+        0x11A9D00011A9E,
+        0x11AB000011AF9,
+        0x11B6000011B68,
+        0x11BC000011BE1,
+        0x11BF000011BFA,
+        0x11C0000011C09,
+        0x11C0A00011C37,
+        0x11C3800011C41,
+        0x11C5000011C5A,
+        0x11C7200011C90,
+        0x11C9200011CA8,
+        0x11CA900011CB7,
+        0x11D0000011D07,
+        0x11D0800011D0A,
+        0x11D0B00011D37,
+        0x11D3A00011D3B,
+        0x11D3C00011D3E,
+        0x11D3F00011D48,
+        0x11D5000011D5A,
+        0x11D6000011D66,
+        0x11D6700011D69,
+        0x11D6A00011D8F,
+        0x11D9000011D92,
+        0x11D9300011D99,
+        0x11DA000011DAA,
+        0x11DB000011DDC,
+        0x11DE000011DEA,
+        0x11EE000011EF7,
+        0x11F0000011F11,
+        0x11F1200011F3B,
+        0x11F3E00011F43,
+        0x11F5000011F5B,
+        0x11FB000011FB1,
+        0x120000001239A,
+        0x1248000012544,
+        0x12F9000012FF1,
+        0x1300000013430,
+        0x1344000013456,
+        0x13460000143FB,
+        0x1440000014647,
+        0x161000001613A,
+        0x1680000016A39,
+        0x16A4000016A5F,
+        0x16A6000016A6A,
+        0x16A7000016ABF,
+        0x16AC000016ACA,
+        0x16AD000016AEE,
+        0x16AF000016AF5,
+        0x16B0000016B37,
+        0x16B4000016B44,
+        0x16B5000016B5A,
+        0x16B6300016B78,
+        0x16B7D00016B90,
+        0x16D4000016D6D,
+        0x16D7000016D7A,
+        0x16E6000016E80,
+        0x16EBB00016ED4,
+        0x16F0000016F4B,
+        0x16F4F00016F88,
+        0x16F8F00016FA0,
+        0x16FE000016FE2,
+        0x16FE300016FE5,
+        0x16FF000016FF4,
+        0x1700000018CD6,
+        0x18CFF00018D1F,
+        0x18D8000018DF3,
+        0x1AFF00001AFF4,
+        0x1AFF50001AFFC,
+        0x1AFFD0001AFFF,
+        0x1B0000001B123,
+        0x1B1320001B133,
+        0x1B1500001B153,
+        0x1B1550001B156,
+        0x1B1640001B168,
+        0x1B1700001B2FC,
+        0x1BC000001BC6B,
+        0x1BC700001BC7D,
+        0x1BC800001BC89,
+        0x1BC900001BC9A,
+        0x1BC9D0001BC9F,
+        0x1CF000001CF2E,
+        0x1CF300001CF47,
+        0x1DA000001DA37,
+        0x1DA3B0001DA6D,
+        0x1DA750001DA76,
+        0x1DA840001DA85,
+        0x1DA9B0001DAA0,
+        0x1DAA10001DAB0,
+        0x1DF000001DF1F,
+        0x1DF250001DF2B,
+        0x1E0000001E007,
+        0x1E0080001E019,
+        0x1E01B0001E022,
+        0x1E0230001E025,
+        0x1E0260001E02B,
+        0x1E08F0001E090,
+        0x1E1000001E12D,
+        0x1E1300001E13E,
+        0x1E1400001E14A,
+        0x1E14E0001E14F,
+        0x1E2900001E2AF,
+        0x1E2C00001E2FA,
+        0x1E4D00001E4FA,
+        0x1E5D00001E5FB,
+        0x1E6C00001E6DF,
+        0x1E6E00001E6F6,
+        0x1E6FE0001E700,
+        0x1E7E00001E7E7,
+        0x1E7E80001E7EC,
+        0x1E7ED0001E7EF,
+        0x1E7F00001E7FF,
+        0x1E8000001E8C5,
+        0x1E8D00001E8D7,
+        0x1E9220001E94C,
+        0x1E9500001E95A,
+        0x200000002A6E0,
+        0x2A7000002B81E,
+        0x2B8200002CEAE,
+        0x2CEB00002EBE1,
+        0x2EBF00002EE5E,
+        0x300000003134B,
+        0x313500003347A,
+    ),
+    "CONTEXTJ": (0x200C0000200E,),
+    "CONTEXTO": (
+        0xB7000000B8,
+        0x37500000376,
+        0x5F3000005F5,
+        0x6600000066A,
+        0x6F0000006FA,
+        0x30FB000030FC,
+    ),
+}

hai-mcp-pr7/.venv/lib/python3.13/site-packages/idna/intranges.py

@@ -0,0 +1,55 @@
+"""
+Given a list of integers, made up of (hopefully) a small number of long runs
+of consecutive integers, compute a representation of the form
+((start1, end1), (start2, end2) ...). Then answer the question "was x present
+in the original list?" in time O(log(# runs)).
+"""
+
+import bisect
+
+
+def intranges_from_list(list_: list[int]) -> tuple[int, ...]:
+    """Represent a list of integers as a sequence of ranges:
+    ((start_0, end_0), (start_1, end_1), ...), such that the original
+    integers are exactly those x such that start_i <= x < end_i for some i.
+
+    Ranges are encoded as single integers (start << 32 | end), not as tuples.
+    """
+
+    sorted_list = sorted(list_)
+    ranges = []
+    last_write = -1
+    for i in range(len(sorted_list)):
+        if i + 1 < len(sorted_list) and sorted_list[i] == sorted_list[i + 1] - 1:
+            continue
+        current_range = sorted_list[last_write + 1 : i + 1]
+        ranges.append(_encode_range(current_range[0], current_range[-1] + 1))
+        last_write = i
+
+    return tuple(ranges)
+
+
+def _encode_range(start: int, end: int) -> int:
+    return (start << 32) | end
+
+
+def _decode_range(r: int) -> tuple[int, int]:
+    return (r >> 32), (r & ((1 << 32) - 1))
+
+
+def intranges_contain(int_: int, ranges: tuple[int, ...]) -> bool:
+    """Determine if `int_` falls into one of the ranges in `ranges`."""
+    tuple_ = _encode_range(int_, 0)
+    pos = bisect.bisect_left(ranges, tuple_)
+    # we could be immediately ahead of a tuple (start, end)
+    # with start < int_ <= end
+    if pos > 0:
+        left, right = _decode_range(ranges[pos - 1])
+        if left <= int_ < right:
+            return True
+    # or we could be immediately behind a tuple (int_, end)
+    if pos < len(ranges):
+        left, _ = _decode_range(ranges[pos])
+        if left == int_:
+            return True
+    return False

hai-mcp-pr7/.venv/lib/python3.13/site-packages/idna/package_data.py

@@ -0,0 +1 @@
+__version__ = "3.18"

hai-mcp-pr7/.venv/lib/python3.13/site-packages/iniconfig-2.3.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+uv

hai-mcp-pr7/.venv/lib/python3.13/site-packages/iniconfig-2.3.0.dist-info/METADATA

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: iniconfig
+Version: 2.3.0
+Summary: brain-dead simple config-ini parsing
+Author-email: Ronny Pfannschmidt <opensource@ronnypfannschmidt.de>, Holger Krekel <holger.krekel@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/pytest-dev/iniconfig
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+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 :: Software Development :: Libraries
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Dynamic: license-file
+
+iniconfig: brain-dead simple parsing of ini files
+=======================================================
+
+iniconfig is a small and simple INI-file parser module
+having a unique set of features:
+
+* maintains order of sections and entries
+* supports multi-line values with or without line-continuations
+* supports "#" comments everywhere
+* raises errors with proper line-numbers
+* no bells and whistles like automatic substitutions
+* iniconfig raises an Error if two sections have the same name.
+
+If you encounter issues or have feature wishes please report them to:
+
+    https://github.com/RonnyPfannschmidt/iniconfig/issues
+
+Basic Example
+===================================
+
+If you have an ini file like this:
+
+.. code-block:: ini
+
+    # content of example.ini
+    [section1] # comment
+    name1=value1  # comment
+    name1b=value1,value2  # comment
+
+    [section2]
+    name2=
+        line1
+        line2
+
+then you can do:
+
+.. code-block:: pycon
+
+    >>> import iniconfig
+    >>> ini = iniconfig.IniConfig("example.ini")
+    >>> ini['section1']['name1'] # raises KeyError if not exists
+    'value1'
+    >>> ini.get('section1', 'name1b', [], lambda x: x.split(","))
+    ['value1', 'value2']
+    >>> ini.get('section1', 'notexist', [], lambda x: x.split(","))
+    []
+    >>> [x.name for x in list(ini)]
+    ['section1', 'section2']
+    >>> list(list(ini)[0].items())
+    [('name1', 'value1'), ('name1b', 'value1,value2')]
+    >>> 'section1' in ini
+    True
+    >>> 'inexistendsection' in ini
+    False

hai-mcp-pr7/.venv/lib/python3.13/site-packages/iniconfig-2.3.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+iniconfig-2.3.0.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2
+iniconfig-2.3.0.dist-info/METADATA,sha256=QNdz-E5OES9JW79PG-nL0tRWwK6271MR910b8yLyFls,2526
+iniconfig-2.3.0.dist-info/RECORD,,
+iniconfig-2.3.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+iniconfig-2.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+iniconfig-2.3.0.dist-info/licenses/LICENSE,sha256=NAn6kfes5VeJRjJnZlbjImT-XvdYFTVyXcmiN3RVG9Q,1098
+iniconfig-2.3.0.dist-info/top_level.txt,sha256=7KfM0fugdlToj9UW7enKXk2HYALQD8qHiyKtjhSzgN8,10
+iniconfig/__init__.py,sha256=XL5eqUYj4mskAOorZ5jfRAinJvJzTI-fJxpP4xfXtaw,7497
+iniconfig/_parse.py,sha256=5ncBl7MAQiaPNnpRrs9FR4t6G6DkgOUs458OY_1CR28,5223
+iniconfig/_version.py,sha256=KNFYe-Vtdt7Z-oHyl8jmDAQ9qXoCNMAEXigj6BR1QUI,704
+iniconfig/exceptions.py,sha256=mipQ_aMxD9CvSvFWN1oTXY4QuRnKAMZ1f3sCdmjDTU0,399
+iniconfig/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0

hai-mcp-pr7/.venv/lib/python3.13/site-packages/iniconfig-2.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

hai-mcp-pr7/.venv/lib/python3.13/site-packages/iniconfig-2.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2010 - 2023 Holger Krekel and others
+
+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.

hai-mcp-pr7/.venv/lib/python3.13/site-packages/iniconfig-2.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+iniconfig

hai-mcp-pr7/.venv/lib/python3.13/site-packages/iniconfig/__init__.py

@@ -0,0 +1,249 @@
+"""brain-dead simple parser for ini-style files.
+(C) Ronny Pfannschmidt, Holger Krekel -- MIT licensed
+"""
+
+import os
+from collections.abc import Callable
+from collections.abc import Iterator
+from collections.abc import Mapping
+from typing import Final
+from typing import TypeVar
+from typing import overload
+
+__all__ = ["IniConfig", "ParseError", "COMMENTCHARS", "iscommentline"]
+
+from . import _parse
+from ._parse import COMMENTCHARS
+from ._parse import iscommentline
+from .exceptions import ParseError
+
+_D = TypeVar("_D")
+_T = TypeVar("_T")
+
+
+class SectionWrapper:
+    config: Final["IniConfig"]
+    name: Final[str]
+
+    def __init__(self, config: "IniConfig", name: str) -> None:
+        self.config = config
+        self.name = name
+
+    def lineof(self, name: str) -> int | None:
+        return self.config.lineof(self.name, name)
+
+    @overload
+    def get(self, key: str) -> str | None: ...
+
+    @overload
+    def get(
+        self,
+        key: str,
+        convert: Callable[[str], _T],
+    ) -> _T | None: ...
+
+    @overload
+    def get(
+        self,
+        key: str,
+        default: None,
+        convert: Callable[[str], _T],
+    ) -> _T | None: ...
+
+    @overload
+    def get(self, key: str, default: _D, convert: None = None) -> str | _D: ...
+
+    @overload
+    def get(
+        self,
+        key: str,
+        default: _D,
+        convert: Callable[[str], _T],
+    ) -> _T | _D: ...
+
+    # TODO: investigate possible mypy bug wrt matching the passed over data
+    def get(  # type: ignore [misc]
+        self,
+        key: str,
+        default: _D | None = None,
+        convert: Callable[[str], _T] | None = None,
+    ) -> _D | _T | str | None:
+        return self.config.get(self.name, key, convert=convert, default=default)
+
+    def __getitem__(self, key: str) -> str:
+        return self.config.sections[self.name][key]
+
+    def __iter__(self) -> Iterator[str]:
+        section: Mapping[str, str] = self.config.sections.get(self.name, {})
+
+        def lineof(key: str) -> int:
+            return self.config.lineof(self.name, key)  # type: ignore[return-value]
+
+        yield from sorted(section, key=lineof)
+
+    def items(self) -> Iterator[tuple[str, str]]:
+        for name in self:
+            yield name, self[name]
+
+
+class IniConfig:
+    path: Final[str]
+    sections: Final[Mapping[str, Mapping[str, str]]]
+    _sources: Final[Mapping[tuple[str, str | None], int]]
+
+    def __init__(
+        self,
+        path: str | os.PathLike[str],
+        data: str | None = None,
+        encoding: str = "utf-8",
+        *,
+        _sections: Mapping[str, Mapping[str, str]] | None = None,
+        _sources: Mapping[tuple[str, str | None], int] | None = None,
+    ) -> None:
+        self.path = os.fspath(path)
+
+        # Determine sections and sources
+        if _sections is not None and _sources is not None:
+            # Use provided pre-parsed data (called from parse())
+            sections_data = _sections
+            sources = _sources
+        else:
+            # Parse the data (backward compatible path)
+            if data is None:
+                with open(self.path, encoding=encoding) as fp:
+                    data = fp.read()
+
+            # Use old behavior (no stripping) for backward compatibility
+            sections_data, sources = _parse.parse_ini_data(
+                self.path, data, strip_inline_comments=False
+            )
+
+        # Assign once to Final attributes
+        self._sources = sources
+        self.sections = sections_data
+
+    @classmethod
+    def parse(
+        cls,
+        path: str | os.PathLike[str],
+        data: str | None = None,
+        encoding: str = "utf-8",
+        *,
+        strip_inline_comments: bool = True,
+        strip_section_whitespace: bool = False,
+    ) -> "IniConfig":
+        """Parse an INI file.
+
+        Args:
+            path: Path to the INI file (used for error messages)
+            data: Optional INI content as string. If None, reads from path.
+            encoding: Encoding to use when reading the file (default: utf-8)
+            strip_inline_comments: Whether to strip inline comments from values
+                (default: True). When True, comments starting with # or ; are
+                removed from values, matching the behavior for section comments.
+            strip_section_whitespace: Whether to strip whitespace from section and key names
+                (default: False). When True, strips Unicode whitespace from section and key names,
+                addressing issue #4. When False, preserves existing behavior for backward compatibility.
+
+        Returns:
+            IniConfig instance with parsed configuration
+
+        Example:
+            # With comment stripping (default):
+            config = IniConfig.parse("setup.cfg")
+            # value = "foo" instead of "foo # comment"
+
+            # Without comment stripping (old behavior):
+            config = IniConfig.parse("setup.cfg", strip_inline_comments=False)
+            # value = "foo # comment"
+
+            # With section name stripping (opt-in for issue #4):
+            config = IniConfig.parse("setup.cfg", strip_section_whitespace=True)
+            # section names and keys have Unicode whitespace stripped
+        """
+        fspath = os.fspath(path)
+
+        if data is None:
+            with open(fspath, encoding=encoding) as fp:
+                data = fp.read()
+
+        sections_data, sources = _parse.parse_ini_data(
+            fspath,
+            data,
+            strip_inline_comments=strip_inline_comments,
+            strip_section_whitespace=strip_section_whitespace,
+        )
+
+        # Call constructor with pre-parsed sections and sources
+        return cls(path=fspath, _sections=sections_data, _sources=sources)
+
+    def lineof(self, section: str, name: str | None = None) -> int | None:
+        lineno = self._sources.get((section, name))
+        return None if lineno is None else lineno + 1
+
+    @overload
+    def get(
+        self,
+        section: str,
+        name: str,
+    ) -> str | None: ...
+
+    @overload
+    def get(
+        self,
+        section: str,
+        name: str,
+        convert: Callable[[str], _T],
+    ) -> _T | None: ...
+
+    @overload
+    def get(
+        self,
+        section: str,
+        name: str,
+        default: None,
+        convert: Callable[[str], _T],
+    ) -> _T | None: ...
+
+    @overload
+    def get(
+        self, section: str, name: str, default: _D, convert: None = None
+    ) -> str | _D: ...
+
+    @overload
+    def get(
+        self,
+        section: str,
+        name: str,
+        default: _D,
+        convert: Callable[[str], _T],
+    ) -> _T | _D: ...
+
+    def get(  # type: ignore
+        self,
+        section: str,
+        name: str,
+        default: _D | None = None,
+        convert: Callable[[str], _T] | None = None,
+    ) -> _D | _T | str | None:
+        try:
+            value: str = self.sections[section][name]
+        except KeyError:
+            return default
+        else:
+            if convert is not None:
+                return convert(value)
+            else:
+                return value
+
+    def __getitem__(self, name: str) -> SectionWrapper:
+        if name not in self.sections:
+            raise KeyError(name)
+        return SectionWrapper(self, name)
+
+    def __iter__(self) -> Iterator[SectionWrapper]:
+        for name in sorted(self.sections, key=self.lineof):  # type: ignore
+            yield SectionWrapper(self, name)
+
+    def __contains__(self, arg: str) -> bool:
+        return arg in self.sections