mm-std 0.3.9__py3-none-any.whl → 0.3.11__py3-none-any.whl

mm_std/__init__.py

@@ -1,3 +1,5 @@
+from .async_concurrency import AsyncScheduler as AsyncScheduler
+from .async_concurrency import async_synchronized as async_synchronized
 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 +21,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,124 @@
+import functools
+import threading
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+from logging import Logger
+from typing import ParamSpec, TypeVar
+
+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")
+
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+def async_synchronized(func: Callable[P, Awaitable[R]]) -> Callable[P, Awaitable[R]]:
+    lock = anyio.Lock()
+
+    @functools.wraps(func)
+    async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        async with lock:
+            return await func(*args, **kwargs)
+
+    return wrapper

mm_std/http_.py

@@ -3,6 +3,7 @@ from dataclasses import asdict, dataclass, field
 from typing import Any
 from urllib.parse import urlencode
 
+import httpx
 import pydash
 import requests
 from requests.auth import AuthBase
@@ -140,6 +141,62 @@ def hrequest(
         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.RequestError 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:
@@ -148,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.9.dist-info → mm_std-0.3.11.dist-info}/METADATA

@@ -1,8 +1,11 @@
 Metadata-Version: 2.4
 Name: mm-std
-Version: 0.3.9
+Version: 0.3.11
 Requires-Python: >=3.12
+Requires-Dist: anyio>=4.9.0
 Requires-Dist: cryptography~=44.0.2
+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

{mm_std-0.3.9.dist-info → mm_std-0.3.11.dist-info}/RECORD

@@ -1,4 +1,5 @@
-mm_std/__init__.py,sha256=wzKZe6qMG7cmZLqnA-thfr4QaFaPudJzcQKqLsfZeB8,2500
+mm_std/__init__.py,sha256=BJzVoqux6-YWxGMyXJS34v6CgKh3V7SrpV7eXIUVfbw,2718
+mm_std/async_concurrency.py,sha256=w2cc35g2jJAew_1QUfoGRFjallFJH8jg6q0Jem92zzs,4313
 mm_std/command.py,sha256=ze286wjUjg0QSTgIu-2WZks53_Vclg69UaYYgPpQvCU,1283
 mm_std/concurrency.py,sha256=4kKLhde6YQYsjJJjH6K5eMQj6FtegEz55Mo5TmhQMM0,5242
 mm_std/config.py,sha256=4ox4D2CgGR76bvZ2n2vGQOYUDagFnlKEDb87to5zpxE,1871
@@ -7,7 +8,7 @@ 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=NkA98bCAqBmjJgoain0KZVORizGwH0TkbtYvjBEsrB4,4305
+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.9.dist-info/METADATA,sha256=QqBM2hxSUenibV7VnHSuu0QHn5eVoKOPGClxbmfklEI,305
-mm_std-0.3.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mm_std-0.3.9.dist-info/RECORD,,
+mm_std-0.3.11.dist-info/METADATA,sha256=JXQBD8DtKcAb1n44v5-JDuv9DM-1bgSHT-xgQUNK1j8,410
+mm_std-0.3.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mm_std-0.3.11.dist-info/RECORD,,