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

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

@@ -1,30 +1,29 @@
 Metadata-Version: 2.1
 Name: python-http_request
-Version: 0.0.5.3
+Version: 0.0.7.1
 Summary: Python http response utils.
 Home-page: https://github.com/ChenyangGao/web-mount-packs/tree/main/python-module/python-http_request
 License: MIT
 Keywords: http,request
 Author: ChenyangGao
 Author-email: wosiwujm@gmail.com
-Requires-Python: >=3.10,<4.0
+Requires-Python: >=3.12,<4.0
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-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 :: Only
 Classifier: Topic :: Software Development
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Dist: integer_tool
-Requires-Dist: python-asynctools
-Requires-Dist: python-filewrap (>=0.1)
-Requires-Dist: python-texttools
+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
 Description-Content-Type: text/markdown
 

python_http_request-0.0.7.1/http_request/__init__.py

@@ -0,0 +1,273 @@
+#!/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"),))
+

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-http_request"
-version = "0.0.5.3"
+version = "0.0.7.1"
 description = "Python http response utils."
 authors = ["ChenyangGao <wosiwujm@gmail.com>"]
 license = "MIT"
@@ -13,7 +13,7 @@ classifiers = [
     "Development Status :: 5 - Production/Stable",
     "Programming Language :: Python",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3 :: Only",
     "Operating System :: OS Independent",
     "Intended Audience :: Developers",
@@ -26,11 +26,11 @@ include = [
 ]
 
 [tool.poetry.dependencies]
-python = "^3.10"
-python-asynctools = "*"
-python-filewrap = ">=0.1"
-python-texttools = "*"
-integer_tool = "*"
+python = "^3.12"
+python-asynctools = ">=0.0.10"
+python-filewrap = ">=0.2.6"
+python-texttools = ">=0.0.3"
+integer_tool = ">=0.0.2"
 
 [build-system]
 requires = ["poetry-core"]

python_http_request-0.0.5.3/http_request/__init__.py

@@ -1,169 +0,0 @@
-#!/usr/bin/env python3
-# encoding: utf-8
-
-__author__ = "ChenyangGao <https://chenyanggao.github.io>"
-__version__ = (0, 0, 5)
-__all__ = [
-    "SupportsGeturl", "url_origin", "complete_url", "cookies_str_to_dict", "headers_str_to_dict", 
-    "encode_multipart_data", "encode_multipart_data_async", 
-]
-
-from itertools import chain
-from collections.abc import AsyncIterable, AsyncIterator, ItemsView, Iterable, Iterator, Mapping
-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, Buffer, SupportsRead
-from integer_tool import int_to_bytes
-from texttools import text_to_dict
-
-
-AnyStr = TypeVar("AnyStr", bytes, str, covariant=True)
-
-CRE_URL_SCHEME: Final = re_compile(r"^(?i:[a-z][a-z0-9.+-]*)://")
-
-
-@runtime_checkable
-class SupportsGeturl(Protocol[AnyStr]):
-    def geturl(self) -> AnyStr: ...
-
-
-def url_origin(url: str, /) -> str:
-    if url.startswith("://"):
-        url = "http" + url
-    elif CRE_URL_SCHEME.match(url) is None:
-        url = "http://" + url
-    urlp = urlsplit(url)
-    scheme, netloc = urlp.scheme, urlp.netloc
-    if not netloc:
-        netloc = "localhost"
-    return f"{scheme}://{netloc}"
-
-
-def complete_url(url: str, /) -> str:
-    if url.startswith("://"):
-        url = "http" + url
-    elif CRE_URL_SCHEME.match(url) is None:
-        url = "http://" + url
-    urlp = urlsplit(url)
-    repl = {"query": "", "fragment": ""}
-    if not urlp.netloc:
-        repl["path"] = "localhost"
-    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, /) -> Buffer:
-    if isinstance(s, Buffer):
-        return 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, 
-) -> tuple[dict, Iterator[Buffer]]:
-    if not boundary:
-        boundary = uuid4().bytes.hex()
-    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:
-            yield boundary_line
-            yield b'Content-Disposition: form-data; name="%s"\r\nContent-Type: application/octet-stream\r\n\r\n' % bytes(quote(name), "ascii")
-            if isinstance(file, Buffer):
-                yield file
-            elif hasattr(file, "read"):
-                yield from bio_chunk_iter(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, 
-) -> tuple[dict, AsyncIterator[Buffer]]:
-    if not boundary:
-        boundary = uuid4().bytes.hex()
-    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:
-            yield boundary_line
-            yield b'Content-Disposition: form-data; name="%s"\r\nContent-Type: application/octet-stream\r\n\r\n' % bytes(quote(name), "ascii")
-            if isinstance(file, Buffer):
-                yield file
-            elif hasattr(file, "read"):
-                async for b in bio_chunk_async_iter(file):
-                    yield b
-            else:
-                async for b in ensure_aiter(file):
-                    yield b
-            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"),))
-