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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-http_request
-Version: 0.0.9
+Version: 0.1.0
 Summary: Python http response utils.
 Home-page: https://github.com/ChenyangGao/python-modules/tree/main/python-http_request
 License: MIT

{python_http_request-0.0.9 → python_http_request-0.1.0}/http_request/__init__.py

@@ -2,7 +2,7 @@
 # encoding: utf-8
 
 __author__ = "ChenyangGao <https://chenyanggao.github.io>"
-__version__ = (0, 0, 9)
+__version__ = (0, 1, 0)
 __all__ = [
     "SupportsGeturl", "url_origin", "complete_url", "ensure_ascii_url", 
     "urlencode", "cookies_str_to_dict", "headers_str_to_dict_by_lines", 
@@ -25,7 +25,10 @@ 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 typing import (
+    cast, overload, runtime_checkable, Any, Final, Literal, Protocol, 
+    TypedDict, 
+)
 from urllib.parse import quote, urlparse, urlunparse
 from uuid import uuid4
 from yarl import URL
@@ -57,15 +60,17 @@ class SupportsGeturl[AnyStr: (bytes, str)](Protocol):
     def geturl(self) -> AnyStr: ...
 
 
-def url_origin(url: str, /, default_port: int = 0) -> str:
+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:
@@ -73,17 +78,27 @@ def url_origin(url: str, /, default_port: int = 0) -> str:
     return f"{scheme}://{netloc}"
 
 
-def complete_url(url: str, /, default_port: int = 0) -> str:
+def complete_url(
+    url: str, 
+    /, 
+    default_port: int = 0, 
+    clean: bool = False, 
+) -> 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
+    if not (clean or default_port):
+        if not CRE_URL_SCHEME_match(url):
+            url = "http://" + url
+        return url
     urlp = urlparse(url)
-    repl = {"query": "", "fragment": ""}
+    if clean:
+        repl = {"params": "", "query": "", "fragment": ""}
+    else:
+        repl = {}
     if not urlp.scheme:
         repl["scheme"] = "http"
     netloc = urlp.netloc
@@ -91,7 +106,10 @@ def complete_url(url: str, /, default_port: int = 0) -> str:
         netloc = "localhost"
     if default_port and not urlp.port:
         netloc = netloc.removesuffix(":") + f":{default_port}"
-    repl["netloc"] = netloc
+    if netloc != urlp.netloc:
+        repl["netloc"] = netloc
+    if not repl:
+        return url
     return urlunparse(urlp._replace(**repl)).rstrip("/")
 
 
@@ -166,12 +184,37 @@ def headers_str_to_dict_by_lines(headers: str, /, ) -> dict[str, str]:
     return dict(batched(lines, 2)) # type: ignore
 
 
+@overload
 def encode_multipart_data(
-    data: None | Mapping[Buffer | str, Any] = None, 
-    files: None | Mapping[Buffer | str, Any] = None, 
+    data: None | Mapping[string, Any] | Iterable[tuple[string, Any]] = None, 
+    files: None | Mapping[string, Any] | Iterable[tuple[string, Any]] = None, 
     boundary: None | str = None, 
     file_suffix: str = "", 
+    *, 
+    async_: Literal[False] = False, 
 ) -> tuple[dict, Iterator[Buffer]]:
+    ...
+@overload
+def encode_multipart_data(
+    data: None | Mapping[string, Any] | Iterable[tuple[string, Any]] = None, 
+    files: None | Mapping[string, Any] | Iterable[tuple[string, Any]] = None, 
+    boundary: None | str = None, 
+    file_suffix: str = "", 
+    *, 
+    async_: Literal[True], 
+) -> tuple[dict, AsyncIterator[Buffer]]:
+    ...
+def encode_multipart_data(
+    data: None | Mapping[string, Any] | Iterable[tuple[string, Any]] = None, 
+    files: None | Mapping[string, Any] | Iterable[tuple[string, Any]] = None, 
+    boundary: None | str = None, 
+    file_suffix: str = "", 
+    *, 
+    async_: bool = False, 
+) -> tuple[dict, Iterator[Buffer]] | tuple[dict, AsyncIterator[Buffer]]:
+    if async_:
+        return encode_multipart_data_async(data, files, boundary)
+
     if not boundary:
         boundary = uuid4().hex
         boundary_bytes = bytes(boundary, "ascii")
@@ -258,8 +301,8 @@ def encode_multipart_data(
 
 
 def encode_multipart_data_async(
-    data: None | Mapping[Buffer | str, Any] = None, 
-    files: None | Mapping[Buffer | str, Any] = None, 
+    data: None | Mapping[string, Any] | Iterable[tuple[string, Any]] = None, 
+    files: None | Mapping[string, Any] | Iterable[tuple[string, Any]] = None, 
     boundary: None | str = None, 
     file_suffix: str = "", 
 ) -> tuple[dict, AsyncIterator[Buffer]]:
@@ -380,8 +423,11 @@ def normalize_request_args(
     params: Any = None, 
     data: Any = None, 
     json: Any = None, 
+    files: None | Mapping[string, Any] | Iterable[tuple[string, Any]] = None, 
     headers: None | Mapping[string, Any] | Iterable[tuple[string, Any]] = None, 
     ensure_ascii: bool = False, 
+    *, 
+    async_: bool = False, 
 ) -> RequestArgs:
     method = ensure_str(method).upper()
     if isinstance(url, SupportsGeturl):
@@ -404,7 +450,14 @@ def normalize_request_args(
     content_type = headers_.get("content-type", "")
     charset      = get_charset(content_type)
     mimetype     = get_mimetype(charset).lower()
-    if data is not None:
+    if files is not None:
+        headers2, data = encode_multipart_data(
+            cast(None | Mapping[string, Any] | Iterable[tuple[string, Any]], data), 
+            files, 
+            async_=async_, # type: ignore
+        )
+        headers_.update(headers2)
+    elif data is not None:
         if isinstance(data, Buffer):
             pass
         elif isinstance(data, (str, UserString)):
@@ -412,7 +465,10 @@ def normalize_request_args(
         elif isinstance(data, AsyncIterable):
             data = async_map(ensure_buffer, data)
         elif isinstance(data, Iterator):
-            data = map(ensure_buffer, data)
+            if async_:
+                data = async_map(ensure_buffer, data)
+            else:
+                data = map(ensure_buffer, data)
         elif mimetype == "application/json":
             if charset == "utf-8":
                 data = json_dumps(data, default=json_default)
@@ -429,13 +485,18 @@ def normalize_request_args(
     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)
+        elif isinstance(json, AsyncIterable):
+            data = async_map(ensure_buffer, json)
+        elif isinstance(json, Iterator):
+            if async_:
+                data = async_map(ensure_buffer, json)
+            else:
+                data = map(ensure_buffer, json)
+        elif charset == "utf-8":
+            data = json_dumps(json, default=json_default)
         else:
             from json import dumps
-            data = dumps(data, default=json_default).encode(charset)
+            data = dumps(json, default=json_default).encode(charset)
         if mimetype != "application/json":
             headers_["content-type"] = "application/json; charset=" + charset
     elif mimetype == "application/json":

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-http_request"
-version = "0.0.9"
+version = "0.1.0"
 description = "Python http response utils."
 authors = ["ChenyangGao <wosiwujm@gmail.com>"]
 license = "MIT"