mm-std 0.0.1__py3-none-any.whl

mm_std/__init__.py

@@ -0,0 +1,46 @@
+from .command import CommandResult as CommandResult
+from .command import run_command as run_command
+from .command import run_ssh_command as run_ssh_command
+from .concurrency import ConcurrentTasks as ConcurrentTasks
+from .concurrency import Scheduler as Scheduler
+from .concurrency import synchronized as synchronized
+from .concurrency import synchronized_parameter as synchronized_parameter
+from .config import BaseConfig as BaseConfig
+from .crypto import fernet_decrypt as fernet_decrypt
+from .crypto import fernet_encrypt as fernet_encrypt
+from .crypto import fernet_generate_key as fernet_generate_key
+from .date import parse_date as parse_date
+from .date import utc_delta as utc_delta
+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 .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 .print_ import PrintFormat as PrintFormat
+from .print_ import fatal as fatal
+from .print_ import print_console as print_console
+from .print_ import print_json as print_json
+from .print_ import print_plain as print_plain
+from .print_ import print_table as print_table
+from .random_ import random_choice as random_choice
+from .random_ import random_decimal as random_decimal
+from .random_ import random_str_choice as random_str_choice
+from .result import Err as Err
+from .result import Ok as Ok
+from .result import Result as Result
+from .result import try_ok as try_ok
+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

@@ -0,0 +1,35 @@
+import subprocess  # nosec
+from dataclasses import dataclass
+
+
+@dataclass
+class CommandResult:
+    stdout: str
+    stderr: str
+    code: int
+
+    @property
+    def out(self) -> str:
+        if self.stdout:
+            return self.stdout + "\n" + self.stderr
+        return self.stderr
+
+
+def run_command(cmd: str, timeout: int | None = 60, capture_output: bool = True, echo_cmd_console: bool = False) -> CommandResult:
+    if echo_cmd_console:
+        print(cmd)  # noqa: T201
+    try:
+        process = subprocess.run(cmd, timeout=timeout, capture_output=capture_output, shell=True, check=False)  # 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)
+    except subprocess.TimeoutExpired:
+        return CommandResult(stdout="", stderr="timeout", code=124)
+
+
+def run_ssh_command(host: str, cmd: str, ssh_key_path: str | None = None, timeout: int = 60) -> CommandResult:
+    ssh_cmd = "ssh -o 'StrictHostKeyChecking=no' -o 'LogLevel=ERROR'"
+    if ssh_key_path:
+        ssh_cmd += f" -i {ssh_key_path} "
+    ssh_cmd += f" {host} {cmd}"
+    return run_command(ssh_cmd, timeout=timeout)

mm_std/concurrency.py

@@ -0,0 +1,157 @@
+import concurrent.futures
+import functools
+import time
+from collections import defaultdict
+from collections.abc import Callable
+from concurrent.futures.thread import ThreadPoolExecutor
+from dataclasses import dataclass, field
+from datetime import datetime
+from logging import Logger
+from threading import Lock, Thread
+from typing import ParamSpec, TypeAlias, TypeVar
+
+from .date import is_too_old, utc_now
+
+Func: TypeAlias = Callable[..., object]
+Args: TypeAlias = tuple[object, ...]
+Kwargs: TypeAlias = dict[str, object]
+
+
+class ConcurrentTasks:
+    def __init__(self, max_workers: int = 5, timeout: int | None = None, thread_name_prefix: str = "concurrent_tasks") -> None:
+        self.max_workers = max_workers
+        self.timeout = timeout
+        self.thread_name_prefix = thread_name_prefix
+        self.tasks: list[ConcurrentTasks.Task] = []
+        self.exceptions: dict[str, Exception] = {}
+        self.error = False
+        self.timeout_error = False
+        self.result: dict[str, object] = {}
+
+    @dataclass
+    class Task:
+        key: str
+        func: Func
+        args: Args
+        kwargs: Kwargs
+
+    def add_task(self, key: str, func: Func, args: Args = (), kwargs: Kwargs | None = None) -> None:
+        if kwargs is None:
+            kwargs = {}
+        self.tasks.append(ConcurrentTasks.Task(key, func, args, kwargs))
+
+    def execute(self) -> None:
+        with ThreadPoolExecutor(self.max_workers, thread_name_prefix=self.thread_name_prefix) as executor:
+            future_to_key = {executor.submit(task.func, *task.args, **task.kwargs): task.key for task in self.tasks}
+            try:
+                result_map = concurrent.futures.as_completed(future_to_key, timeout=self.timeout)
+                for future in result_map:
+                    key = future_to_key[future]
+                    try:
+                        self.result[key] = future.result()
+                    except Exception as err:
+                        self.error = True
+                        self.exceptions[key] = err
+            except concurrent.futures.TimeoutError:
+                self.error = True
+                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]]:
+    locks: dict[object, Lock] = defaultdict(Lock)
+
+    def outer(func: Callable[P, T]) -> Callable[P, T | None]:
+        @functools.wraps(func)
+        def wrapper(*args: P.args, **kwargs: P.kwargs) -> T | None:
+            if skip_if_locked and locks[args[arg_index]].locked():
+                return None
+            try:
+                with locks[args[arg_index]]:
+                    return func(*args, **kwargs)
+            finally:
+                locks.pop(args[arg_index], None)
+
+        wrapper.locks = locks  # type: ignore[attr-defined]
+        return wrapper
+
+    return outer
+
+
+def synchronized(fn: Callable[P, T]) -> Callable[P, T]:
+    lock = Lock()
+
+    @functools.wraps(fn)
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+        with lock:
+            return fn(*args, **kwargs)
+
+    return wrapper
+
+
+class Scheduler:
+    def __init__(self, log: Logger, loop_delay: float = 0.5, debug: bool = False):
+        self.log = log
+        self.debug = debug
+        self.loop_delay = loop_delay
+        self.stopped = False
+        self.jobs: list[Scheduler.Job] = []
+        self.run_immediately_jobs: list[Scheduler.Job] = []
+        self._debug("init")
+
+    @dataclass
+    class Job:
+        func: Func
+        args: tuple[object, ...]
+        interval: int
+        is_running: bool = False
+        last_at: datetime = field(default_factory=utc_now)
+
+        def __str__(self) -> str:
+            return str(self.func)
+
+    def add_job(self, func: Func, interval: int, args: tuple[object, ...] = (), run_immediately: bool = False) -> None:
+        job = Scheduler.Job(func, args, interval)
+        self.jobs.append(job)
+        if run_immediately:
+            self.run_immediately_jobs.append(job)
+
+    def _run_job(self, job: Job) -> None:
+        self._debug(f"_run_job: {job}")
+        if self.stopped:
+            return
+        try:
+            job.func(*job.args)
+            self._debug(f"_run_job: {job} done")
+        except Exception as e:
+            self.log.exception("scheduler error: %s", str(e))
+            self._debug(f"_run_job: {job} error")
+        finally:
+            job.is_running = False
+
+    def _start(self) -> None:
+        self._debug(f"_start: jobs={len(self.jobs)}, run_immediately_jobs={len(self.run_immediately_jobs)}")
+        for j in self.run_immediately_jobs:
+            j.is_running = True
+            j.last_at = utc_now()
+            Thread(target=self._run_job, args=(j,)).start()
+        while not self.stopped:
+            for j in self.jobs:
+                if not j.is_running and is_too_old(j.last_at, j.interval):
+                    j.is_running = True
+                    j.last_at = utc_now()
+                    Thread(target=self._run_job, args=(j,)).start()
+            time.sleep(self.loop_delay)
+
+    def _debug(self, message: str) -> None:
+        if self.debug:
+            self.log.debug("Scheduler: %s", message)
+
+    def start(self) -> None:
+        Thread(target=self._start).start()
+
+    def stop(self) -> None:
+        self.stopped = True

mm_std/config.py

@@ -0,0 +1,78 @@
+import io
+from pathlib import Path
+from typing import TypeVar
+
+import yaml
+from pydantic import BaseModel, ConfigDict, ValidationError
+
+from .print_ import PrintFormat, print_console, print_json, print_plain, print_table
+from .str import str_to_list
+from .zip import read_text_from_zip_archive
+
+T = TypeVar("T")
+
+
+class BaseConfig(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    @classmethod
+    def to_list_str_validator(
+        cls,
+        v: str | list[str] | None,
+        *,
+        lower: bool = False,
+        unique: bool = False,
+        remove_comments: bool = False,
+        split_line: bool = False,
+    ) -> list[str]:
+        if v is None:
+            return []
+        if isinstance(v, str):
+            return str_to_list(v, unique=unique, remove_comments=remove_comments, split_line=split_line, lower=lower)
+        return v
+
+    @classmethod
+    def read_config(  # nosec
+        cls: type[T],
+        config_path: io.TextIOWrapper | str | Path,
+        error_print_type: PrintFormat = PrintFormat.PLAIN,
+        zip_password: str = "",
+    ) -> T:
+        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)))
+            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)))
+            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)))
+
+            # 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))
+        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)
+        except Exception as err:
+            if error_print_type == "json":
+                print_json({"exception": str(err)})
+            else:
+                print_console(f"config error: {err!s}")
+            exit(1)

mm_std/crypto.py

@@ -0,0 +1,13 @@
+from cryptography.fernet import Fernet
+
+
+def fernet_generate_key() -> str:
+    return Fernet.generate_key().decode()
+
+
+def fernet_encrypt(*, data: str, key: str) -> str:
+    return Fernet(key).encrypt(data.encode()).decode()
+
+
+def fernet_decrypt(*, encoded_data: str, key: str) -> str:
+    return Fernet(key).decrypt(encoded_data).decode()

mm_std/date.py

@@ -0,0 +1,48 @@
+import random
+from datetime import UTC, datetime, timedelta
+
+from dateutil import parser
+
+
+def utc_now() -> datetime:
+    return datetime.now(UTC)
+
+
+def utc_delta(
+    *,
+    days: int | None = None,
+    hours: int | None = None,
+    minutes: int | None = None,
+    seconds: int | None = None,
+) -> datetime:
+    params = {}
+    if days:
+        params["days"] = days
+    if hours:
+        params["hours"] = hours
+    if minutes:
+        params["minutes"] = minutes
+    if seconds:
+        params["seconds"] = seconds
+    return datetime.now(UTC) + timedelta(**params)
+
+
+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,
+    range_hours: int = 0,
+    range_minutes: int = 0,
+    range_seconds: int = 0,
+) -> datetime:
+    if from_time is None:
+        from_time = utc_now()
+    to_time = from_time + timedelta(hours=range_hours, minutes=range_minutes, seconds=range_seconds)
+    return from_time + (to_time - from_time) * random.random()
+
+
+def is_too_old(value: datetime | None, seconds: int) -> bool:
+    return value is None or value < utc_delta(seconds=-1 * seconds)

mm_std/dict.py

@@ -0,0 +1,4 @@
+def replace_empty_values(data: dict[object, object], defaults: dict[object, object]) -> None:
+    for k, v in defaults.items():
+        if not data.get(k):
+            data[k] = v

mm_std/env.py

@@ -0,0 +1,9 @@
+import os
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+def get_dotenv(key: str) -> str | None:
+    return os.getenv(key)

mm_std/fs.py

@@ -0,0 +1,13 @@
+from pathlib import Path
+
+
+def read_text(path: str | Path) -> str:
+    if isinstance(path, str):
+        path = Path(path)
+    return path.read_text()
+
+
+def get_filename_without_extension(path: str | Path) -> str:
+    if isinstance(path, str):
+        path = Path(path)
+    return path.stem

mm_std/json_.py

@@ -0,0 +1,36 @@
+import json
+from dataclasses import asdict, is_dataclass
+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
+
+from mm_std.result import Err, Ok
+
+
+class CustomJSONEncoder(JSONEncoder):
+    def default(self, o: Any) -> Any:
+        if isinstance(o, Ok):
+            return {"ok": o.ok}
+        if isinstance(o, Err):
+            return {"err": o.err}
+        if isinstance(o, Decimal):
+            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 JSONEncoder.default(self, o)
+
+
+def json_dumps(data: object) -> str:
+    return json.dumps(data, cls=CustomJSONEncoder)

mm_std/log.py

@@ -0,0 +1,22 @@
+import logging
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+
+
+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

@@ -0,0 +1,154 @@
+import json
+import socket
+import time
+from dataclasses import asdict, dataclass, field
+from json import JSONDecodeError
+from typing import Any, TypeVar, cast
+from urllib.parse import urlencode
+
+import pydash
+import requests
+
+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
+
+T = TypeVar("T")
+
+
+@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(self, error: str | None = None) -> Err:
+        return Err(error or self.error or "error", data=asdict(self))
+
+    def to_ok_result(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: int = 10,
+    user_agent: str | None = None,
+    json_params: bool = True,
+    auth: Any = None,
+    verify: bool = True,
+) -> HResponse:
+    method = method.upper()
+    proxies = {"http": proxy, "https": proxy} if proxy else None
+    if not headers:
+        headers = {}
+    try:
+        headers["user-agent"] = user_agent
+        request_params = {
+            "proxies": proxies,
+            "timeout": timeout,
+            "headers": headers,
+            "cookies": cookies,
+            "auth": auth,
+            "verify": verify,
+        }
+        if method == "GET":
+            request_params["params"] = params
+        elif json_params:
+            request_params["json"] = params
+        else:
+            request_params["data"] = params
+        r = requests.request(method, url, **request_params)
+        return HResponse(code=r.status_code, body=r.text, headers=dict(r.headers))
+    except requests.exceptions.Timeout:
+        return HResponse(error="timeout")
+    except requests.exceptions.ProxyError:
+        return HResponse(error="proxy_error")
+    except requests.exceptions.ConnectionError as err:
+        return HResponse(error=f"connection_error: {err}")
+    except Exception as err:
+        return HResponse(error=f"exception: {err}")
+
+
+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)
+
+
+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

@@ -0,0 +1,54 @@
+import sys
+from enum import Enum, unique
+from typing import Any, NoReturn
+
+import rich
+from rich.console import Console
+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) -> None:
+    if len(messages) == 1:
+        message = messages[0]
+        if isinstance(message, str):
+            print(message)  # noqa: T201
+        else:
+            if print_json:
+                rich.print_json(json_dumps(message))
+            else:
+                rich.print(message)
+    else:
+        rich.print(messages)
+
+
+def print_plain(messages: object, print_format: PrintFormat | None = None) -> None:
+    if print_format is None or print_format == PrintFormat.PLAIN:
+        print(messages)  # noqa: T201
+
+
+def print_json(data: object, print_format: PrintFormat | None = None) -> None:
+    if print_format is None or print_format == PrintFormat.JSON:
+        rich.print_json(json_dumps(data))
+
+
+def print_table(title: str, columns: list[str], rows: list[list[Any]], print_format: PrintFormat | None = None) -> None:
+    if print_format is None or print_format == PrintFormat.TABLE:
+        table = Table(*columns, title=title)
+        for row in rows:
+            table.add_row(*(str(cell) for cell in row))
+        console = Console()
+        console.print(table)

mm_std/random_.py

@@ -0,0 +1,38 @@
+import random
+from collections.abc import Sequence
+from decimal import Decimal
+from typing import TypeVar
+
+T = TypeVar("T", contravariant=True)
+
+
+def random_choice(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)))

mm_std/result.py

@@ -0,0 +1,266 @@
+from __future__ import annotations
+
+import time
+from collections.abc import Callable
+from typing import Any, Generic, Literal, NoReturn, TypeAlias, TypeVar
+
+T = TypeVar("T", covariant=True)  # Success type
+U = TypeVar("U")
+F = TypeVar("F")
+TBE = TypeVar("TBE", bound=BaseException)
+
+
+class Ok(Generic[T]):
+    __match_args__ = ("ok",)
+
+    def __init__(self, value: T, data: Any = None) -> None:
+        self._value = value
+        self.data = data
+
+    def __repr__(self) -> str:
+        if self.data is None:
+            return f"Ok({self._value!r})"
+        else:
+            return f"Ok({self._value!r}, data={self.data!r})"
+
+    def __eq__(self, other: Any) -> bool:
+        return isinstance(other, Ok) and self._value == other._value and self.data == other.data
+
+    def __ne__(self, other: Any) -> bool:
+        return not (self == other)
+
+    def __hash__(self) -> int:
+        return hash((True, self._value, self.data))
+
+    def is_ok(self) -> Literal[True]:
+        return True
+
+    def is_err(self) -> Literal[False]:
+        return False
+
+    @property
+    def ok(self) -> T:
+        return self._value
+
+    @property
+    def err(self) -> None:
+        return None
+
+    def expect(self, _message: str) -> T:
+        return self._value
+
+    def expect_err(self, message: str) -> NoReturn:
+        raise UnwrapError(self, message)
+
+    def unwrap(self) -> T:
+        return self._value
+
+    def unwrap_err(self) -> NoReturn:
+        raise UnwrapError(self, "Called `Result.unwrap_err()` on an `Ok` value")
+
+    def unwrap_or(self, _default: U) -> T:
+        return self._value
+
+    def unwrap_or_else(self, op: object) -> T:
+        return self._value
+
+    def unwrap_or_raise(self, e: object) -> T:
+        return self._value
+
+    def map(self, op: Callable[[T], U]) -> Ok[U]:
+        return Ok(op(self._value), data=self.data)
+
+    def map_or(self, default: object, op: Callable[[T], U]) -> U:
+        return op(self._value)
+
+    def map_or_else(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._value)
+
+    def map_err(self, op: object) -> Ok[T]:
+        """
+        The contained result is `Ok`, so return `Ok` with the original value
+        """
+        return self
+
+    def and_then(self, op: Callable[[T], U | Result[U]]) -> Result[U]:
+        """
+        The contained result is `Ok`, so return the result of `op` with the
+        original value passed in. If return of `op` function is not Result, it will be a Ok value.
+        """
+        try:
+            res = op(self._value)
+            if not isinstance(res, Ok | Err):
+                res = Ok(res)
+        except Exception as e:
+            res = Err(e)
+        res.data = self.data
+        return res
+
+    def or_else(self, op: object) -> Ok[T]:
+        return self
+
+    def ok_or_err(self) -> T | str:
+        return self._value
+
+    def ok_or_none(self) -> T | None:
+        return self._value
+
+
+class Err:
+    __match_args__ = ("err",)
+
+    def __init__(self, value: str | Exception, data: Any = None) -> None:
+        self._value = f"exception: {value}" if isinstance(value, Exception) else value
+        self.data = data
+
+    def __repr__(self) -> str:
+        if self.data is None:
+            return f"Err({self._value!r})"
+        else:
+            return f"Err({self._value!r}, data={self.data!r})"
+
+    def __eq__(self, other: Any) -> bool:
+        return isinstance(other, Err) and self._value == other._value and self.data == other.data
+
+    def __ne__(self, other: Any) -> bool:
+        return not (self == other)
+
+    def __hash__(self) -> int:
+        return hash((False, self._value, self.data))
+
+    def is_ok(self) -> Literal[False]:
+        return False
+
+    def is_err(self) -> Literal[True]:
+        return True
+
+    @property
+    def ok(self) -> None:
+        """
+        Return `None`.
+        """
+        return None
+
+    @property
+    def err(self) -> str:
+        """
+        Return the error.
+        """
+        return self._value
+
+    def expect(self, message: str) -> NoReturn:
+        """
+        Raises an `UnwrapError`.
+        """
+        exc = UnwrapError(
+            self,
+            f"{message}: {self._value!r}",
+        )
+        if isinstance(self._value, BaseException):
+            raise exc from self._value
+        raise exc
+
+    def expect_err(self, _message: str) -> str:
+        """
+        Return the inner value
+        """
+        return self._value
+
+    def unwrap(self) -> NoReturn:
+        """
+        Raises an `UnwrapError`.
+        """
+        exc = UnwrapError(
+            self,
+            f"Called `Result.unwrap()` on an `Err` value: {self._value!r}",
+        )
+        if isinstance(self._value, BaseException):
+            raise exc from self._value
+        raise exc
+
+    def unwrap_err(self) -> str:
+        """
+        Return the inner value
+        """
+        return self._value
+
+    def unwrap_or(self, default: U) -> U:
+        """
+        Return `default`.
+        """
+        return default
+
+    def unwrap_or_else(self, op: Callable[[str], T]) -> T:
+        """
+        The contained result is ``Err``, so return the result of applying
+        ``op`` to the error value.
+        """
+        return op(self._value)
+
+    def unwrap_or_raise(self, e: type[TBE]) -> NoReturn:
+        """
+        The contained result is ``Err``, so raise the exception with the value.
+        """
+        raise e(self._value)
+
+    def map(self, op: object) -> Err:
+        """
+        Return `Err` with the same value
+        """
+        return self
+
+    def map_or(self, default: U, op: object) -> U:
+        """
+        Return the default value
+        """
+        return default
+
+    def map_or_else(self, err_op: Callable[[str], U], ok_op: object) -> U:
+        """
+        Return the result of the default operation
+        """
+        return err_op(self._value)
+
+    def and_then(self, op: object) -> Err:
+        """
+        The contained result is `Err`, so return `Err` with the original value
+        """
+        return self
+
+    def ok_or_err(self) -> T | str:
+        return self._value
+
+    def ok_or_none(self) -> T | None:
+        return None
+
+
+Result: TypeAlias = Ok[T] | Err
+
+
+class UnwrapError(Exception):
+    _result: Result[object]
+
+    def __init__(self, result: Result[object], message: str) -> None:
+        self._result = result
+        super().__init__(message)
+
+    @property
+    def result(self) -> Result[Any]:
+        return self._result
+
+
+def try_ok(fn: Callable[..., Result[T]], *, args: tuple[object], attempts: int, delay: int | float = 0) -> Result[T]:
+    if attempts <= 0:
+        raise ValueError("attempts must be more than zero")
+    res: Result[T] = Err("not started")
+    for _ in range(attempts):
+        res = fn(*args)
+        if res.is_ok():
+            return res
+        if delay:
+            time.sleep(delay)
+    return res

mm_std/str.py

@@ -0,0 +1,106 @@
+import re
+from collections.abc import Iterable
+from decimal import Decimal
+
+import pydash
+
+
+def str_to_list(
+    data: str | Iterable[object] | None,
+    lower: bool = False,
+    remove_comments: bool = False,
+    unique: bool = False,
+    split_line: bool = False,
+) -> list[str]:
+    match data:
+        case None | "" | []:
+            return []
+        case str():
+            if lower:
+                data = data.lower()
+            result = [line.strip() for line in data.split("\n") if line.strip()]
+            if remove_comments:
+                result = [line.split("#")[0].strip() for line in result]
+                result = [line for line in result if line]
+            if unique:
+                result = pydash.uniq(result)
+
+            if split_line:
+                new_result = []
+                for line in result:
+                    new_result.extend(line.split())
+                return new_result
+
+            return result
+        case Iterable():
+            return [str(x) for x in data]
+        case _:
+            raise ValueError("data has a wrong type")
+
+
+def number_with_separator(
+    value: float | str | Decimal | None,
+    prefix: str = "",
+    suffix: str = "",
+    separator: str = "_",
+    hide_zero: bool = False,
+    round_digits: int = 2,
+) -> str:
+    if value is None or value == "":
+        return ""
+    if float(value) == 0:
+        return "" if hide_zero else f"{prefix}0{suffix}"
+    if float(value) > 1000:
+        value = "".join(
+            reversed([x + (separator if i and not i % 3 else "") for i, x in enumerate(reversed(str(int(value))))]),
+        )
+    else:
+        value = round(value, round_digits)  # type:ignore[arg-type,assignment]
+
+    return f"{prefix}{value}{suffix}"
+
+
+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
+
+
+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
+
+
+def split_on_plus_minus_tokens(value: str) -> list[str]:
+    value = "".join(value.split())
+    if not value:
+        raise ValueError("value is empty")
+    if "++" in value:
+        raise ValueError("++ in value")
+    if "--" in value:
+        raise ValueError("-- in value")
+    if value.endswith("-"):
+        raise ValueError("ends with -")
+    if value.endswith("+"):
+        raise ValueError("ends with +")
+
+    if not value.startswith("+") and not value.startswith("-"):
+        value = "+" + value
+
+    result: list[str] = []
+    rest_value = value
+    while True:
+        if not rest_value:
+            return result
+        items = re.split(r"[+\-]", rest_value)
+        if rest_value.startswith("+"):
+            result.append("+" + items[1])
+            rest_value = rest_value.removeprefix("+" + items[1])
+        elif rest_value.startswith("-"):
+            result.append("-" + items[1])
+            rest_value = rest_value.removeprefix("-" + items[1])

mm_std/telegram.py

@@ -0,0 +1,35 @@
+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

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

mm_std/zip.py

@@ -0,0 +1,8 @@
+from zipfile import ZipFile
+
+
+def read_text_from_zip_archive(zip_archive_path: str, filename: str | None = None, password: str | None = None) -> str:
+    with ZipFile(zip_archive_path) as zipfile:
+        if filename is None:
+            filename = zipfile.filelist[0].filename
+        return zipfile.read(filename, pwd=password.encode() if password else None).decode()

mm_std-0.0.1.dist-info/METADATA

@@ -0,0 +1,28 @@
+Metadata-Version: 2.1
+Name: mm-std
+Version: 0.0.1
+Requires-Python: >=3.11
+Requires-Dist: requests ~=2.32.3
+Requires-Dist: PySocks ~=1.7.1
+Requires-Dist: pydash ~=8.0.0
+Requires-Dist: python-dateutil ~=2.9.0
+Requires-Dist: pydantic ~=2.8.2
+Requires-Dist: python-dotenv ~=1.0.1
+Requires-Dist: PyYAML ~=6.0.1
+Requires-Dist: cryptography ~=43.0.0
+Requires-Dist: rich
+Provides-Extra: dev
+Requires-Dist: build ~=1.2.1 ; extra == 'dev'
+Requires-Dist: twine ~=5.1.0 ; extra == 'dev'
+Requires-Dist: pytest ~=8.3.2 ; extra == 'dev'
+Requires-Dist: pytest-xdist ~=3.6.1 ; extra == 'dev'
+Requires-Dist: pytest-httpserver ~=1.0.8 ; extra == 'dev'
+Requires-Dist: coverage ~=7.6.0 ; extra == 'dev'
+Requires-Dist: ruff ~=0.5.2 ; extra == 'dev'
+Requires-Dist: pip-audit ~=2.7.0 ; extra == 'dev'
+Requires-Dist: bandit ~=1.7.7 ; extra == 'dev'
+Requires-Dist: mypy ~=1.11.0 ; extra == 'dev'
+Requires-Dist: types-python-dateutil ~=2.9.0 ; extra == 'dev'
+Requires-Dist: types-requests ~=2.32.0.20240523 ; extra == 'dev'
+Requires-Dist: types-PyYAML ~=6.0.12.12 ; extra == 'dev'
+

mm_std-0.0.1.dist-info/RECORD

@@ -0,0 +1,24 @@
+mm_std/__init__.py,sha256=4pa6AjO-0mfrfBi6FS5sqOk1HFAKt2OMovA12ys7UvQ,2288
+mm_std/command.py,sha256=r1n9ZHyMFhNkNOH9grRCm5J0hhX4_v0c2wdaal8iCZY,1270
+mm_std/concurrency.py,sha256=XSPYLUsGO1G0mcsdTn_Hwg5nb694-nUMhwQ6TvOrMCc,5340
+mm_std/config.py,sha256=ftYrsZ4i715I20s2q8vqYyniMSCIAVrh-9TtAzsyMfQ,3147
+mm_std/crypto.py,sha256=jdk0_TCmeU0pPXMyz9xH6kQHSjjZ9GcGClBwQps5vBo,340
+mm_std/date.py,sha256=eJFQHY2sxO6e7XBAsXoki0dC5XvqiE-mA4LDUXzw3DM,1200
+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=-xt2tEov3vhXR44Rlj4JohL-g1n7k7JUobo4kHTubzg,4702
+mm_std/print_.py,sha256=mMixwfdrLEYW15ez7_QxXdrV-d38q9XJP8tB8F7P2pI,1553
+mm_std/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mm_std/random_.py,sha256=KZauQzHsJaCVIeyHrJ74hiH34hdFE7pUxuv5i0Hl28g,1175
+mm_std/result.py,sha256=EBump_FnfPk7kU7-e_Y95qrOO-myW25XGyNdjExEqrI,6989
+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.0.1.dist-info/METADATA,sha256=Zm0BysQQEMeSy21mDQSSfm3mgvKpftqCnAQf0tJ0DKE,1055
+mm_std-0.0.1.dist-info/WHEEL,sha256=Rp8gFpivVLXx-k3U95ozHnQw8yDcPxmhOpn_Gx8d5nc,91
+mm_std-0.0.1.dist-info/top_level.txt,sha256=KOhw9T6TIeq7JXPPeJXvOxBaQI3gMYLTUH5Mtil3BzA,7
+mm_std-0.0.1.dist-info/RECORD,,

mm_std-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (72.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mm_std-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+mm_std