python-http_request 0.0.7.1__tar.gz → 0.0.9__tar.gz

{python_http_request-0.0.7.1 → python_http_request-0.0.9}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: python-http_request
-Version: 0.0.7.1
+Version: 0.0.9
 Summary: Python http response utils.
-Home-page: https://github.com/ChenyangGao/web-mount-packs/tree/main/python-module/python-http_request
+Home-page: https://github.com/ChenyangGao/python-modules/tree/main/python-http_request
 License: MIT
 Keywords: http,request
 Author: ChenyangGao
@@ -20,11 +20,14 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Software Development
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Dist: integer_tool (>=0.0.2)
-Requires-Dist: python-asynctools (>=0.0.10)
-Requires-Dist: python-filewrap (>=0.2.6)
-Requires-Dist: python-texttools (>=0.0.3)
-Project-URL: Repository, https://github.com/ChenyangGao/web-mount-packs/tree/main/python-module/python-http_request
+Requires-Dist: http_response (>=0.0.4)
+Requires-Dist: orjson
+Requires-Dist: python-asynctools (>=0.1.3)
+Requires-Dist: python-dicttools (>=0.0.1)
+Requires-Dist: python-ensure (>=0.0.1)
+Requires-Dist: python-filewrap (>=0.2.8)
+Requires-Dist: python-texttools (>=0.0.4)
+Project-URL: Repository, https://github.com/ChenyangGao/python-modules/tree/main/python-http_request
 Description-Content-Type: text/markdown
 
 # Python http response utils.

python_http_request-0.0.9/http_request/__init__.py

@@ -0,0 +1,449 @@
+#!/usr/bin/env python3
+# encoding: utf-8
+
+__author__ = "ChenyangGao <https://chenyanggao.github.io>"
+__version__ = (0, 0, 9)
+__all__ = [
+    "SupportsGeturl", "url_origin", "complete_url", "ensure_ascii_url", 
+    "urlencode", "cookies_str_to_dict", "headers_str_to_dict_by_lines", 
+    "headers_str_to_dict", "encode_multipart_data", "encode_multipart_data_async", 
+    "normalize_request_args", 
+]
+
+from collections import UserString
+from collections.abc import (
+    AsyncIterable, AsyncIterator, Buffer, Iterable, Iterator, 
+    Mapping, Sequence, 
+)
+from decimal import Decimal
+from fractions import Fraction
+from io import TextIOWrapper
+from itertools import batched
+from mimetypes import guess_type
+from numbers import Integral, Real
+from os import PathLike
+from os.path import basename
+from re import compile as re_compile, Pattern
+from string import punctuation
+from typing import runtime_checkable, Any, Final, Protocol, TypedDict
+from urllib.parse import quote, urlparse, urlunparse
+from uuid import uuid4
+from yarl import URL
+
+from asynctools import async_map
+from dicttools import dict_map, iter_items
+from ensure import ensure_bytes, ensure_buffer, ensure_str
+from filewrap import bio_chunk_iter, bio_chunk_async_iter, SupportsRead
+from http_response import get_charset, get_mimetype
+from orjson import dumps as json_dumps
+from texttools import text_to_dict
+
+
+type string = Buffer | str | UserString
+
+QUERY_KEY_TRANSTAB: Final = {k: f"%{k:02X}" for k in b"&="}
+CRE_URL_SCHEME_match: Final = re_compile(r"(?i:[a-z][a-z0-9.+-]*)://").match
+
+
+class RequestArgs(TypedDict):
+    method: str
+    url: str
+    data: Buffer | Iterable[Buffer] | AsyncIterable[Buffer]
+    headers: dict[str, str]
+
+
+@runtime_checkable
+class SupportsGeturl[AnyStr: (bytes, str)](Protocol):
+    def geturl(self) -> AnyStr: ...
+
+
+def url_origin(url: str, /, default_port: int = 0) -> str:
+    if url.startswith("/"):
+        url = "http://localhost" + url
+    elif url.startswith("//"):
+        url = "http:" + url
+    elif url.startswith("://"):
+        url = "http" + url
+    elif not CRE_URL_SCHEME_match(url):
+        url = "http://" + url
+    urlp = urlparse(url)
+    scheme, netloc = urlp.scheme or "http", urlp.netloc or "localhost"
+    if default_port and not urlp.port:
+        netloc = netloc.removesuffix(":") + f":{default_port}"
+    return f"{scheme}://{netloc}"
+
+
+def complete_url(url: str, /, default_port: int = 0) -> str:
+    if url.startswith("/"):
+        url = "http://localhost" + url
+    elif url.startswith("//"):
+        url = "http:" + url
+    elif url.startswith("://"):
+        url = "http" + url
+    elif not CRE_URL_SCHEME_match(url):
+        url = "http://" + url
+    urlp = urlparse(url)
+    repl = {"query": "", "fragment": ""}
+    if not urlp.scheme:
+        repl["scheme"] = "http"
+    netloc = urlp.netloc
+    if not netloc:
+        netloc = "localhost"
+    if default_port and not urlp.port:
+        netloc = netloc.removesuffix(":") + f":{default_port}"
+    repl["netloc"] = netloc
+    return urlunparse(urlp._replace(**repl)).rstrip("/")
+
+
+def ensure_ascii_url(url: str, /) -> str:
+    if url.isascii():
+        return url
+    return quote(url, safe=punctuation)
+
+
+def urlencode(
+    payload: string | Mapping[Any, Any] | Iterable[tuple[Any, Any]], 
+    /, 
+    encoding: str = "utf-8", 
+    errors: str = "strict", 
+) -> str:
+    if isinstance(payload, str):
+        return payload
+    elif isinstance(payload, UserString):
+        return str(payload)
+    elif isinstance(payload, Buffer):
+        return str(payload, encoding, errors)
+    def encode_iter(payload: Iterable[tuple[Any, Any]], /) -> Iterator[str]:
+        for i, (k, v) in enumerate(payload):
+            if i:
+                yield "&"
+            if isinstance(k, Buffer):
+                k = str(k, encoding, errors)
+            else:
+                k = str(k)
+            yield k.translate(QUERY_KEY_TRANSTAB)
+            yield "="
+            if v is True:
+                yield "true"
+            elif v is False:
+                yield "false"
+            elif v is None:
+                yield "null"
+            elif isinstance(v, (str, UserString)):
+                pass
+            elif isinstance(v, Buffer):
+                v = str(v, encoding, errors)
+            elif isinstance(v, (Mapping, Iterable)):
+                v = json_dumps(v, default=json_default).decode("utf-8")
+            else:
+                v = str(v)
+            yield v.replace("&", "%26")
+    return "".join(encode_iter(iter_items(payload)))
+
+
+def cookies_str_to_dict(
+    cookies: str, 
+    /, 
+    kv_sep: str | Pattern[str] = re_compile(r"\s*=\s*"), 
+    entry_sep: str | Pattern[str] = re_compile(r"\s*;\s*"), 
+) -> dict[str, str]:
+    return text_to_dict(cookies.strip(), kv_sep, entry_sep)
+
+
+def headers_str_to_dict(
+    headers: str, 
+    /, 
+    kv_sep: str | Pattern[str] = re_compile(r":\s+"), 
+    entry_sep: str | Pattern[str] = re_compile("\n+"), 
+) -> dict[str, str]:
+    return text_to_dict(headers.strip(), kv_sep, entry_sep)
+
+
+def headers_str_to_dict_by_lines(headers: str, /, ) -> dict[str, str]:
+    lines = headers.strip().split("\n")
+    if len(lines) & 1:
+        lines.append("")
+    return dict(batched(lines, 2)) # type: ignore
+
+
+def encode_multipart_data(
+    data: None | Mapping[Buffer | str, Any] = None, 
+    files: None | Mapping[Buffer | str, Any] = None, 
+    boundary: None | str = None, 
+    file_suffix: str = "", 
+) -> tuple[dict, Iterator[Buffer]]:
+    if not boundary:
+        boundary = uuid4().hex
+        boundary_bytes = bytes(boundary, "ascii")
+    elif isinstance(boundary, str):
+        boundary_bytes = bytes(boundary, "latin-1")
+    else:
+        boundary_bytes = bytes(boundary)
+        boundary = str(boundary_bytes, "latin-1")
+    boundary_line = b"--%s\r\n" % boundary_bytes
+    suffix = ensure_bytes(file_suffix)
+    if suffix and not suffix.startswith(b"."):
+        suffix = b"." + suffix
+
+    def encode_item(name, value, /, is_file=False) -> Iterator[Buffer]:
+        headers = {b"content-disposition": b'form-data; name="%s"' % bytes(quote(name), "ascii")}
+        filename = b""
+        if isinstance(value, (list, tuple)):
+            match value:
+                case [value]:
+                    pass
+                case [_, value]:
+                    pass
+                case [_, value, file_type]:
+                    if file_type:
+                        headers[b"content-type"] = ensure_bytes(file_type)
+                case [_, value, file_type, file_headers, *rest]:
+                    for k, v in iter_items(file_headers):
+                        headers[ensure_bytes(k).lower()] = ensure_bytes(v)
+                    if file_type:
+                        headers[b"content-type"] = ensure_bytes(file_type)
+        if isinstance(value, (PathLike, SupportsRead)):
+            is_file = True
+            if isinstance(value, PathLike):
+                file: SupportsRead[Buffer] = open(value, "rb")
+            elif isinstance(value, TextIOWrapper):
+                file = value.buffer
+            else:
+                file = value
+            value = bio_chunk_iter(file)
+            if not filename:
+                filename = ensure_bytes(basename(getattr(file, "name", b"") or b""))
+        elif isinstance(value, Buffer):
+            pass
+        elif isinstance(value, (str, UserString)):
+            value = ensure_bytes(value)
+        elif isinstance(value, Iterable):
+            value = map(ensure_buffer, value)
+        else:
+            value = ensure_buffer(value)
+        if is_file:
+            if filename:
+                filename = bytes(quote(filename), "ascii")
+                if suffix and not filename.endswith(suffix):
+                    filename += suffix
+            else:
+                filename = bytes(uuid4().hex, "ascii") + suffix
+            if b"content-type" not in headers:
+                headers[b"content-type"] = ensure_bytes(
+                    guess_type(str(filename, "latin-1"))[0] or b"application/octet-stream")
+            headers[b"content-disposition"] += b'; filename="%s"' % filename
+        yield boundary_line
+        for entry in headers.items():
+            yield b"%s: %s\r\n" % entry
+        yield b"\r\n"
+        if isinstance(value, Buffer):
+            yield value
+        else:
+            yield from value
+
+    def encode_iter() -> Iterator[Buffer]:
+        if data:
+            for name, value in iter_items(data):
+                yield boundary_line
+                yield from encode_item(name, value)
+                yield b"\r\n"
+        if files:
+            for name, value in iter_items(files):
+                yield boundary_line
+                yield from encode_item(name, value, is_file=True)
+                yield b"\r\n"
+        yield b'--%s--\r\n' % boundary_bytes
+
+    return {"content-type": "multipart/form-data; boundary="+boundary}, encode_iter()
+
+
+def encode_multipart_data_async(
+    data: None | Mapping[Buffer | str, Any] = None, 
+    files: None | Mapping[Buffer | str, Any] = None, 
+    boundary: None | str = None, 
+    file_suffix: str = "", 
+) -> tuple[dict, AsyncIterator[Buffer]]:
+    if not boundary:
+        boundary = uuid4().hex
+        boundary_bytes = bytes(boundary, "ascii")
+    elif isinstance(boundary, str):
+        boundary_bytes = bytes(boundary, "latin-1")
+    else:
+        boundary_bytes = bytes(boundary)
+        boundary = str(boundary_bytes, "latin-1")
+    boundary_line = b"--%s\r\n" % boundary_bytes
+    suffix = ensure_bytes(file_suffix)
+    if suffix and not suffix.startswith(b"."):
+        suffix = b"." + suffix
+
+    async def encode_item(name, value, /, is_file=False) -> AsyncIterator[Buffer]:
+        headers = {b"content-disposition": b'form-data; name="%s"' % bytes(quote(name), "ascii")}
+        filename = b""
+        if isinstance(value, (list, tuple)):
+            match value:
+                case [value]:
+                    pass
+                case [_, value]:
+                    pass
+                case [_, value, file_type]:
+                    if file_type:
+                        headers[b"content-type"] = ensure_bytes(file_type)
+                case [_, value, file_type, file_headers, *rest]:
+                    for k, v in iter_items(file_headers):
+                        headers[ensure_bytes(k).lower()] = ensure_bytes(v)
+                    if file_type:
+                        headers[b"content-type"] = ensure_bytes(file_type)
+        if isinstance(value, (PathLike, SupportsRead)):
+            is_file = True
+            if isinstance(value, PathLike):
+                file: SupportsRead[Buffer] = open(value, "rb")
+            elif isinstance(value, TextIOWrapper):
+                file = value.buffer
+            else:
+                file = value
+            value = bio_chunk_async_iter(file)
+            if not filename:
+                filename = ensure_bytes(basename(getattr(file, "name", b"") or b""))
+        elif isinstance(value, Buffer):
+            pass
+        elif isinstance(value, (str, UserString)):
+            value = ensure_bytes(value)
+        elif isinstance(value, Iterable):
+            value = async_map(ensure_buffer, value)
+        else:
+            value = ensure_buffer(value)
+        if is_file:
+            if filename:
+                filename = bytes(quote(filename), "ascii")
+                if suffix and not filename.endswith(suffix):
+                    filename += suffix
+            else:
+                filename = bytes(uuid4().hex, "ascii") + suffix
+            if b"content-type" not in headers:
+                headers[b"content-type"] = ensure_bytes(
+                    guess_type(str(filename, "latin-1"))[0] or b"application/octet-stream")
+            headers[b"content-disposition"] += b'; filename="%s"' % filename
+        yield boundary_line
+        for entry in headers.items():
+            yield b"%s: %s\r\n" % entry
+        yield b"\r\n"
+        if isinstance(value, Buffer):
+            yield value
+        elif isinstance(value, AsyncIterable):
+            async for line in value:
+                yield line
+        else:
+            for line in value:
+                yield line
+
+    async def encode_iter() -> AsyncIterator[Buffer]:
+        if data:
+            for name, value in iter_items(data):
+                yield boundary_line
+                async for line in encode_item(name, value):
+                    yield line
+                yield b"\r\n"
+        if files:
+            for name, value in iter_items(files):
+                yield boundary_line
+                async for line in encode_item(name, value, is_file=True):
+                    yield line
+                yield b"\r\n"
+        yield b'--%s--\r\n' % boundary_bytes
+
+    return {"content-type": "multipart/form-data; boundary="+boundary}, encode_iter()
+
+
+def json_default(o, /):
+    if isinstance(o, Mapping):
+        return dict(o)
+    elif isinstance(o, Buffer):
+        return ensure_str(o)
+    elif isinstance(o, UserString):
+        return str(o)
+    elif isinstance(o, Integral):
+        return int(o)
+    elif isinstance(o, (Real, Fraction, Decimal)):
+        try:
+            return float(o)
+        except Exception:
+            return str(o)
+    elif isinstance(o, (Iterator, Sequence)):
+        return list(o)
+    else:
+        return str(o)
+
+
+def normalize_request_args(
+    method: string, 
+    url: string | SupportsGeturl | URL, 
+    params: Any = None, 
+    data: Any = None, 
+    json: Any = None, 
+    headers: None | Mapping[string, Any] | Iterable[tuple[string, Any]] = None, 
+    ensure_ascii: bool = False, 
+) -> RequestArgs:
+    method = ensure_str(method).upper()
+    if isinstance(url, SupportsGeturl):
+        url = url.geturl()
+    elif isinstance(url, URL):
+        url = str(url)
+    url = complete_url(ensure_str(url))
+    if params and (params := urlencode(params)):
+        urlp = urlparse(url)
+        if query := urlp.query:
+            params = query + "&" + params
+        url = urlunparse(urlp._replace(query=params))
+    if ensure_ascii:
+        url = ensure_ascii_url(url)
+    headers_ = dict_map(
+        headers or (), 
+        key=lambda k: ensure_str(k).lower(), 
+        value=ensure_str, 
+    )
+    content_type = headers_.get("content-type", "")
+    charset      = get_charset(content_type)
+    mimetype     = get_mimetype(charset).lower()
+    if data is not None:
+        if isinstance(data, Buffer):
+            pass
+        elif isinstance(data, (str, UserString)):
+            data = data.encode(charset)
+        elif isinstance(data, AsyncIterable):
+            data = async_map(ensure_buffer, data)
+        elif isinstance(data, Iterator):
+            data = map(ensure_buffer, data)
+        elif mimetype == "application/json":
+            if charset == "utf-8":
+                data = json_dumps(data, default=json_default)
+            else:
+                from json import dumps
+                data = dumps(data, default=json_default).encode(charset)
+        elif isinstance(data, (Mapping, Sequence)):
+            if data:
+                data = urlencode(data, charset).encode(charset)
+                if mimetype != "application/x-www-form-urlencoded":
+                    headers_["content-type"] = "application/x-www-form-urlencoded"
+        else:
+            data = str(data).encode(charset)
+    elif json is not None:
+        if isinstance(json, Buffer):
+            data = json
+        elif isinstance(data, AsyncIterable):
+            data = async_map(ensure_buffer, data)
+        if charset == "utf-8":
+            data = json_dumps(data, default=json_default)
+        else:
+            from json import dumps
+            data = dumps(data, default=json_default).encode(charset)
+        if mimetype != "application/json":
+            headers_["content-type"] = "application/json; charset=" + charset
+    elif mimetype == "application/json":
+        data = b"null"
+    return {
+        "url": url, 
+        "method": method, 
+        "data": data, 
+        "headers": headers_
+    }
+

{python_http_request-0.0.7.1 → python_http_request-0.0.9}/pyproject.toml

@@ -1,12 +1,12 @@
 [tool.poetry]
 name = "python-http_request"
-version = "0.0.7.1"
+version = "0.0.9"
 description = "Python http response utils."
 authors = ["ChenyangGao <wosiwujm@gmail.com>"]
 license = "MIT"
 readme = "readme.md"
-homepage = "https://github.com/ChenyangGao/web-mount-packs/tree/main/python-module/python-http_request"
-repository = "https://github.com/ChenyangGao/web-mount-packs/tree/main/python-module/python-http_request"
+homepage = "https://github.com/ChenyangGao/python-modules/tree/main/python-http_request"
+repository = "https://github.com/ChenyangGao/python-modules/tree/main/python-http_request"
 keywords = ["http", "request"]
 classifiers = [
     "License :: OSI Approved :: MIT License",
@@ -27,10 +27,13 @@ include = [
 
 [tool.poetry.dependencies]
 python = "^3.12"
-python-asynctools = ">=0.0.10"
-python-filewrap = ">=0.2.6"
-python-texttools = ">=0.0.3"
-integer_tool = ">=0.0.2"
+http_response = ">=0.0.4"
+orjson = "*"
+python-asynctools = ">=0.1.3"
+python-dicttools = ">=0.0.1"
+python-ensure = ">=0.0.1"
+python-filewrap = ">=0.2.8"
+python-texttools = ">=0.0.4"
 
 [build-system]
 requires = ["poetry-core"]

python_http_request-0.0.7.1/http_request/__init__.py

@@ -1,273 +0,0 @@
-#!/usr/bin/env python3
-# encoding: utf-8
-
-__author__ = "ChenyangGao <https://chenyanggao.github.io>"
-__version__ = (0, 0, 7)
-__all__ = [
-    "SupportsGeturl", "url_origin", "complete_url", "cookies_str_to_dict", "headers_str_to_dict", 
-    "encode_multipart_data", "encode_multipart_data_async", 
-]
-
-from collections.abc import AsyncIterable, AsyncIterator, Buffer, ItemsView, Iterable, Iterator, Mapping
-from itertools import chain
-from mimetypes import guess_type
-from os import fsdecode
-from os.path import basename
-from re import compile as re_compile, Pattern
-from typing import runtime_checkable, Any, Final, Protocol, TypeVar
-from urllib.parse import quote, urlsplit, urlunsplit
-from uuid import uuid4
-
-from asynctools import ensure_aiter, async_chain
-from filewrap import bio_chunk_iter, bio_chunk_async_iter, SupportsRead
-from integer_tool import int_to_bytes
-from texttools import text_to_dict
-
-
-AnyStr = TypeVar("AnyStr", bytes, str, covariant=True)
-
-CRE_URL_SCHEME_match: Final = re_compile(r"(?i:[a-z][a-z0-9.+-]*)://").match
-
-
-@runtime_checkable
-class SupportsGeturl(Protocol[AnyStr]):
-    def geturl(self) -> AnyStr: ...
-
-
-def url_origin(url: str, /, default_port: int = 0) -> str:
-    if url.startswith("/"):
-        url = "http://localhost" + url
-    elif url.startswith("//"):
-        url = "http:" + url
-    elif url.startswith("://"):
-        url = "http" + url
-    elif not CRE_URL_SCHEME_match(url):
-        url = "http://" + url
-    urlp = urlsplit(url)
-    scheme, netloc = urlp.scheme or "http", urlp.netloc or "localhost"
-    if default_port and not urlp.port:
-        netloc = netloc.removesuffix(":") + f":{default_port}"
-    return f"{scheme}://{netloc}"
-
-
-def complete_url(url: str, /, default_port: int = 0) -> str:
-    if url.startswith("/"):
-        url = "http://localhost" + url
-    elif url.startswith("//"):
-        url = "http:" + url
-    elif url.startswith("://"):
-        url = "http" + url
-    elif not CRE_URL_SCHEME_match(url):
-        url = "http://" + url
-    urlp = urlsplit(url)
-    repl = {"query": "", "fragment": ""}
-    if not urlp.scheme:
-        repl["scheme"] = "http"
-    netloc = urlp.netloc
-    if not netloc:
-        netloc = "localhost"
-    if default_port and not urlp.port:
-        netloc = netloc.removesuffix(":") + f":{default_port}"
-    repl["netloc"] = netloc
-    return urlunsplit(urlp._replace(**repl)).rstrip("/")
-
-
-def cookies_str_to_dict(
-    cookies: str, 
-    /, 
-    kv_sep: str | Pattern[str] = re_compile(r"\s*=\s*"), 
-    entry_sep: str | Pattern[str] = re_compile(r"\s*;\s*"), 
-) -> dict[str, str]:
-    return text_to_dict(cookies.strip(), kv_sep, entry_sep)
-
-
-def headers_str_to_dict(
-    headers: str, 
-    /, 
-    kv_sep: str | Pattern[str] = re_compile(r":\s+"), 
-    entry_sep: str | Pattern[str] = re_compile("\n+"), 
-) -> dict[str, str]:
-    return text_to_dict(headers.strip(), kv_sep, entry_sep)
-
-
-def ensure_bytes(s, /) -> bytes:
-    if isinstance(s, bytes):
-        return s
-    elif isinstance(s, memoryview):
-        return s.tobytes()
-    elif isinstance(s, Buffer):
-        return bytes(s)
-    if isinstance(s, int):
-        return int_to_bytes(s)
-    elif isinstance(s, str):
-        return bytes(s, "utf-8")
-    try:
-        return bytes(s)
-    except TypeError:
-        return bytes(str(s), "utf-8")
-
-
-def encode_multipart_data(
-    data: None | Mapping[str, Any] = None, 
-    files: None | Mapping[str, Buffer | SupportsRead[Buffer] | Iterable[Buffer]] = None, 
-    boundary: None | str = None, 
-    file_suffix: str = "", 
-) -> tuple[dict, Iterator[Buffer]]:
-    if not boundary:
-        boundary = uuid4().hex
-    suffix = bytes(file_suffix, "ascii")
-    if suffix and not suffix.startswith(b"."):
-        suffix = b"." + suffix
-    headers = {"Content-Type": f"multipart/form-data; boundary={boundary}"}
-
-    def encode_data(data) -> Iterator[Buffer]:
-        if not data:
-            return
-        if isinstance(data, Mapping):
-            data = ItemsView(data)
-        for name, value in data:
-            yield boundary_line
-            yield b'Content-Disposition: form-data; name="%s"\r\n\r\n' % bytes(quote(name), "ascii")
-            yield ensure_bytes(value)
-            yield b"\r\n"
-
-    def encode_files(files) -> Iterator[Buffer]:
-        if not files:
-            return
-        if isinstance(files, Mapping):
-            files = ItemsView(files)
-        for name, file in files:
-            headers: dict[bytes, bytes] = {b"Content-Disposition": b'form-data; name="%s"' % quote(name).encode("ascii")}
-            filename: bytes | str = ""
-            if isinstance(file, (list, tuple)):
-                match file:
-                    case [file]:
-                        pass
-                    case [file_name, file]:
-                        pass
-                    case [file_name, file, file_type]:
-                        if file_type:
-                            headers[b"Content-Type"] = ensure_bytes(file_type)
-                    case [file_name, file, file_type, file_headers, *rest]:
-                        if isinstance(file_headers, Mapping):
-                            file_headers = ItemsView(file_headers)
-                        for k, v in file_headers:
-                            headers[ensure_bytes(k).title()] = ensure_bytes(v)
-                        if file_type:
-                            headers[b"Content-Type"] = ensure_bytes(file_type)
-            if isinstance(file, Buffer):
-                pass
-            elif isinstance(file, str):
-                file = file.encode("utf-8")
-            elif hasattr(file, "read"):
-                file = bio_chunk_iter(file)
-                if not filename:
-                    path = getattr(file, "name", None)
-                    if path:
-                        filename = basename(path)
-                        if b"Content-Type" not in headers:
-                            headers[b"Content-Type"] = ensure_bytes(guess_type(fsdecode(filename))[0] or b"application/octet-stream")
-            if filename:
-                name = bytes(quote(filename), "ascii")
-                if not name.endswith(suffix):
-                    name += suffix
-                headers[b"Content-Disposition"] += b'; filename="%s"' % name
-            else:
-                headers[b"Content-Disposition"] += b'; filename="%032x%s"' % (uuid4().int, suffix)
-            yield boundary_line
-            for entry in headers.items():
-                yield b"%s: %s\r\n" % entry
-            yield b"\r\n"
-            if isinstance(file, Buffer):
-                yield file
-            else:
-                yield from file
-            yield b"\r\n"
-
-    boundary_line = b"--%s\r\n" % boundary.encode("utf-8")
-    return headers, chain(encode_data(data), encode_files(files), (b'--%s--\r\n' % boundary.encode("ascii"),))
-
-
-def encode_multipart_data_async(
-    data: None | Mapping[str, Any] = None, 
-    files: None | Mapping[str, Buffer | SupportsRead[Buffer] | Iterable[Buffer] | AsyncIterable[Buffer]] = None, 
-    boundary: None | str = None, 
-    file_suffix: str = "", 
-) -> tuple[dict, AsyncIterator[Buffer]]:
-    if not boundary:
-        boundary = uuid4().hex
-    suffix = bytes(file_suffix, "ascii")
-    if suffix and not suffix.startswith(b"."):
-        suffix = b"." + suffix
-    headers = {"Content-Type": f"multipart/form-data; boundary={boundary}"}
-
-    async def encode_data(data) -> AsyncIterator[Buffer]:
-        if not data:
-            return
-        if isinstance(data, Mapping):
-            data = ItemsView(data)
-        for name, value in data:
-            yield boundary_line
-            yield b'Content-Disposition: form-data; name="%s"\r\n\r\n' % bytes(quote(name), "ascii")
-            yield ensure_bytes(value)
-            yield b"\r\n"
-
-    async def encode_files(files) -> AsyncIterator[Buffer]:
-        if not files:
-            return
-        if isinstance(files, Mapping):
-            files = ItemsView(files)
-        for name, file in files:
-            headers: dict[bytes, bytes] = {b"Content-Disposition": b'form-data; name="%s"' % quote(name).encode("ascii")}
-            filename: bytes | str = ""
-            if isinstance(file, (list, tuple)):
-                match file:
-                    case [file]:
-                        pass
-                    case [file_name, file]:
-                        pass
-                    case [file_name, file, file_type]:
-                        if file_type:
-                            headers[b"Content-Type"] = ensure_bytes(file_type)
-                    case [file_name, file, file_type, file_headers, *rest]:
-                        if isinstance(file_headers, Mapping):
-                            file_headers = ItemsView(file_headers)
-                        for k, v in file_headers:
-                            headers[ensure_bytes(k).title()] = ensure_bytes(v)
-                        if file_type:
-                            headers[b"Content-Type"] = ensure_bytes(file_type)
-            if isinstance(file, Buffer):
-                pass
-            elif isinstance(file, str):
-                file = file.encode("utf-8")
-            elif hasattr(file, "read"):
-                file = bio_chunk_async_iter(file)
-                if not filename:
-                    path = getattr(file, "name", None)
-                    if path:
-                        filename = basename(path)
-                        if b"Content-Type" not in headers:
-                            headers[b"Content-Type"] = ensure_bytes(guess_type(fsdecode(filename))[0] or b"application/octet-stream")
-            else:
-                file = ensure_aiter(file)
-            if filename:
-                name = bytes(quote(filename), "ascii")
-                if not name.endswith(suffix):
-                    name += suffix
-                headers[b"Content-Disposition"] += b'; filename="%s"' % name
-            else:
-                headers[b"Content-Disposition"] += b'; filename="%032x%s"' % (uuid4().int, suffix)
-            yield boundary_line
-            for entry in headers.items():
-                yield b"%s: %s\r\n" % entry
-            yield b"\r\n"
-            if isinstance(file, Buffer):
-                yield file
-            else:
-                async for chunk in file:
-                    yield chunk
-            yield b"\r\n"
-
-    boundary_line = b"--%s\r\n" % boundary.encode("utf-8")
-    return headers, async_chain(encode_data(data), encode_files(files), (b'--%s--\r\n' % boundary.encode("ascii"),))
-