mm-std 0.3.16__py3-none-any.whl → 0.3.18__py3-none-any.whl

mm_std/__init__.py

@@ -2,6 +2,7 @@ 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.async_decorators import async_synchronized as async_synchronized
+from .concurrency.async_decorators import async_synchronized_parameter as async_synchronized_parameter
 from .concurrency.async_scheduler import AsyncScheduler as AsyncScheduler
 from .concurrency.async_task_runner import AsyncTaskRunner as AsyncTaskRunner
 from .concurrency.sync_decorators import synchronized as synchronized
@@ -22,10 +23,10 @@ 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 hra as hra
 from .http_ import hrequest as hrequest
+from .http_ import hrequest_async as hrequest_async
 from .json_ import CustomJSONEncoder as CustomJSONEncoder
 from .json_ import json_dumps as json_dumps
 from .log import init_logger as init_logger

mm_std/concurrency/async_decorators.py

@@ -1,15 +1,15 @@
+import asyncio
 import functools
+from collections import defaultdict
 from collections.abc import Awaitable, Callable
 from typing import ParamSpec, TypeVar
 
-import anyio
-
 P = ParamSpec("P")
 R = TypeVar("R")
 
 
 def async_synchronized(func: Callable[P, Awaitable[R]]) -> Callable[P, Awaitable[R]]:
-    lock = anyio.Lock()
+    lock = asyncio.Lock()
 
     @functools.wraps(func)
     async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
@@ -17,3 +17,38 @@ def async_synchronized(func: Callable[P, Awaitable[R]]) -> Callable[P, Awaitable
             return await func(*args, **kwargs)
 
     return wrapper
+
+
+T = TypeVar("T")
+
+
+def async_synchronized_parameter[T, **P](
+    arg_index: int = 0, skip_if_locked: bool = False
+) -> Callable[[Callable[P, Awaitable[T]]], Callable[P, Awaitable[T | None]]]:
+    locks: dict[object, asyncio.Lock] = defaultdict(asyncio.Lock)
+
+    def outer(func: Callable[P, Awaitable[T]]) -> Callable[P, Awaitable[T | None]]:
+        @functools.wraps(func)
+        async def wrapper(*args: P.args, **kwargs: P.kwargs) -> T | None:
+            if len(args) <= arg_index:
+                raise ValueError(f"Function called with fewer than {arg_index + 1} positional arguments")
+
+            key = args[arg_index]
+
+            if skip_if_locked and locks[key].locked():
+                return None
+
+            try:
+                async with locks[key]:
+                    return await func(*args, **kwargs)
+            finally:
+                # Clean up the lock if no one is waiting
+                # TODO: I'm not sure if the next like is OK
+                if not locks[key].locked() and not locks[key]._waiters:  # noqa: SLF001
+                    locks.pop(key, None)
+
+        # Store locks for potential external access
+        wrapper.locks = locks  # type: ignore[attr-defined]
+        return wrapper
+
+    return outer

mm_std/concurrency/async_scheduler.py

@@ -1,19 +1,29 @@
 import asyncio
-import threading
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass, field
 from datetime import datetime
 from logging import Logger
 from typing import Any
 
-import anyio
-
 from mm_std.date import utc_now
-from mm_std.types_ import Args, AsyncFunc, Kwargs
+
+type AsyncFunc = Callable[..., Awaitable[object]]
+type Args = tuple[object, ...]
+type Kwargs = dict[str, object]
 
 
 class AsyncScheduler:
+    """
+    A scheduler for running async tasks at fixed intervals.
+
+    Each task runs on its own schedule and waits for the specified interval
+    between executions.
+    """
+
     @dataclass
     class TaskInfo:
+        """Information about a scheduled task."""
+
         task_id: str
         interval: float
         func: AsyncFunc
@@ -24,16 +34,29 @@ class AsyncScheduler:
         last_run: datetime | None = None
         running: bool = False
 
-    def __init__(self, logger: Logger) -> None:
+    def __init__(self, logger: Logger, name: str = "AsyncScheduler") -> None:
+        """Initialize the async scheduler."""
         self.tasks: dict[str, AsyncScheduler.TaskInfo] = {}
         self._running: bool = False
-        self._cancel_scope: anyio.CancelScope | None = None
+        self._tasks: list[asyncio.Task[Any]] = []
         self._main_task: asyncio.Task[Any] | None = None
-        self._thread: threading.Thread | None = None
         self._logger = logger
+        self._name = name
 
     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."""
+        """
+        Register a new task with the scheduler.
+
+        Args:
+            task_id: Unique identifier for the task
+            interval: Time in seconds between task executions
+            func: Async function to execute
+            args: Positional arguments to pass to the function
+            kwargs: Keyword arguments to pass to the function
+
+        Raises:
+            ValueError: If a task with the same ID already exists
+        """
         if kwargs is None:
             kwargs = {}
         if task_id in self.tasks:
@@ -41,70 +64,107 @@ class AsyncScheduler:
         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."""
+        """
+        Internal loop for running a single task repeatedly.
+
+        Args:
+            task_id: ID of the task to run
+        """
         task = self.tasks[task_id]
-        while self._running:
-            task.last_run = utc_now()
-            task.run_count += 1
-            try:
-                await task.func(*task.args, **task.kwargs)
-            except Exception:
-                task.error_count += 1
-                self._logger.exception("AsyncScheduler exception")
-
-            # Calculate elapsed time and sleep if needed so that tasks never overlap.
-            elapsed = (utc_now() - task.last_run).total_seconds()
-            sleep_time = task.interval - elapsed
-            if sleep_time > 0:
+        task.running = True
+
+        try:
+            while self._running:
+                task.last_run = utc_now()
+                task.run_count += 1
                 try:
-                    await anyio.sleep(sleep_time)
+                    await task.func(*task.args, **task.kwargs)
                 except Exception:
-                    self._logger.exception("AsyncScheduler exception")
+                    task.error_count += 1
+                    self._logger.exception(f"Exception in task {task_id}")
+
+                # Calculate elapsed time and sleep if needed
+                elapsed = (utc_now() - task.last_run).total_seconds()
+                sleep_time = max(0, task.interval - elapsed)
+                if sleep_time > 0:
+                    try:
+                        await asyncio.sleep(sleep_time)
+                    except asyncio.CancelledError:
+                        break
+        finally:
+            task.running = False
+            self._logger.debug(f"Task {task_id} stopped")
 
     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.debug("Task group cancelled. Exiting _start_all_tasks.")
+        """Starts all tasks concurrently using asyncio tasks."""
+        self._tasks = []
+
+        for task_id in self.tasks:
+            task = asyncio.create_task(self._run_task(task_id), name=self._name + "-" + task_id)
+            self._tasks.append(task)
+
+        try:
+            # Keep the main task alive while the scheduler is running
+            while self._running:  # noqa: ASYNC110
+                await asyncio.sleep(0.1)
+        except asyncio.CancelledError:
+            self._logger.debug("Main scheduler task cancelled")
+        finally:
+            # Cancel all running tasks when we exit
+            for task in self._tasks:
+                if not task.done():
+                    task.cancel()
+
+            # Wait for all tasks to finish
+            if self._tasks:
+                await asyncio.gather(*self._tasks, return_exceptions=True)
+            self._tasks = []
 
     def start(self) -> None:
         """
         Start the scheduler.
 
-        This method launches the scheduler in a background thread,
-        which runs an AnyIO event loop.
+        Creates tasks in the current event loop for each registered task.
         """
         if self._running:
             self._logger.warning("AsyncScheduler already running")
             return
+
         self._running = True
         self._logger.debug("Starting AsyncScheduler")
-
-        # Create a task in the current event loop
         self._main_task = asyncio.create_task(self._start_all_tasks())
 
     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.
+        Cancels all running tasks and waits for them to complete.
         """
         if not self._running:
             self._logger.warning("AsyncScheduler not running")
             return
+
         self._logger.debug("Stopping AsyncScheduler")
         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
+        if self._main_task and not self._main_task.done():
+            self._main_task.cancel()
+
         self._logger.debug("AsyncScheduler stopped")
+
+    def is_running(self) -> bool:
+        """
+        Check if the scheduler is currently running.
+
+        Returns:
+            True if the scheduler is running, False otherwise
+        """
+        return self._running
+
+    def clear_tasks(self) -> None:
+        """Clear all tasks from the scheduler."""
+        if self._running:
+            self._logger.warning("Cannot clear tasks while scheduler is running")
+            return
+        self.tasks.clear()
+        self._logger.debug("Cleared all tasks from the scheduler")

mm_std/concurrency/async_task_runner.py

@@ -1,11 +1,10 @@
 from __future__ import annotations
 
-from collections.abc import Awaitable, Callable
+import asyncio
+from collections.abc import Awaitable
 from dataclasses import dataclass
 from typing import Any
 
-import anyio
-
 
 class AsyncTaskRunner:
     """
@@ -25,20 +24,20 @@ class AsyncTaskRunner:
         """Individual task representation"""
 
         task_id: str
-        async_func: Callable[..., Awaitable[Any]]
-        args: tuple[Any, ...]
-        kwargs: dict[str, Any]
+        awaitable: Awaitable[Any]
 
-    def __init__(self, max_concurrent_tasks: int, timeout: float | None = None) -> None:
+    def __init__(self, max_concurrent_tasks: int, timeout: float | None = None, name: str | None = None) -> None:
         """
         :param max_concurrent_tasks: Maximum number of tasks that can run concurrently.
         :param timeout: Optional overall timeout in seconds for running all tasks.
+        :param name: Optional name for the runner.
         """
         if timeout is not None and timeout <= 0:
             raise ValueError("Timeout must be positive if specified.")
         self.max_concurrent_tasks: int = max_concurrent_tasks
         self.timeout: float | None = timeout
-        self.limiter: anyio.CapacityLimiter = anyio.CapacityLimiter(max_concurrent_tasks)
+        self.name = name
+        self.semaphore: asyncio.Semaphore = asyncio.Semaphore(max_concurrent_tasks)
         self._tasks: list[AsyncTaskRunner.Task] = []
         self._was_run: bool = False
         self._task_ids: set[str] = set()
@@ -46,17 +45,13 @@ class AsyncTaskRunner:
     def add_task(
         self,
         task_id: str,
-        async_func: Callable[..., Awaitable[Any]],
-        *args: object,
-        **kwargs: object,
+        awaitable: Awaitable[Any],
     ) -> None:
         """
         Adds a task to the runner that will be executed when run() is called.
 
         :param task_id: Unique identifier for the task.
-        :param async_func: The asynchronous function to execute.
-        :param args: Positional arguments for async_func.
-        :param kwargs: Keyword arguments for async_func.
+        :param awaitable: The awaitable (coroutine) to execute.
         :raises RuntimeError: If the runner has already been used.
         :raises ValueError: If task_id is empty or already exists.
         """
@@ -70,11 +65,11 @@ class AsyncTaskRunner:
             raise ValueError(f"Task ID '{task_id}' already exists. All task IDs must be unique.")
 
         self._task_ids.add(task_id)
-        self._tasks.append(AsyncTaskRunner.Task(task_id, async_func, args, kwargs))
+        self._tasks.append(AsyncTaskRunner.Task(task_id, awaitable))
 
     async def run(self) -> AsyncTaskRunner.Result:
         """
-        Executes all added tasks with concurrency limited by the capacity limiter.
+        Executes all added tasks with concurrency limited by the semaphore.
         If a timeout is specified, non-finished tasks are cancelled.
 
         :return: AsyncTaskRunner.Result containing task results, exceptions, and flags indicating overall status.
@@ -89,24 +84,30 @@ class AsyncTaskRunner:
         is_timeout: bool = False
 
         async def run_task(task: AsyncTaskRunner.Task) -> None:
-            async with self.limiter:
+            async with self.semaphore:
                 try:
-                    res: Any = await task.async_func(*task.args, **task.kwargs)
+                    res: Any = await task.awaitable
                     results[task.task_id] = res
                 except Exception as e:
                     exceptions[task.task_id] = e
 
+        # Create asyncio tasks for all runner tasks
+        tasks = [asyncio.create_task(run_task(task)) for task in self._tasks]
+
         try:
             if self.timeout is not None:
-                with anyio.fail_after(self.timeout):
-                    async with anyio.create_task_group() as tg:
-                        for task in self._tasks:
-                            tg.start_soon(run_task, task)
+                # Run with timeout
+                await asyncio.wait_for(asyncio.gather(*tasks), timeout=self.timeout)
             else:
-                async with anyio.create_task_group() as tg:
-                    for task in self._tasks:
-                        tg.start_soon(run_task, task)
+                # Run without timeout
+                await asyncio.gather(*tasks)
         except TimeoutError:
+            # Cancel all running tasks on timeout
+            for task in tasks:
+                if not task.done():
+                    task.cancel()
+            # Wait for tasks to complete cancellation
+            await asyncio.gather(*tasks, return_exceptions=True)
             is_timeout = True
 
         is_ok: bool = (not exceptions) and (not is_timeout)

mm_std/http_.py

@@ -1,12 +1,14 @@
+import asyncio
 import json
 from dataclasses import asdict, dataclass, field
 from typing import Any
 from urllib.parse import urlencode
 
-import anyio
-import httpx
+import aiohttp
 import pydash
 import requests
+import rich
+from aiohttp_socks import ProxyConnector
 from requests.auth import AuthBase
 
 from mm_std.result import Err, Ok, Result
@@ -142,7 +144,7 @@ def hrequest(
         return HResponse(error=f"exception: {err}")
 
 
-async def async_hrequest(
+async def hrequest_async(
     url: str,
     *,
     method: str = "GET",
@@ -150,16 +152,17 @@ async def async_hrequest(
     params: dict[str, Any] | None = None,
     headers: dict[str, Any] | None = None,
     cookies: dict[str, Any] | None = None,
-    timeout: float = 10,  # noqa: ASYNC109
+    timeout: float = 10,
     user_agent: str | None = None,
     json_params: bool = True,
-    auth: httpx.Auth | tuple[str, str] | None = None,
+    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:
@@ -171,33 +174,54 @@ async def async_hrequest(
     else:
         data = params
 
-    with anyio.move_on_after(timeout):
-        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}")
-    return HResponse(error="timeout")
+    try:
+        # Configure connector based on proxy type
+        if proxy:
+            # HTTP proxy will be handled in request kwargs
+            connector = ProxyConnector.from_url(proxy) if proxy.startswith("socks5://") else aiohttp.TCPConnector(ssl=verify)
+        else:
+            connector = aiohttp.TCPConnector(ssl=verify)
+
+        timeout_obj = aiohttp.ClientTimeout(total=timeout)
+
+        async with aiohttp.ClientSession(connector=connector, timeout=timeout_obj, cookies=cookies) as session:
+            request_kwargs: dict[str, Any] = {"headers": headers}
+
+            if query_params:
+                request_kwargs["params"] = query_params
+            if json_:
+                request_kwargs["json"] = json_
+            if data:
+                request_kwargs["data"] = data
+
+            if auth and isinstance(auth, tuple) and len(auth) == 2:
+                request_kwargs["auth"] = aiohttp.BasicAuth(auth[0], auth[1])
+
+            # Set HTTP proxy (not needed for SOCKS5)
+            if proxy and not proxy.startswith("socks5://"):
+                request_kwargs["proxy"] = proxy
+
+            try:
+                async with await asyncio.wait_for(session.request(method, url, **request_kwargs), timeout=timeout) as response:
+                    body = await response.text()
+                    return HResponse(code=response.status, body=body, headers=dict(response.headers))
+            except TimeoutError:
+                return HResponse(error="timeout")
+            except (aiohttp.ClientProxyConnectionError, aiohttp.ClientHttpProxyError):
+                return HResponse(error="proxy_error")
+            except aiohttp.ClientConnectorError as err:
+                return HResponse(error=f"connection_error: {err}")
+            except aiohttp.ClientError as err:
+                rich.inspect(err)
+                return HResponse(error=f"connection_error: {err}")
+            except Exception as err:
+                if "couldn't connect to proxy" in str(err).lower():
+                    return HResponse(error="proxy_error")
+                return HResponse(error=f"exception: {err}")
+    except TimeoutError:
+        return HResponse(error="timeout")
+    except Exception as err:
+        return HResponse(error=f"exception: {err}")
 
 
 def add_query_params_to_url(url: str, params: dict[str, object]) -> str:
@@ -208,4 +232,4 @@ def add_query_params_to_url(url: str, params: dict[str, object]) -> str:
 
 
 hr = hrequest
-ahr = async_hrequest
+hra = hrequest_async

{mm_std-0.3.16.dist-info → mm_std-0.3.18.dist-info}/METADATA

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: mm-std
-Version: 0.3.16
+Version: 0.3.18
 Requires-Python: >=3.12
-Requires-Dist: anyio>=4.9.0
+Requires-Dist: aiohttp-socks~=0.10.1
+Requires-Dist: aiohttp~=3.11.14
 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

{mm_std-0.3.16.dist-info → mm_std-0.3.18.dist-info}/RECORD

@@ -1,4 +1,4 @@
-mm_std/__init__.py,sha256=UkRzp_lm7yddXImD8nRlJtBnx9YlopWJKqukcbqjRyo,2881
+mm_std/__init__.py,sha256=yxfH7ROIU5jwRQEeFIloTlDPZm_8443PKk50xzmQq7c,2984
 mm_std/command.py,sha256=ze286wjUjg0QSTgIu-2WZks53_Vclg69UaYYgPpQvCU,1283
 mm_std/config.py,sha256=4ox4D2CgGR76bvZ2n2vGQOYUDagFnlKEDb87to5zpxE,1871
 mm_std/crypto.py,sha256=jdk0_TCmeU0pPXMyz9xH6kQHSjjZ9GcGClBwQps5vBo,340
@@ -6,7 +6,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=x5d4wnQcPlB_IYaYNCQGz7iOTEft8cQmMggHt30o7xI,6193
+mm_std/http_.py,sha256=cozBUGZcbKp9sZuEnu7bklwa6lTE0RxEUVo_aNt1_kE,7468
 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,12 +19,12 @@ mm_std/toml.py,sha256=CNznWKR0bpOxS6e3VB5LGS-Oa9lW-wterkcPUFtPcls,610
 mm_std/types_.py,sha256=9FGd2q47a8M9QQgsWJR1Kq34jLxBAkYSoJuwih4PPqg,257
 mm_std/zip.py,sha256=axzF1BwcIygtfNNTefZH7hXKaQqwe-ZH3ChuRWr9dnk,396
 mm_std/concurrency/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mm_std/concurrency/async_decorators.py,sha256=tJ5u-_G9mAF3zrFr1aBUhYh03rB-K_6oiDKGdmGdlGk,449
-mm_std/concurrency/async_scheduler.py,sha256=-crLjrFwRJSNGdyhU3brCvqP7EPPLwEVfZFbDCBe9Qo,3995
-mm_std/concurrency/async_task_runner.py,sha256=D4fD_hwSVy55sM_-U1_sdVYlkahnQeigXdMfbIi8Rpc,4492
+mm_std/concurrency/async_decorators.py,sha256=xEpyipzp3ZhaPHtdeTE-Ikrt67SUTFKBE6LQPeoeh6Q,1735
+mm_std/concurrency/async_scheduler.py,sha256=qS3QKMA0xpoxCZWjDW1ItAwKMTQ5h8esXMMRA0eXtxE,5644
+mm_std/concurrency/async_task_runner.py,sha256=zYC2Jv5taUh8dnyDfWwh394SkzTXtdE9hOhvjV2FWKc,4493
 mm_std/concurrency/sync_decorators.py,sha256=syCQBOmN7qPO55yzgJB2rbkh10CVww376hmyvs6e5tA,1080
 mm_std/concurrency/sync_scheduler.py,sha256=j4tBL_cBI1spr0cZplTA7N2CoYsznuORMeRN8rpR6gY,2407
 mm_std/concurrency/sync_task_runner.py,sha256=s5JPlLYLGQGHIxy4oDS-PN7O9gcy-yPZFoNm8RQwzcw,1780
-mm_std-0.3.16.dist-info/METADATA,sha256=tXTemaQ7P5DOoxtamgJjtXkXVrhzvHOaaNyH4PavjYg,410
-mm_std-0.3.16.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mm_std-0.3.16.dist-info/RECORD,,
+mm_std-0.3.18.dist-info/METADATA,sha256=AUl95Lq0McMhB-E8PsxqPEbYsxuiQI0cA1t5AX208qg,415
+mm_std-0.3.18.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mm_std-0.3.18.dist-info/RECORD,,