mm-http 0.0.1__py3-none-any.whl

mm_http/__init__.py

@@ -0,0 +1,5 @@
+from .http_request import http_request
+from .http_request_sync import http_request_sync
+from .response import HttpError, HttpResponse
+
+__all__ = ["HttpError", "HttpResponse", "http_request", "http_request_sync"]

mm_http/http_request.py

@@ -0,0 +1,128 @@
+from typing import Any
+
+import aiohttp
+from aiohttp import ClientHttpProxyError, InvalidUrlClientError
+from aiohttp.typedefs import LooseCookies
+from aiohttp_socks import ProxyConnectionError, ProxyConnector
+from multidict import CIMultiDictProxy
+
+from .response import HttpError, HttpResponse
+
+
+async def http_request(
+    url: str,
+    *,
+    method: str = "GET",
+    params: dict[str, Any] | None = None,
+    data: dict[str, object] | None = None,
+    json: dict[str, object] | None = None,
+    headers: dict[str, str] | None = None,
+    cookies: LooseCookies | None = None,
+    user_agent: str | None = None,
+    proxy: str | None = None,
+    timeout: float | None = 10.0,
+) -> HttpResponse:
+    """
+    Send an HTTP request and return the response.
+    """
+    timeout_ = aiohttp.ClientTimeout(total=timeout) if timeout else None
+    if user_agent:
+        if not headers:
+            headers = {}
+        headers["User-Agent"] = user_agent
+
+    try:
+        if proxy and proxy.startswith("socks"):
+            return await _request_with_socks_proxy(
+                url,
+                method=method,
+                params=params,
+                data=data,
+                json=json,
+                headers=headers,
+                cookies=cookies,
+                proxy=proxy,
+                timeout=timeout_,
+            )
+        return await _request_with_http_or_none_proxy(
+            url,
+            method=method,
+            params=params,
+            data=data,
+            json=json,
+            headers=headers,
+            cookies=cookies,
+            proxy=proxy,
+            timeout=timeout_,
+        )
+    except TimeoutError as err:
+        return HttpResponse(error=HttpError.TIMEOUT, error_message=str(err))
+    except (aiohttp.ClientProxyConnectionError, ProxyConnectionError, ClientHttpProxyError) as err:
+        return HttpResponse(error=HttpError.PROXY, error_message=str(err))
+    except InvalidUrlClientError as e:
+        return HttpResponse(error=HttpError.INVALID_URL, error_message=str(e))
+    except Exception as err:
+        return HttpResponse(error=HttpError.ERROR, error_message=str(err))
+
+
+async def _request_with_http_or_none_proxy(
+    url: str,
+    *,
+    method: str = "GET",
+    params: dict[str, Any] | None = None,
+    data: dict[str, object] | None = None,
+    json: dict[str, object] | None = None,
+    headers: dict[str, str] | None = None,
+    cookies: LooseCookies | None = None,
+    proxy: str | None = None,
+    timeout: aiohttp.ClientTimeout | None,
+) -> HttpResponse:
+    async with aiohttp.request(
+        method, url, params=params, data=data, json=json, headers=headers, cookies=cookies, proxy=proxy, timeout=timeout
+    ) as res:
+        return HttpResponse(
+            status_code=res.status,
+            error=None,
+            error_message=None,
+            body=(await res.read()).decode(),
+            headers=headers_dict(res.headers),
+        )
+
+
+async def _request_with_socks_proxy(
+    url: str,
+    *,
+    method: str = "GET",
+    proxy: str,
+    params: dict[str, Any] | None = None,
+    data: dict[str, object] | None = None,
+    json: dict[str, object] | None = None,
+    headers: dict[str, str] | None = None,
+    cookies: LooseCookies | None = None,
+    timeout: aiohttp.ClientTimeout | None,
+) -> HttpResponse:
+    connector = ProxyConnector.from_url(proxy)
+    async with (
+        aiohttp.ClientSession(connector=connector) as session,
+        session.request(
+            method, url, params=params, data=data, json=json, headers=headers, cookies=cookies, timeout=timeout
+        ) as res,
+    ):
+        return HttpResponse(
+            status_code=res.status,
+            error=None,
+            error_message=None,
+            body=(await res.read()).decode(),
+            headers=headers_dict(res.headers),
+        )
+
+
+def headers_dict(headers: CIMultiDictProxy[str]) -> dict[str, str]:
+    result: dict[str, str] = {}
+    for key in headers:
+        values = headers.getall(key)
+        if len(values) == 1:
+            result[key] = values[0]
+        else:
+            result[key] = ", ".join(values)
+    return result

mm_http/http_request_sync.py

@@ -0,0 +1,63 @@
+from typing import Any
+
+import requests
+from requests.exceptions import InvalidSchema, MissingSchema, ProxyError
+
+from .response import HttpError, HttpResponse
+
+
+def http_request_sync(
+    url: str,
+    *,
+    method: str = "GET",
+    params: dict[str, Any] | None = None,
+    data: dict[str, Any] | None = None,
+    json: dict[str, Any] | None = None,
+    headers: dict[str, Any] | None = None,
+    cookies: dict[str, Any] | None = None,
+    user_agent: str | None = None,
+    proxy: str | None = None,
+    timeout: float | None = 10.0,
+) -> HttpResponse:
+    """
+    Send a synchronous HTTP request and return the response.
+    """
+    if user_agent:
+        if headers is None:
+            headers = {}
+        headers["User-Agent"] = user_agent
+
+    proxies: dict[str, str] | None = None
+    if proxy:
+        proxies = {
+            "http": proxy,
+            "https": proxy,
+        }
+
+    try:
+        res = requests.request(
+            method=method,
+            url=url,
+            params=params,
+            data=data,
+            json=json,
+            headers=headers,
+            cookies=cookies,
+            timeout=timeout,
+            proxies=proxies,
+        )
+        return HttpResponse(
+            status_code=res.status_code,
+            error=None,
+            error_message=None,
+            body=res.text,
+            headers=dict(res.headers),
+        )
+    except requests.Timeout as e:
+        return HttpResponse(error=HttpError.TIMEOUT, error_message=str(e))
+    except ProxyError as e:
+        return HttpResponse(error=HttpError.PROXY, error_message=str(e))
+    except (InvalidSchema, MissingSchema) as e:
+        return HttpResponse(error=HttpError.INVALID_URL, error_message=str(e))
+    except Exception as e:
+        return HttpResponse(error=HttpError.ERROR, error_message=str(e))

mm_http/response.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import enum
+import json
+from dataclasses import dataclass
+from typing import Any
+
+import pydash
+from mm_result import Result
+from pydantic import GetCoreSchemaHandler
+from pydantic_core import CoreSchema, core_schema
+
+
+@enum.unique
+class HttpError(str, enum.Enum):
+    TIMEOUT = "timeout"
+    PROXY = "proxy"
+    INVALID_URL = "invalid_url"
+    CONNECTION = "connection"
+    ERROR = "error"
+
+
+@dataclass
+class HttpResponse:
+    status_code: int | None = None
+    error: HttpError | None = None
+    error_message: str | None = None
+    body: str | None = None
+    headers: dict[str, str] | None = None
+
+    def parse_json_body(self, path: str | None = None, none_on_error: bool = False) -> Any:  # noqa: ANN401
+        if self.body is None:
+            if none_on_error:
+                return None
+            raise ValueError("Body is None")
+
+        try:
+            res = json.loads(self.body)
+            return pydash.get(res, path, None) if path else res
+        except json.JSONDecodeError:
+            if none_on_error:
+                return None
+            raise
+
+    def is_err(self) -> bool:
+        return self.error is not None or (self.status_code is not None and self.status_code >= 400)
+
+    def to_err[T](self, error: str | Exception | tuple[str, Exception] | None = None) -> Result[T]:
+        return Result.err(error or self.error or "error", extra=self.to_dict())
+
+    def to_ok[T](self, value: T) -> Result[T]:
+        return Result.ok(value, extra=self.to_dict())
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "status_code": self.status_code,
+            "error": self.error.value if self.error else None,
+            "error_message": self.error_message,
+            "body": self.body,
+            "headers": self.headers,
+        }
+
+    @property
+    def content_type(self) -> str | None:
+        if self.headers is None:
+            return None
+        for key in self.headers:
+            if key.lower() == "content-type":
+                return self.headers[key]
+        return None
+
+    def __repr__(self) -> str:
+        parts: list[str] = []
+        if self.status_code is not None:
+            parts.append(f"status_code={self.status_code!r}")
+        if self.error is not None:
+            parts.append(f"error={self.error!r}")
+        if self.error_message is not None:
+            parts.append(f"error_message={self.error_message!r}")
+        if self.body is not None:
+            parts.append(f"body={self.body!r}")
+        if self.headers is not None:
+            parts.append(f"headers={self.headers!r}")
+        return f"HttpResponse({', '.join(parts)})"
+
+    @classmethod
+    def __get_pydantic_core_schema__(cls, _source_type: type[Any], _handler: GetCoreSchemaHandler) -> CoreSchema:
+        return core_schema.no_info_after_validator_function(
+            cls._validate,
+            core_schema.any_schema(),
+            serialization=core_schema.plain_serializer_function_ser_schema(lambda x: x.to_dict()),
+        )
+
+    @classmethod
+    def _validate(cls, value: object) -> HttpResponse:
+        if isinstance(value, cls):
+            return value
+        if isinstance(value, dict):
+            return cls(
+                status_code=value.get("status_code"),
+                error=HttpError(value["error"]) if value.get("error") else None,
+                error_message=value.get("error_message"),
+                body=value.get("body"),
+                headers=value.get("headers"),
+            )
+        raise TypeError(f"Invalid value for HttpResponse: {value}")

mm_http-0.0.1.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: mm-http
+Version: 0.0.1
+Requires-Python: >=3.13
+Requires-Dist: aiohttp-socks~=0.10.1
+Requires-Dist: aiohttp~=3.12.2
+Requires-Dist: mm-result>=0.0.2
+Requires-Dist: pydantic>=2.11.5
+Requires-Dist: pydash>=8.0.5
+Requires-Dist: requests[socks]~=2.32.3

mm_http-0.0.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+mm_http/__init__.py,sha256=vW7ASPktUjm6S2Q7_biiA4F_PzG7gPF8gK3E7bBO4yQ,212
+mm_http/http_request.py,sha256=3yapH-ADtSGqV7pMQj1cGWrGywDmRnTIE53AzM6ECtg,4116
+mm_http/http_request_sync.py,sha256=lajd4Xt_wHKuRYyPtybO5CHHvquLzGPZEMHzKjN1wlM,1819
+mm_http/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_http/response.py,sha256=Ve0uE6BzQ4FPoaF-DbJ_9iCI2vqyDfbxGTMm1L3Bndc,3576
+mm_http-0.0.1.dist-info/METADATA,sha256=CgOzxJf2MJaO6k2EC5JBtJNQsD888ievm2BNszyHKGg,275
+mm_http-0.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mm_http-0.0.1.dist-info/RECORD,,

mm_http-0.0.1.dist-info/WHEEL

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