mm-std 0.3.8__py3-none-any.whl → 0.3.10__py3-none-any.whl

mm_std/__init__.py

@@ -1,3 +1,4 @@
+from .async_concurrency import AsyncScheduler as AsyncScheduler
 from .command import CommandResult as CommandResult
 from .command import run_command as run_command
 from .command import run_ssh_command as run_ssh_command
@@ -19,6 +20,8 @@ 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 ahr as ahr
+from .http_ import async_hrequest as async_hrequest
 from .http_ import hr as hr
 from .http_ import hrequest as hrequest
 from .json_ import CustomJSONEncoder as CustomJSONEncoder

mm_std/async_concurrency.py

@@ -0,0 +1,107 @@
+import threading
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+from logging import Logger
+
+import anyio
+
+# Type aliases for clarity
+AsyncFunc = Callable[..., Awaitable[object]]
+Args = tuple[object, ...]
+Kwargs = dict[str, object]
+
+
+class AsyncScheduler:
+    @dataclass
+    class TaskInfo:
+        task_id: str
+        interval: float
+        func: AsyncFunc
+        args: Args = ()
+        kwargs: Kwargs = field(default_factory=dict)
+        run_count: int = 0
+        last_run: datetime | None = None
+        running: bool = False
+
+    def __init__(self, logger: Logger) -> None:
+        self.tasks: dict[str, AsyncScheduler.TaskInfo] = {}
+        self._running: bool = False
+        self._cancel_scope: anyio.CancelScope | None = None
+        self._thread: threading.Thread | None = None
+        self._logger = logger
+
+    def add_task(self, task_id: str, interval: float, func: AsyncFunc, args: Args = (), kwargs: Kwargs | None = None) -> None:
+        """Register a new task with the scheduler."""
+        if kwargs is None:
+            kwargs = {}
+        if task_id in self.tasks:
+            raise ValueError(f"Task with id {task_id} already exists")
+        self.tasks[task_id] = AsyncScheduler.TaskInfo(task_id=task_id, interval=interval, func=func, args=args, kwargs=kwargs)
+
+    async def _run_task(self, task_id: str) -> None:
+        """Internal loop for running a single task repeatedly."""
+        task = self.tasks[task_id]
+        while self._running:
+            task.last_run = datetime.now(UTC)
+            task.run_count += 1
+            try:
+                await task.func(*task.args, **task.kwargs)
+            except Exception:
+                self._logger.exception("AsyncScheduler exception")
+
+            # Calculate elapsed time and sleep if needed so that tasks never overlap.
+            elapsed = (datetime.now(UTC) - task.last_run).total_seconds()
+            sleep_time = task.interval - elapsed
+            if sleep_time > 0:
+                try:
+                    await anyio.sleep(sleep_time)
+                except Exception:
+                    self._logger.exception("AsyncScheduler exception")
+
+    async def _start_all_tasks(self) -> None:
+        """Starts all tasks concurrently in an AnyIO task group."""
+        async with anyio.create_task_group() as tg:
+            self._cancel_scope = tg.cancel_scope
+            for task_id in self.tasks:
+                tg.start_soon(self._run_task, task_id)
+            try:
+                while self._running:  # noqa: ASYNC110
+                    await anyio.sleep(0.1)
+            except anyio.get_cancelled_exc_class():
+                self._logger.info("Task group cancelled. Exiting _start_all_tasks.")
+
+    def start(self) -> None:
+        """
+        Start the scheduler.
+
+        This method launches the scheduler in a background thread,
+        which runs an AnyIO event loop.
+        """
+        if self._running:
+            self._logger.warning("Scheduler already running")
+            return
+        self._running = True
+        self._logger.info("Starting scheduler")
+        self._thread = threading.Thread(target=lambda: anyio.run(self._start_all_tasks), daemon=True)
+        self._thread.start()
+
+    def stop(self) -> None:
+        """
+        Stop the scheduler.
+
+        The running flag is set to False so that each task's loop will exit.
+        This method then waits for the background thread to finish.
+        """
+        if not self._running:
+            self._logger.warning("Scheduler not running")
+            return
+        self._logger.info("Stopping scheduler")
+        self._running = False
+        if self._cancel_scope is not None:
+            self._cancel_scope.cancel()
+
+        if self._thread:
+            self._thread.join(timeout=5)
+            self._thread = None
+        self._logger.info("Scheduler stopped")

mm_std/config.py

@@ -1,7 +1,7 @@
 import sys
 import tomllib
 from pathlib import Path
-from typing import NoReturn
+from typing import NoReturn, Self
 
 from pydantic import BaseModel, ConfigDict, ValidationError
 
@@ -35,7 +35,7 @@ class BaseConfig(BaseModel):
         sys.exit(1)
 
     @classmethod
-    def read_toml_config[T](cls: type[T], config_path: Path, zip_password: str = "") -> Result[T]:  # nosec
+    def read_toml_config(cls, config_path: Path, zip_password: str = "") -> Result[Self]:  # nosec
         try:
             config_path = config_path.expanduser()
             if config_path.name.endswith(".zip"):

mm_std/http_.py

@@ -5,7 +5,8 @@ from urllib.parse import urlencode
 
 import httpx
 import pydash
-from httpx._types import AuthTypes
+import requests
+from requests.auth import AuthBase
 
 from mm_std.result import Err, Ok, Result
 
@@ -90,7 +91,7 @@ def hrequest(
     timeout: float = 10,
     user_agent: str | None = None,
     json_params: bool = True,
-    auth: AuthTypes | None = None,
+    auth: AuthBase | tuple[str, str] | None = None,
     verify: bool = True,
 ) -> HResponse:
     query_params: dict[str, Any] | None = None
@@ -108,11 +109,18 @@ def hrequest(
     else:
         data = params
 
+    proxies = None
+    if proxy:
+        proxies = {
+            "http": proxy,
+            "https": proxy,
+        }
+
     try:
-        r = httpx.request(
+        r = requests.request(
             method,
             url,
-            proxy=proxy,
+            proxies=proxies,
             timeout=timeout,
             cookies=cookies,
             auth=auth,
@@ -123,11 +131,67 @@ def hrequest(
             data=data,
         )
         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.RequestException as err:
+        return HResponse(error=f"connection_error: {err}")
+    except Exception as err:
+        return HResponse(error=f"exception: {err}")
+
+
+async def async_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,  # noqa: ASYNC109
+    user_agent: str | None = None,
+    json_params: bool = True,
+    auth: httpx.Auth | tuple[str, str] | 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:
+        async with httpx.AsyncClient(
+            proxy=proxy,
+            timeout=timeout,
+            cookies=cookies,
+            auth=auth,
+            verify=verify,
+        ) as client:
+            r = await client.request(
+                method,
+                url,
+                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:
+    except httpx.RequestError as err:
         return HResponse(error=f"connection_error: {err}")
     except Exception as err:
         return HResponse(error=f"exception: {err}")
@@ -141,3 +205,4 @@ def add_query_params_to_url(url: str, params: dict[str, object]) -> str:
 
 
 hr = hrequest
+ahr = async_hrequest

{mm_std-0.3.8.dist-info → mm_std-0.3.10.dist-info}/METADATA

@@ -1,11 +1,14 @@
 Metadata-Version: 2.4
 Name: mm-std
-Version: 0.3.8
+Version: 0.3.10
 Requires-Python: >=3.12
+Requires-Dist: anyio>=4.9.0
 Requires-Dist: cryptography~=44.0.2
-Requires-Dist: httpx[http2,socks]~=0.28.1
+Requires-Dist: httpx[socks]>=0.28.1
+Requires-Dist: pydantic-settings>=2.8.1
 Requires-Dist: pydantic~=2.10.6
 Requires-Dist: pydash~=8.0.5
 Requires-Dist: python-dotenv~=1.0.1
+Requires-Dist: requests[socks]~=2.32.3
 Requires-Dist: rich~=13.9.4
 Requires-Dist: tomlkit~=0.13.2

{mm_std-0.3.8.dist-info → mm_std-0.3.10.dist-info}/RECORD

@@ -1,13 +1,14 @@
-mm_std/__init__.py,sha256=wzKZe6qMG7cmZLqnA-thfr4QaFaPudJzcQKqLsfZeB8,2500
+mm_std/__init__.py,sha256=HBJRK8f5Qz3v3XtwT7r5lvaANNknAuoV1NsPuO9yQDc,2646
+mm_std/async_concurrency.py,sha256=Zp0_tcRhoGJPJ1iueXKTlJHv0IZDDYLgOmpHSvb1kKs,3925
 mm_std/command.py,sha256=ze286wjUjg0QSTgIu-2WZks53_Vclg69UaYYgPpQvCU,1283
 mm_std/concurrency.py,sha256=4kKLhde6YQYsjJJjH6K5eMQj6FtegEz55Mo5TmhQMM0,5242
-mm_std/config.py,sha256=4DGzjLO8TYno1xF8wj2hRaw2-gfNzt_W1_bt7w8ovno,1874
+mm_std/config.py,sha256=4ox4D2CgGR76bvZ2n2vGQOYUDagFnlKEDb87to5zpxE,1871
 mm_std/crypto.py,sha256=jdk0_TCmeU0pPXMyz9xH6kQHSjjZ9GcGClBwQps5vBo,340
 mm_std/date.py,sha256=976eEkSONuNqHQBgSRu8hrtH23tJqztbmHFHLdbP2TY,1879
 mm_std/dict.py,sha256=6GkhJPXD0LiJDxPcYe6jPdEDw-MN7P7mKu6U5XxwYDk,675
 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/http_.py,sha256=JkyHZ29EOC6Ulqw_5eBNLmeMrca6NDGueTSwpj96aKM,6003
 mm_std/json_.py,sha256=Naa6mBE4D0yiQGkPNRrFvndnUH3R7ovw3FeaejWV60o,1196
 mm_std/log.py,sha256=6ux6njNKc_ZCQlvWn1FZR6vcSY2Cem-mQzmNXvsg5IE,913
 mm_std/net.py,sha256=qdRCBIDneip6FaPNe5mx31UtYVmzqam_AoUF7ydEyjA,590
@@ -19,6 +20,6 @@ mm_std/str.py,sha256=BEjJ1p5O4-uSYK0h-enasSSDdwzkBbiwdQ4_dsrlEE8,3257
 mm_std/toml.py,sha256=CNznWKR0bpOxS6e3VB5LGS-Oa9lW-wterkcPUFtPcls,610
 mm_std/types_.py,sha256=hvZlnvBWyB8CL_MeEWWD0Y0nN677plibYn3yD-5g7xs,99
 mm_std/zip.py,sha256=axzF1BwcIygtfNNTefZH7hXKaQqwe-ZH3ChuRWr9dnk,396
-mm_std-0.3.8.dist-info/METADATA,sha256=ORA3px7Ci92urZag-sz32QlEEDSwTuIQnjgt_eGTWwI,308
-mm_std-0.3.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mm_std-0.3.8.dist-info/RECORD,,
+mm_std-0.3.10.dist-info/METADATA,sha256=1i_m2ldTzID9GccEEPB8ZDqs1DOlGsSdVgkoaHhNdZQ,410
+mm_std-0.3.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mm_std-0.3.10.dist-info/RECORD,,