mm-std 0.4.17__py3-none-any.whl → 0.5.0__py3-none-any.whl

mm_std/http/http_request.py

@@ -1,126 +0,0 @@
-import aiohttp
-from aiohttp import ClientHttpProxyError, InvalidUrlClientError
-from aiohttp.typedefs import LooseCookies, Query
-from aiohttp_socks import ProxyConnectionError, ProxyConnector
-from multidict import CIMultiDictProxy
-
-from mm_std.http.http_response import HttpError, HttpResponse
-
-
-async def http_request(
-    url: str,
-    *,
-    method: str = "GET",
-    params: Query | 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: Query | 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: Query | 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_std/http/http_request_sync.py

@@ -1,63 +0,0 @@
-from typing import Any
-
-import requests
-from requests.exceptions import InvalidSchema, MissingSchema, ProxyError
-
-from mm_std.http.http_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_std/http/http_response.py

@@ -1,119 +0,0 @@
-from __future__ import annotations
-
-import enum
-import json
-from typing import Any
-
-import pydash
-from pydantic import GetCoreSchemaHandler
-from pydantic_core import CoreSchema, core_schema
-
-from mm_std.result import Result
-
-
-@enum.unique
-class HttpError(str, enum.Enum):
-    TIMEOUT = "timeout"
-    PROXY = "proxy"
-    INVALID_URL = "invalid_url"
-    CONNECTION = "connection"
-    ERROR = "error"
-
-
-class HttpResponse:
-    status_code: int | None
-    error: HttpError | None
-    error_message: str | None
-    body: str | None
-    headers: dict[str, str] | None
-
-    def __init__(
-        self,
-        status_code: int | None = None,
-        error: HttpError | None = None,
-        error_message: str | None = None,
-        body: str | None = None,
-        headers: dict[str, str] | None = None,
-    ) -> None:
-        self.status_code = status_code
-        self.error = error
-        self.error_message = error_message
-        self.body = body
-        self.headers = headers
-
-    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_std/json_.py

@@ -1,38 +0,0 @@
-import json
-from collections.abc import Callable
-from dataclasses import asdict, is_dataclass
-from datetime import date, datetime
-from decimal import Decimal
-from enum import Enum
-from json import JSONEncoder
-from pathlib import Path
-
-from pydantic import BaseModel
-
-from mm_std.result import Result
-
-
-class CustomJSONEncoder(JSONEncoder):
-    def default(self, o: object) -> object:
-        if isinstance(o, Result):
-            return o.to_dict()
-        if isinstance(o, Decimal):
-            return str(o)
-        if isinstance(o, Path):
-            return str(o)
-        if isinstance(o, datetime | date):
-            return o.isoformat()
-        if is_dataclass(o) and not isinstance(o, type):
-            return asdict(o)
-        if isinstance(o, Enum):
-            return o.value
-        if isinstance(o, BaseModel):
-            return o.model_dump()
-        if isinstance(o, Exception):
-            return str(o)
-
-        return super().default(o)
-
-
-def json_dumps(data: object, default_serializer: Callable[[object], str] | None = str) -> str:
-    return json.dumps(data, cls=CustomJSONEncoder, default=default_serializer)

mm_std/log.py

@@ -1,85 +0,0 @@
-import logging
-from logging.handlers import RotatingFileHandler
-from pathlib import Path
-
-from rich.logging import RichHandler
-
-
-class ExtraFormatter(logging.Formatter):
-    def format(self, record: logging.LogRecord) -> str:
-        base = super().format(record)
-        extras = {
-            key: value
-            for key, value in record.__dict__.items()
-            if key not in logging.LogRecord.__dict__
-            and key
-            not in (
-                "name",
-                "msg",
-                "args",
-                "levelname",
-                "levelno",
-                "pathname",
-                "filename",
-                "module",
-                "exc_info",
-                "exc_text",
-                "stack_info",
-                "lineno",
-                "funcName",
-                "created",
-                "msecs",
-                "relativeCreated",
-                "thread",
-                "threadName",
-                "processName",
-                "process",
-                "message",
-                "taskName",
-                "asctime",
-            )
-        }
-        if extras:
-            extras_str = " | " + " ".join(f"{k}={v}" for k, v in extras.items())
-            return base + extras_str
-        return base
-
-
-def configure_logging(developer_console: bool = False, console_level: int = logging.INFO) -> None:
-    """
-    Configure the root logger with a custom formatter that includes extra fields.
-    """
-    logger = logging.getLogger()
-    logger.setLevel(console_level)
-    logger.handlers.clear()
-
-    console_handler: logging.Handler
-
-    if developer_console:
-        console_handler = RichHandler(rich_tracebacks=True, show_time=True, show_level=True, show_path=False)
-        formatter = ExtraFormatter("{message}", style="{")
-    else:
-        console_handler = logging.StreamHandler()
-        formatter = ExtraFormatter("{asctime} - {name} - {levelname} - {message}", datefmt="%Y-%m-%d %H:%M:%S", style="{")
-    console_handler.setFormatter(formatter)
-
-    logger.addHandler(console_handler)
-
-
-def init_logger(name: str, file_path: str | None = None, file_mkdir: bool = True, level: int = logging.DEBUG) -> logging.Logger:
-    log = logging.getLogger(name)
-    log.setLevel(level)
-    log.propagate = False
-    fmt = logging.Formatter(fmt="%(asctime)s - %(name)s - %(levelname)s - %(message)s", datefmt="%Y-%m-%d %H:%M:%S")
-    console_handler = logging.StreamHandler()
-    console_handler.setLevel(logging.DEBUG)
-    console_handler.setFormatter(fmt)
-    log.addHandler(console_handler)
-    if file_path:
-        if file_mkdir:
-            Path(file_path).parent.mkdir(exist_ok=True)
-        file_handler = RotatingFileHandler(file_path, maxBytes=10 * 1024 * 1024, backupCount=1)
-        file_handler.setLevel(logging.INFO)
-        file_handler.setFormatter(fmt)
-        log.addHandler(file_handler)
-    return log

mm_std/net.py

@@ -1,22 +0,0 @@
-import socket
-import time
-from typing import cast
-
-
-def check_port(ip: str, port: int, attempts: int = 3, sleep_seconds: float = 1, timeout: float = 1) -> bool:
-    for _ in range(attempts):
-        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        sock.settimeout(timeout)
-        res = sock.connect_ex((ip, port)) == 0
-        if res:
-            return True
-        time.sleep(sleep_seconds)
-    return False
-
-
-def get_free_local_port() -> int:
-    sock = socket.socket()
-    sock.bind(("", 0))
-    port = sock.getsockname()[1]
-    sock.close()
-    return cast(int, port)

mm_std/print_.py

@@ -1,58 +0,0 @@
-import sys
-from collections.abc import Callable
-from enum import Enum, unique
-from typing import Any, NoReturn
-
-import rich
-from rich.console import Console
-from rich.syntax import Syntax
-from rich.table import Table
-
-from mm_std.json_ import json_dumps
-
-
-@unique
-class PrintFormat(str, Enum):
-    PLAIN = "plain"
-    TABLE = "table"
-    JSON = "json"
-
-
-def fatal(message: str, code: int = 1) -> NoReturn:
-    print(message, file=sys.stderr)  # noqa: T201
-    sys.exit(code)
-
-
-def print_console(*messages: object, print_json: bool = False, default: Callable[[object], str] | None = str) -> None:
-    if len(messages) == 1:
-        message = messages[0]
-        if isinstance(message, str):
-            print(message)  # noqa: T201
-        elif print_json:
-            rich.print_json(json_dumps(message, default_serializer=default))
-        else:
-            rich.print(message)
-    else:
-        rich.print(messages)
-
-
-def print_plain(messages: object) -> None:
-    print(messages)  # noqa: T201
-
-
-def print_json(data: object, default_serializer: Callable[[object], str] | None = None) -> None:
-    rich.print_json(json_dumps(data, default_serializer=default_serializer))
-
-
-def print_table(title: str, columns: list[str], rows: list[list[Any]]) -> None:
-    table = Table(*columns, title=title)
-    for row in rows:
-        table.add_row(*(str(cell) for cell in row))
-    console = Console()
-    console.print(table)
-
-
-def pretty_print_toml(data: str, line_numbers: bool = False, theme: str = "monokai") -> None:
-    console = Console()
-    syntax = Syntax(data, "toml", theme=theme, line_numbers=line_numbers)
-    console.print(syntax)

mm_std/random_.py

@@ -1,35 +0,0 @@
-import random
-from collections.abc import Sequence
-from decimal import Decimal
-
-
-def random_choice[T](source: Sequence[T] | T | None) -> T | None:
-    """Deprecated, don't use it"""
-    if source is None:
-        return None
-    if isinstance(source, str):
-        return source  # type: ignore[return-value]
-    if isinstance(source, Sequence):
-        if source:
-            return random.choice(source)  # type:ignore[no-any-return]
-        return None
-    return source
-
-
-def random_str_choice(source: Sequence[str] | str | None) -> str | None:
-    if source is None:
-        return None
-    if isinstance(source, str):
-        return source
-    if isinstance(source, Sequence):
-        if source:
-            return random.choice(source)
-        return None
-    return source
-
-
-def random_decimal(from_: Decimal, to: Decimal) -> Decimal:
-    from_ndigits = abs(from_.as_tuple().exponent)  # type:ignore[arg-type]
-    to_ndigits = abs(to.as_tuple().exponent)  # type:ignore[arg-type]
-    ndigits = max(from_ndigits, to_ndigits)
-    return Decimal(str(round(random.uniform(float(from_), float(to)), ndigits)))