mm-std 0.1.8__py3-none-any.whl → 0.1.10__py3-none-any.whl

mm_std/__init__.py

@@ -15,16 +15,17 @@ from .date import utc_now as utc_now
 from .date import utc_random as utc_random
 from .dict import replace_empty_values as replace_empty_values
 from .env import get_dotenv as get_dotenv
+from .http_ import CHROME_USER_AGENT as CHROME_USER_AGENT
+from .http_ import FIREFOX_USER_AGENT as FIREFOX_USER_AGENT
+from .http_ import HResponse as HResponse
+from .http_ import add_query_params_to_url as add_query_params_to_url
+from .http_ import hr as hr
+from .http_ import hrequest as hrequest
 from .json_ import CustomJSONEncoder as CustomJSONEncoder
 from .json_ import json_dumps as json_dumps
 from .log import init_logger as init_logger
-from .net import CHROME_USER_AGENT as CHROME_USER_AGENT
-from .net import FIREFOX_USER_AGENT as FIREFOX_USER_AGENT
-from .net import HResponse as HResponse
-from .net import add_query_params_to_url as add_query_params_to_url
 from .net import check_port as check_port
-from .net import hr as hr
-from .net import hrequest as hrequest
+from .net import get_free_local_port as get_free_local_port
 from .print_ import PrintFormat as PrintFormat
 from .print_ import fatal as fatal
 from .print_ import print_console as print_console
@@ -42,5 +43,4 @@ from .str import number_with_separator as number_with_separator
 from .str import str_ends_with_any as str_ends_with_any
 from .str import str_starts_with_any as str_starts_with_any
 from .str import str_to_list as str_to_list
-from .telegram import send_telegram_message as send_telegram_message
 from .zip import read_text_from_zip_archive as read_text_from_zip_archive

mm_std/command.py

@@ -19,7 +19,7 @@ def run_command(cmd: str, timeout: int | None = 60, capture_output: bool = True,
     if echo_cmd_console:
         print(cmd)  # noqa: T201
     try:
-        process = subprocess.run(cmd, timeout=timeout, capture_output=capture_output, shell=True, check=False)  # nosec
+        process = subprocess.run(cmd, timeout=timeout, capture_output=capture_output, shell=True, check=False)  # noqa: S602 # nosec
         stdout = process.stdout.decode("utf-8") if capture_output else ""
         stderr = process.stderr.decode("utf-8") if capture_output else ""
         return CommandResult(stdout=stdout, stderr=stderr, code=process.returncode)

mm_std/concurrency.py

@@ -8,7 +8,6 @@ from dataclasses import dataclass, field
 from datetime import datetime
 from logging import Logger
 from threading import Lock, Thread
-from typing import ParamSpec, TypeVar
 
 from .date import is_too_old, utc_now
 
@@ -57,11 +56,7 @@ class ConcurrentTasks:
                 self.timeout_error = True
 
 
-T = TypeVar("T")
-P = ParamSpec("P")
-
-
-def synchronized_parameter(arg_index: int = 0, skip_if_locked: bool = False) -> Callable[..., Callable[P, T | None]]:
+def synchronized_parameter[T, **P](arg_index: int = 0, skip_if_locked: bool = False) -> Callable[..., Callable[P, T | None]]:
     locks: dict[object, Lock] = defaultdict(Lock)
 
     def outer(func: Callable[P, T]) -> Callable[P, T | None]:
@@ -81,7 +76,7 @@ def synchronized_parameter(arg_index: int = 0, skip_if_locked: bool = False) ->
     return outer
 
 
-def synchronized(fn: Callable[P, T]) -> Callable[P, T]:
+def synchronized[T, **P](fn: Callable[P, T]) -> Callable[P, T]:
     lock = Lock()
 
     @functools.wraps(fn)
@@ -93,7 +88,7 @@ def synchronized(fn: Callable[P, T]) -> Callable[P, T]:
 
 
 class Scheduler:
-    def __init__(self, log: Logger, loop_delay: float = 0.5, debug: bool = False):
+    def __init__(self, log: Logger, loop_delay: float = 0.5, debug: bool = False) -> None:
         self.log = log
         self.debug = debug
         self.loop_delay = loop_delay
@@ -126,8 +121,8 @@ class Scheduler:
         try:
             job.func(*job.args)
             self._debug(f"_run_job: {job} done")
-        except Exception as e:
-            self.log.exception("scheduler error: %s", str(e))
+        except Exception:
+            self.log.exception("scheduler error")
             self._debug(f"_run_job: {job} error")
         finally:
             job.is_running = False

mm_std/config.py

@@ -1,10 +1,11 @@
 import io
 from pathlib import Path
+from typing import Self
 
 import yaml
 from pydantic import BaseModel, ConfigDict, ValidationError
 
-from .print_ import PrintFormat, print_console, print_json, print_plain, print_table
+from .result import Err, Ok, Result
 from .str import str_to_list
 from .zip import read_text_from_zip_archive
 
@@ -29,47 +30,27 @@ class BaseConfig(BaseModel):
         return v
 
     @classmethod
-    def read_config[T](  # nosec: B107
-        cls: type[T],
-        config_path: io.TextIOWrapper | str | Path,
-        error_print_type: PrintFormat = PrintFormat.PLAIN,
-        zip_password: str = "",
-    ) -> T:
+    def read_config(cls, config_path: io.TextIOWrapper | str | Path, zip_password: str = "") -> Result[Self]:  # nosec
         try:
             # is it zip archive?
             if isinstance(config_path, str) and config_path.endswith(".zip"):
                 config_path = str(Path(config_path).expanduser())
-                return cls(**yaml.full_load(read_text_from_zip_archive(config_path, password=zip_password)))
+                return Ok(cls(**yaml.full_load(read_text_from_zip_archive(config_path, password=zip_password))))
             if isinstance(config_path, io.TextIOWrapper) and config_path.name.endswith(".zip"):
                 config_path = str(Path(config_path.name).expanduser())
-                return cls(**yaml.full_load(read_text_from_zip_archive(config_path, password=zip_password)))
+                return Ok(cls(**yaml.full_load(read_text_from_zip_archive(config_path, password=zip_password))))
             if isinstance(config_path, Path) and config_path.name.endswith(".zip"):
                 config_path = str(config_path.expanduser())
-                return cls(**yaml.full_load(read_text_from_zip_archive(config_path, password=zip_password)))
+                return Ok(cls(**yaml.full_load(read_text_from_zip_archive(config_path, password=zip_password))))
 
             # plain yml file
             if isinstance(config_path, str):
-                return cls(**yaml.full_load(Path(config_path).expanduser().read_text()))
-            elif isinstance(config_path, Path):
-                return cls(**yaml.full_load(config_path.expanduser().read_text()))
-            else:
-                return cls(**yaml.full_load(config_path))
+                return Ok(cls(**yaml.full_load(Path(config_path).expanduser().read_text())))
+            if isinstance(config_path, Path):
+                return Ok(cls(**yaml.full_load(config_path.expanduser().read_text())))
+
+            return Ok(cls(**yaml.full_load(config_path)))
         except ValidationError as err:
-            print_plain("config validation errors", error_print_type)
-            json_errors = []
-            rows = []
-            for e in err.errors():
-                loc = e["loc"]
-                field = ".".join(str(lo) for lo in loc) if len(loc) > 0 else ""
-                print_plain(f"{field} {e['msg']}", error_print_type)
-                json_errors.append({field: e["msg"]})
-                rows.append([field, e["msg"]])
-            print_table("config validation errors", ["field", "message"], rows)
-            print_json({"errors": json_errors}, error_print_type)
-            exit(1)
+            return Err("validator error", data={"validaton_errors": err})
         except Exception as err:
-            if error_print_type == "json":
-                print_json({"exception": str(err)})
-            else:
-                print_console(f"config error: {err!s}")
-            exit(1)
+            return Err(err)

mm_std/date.py

@@ -43,19 +43,15 @@ def parse_date(value: str, ignore_tz: bool = False) -> datetime:
 
     for fmt in date_formats:
         try:
-            dt = datetime.strptime(value, fmt)
+            dt = datetime.strptime(value, fmt)  # noqa: DTZ007
             if ignore_tz and dt.tzinfo is not None:
                 dt = dt.replace(tzinfo=None)
-            return dt
+            return dt  # noqa: TRY300
         except ValueError:
             continue
     raise ValueError(f"Time data '{value}' does not match any known format.")
 
 
-# def parse_date(value: str, ignore_tz: bool = False) -> datetime:
-#     return parser.parse(value, ignoretz=ignore_tz)
-
-
 def utc_random(
     *,
     from_time: datetime | None = None,

mm_std/http_.py

@@ -0,0 +1,143 @@
+import json
+from dataclasses import asdict, dataclass, field
+from typing import Any
+from urllib.parse import urlencode
+
+import httpx
+import pydash
+from httpx._types import AuthTypes
+
+from mm_std.result import Err, Ok, Result
+
+FIREFOX_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:134.0) Gecko/20100101 Firefox/134.0"
+SAFARI_USER_AGENT = (
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.2 Safari/605.1.15"
+)
+CHROME_USER_AGENT = (
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36"
+)
+
+
+@dataclass
+class HResponse:
+    code: int = 0
+    error: str | None = None
+    body: str = ""
+    headers: dict[str, str] = field(default_factory=dict)
+
+    _json_data: Any = None
+    _json_parsed = False
+    _json_parsed_error = False
+
+    def _parse_json(self) -> None:
+        try:
+            self._json_data = None
+            self._json_data = json.loads(self.body)
+            self._json_parsed_error = False
+        except json.JSONDecodeError:
+            self._json_parsed_error = True
+        self._json_parsed = True
+
+    @property
+    def json(self) -> Any:  # noqa: ANN401
+        if not self._json_parsed:
+            self._parse_json()
+        return self._json_data
+
+    @property
+    def json_parse_error(self) -> bool:
+        if not self._json_parsed:
+            self._parse_json()
+        return self._json_parsed_error
+
+    @property
+    def content_type(self) -> str | None:
+        for key in self.headers:
+            if key.lower() == "content-type":
+                return self.headers[key]
+        return None
+
+    def to_err_result[T](self, error: str | None = None) -> Err:
+        return Err(error or self.error or "error", data=asdict(self))
+
+    def to_ok_result[T](self, result: T) -> Result[T]:
+        return Ok(result, data=asdict(self))
+
+    def is_error(self) -> bool:
+        return self.error is not None
+
+    def is_timeout_error(self) -> bool:
+        return self.error == "timeout"
+
+    def is_proxy_error(self) -> bool:
+        return self.error == "proxy_error"
+
+    def is_connection_error(self) -> bool:
+        return self.error is not None and self.error.startswith("connection_error:")
+
+    def to_dict(self) -> dict[str, Any]:
+        return pydash.omit(asdict(self), "_json_data")
+
+
+def hrequest(
+    url: str,
+    *,
+    method: str = "GET",
+    proxy: str | None = None,
+    params: dict[str, Any] | None = None,
+    headers: dict[str, Any] | None = None,
+    cookies: dict[str, Any] | None = None,
+    timeout: float = 10,
+    user_agent: str | None = None,
+    json_params: bool = True,
+    auth: AuthTypes | None = None,
+    verify: bool = True,
+) -> HResponse:
+    query_params: dict[str, Any] | None = None
+    data: dict[str, Any] | None = None
+    json_: dict[str, Any] | None = None
+    method = method.upper()
+    if not headers:
+        headers = {}
+    if user_agent:
+        headers["user-agent"] = user_agent
+    if method == "GET":
+        query_params = params
+    elif json_params:
+        json_ = params
+    else:
+        data = params
+
+    try:
+        r = httpx.request(
+            method,
+            url,
+            proxy=proxy,
+            timeout=timeout,
+            cookies=cookies,
+            auth=auth,
+            verify=verify,
+            headers=headers,
+            params=query_params,
+            json=json_,
+            data=data,
+        )
+        return HResponse(code=r.status_code, body=r.text, headers=dict(r.headers))
+    except httpx.TimeoutException:
+        return HResponse(error="timeout")
+    except httpx.ProxyError:
+        return HResponse(error="proxy_error")
+    except httpx.HTTPError as err:
+        return HResponse(error=f"connection_error: {err}")
+    except Exception as err:
+        return HResponse(error=f"exception: {err}")
+
+
+def add_query_params_to_url(url: str, params: dict[str, object]) -> str:
+    query_params = urlencode({k: v for k, v in params.items() if v is not None})
+    if query_params:
+        url += f"?{query_params}"
+    return url
+
+
+hr = hrequest

mm_std/json_.py

@@ -4,7 +4,6 @@ from datetime import date, datetime
 from decimal import Decimal
 from enum import Enum
 from json import JSONEncoder
-from typing import Any
 
 from pydantic import BaseModel
 
@@ -12,7 +11,7 @@ from mm_std.result import Err, Ok
 
 
 class CustomJSONEncoder(JSONEncoder):
-    def default(self, o: Any) -> Any:
+    def default(self, o: object) -> object:
         if isinstance(o, Ok):
             return {"ok": o.ok}
         if isinstance(o, Err):

mm_std/net.py

@@ -1,134 +1,6 @@
-import json
 import socket
 import time
-from dataclasses import asdict, dataclass, field
-from json import JSONDecodeError
-from typing import Any, cast
-from urllib.parse import urlencode
-
-import httpx
-import pydash
-
-from mm_std.result import Err, Ok, Result
-
-FIREFOX_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:108.0) Gecko/20100101 Firefox/108.0"
-SAFARI_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.3 Safari/605.1.15"  # fmt: skip # noqa
-CHROME_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/109.0.0.0 Safari/537.36"  # fmt: skip # noqa
-
-
-@dataclass
-class HResponse:
-    code: int = 0
-    error: str | None = None
-    body: str = ""
-    headers: dict[str, str] = field(default_factory=dict)
-
-    _json_data: Any = None
-    _json_parsed = False
-    _json_parsed_error = False
-
-    def _parse_json(self) -> None:
-        try:
-            self._json_data = None
-            self._json_data = json.loads(self.body)
-            self._json_parsed_error = False
-        except JSONDecodeError:
-            self._json_parsed_error = True
-        self._json_parsed = True
-
-    @property
-    def json(self) -> Any:
-        if not self._json_parsed:
-            self._parse_json()
-        return self._json_data
-
-    @property
-    def json_parse_error(self) -> bool:
-        if not self._json_parsed:
-            self._parse_json()
-        return self._json_parsed_error
-
-    @property
-    def content_type(self) -> str | None:
-        for key in self.headers.keys():
-            if key.lower() == "content-type":
-                return self.headers[key]
-        return None
-
-    def to_err_result[T](self, error: str | None = None) -> Err:
-        return Err(error or self.error or "error", data=asdict(self))
-
-    def to_ok_result[T](self, result: T) -> Result[T]:
-        return Ok(result, data=asdict(self))
-
-    def is_error(self) -> bool:
-        return self.error is not None
-
-    def is_timeout_error(self) -> bool:
-        return self.error == "timeout"
-
-    def is_proxy_error(self) -> bool:
-        return self.error == "proxy_error"
-
-    def is_connection_error(self) -> bool:
-        return self.error is not None and self.error.startswith("connection_error:")
-
-    def to_dict(self) -> dict[str, Any]:
-        return pydash.omit(asdict(self), "_json_data")
-
-
-def hrequest(
-    url: str,
-    *,
-    method: str = "GET",
-    proxy: str | None = None,
-    params: dict[str, Any] | None = None,
-    headers: dict[str, Any] | None = None,
-    cookies: dict[str, Any] | None = None,
-    timeout: float = 10,
-    user_agent: str | None = None,
-    json_params: bool = True,
-    auth: Any = None,
-    verify: bool = True,
-) -> HResponse:
-    query_params: dict[str, Any] | None = None
-    data: dict[str, Any] | None = None
-    json_: dict[str, Any] | None = None
-    method = method.upper()
-    if not headers:
-        headers = {}
-    if user_agent:
-        headers["user-agent"] = user_agent
-    if method == "GET":
-        query_params = params
-    elif json_params:
-        json_ = params
-    else:
-        data = params
-
-    try:
-        r = httpx.request(
-            method,
-            url,
-            proxy=proxy,
-            timeout=timeout,
-            cookies=cookies,
-            auth=auth,
-            verify=verify,
-            headers=headers,
-            params=query_params,
-            json=json_,
-            data=data,
-        )
-        return HResponse(code=r.status_code, body=r.text, headers=dict(r.headers))
-    except httpx.TimeoutException:
-        return HResponse(error="timeout")
-    except httpx.ProxyError:
-        return HResponse(error="proxy_error")
-    except httpx.HTTPError as err:
-        return HResponse(error=f"connection_error: {err}")
-    except Exception as err:
-        return HResponse(error=f"exception: {err}")
+from typing import cast
 
 
 def check_port(ip: str, port: int, attempts: int = 3, sleep_seconds: float = 1, timeout: float = 1) -> bool:
@@ -148,13 +20,3 @@ def get_free_local_port() -> int:
     port = sock.getsockname()[1]
     sock.close()
     return cast(int, port)
-
-
-def add_query_params_to_url(url: str, params: dict[str, object]) -> str:
-    query_params = urlencode({k: v for k, v in params.items() if v is not None})
-    if query_params:
-        url += f"?{query_params}"
-    return url
-
-
-hr = hrequest

mm_std/print_.py

@@ -26,11 +26,10 @@ def print_console(*messages: object, print_json: bool = False) -> None:
         message = messages[0]
         if isinstance(message, str):
             print(message)  # noqa: T201
+        elif print_json:
+            rich.print_json(json_dumps(message))
         else:
-            if print_json:
-                rich.print_json(json_dumps(message))
-            else:
-                rich.print(message)
+            rich.print(message)
     else:
         rich.print(messages)
 

mm_std/result.py

@@ -1,29 +1,30 @@
 from __future__ import annotations
 
 import time
-from collections.abc import Callable
-from typing import Any, Literal, NoReturn
+from typing import TYPE_CHECKING, Any, Literal, NoReturn
 
 from pydantic_core import core_schema
 
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
 
 class Ok[T]:
     __match_args__ = ("ok",)
 
-    def __init__(self, ok: T, data: Any = None) -> None:
+    def __init__(self, ok: T, data: object = None) -> None:
         self.ok = ok
         self.data = data
 
     def __repr__(self) -> str:
         if self.data is None:
             return f"Ok({self.ok!r})"
-        else:
-            return f"Ok({self.ok!r}, data={self.data!r})"
+        return f"Ok({self.ok!r}, data={self.data!r})"
 
-    def __eq__(self, other: Any) -> bool:
+    def __eq__(self, other: object) -> bool:
         return isinstance(other, Ok) and self.ok == other.ok and self.data == other.data
 
-    def __ne__(self, other: Any) -> bool:
+    def __ne__(self, other: object) -> bool:
         return not (self == other)
 
     def __hash__(self) -> int:
@@ -54,26 +55,26 @@ class Ok[T]:
     def unwrap_or[U](self, _default: U) -> T:
         return self.ok
 
-    def unwrap_or_else(self, op: object) -> T:
+    def unwrap_or_else(self, _op: object) -> T:
         return self.ok
 
-    def unwrap_or_raise(self, e: object) -> T:
+    def unwrap_or_raise(self, _e: object) -> T:
         return self.ok
 
     def map[U](self, op: Callable[[T], U]) -> Ok[U]:
         return Ok(op(self.ok), data=self.data)
 
-    def map_or[U](self, default: object, op: Callable[[T], U]) -> U:
+    def map_or[U](self, _default: object, op: Callable[[T], U]) -> U:
         return op(self.ok)
 
-    def map_or_else[U](self, err_op: object, ok_op: Callable[[T], U]) -> U:
+    def map_or_else[U](self, _err_op: object, ok_op: Callable[[T], U]) -> U:
         """
         The contained result is `Ok`, so return original value mapped to
         a new value using the passed in `op` function.
         """
         return ok_op(self.ok)
 
-    def map_err(self, op: object) -> Ok[T]:
+    def map_err(self, _op: object) -> Ok[T]:
         """
         The contained result is `Ok`, so return `Ok` with the original value
         """
@@ -93,7 +94,7 @@ class Ok[T]:
         res.data = self.data
         return res
 
-    def or_else(self, op: object) -> Ok[T]:
+    def or_else(self, _op: object) -> Ok[T]:
         return self
 
     def ok_or_err(self) -> T | str:
@@ -103,7 +104,7 @@ class Ok[T]:
         return self.ok
 
     @classmethod
-    def __get_pydantic_core_schema__(cls, _source_type: Any, _handler: Any) -> core_schema.CoreSchema:
+    def __get_pydantic_core_schema__(cls, _source_type: object, _handler: object) -> core_schema.CoreSchema:
         return core_schema.model_schema(
             cls,
             core_schema.model_fields_schema(
@@ -118,20 +119,19 @@ class Ok[T]:
 class Err:
     __match_args__ = ("err",)
 
-    def __init__(self, err: str | Exception, data: Any = None) -> None:
+    def __init__(self, err: str | Exception, data: object = None) -> None:
         self.err = f"exception: {err}" if isinstance(err, Exception) else err
         self.data = data
 
     def __repr__(self) -> str:
         if self.data is None:
             return f"Err({self.err!r})"
-        else:
-            return f"Err({self.err!r}, data={self.data!r})"
+        return f"Err({self.err!r}, data={self.data!r})"
 
-    def __eq__(self, other: Any) -> bool:
+    def __eq__(self, other: object) -> bool:
         return isinstance(other, Err) and self.err == other.err and self.data == other.data
 
-    def __ne__(self, other: Any) -> bool:
+    def __ne__(self, other: object) -> bool:
         return not (self == other)
 
     def __hash__(self) -> int:
@@ -199,25 +199,25 @@ class Err:
         """
         raise e(self.err)
 
-    def map(self, op: object) -> Err:
+    def map(self, _op: object) -> Err:
         """
         Return `Err` with the same value
         """
         return self
 
-    def map_or[U](self, default: U, op: object) -> U:
+    def map_or[U](self, default: U, _op: object) -> U:
         """
         Return the default value
         """
         return default
 
-    def map_or_else[U](self, err_op: Callable[[str], U], ok_op: object) -> U:
+    def map_or_else[U](self, err_op: Callable[[str], U], _ok_op: object) -> U:
         """
         Return the result of the default operation
         """
         return err_op(self.err)
 
-    def and_then(self, op: object) -> Err:
+    def and_then(self, _op: object) -> Err:
         """
         The contained result is `Err`, so return `Err` with the original value
         """
@@ -230,7 +230,7 @@ class Err:
         return None
 
     @classmethod
-    def __get_pydantic_core_schema__(cls, _source_type: Any, _handler: Any) -> core_schema.CoreSchema:
+    def __get_pydantic_core_schema__(cls, _source_type: object, _handler: object) -> core_schema.CoreSchema:
         return core_schema.model_schema(
             cls,
             core_schema.model_fields_schema(
@@ -257,7 +257,7 @@ class UnwrapError(Exception):
         return self._result
 
 
-def try_ok[T](fn: Callable[..., Result[T]], *, args: tuple[object], attempts: int, delay: int | float = 0) -> Result[T]:
+def try_ok[T](fn: Callable[..., Result[T]], *, args: tuple[object], attempts: int, delay: float = 0) -> Result[T]:
     if attempts <= 0:
         raise ValueError("attempts must be more than zero")
     res: Result[T] = Err("not started")

mm_std/str.py

@@ -62,18 +62,12 @@ def number_with_separator(
 
 def str_starts_with_any(value: str, prefixes: list[str]) -> bool:
     """check if str starts with any of prefixes"""
-    for prefix in prefixes:
-        if value.startswith(prefix):
-            return True
-    return False
+    return any(value.startswith(prefix) for prefix in prefixes)
 
 
 def str_ends_with_any(value: str, prefixes: list[str]) -> bool:
     """check if str ends with any of prefixes"""
-    for prefix in prefixes:
-        if value.endswith(prefix):
-            return True
-    return False
+    return any(value.endswith(prefix) for prefix in prefixes)
 
 
 def split_on_plus_minus_tokens(value: str) -> list[str]:

mm_std/types_.py

@@ -0,0 +1,4 @@
+from collections.abc import Callable
+from typing import Any
+
+type CallableAny = Callable[..., Any]

mm_std-0.1.10.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: mm-std
+Version: 0.1.10
+Requires-Python: >=3.12
+Requires-Dist: cryptography~=44.0.0
+Requires-Dist: httpx[http2,socks]~=0.28.1
+Requires-Dist: pydantic~=2.10.5
+Requires-Dist: pydash~=8.0.5
+Requires-Dist: python-dotenv~=1.0.1
+Requires-Dist: pyyaml~=6.0.2
+Requires-Dist: rich~=13.9.4

mm_std-0.1.10.dist-info/RECORD

@@ -0,0 +1,23 @@
+mm_std/__init__.py,sha256=dtYnmQP_HkWxIJvuCJGpex3RHvG2V0Ekh7oYstRQoco,2291
+mm_std/command.py,sha256=ze286wjUjg0QSTgIu-2WZks53_Vclg69UaYYgPpQvCU,1283
+mm_std/concurrency.py,sha256=4kKLhde6YQYsjJJjH6K5eMQj6FtegEz55Mo5TmhQMM0,5242
+mm_std/config.py,sha256=je47fOnFPooO65vc15LaR_Pi0HPfmhQmHJKU7ft_I08,2300
+mm_std/crypto.py,sha256=jdk0_TCmeU0pPXMyz9xH6kQHSjjZ9GcGClBwQps5vBo,340
+mm_std/date.py,sha256=976eEkSONuNqHQBgSRu8hrtH23tJqztbmHFHLdbP2TY,1879
+mm_std/dict.py,sha256=kJBPVG9vEqHiSgKKoji8gVGL1yEBbxAmFNn0zz17AUg,180
+mm_std/env.py,sha256=5zaR9VeIfObN-4yfgxoFeU5IM1GDeZZj9SuYf7t9sOA,125
+mm_std/fs.py,sha256=RwarNRJq3tIMG6LVX_g03hasfYpjYFh_O27oVDt5IPQ,291
+mm_std/http_.py,sha256=QaPPXVb-rOS0BpoKdYQ0ABm_-mcR5dNa7Uqn-SeW_kE,4119
+mm_std/json_.py,sha256=VWjJsfLt-dQJiwc7vgpTElMr69NxpzX_mpmBoCkeoT8,999
+mm_std/log.py,sha256=6ux6njNKc_ZCQlvWn1FZR6vcSY2Cem-mQzmNXvsg5IE,913
+mm_std/net.py,sha256=qdRCBIDneip6FaPNe5mx31UtYVmzqam_AoUF7ydEyjA,590
+mm_std/print_.py,sha256=HAhaiEMZZLV3CpG6UfwoUb6-Ftcun16YFC-CRcAcXOY,1525
+mm_std/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_std/random_.py,sha256=OuUX4VJeSd13NZBya4qrGpR2TfN7_87tfebOY6DBUnI,1113
+mm_std/result.py,sha256=w2Y1dji0LozcJpPMnFkqN0UbxJUm1C8Kc5ZB1vLXx20,7443
+mm_std/str.py,sha256=jS7VAI7i_a3iqnfaW4Iw2LZRTv0Tml4kmMbP2S2IUF4,3067
+mm_std/types_.py,sha256=hvZlnvBWyB8CL_MeEWWD0Y0nN677plibYn3yD-5g7xs,99
+mm_std/zip.py,sha256=2EXcae4HO5U4kObj2Lj8jl5F2OUpT-WRlJybTyFzt6I,370
+mm_std-0.1.10.dist-info/METADATA,sha256=I1b0CBj5aAvOH54hNApMxiKu1GJUZpqw_D5mrEuZa8k,307
+mm_std-0.1.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mm_std-0.1.10.dist-info/RECORD,,

{mm_std-0.1.8.dist-info → mm_std-0.1.10.dist-info}/WHEEL

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

mm_std/telegram.py

@@ -1,35 +0,0 @@
-import time
-
-import pydash
-
-from mm_std import Err, Ok, Result
-from mm_std.net import hrequest
-
-
-def send_telegram_message(bot_token: str, chat_id: int, message: str, long_message_delay: int = 3) -> Result[list[int]]:
-    messages = _split_string(message, 4096)
-    responses = []
-    result = []
-    while True:
-        text = messages.pop(0)
-        params = {"chat_id": chat_id, "text": text}
-        res = hrequest(f"https://api.telegram.org/bot{bot_token}/sendMessage", method="post", params=params)
-        responses.append(res.json)
-        if res.error is not None:
-            return Err(res.error, data={"last_res": res.to_dict(), "responses": responses})
-
-        message_id = pydash.get(res.json, "result.message_id")
-        if message_id:
-            result.append(message_id)
-        else:
-            return Err("unknown_response", data={"last_res": res.to_dict(), "responses": responses})
-
-        if len(messages):
-            time.sleep(long_message_delay)
-        else:
-            break
-    return Ok(result, data={"responses": responses})
-
-
-def _split_string(text: str, chars_per_string: int) -> list[str]:
-    return [text[i : i + chars_per_string] for i in range(0, len(text), chars_per_string)]

mm_std/types.py

@@ -1,4 +0,0 @@
-from collections.abc import Callable
-from typing import Any, TypeAlias
-
-CallableAny: TypeAlias = Callable[..., Any]

mm_std-0.1.8.dist-info/METADATA

@@ -1,11 +0,0 @@
-Metadata-Version: 2.3
-Name: mm-std
-Version: 0.1.8
-Requires-Python: >=3.12
-Requires-Dist: cryptography~=44.0.0
-Requires-Dist: httpx[http2,socks]~=0.28.0
-Requires-Dist: pydantic~=2.10.2
-Requires-Dist: pydash~=8.0.4
-Requires-Dist: python-dotenv~=1.0.1
-Requires-Dist: pyyaml~=6.0.1
-Requires-Dist: rich~=13.0

mm_std-0.1.8.dist-info/RECORD

@@ -1,23 +0,0 @@
-mm_std/__init__.py,sha256=4pa6AjO-0mfrfBi6FS5sqOk1HFAKt2OMovA12ys7UvQ,2288
-mm_std/command.py,sha256=r1n9ZHyMFhNkNOH9grRCm5J0hhX4_v0c2wdaal8iCZY,1270
-mm_std/concurrency.py,sha256=SZGSTlswpFRZwsI7ztFWYca1XOPToLe0oBNJBZlSlgo,5311
-mm_std/config.py,sha256=Wo_VS6MO1vTZosOHv97mCo41YYGKZaRAeergaSVzUcs,3111
-mm_std/crypto.py,sha256=jdk0_TCmeU0pPXMyz9xH6kQHSjjZ9GcGClBwQps5vBo,340
-mm_std/date.py,sha256=dhlBE8dTzPe0Qhu5f6YMeR5ka5k2B0IoMe8VA7_-pII,1969
-mm_std/dict.py,sha256=kJBPVG9vEqHiSgKKoji8gVGL1yEBbxAmFNn0zz17AUg,180
-mm_std/env.py,sha256=5zaR9VeIfObN-4yfgxoFeU5IM1GDeZZj9SuYf7t9sOA,125
-mm_std/fs.py,sha256=RwarNRJq3tIMG6LVX_g03hasfYpjYFh_O27oVDt5IPQ,291
-mm_std/json_.py,sha256=12uGLwmnrRA63QI0nUx-UU33zXcyShbsKCoOQiIJ8io,1016
-mm_std/log.py,sha256=6ux6njNKc_ZCQlvWn1FZR6vcSY2Cem-mQzmNXvsg5IE,913
-mm_std/net.py,sha256=k3kl9OY23VoF2md6UyRBDQ9lhRzWlFCuhalDtv6Of90,4686
-mm_std/print_.py,sha256=mMixwfdrLEYW15ez7_QxXdrV-d38q9XJP8tB8F7P2pI,1553
-mm_std/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_std/random_.py,sha256=OuUX4VJeSd13NZBya4qrGpR2TfN7_87tfebOY6DBUnI,1113
-mm_std/result.py,sha256=1uCb2YySZGHLVNrGRQYhs6BngB8aEW2MKY9Bx6j2wNQ,7407
-mm_std/str.py,sha256=nG5XF5870xM2PAvU0LZrJDk-d54LYwRLGnSahIekOVw,3151
-mm_std/telegram.py,sha256=QrHPnsy0LTeqpd-g3RaHhk7gWIfHZEgnMs-S5DLW-vU,1220
-mm_std/types.py,sha256=KpFtJ-BTmDfmmFeOSlgq6cMbCfGGOQjh1oWvdcrW-kw,116
-mm_std/zip.py,sha256=2EXcae4HO5U4kObj2Lj8jl5F2OUpT-WRlJybTyFzt6I,370
-mm_std-0.1.8.dist-info/METADATA,sha256=qS2lfsHdWITmGzMWqikfNAAA-bZrWRfZHayi1_tF5bA,304
-mm_std-0.1.8.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-mm_std-0.1.8.dist-info/RECORD,,