python-http_request 0.0.7.1__py3-none-any.whl → 0.0.8__py3-none-any.whl

http_request/__init__.py

@@ -2,23 +2,29 @@
 # encoding: utf-8
 
 __author__ = "ChenyangGao <https://chenyanggao.github.io>"
-__version__ = (0, 0, 7)
+__version__ = (0, 0, 8)
 __all__ = [
-    "SupportsGeturl", "url_origin", "complete_url", "cookies_str_to_dict", "headers_str_to_dict", 
+    "SupportsGeturl", "url_origin", "complete_url", "cookies_str_to_dict", 
+    "headers_str_to_dict_by_lines", "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 collections import UserString
+from collections.abc import (
+    AsyncIterable, AsyncIterator, Buffer, Iterable, Iterator, Mapping, 
+)
+from io import TextIOWrapper
+from itertools import batched
 from mimetypes import guess_type
-from os import fsdecode
+from os import PathLike
 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 asynctools import async_map
+from dicttools import iter_items
 from filewrap import bio_chunk_iter, bio_chunk_async_iter, SupportsRead
 from integer_tool import int_to_bytes
 from texttools import text_to_dict
@@ -90,184 +96,237 @@ def headers_str_to_dict(
     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")
+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 ensure_bytes(
+    o, 
+    /, 
+    encoding: str = "utf-8", 
+    errors: str = "strict", 
+) -> bytes:
+    if isinstance(o, bytes):
+        return o
+    elif isinstance(o, memoryview):
+        return o.tobytes()
+    elif isinstance(o, Buffer):
+        return bytes(o)
+    elif isinstance(o, int):
+        return int_to_bytes(o)
+    elif isinstance(o, (str, UserString)):
+        return o.encode(encoding, errors)
+    try:
+        return bytes(o)
+    except TypeError:
+        return bytes(str(o), encoding, errors)
+
+
+def ensure_buffer(
+    o, 
+    /, 
+    encoding: str = "utf-8", 
+    errors: str = "strict", 
+) -> Buffer:
+    if isinstance(o, Buffer):
+        return o
+    elif isinstance(o, int):
+        return int_to_bytes(o)
+    elif isinstance(o, (str, UserString)):
+        return o.encode(encoding, errors)
     try:
-        return bytes(s)
+        return bytes(o)
     except TypeError:
-        return bytes(str(s), "utf-8")
+        return bytes(str(o), encoding, errors)
 
 
 def encode_multipart_data(
-    data: None | Mapping[str, Any] = None, 
-    files: None | Mapping[str, Buffer | SupportsRead[Buffer] | Iterable[Buffer]] = None, 
+    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
-    suffix = bytes(file_suffix, "ascii")
+        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
-    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
+
+    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:
-                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
+                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:
-                yield from file
-            yield b"\r\n"
+                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
 
-    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"),))
+    return {"content-type": "multipart/form-data; boundary="+boundary}, encode_iter()
 
 
 def encode_multipart_data_async(
-    data: None | Mapping[str, Any] = None, 
-    files: None | Mapping[str, Buffer | SupportsRead[Buffer] | Iterable[Buffer] | AsyncIterable[Buffer]] = None, 
+    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
-    suffix = bytes(file_suffix, "ascii")
+        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
-    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")
+
+    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 = ensure_aiter(file)
+                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:
-                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
+                filename = bytes(quote(filename), "ascii")
+                if suffix and not filename.endswith(suffix):
+                    filename += suffix
             else:
-                async for chunk in file:
-                    yield chunk
-            yield b"\r\n"
+                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
 
-    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"),))
+    return {"content-type": "multipart/form-data; boundary="+boundary}, encode_iter()
 

{python_http_request-0.0.7.1.dist-info → python_http_request-0.0.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-http_request
-Version: 0.0.7.1
+Version: 0.0.8
 Summary: Python http response utils.
 Home-page: https://github.com/ChenyangGao/web-mount-packs/tree/main/python-module/python-http_request
 License: MIT
@@ -20,10 +20,11 @@ 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)
+Requires-Dist: integer_tool (>=0.0.5)
+Requires-Dist: python-asynctools (>=0.1.3)
+Requires-Dist: python-dicttools (>=0.0.1)
+Requires-Dist: python-filewrap (>=0.2.8)
+Requires-Dist: python-texttools (>=0.0.4)
 Project-URL: Repository, https://github.com/ChenyangGao/web-mount-packs/tree/main/python-module/python-http_request
 Description-Content-Type: text/markdown
 

python_http_request-0.0.8.dist-info/RECORD

@@ -0,0 +1,7 @@
+LICENSE,sha256=o5242_N2TgDsWwFhPn7yr8YJNF7XsJM5NxUMtcT97bc,1100
+http_request/__init__.py,sha256=PN6Z9dOJjNkmtTqbcOJkT4ZYl3bzLhihm9PDfkJl0pE,11700
+http_request/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+python_http_request-0.0.8.dist-info/LICENSE,sha256=o5242_N2TgDsWwFhPn7yr8YJNF7XsJM5NxUMtcT97bc,1100
+python_http_request-0.0.8.dist-info/METADATA,sha256=7dsy4s6zE0WoMaVj6soTRCW6nQKwYS26QJlJQL3vAls,1520
+python_http_request-0.0.8.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+python_http_request-0.0.8.dist-info/RECORD,,

python_http_request-0.0.7.1.dist-info/RECORD

@@ -1,7 +0,0 @@
-LICENSE,sha256=o5242_N2TgDsWwFhPn7yr8YJNF7XsJM5NxUMtcT97bc,1100
-http_request/__init__.py,sha256=kF6myD_k_IErV9JaoDT9dNaJO5Kd72EjDbwYDswohxk,10464
-http_request/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-python_http_request-0.0.7.1.dist-info/LICENSE,sha256=o5242_N2TgDsWwFhPn7yr8YJNF7XsJM5NxUMtcT97bc,1100
-python_http_request-0.0.7.1.dist-info/METADATA,sha256=jHqEf5N1uINz6-kK3_qgq2_PyzVfbhFL6t9BmSFGE8Q,1481
-python_http_request-0.0.7.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-python_http_request-0.0.7.1.dist-info/RECORD,,