mm-std 0.3.19__py3-none-any.whl → 0.3.21__py3-none-any.whl

mm_std/__init__.py

@@ -29,6 +29,7 @@ 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 configure_structlog as configure_structlog
 from .log import init_logger as init_logger
 from .net import check_port as check_port
 from .net import get_free_local_port as get_free_local_port

mm_std/concurrency/async_scheduler.py

@@ -2,15 +2,18 @@ import asyncio
 from collections.abc import Awaitable, Callable
 from dataclasses import dataclass, field
 from datetime import datetime
-from logging import Logger
 from typing import Any
 
+import structlog
+
 from mm_std.date import utc_now
 
 type AsyncFunc = Callable[..., Awaitable[object]]
 type Args = tuple[object, ...]
 type Kwargs = dict[str, object]
 
+logger = structlog.stdlib.get_logger()
+
 
 class AsyncScheduler:
     """
@@ -34,13 +37,12 @@ class AsyncScheduler:
         last_run: datetime | None = None
         running: bool = False
 
-    def __init__(self, logger: Logger, name: str = "AsyncScheduler") -> None:
+    def __init__(self, name: str = "AsyncScheduler") -> None:
         """Initialize the async scheduler."""
         self.tasks: dict[str, AsyncScheduler.TaskInfo] = {}
         self._running: bool = False
         self._tasks: list[asyncio.Task[Any]] = []
         self._main_task: asyncio.Task[Any] | 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:
@@ -81,7 +83,7 @@ class AsyncScheduler:
                     await task.func(*task.args, **task.kwargs)
                 except Exception:
                     task.error_count += 1
-                    self._logger.exception(f"Exception in task {task_id}")
+                    logger.exception("Error in task", task_id=task_id, error=task.error_count)
 
                 # Calculate elapsed time and sleep if needed
                 elapsed = (utc_now() - task.last_run).total_seconds()
@@ -93,7 +95,7 @@ class AsyncScheduler:
                         break
         finally:
             task.running = False
-            self._logger.debug(f"Task {task_id} stopped")
+            logger.debug("Finished task", task_id=task_id, elapsed=elapsed)
 
     async def _start_all_tasks(self) -> None:
         """Starts all tasks concurrently using asyncio tasks."""
@@ -108,7 +110,7 @@ class AsyncScheduler:
             while self._running:  # noqa: ASYNC110
                 await asyncio.sleep(0.1)
         except asyncio.CancelledError:
-            self._logger.debug("Main scheduler task cancelled")
+            logger.debug("Cancelled all tasks")
         finally:
             # Cancel all running tasks when we exit
             for task in self._tasks:
@@ -127,11 +129,11 @@ class AsyncScheduler:
         Creates tasks in the current event loop for each registered task.
         """
         if self._running:
-            self._logger.warning("AsyncScheduler already running")
+            logger.warning("AsyncScheduler already running")
             return
 
         self._running = True
-        self._logger.debug("Starting AsyncScheduler")
+        logger.debug("starting")
         self._main_task = asyncio.create_task(self._start_all_tasks())
 
     def stop(self) -> None:
@@ -141,16 +143,16 @@ class AsyncScheduler:
         Cancels all running tasks and waits for them to complete.
         """
         if not self._running:
-            self._logger.warning("AsyncScheduler not running")
+            logger.warning("now running")
             return
 
-        self._logger.debug("Stopping AsyncScheduler")
+        logger.debug("stopping")
         self._running = False
 
         if self._main_task and not self._main_task.done():
             self._main_task.cancel()
 
-        self._logger.debug("AsyncScheduler stopped")
+        logger.debug("stopped")
 
     def is_running(self) -> bool:
         """
@@ -164,7 +166,7 @@ class AsyncScheduler:
     def clear_tasks(self) -> None:
         """Clear all tasks from the scheduler."""
         if self._running:
-            self._logger.warning("Cannot clear tasks while scheduler is running")
+            logger.warning("Cannot clear tasks while scheduler is running")
             return
         self.tasks.clear()
-        self._logger.debug("Cleared all tasks from the scheduler")
+        logger.debug("cleared tasks")

mm_std/concurrency/async_task_runner.py

@@ -5,6 +5,10 @@ from collections.abc import Awaitable
 from dataclasses import dataclass
 from typing import Any
 
+import structlog
+
+logger = structlog.stdlib.get_logger()
+
 
 class AsyncTaskRunner:
     """
@@ -26,17 +30,21 @@ class AsyncTaskRunner:
         task_id: str
         awaitable: Awaitable[Any]
 
-    def __init__(self, max_concurrent_tasks: int, timeout: float | None = None, name: str | None = None) -> None:
+    def __init__(
+        self, max_concurrent_tasks: int, timeout: float | None = None, name: str | None = None, no_logging: bool = False
+    ) -> 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.
+        :param no_logging: If True, suppresses logging for task exception.
         """
         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.name = name
+        self.no_logging = no_logging
         self.semaphore: asyncio.Semaphore = asyncio.Semaphore(max_concurrent_tasks)
         self._tasks: list[AsyncTaskRunner.Task] = []
         self._was_run: bool = False
@@ -92,6 +100,8 @@ class AsyncTaskRunner:
                     res: Any = await task.awaitable
                     results[task.task_id] = res
                 except Exception as e:
+                    if not self.no_logging:
+                        logger.exception("Task raised an exception", task_id=task.task_id)
                     exceptions[task.task_id] = e
 
         # Create asyncio tasks for all runner tasks

mm_std/log.py

@@ -2,6 +2,9 @@ import logging
 from logging.handlers import RotatingFileHandler
 from pathlib import Path
 
+import structlog
+from structlog.typing import Processor
+
 
 def init_logger(name: str, file_path: str | None = None, file_mkdir: bool = True, level: int = logging.DEBUG) -> logging.Logger:
     log = logging.getLogger(name)
@@ -20,3 +23,54 @@ def init_logger(name: str, file_path: str | None = None, file_mkdir: bool = True
         file_handler.setFormatter(fmt)
         log.addHandler(file_handler)
     return log
+
+
+def configure_structlog(json_logs: bool = False, log_level: str = "DEBUG", compact: bool = False) -> None:
+    timestamper: Processor = structlog.processors.TimeStamper(fmt="%H:%M:%S" if compact else "[%Y-%m-%d %H:%M:%S.%f]")
+
+    shared_processors: list[Processor] = [
+        structlog.contextvars.merge_contextvars,
+        structlog.stdlib.add_logger_name,
+        structlog.stdlib.add_log_level,
+        structlog.stdlib.PositionalArgumentsFormatter(),
+        structlog.stdlib.ExtraAdder(),
+        timestamper,
+        structlog.processors.StackInfoRenderer(),
+    ]
+
+    if json_logs:
+        # Format the exception only for JSON logs, as we want to pretty-print them when
+        # using the ConsoleRenderer
+        shared_processors.append(structlog.processors.format_exc_info)
+
+    structlog.configure(
+        processors=shared_processors  # noqa: RUF005
+        + [
+            # Prepare event dict for `ProcessorFormatter`.
+            structlog.stdlib.ProcessorFormatter.wrap_for_formatter,
+        ],
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        cache_logger_on_first_use=True,
+    )
+
+    log_renderer: Processor
+    log_renderer = structlog.processors.JSONRenderer() if json_logs else structlog.dev.ConsoleRenderer()
+
+    formatter: structlog.stdlib.ProcessorFormatter = structlog.stdlib.ProcessorFormatter(
+        # These run ONLY on `logging` entries that do NOT originate within
+        # structlog.
+        foreign_pre_chain=shared_processors,
+        # These run on ALL entries after the pre_chain is done.
+        processors=[
+            # Remove _record & _from_structlog.
+            structlog.stdlib.ProcessorFormatter.remove_processors_meta,
+            log_renderer,
+        ],
+    )
+
+    handler = logging.StreamHandler()
+    # Use OUR `ProcessorFormatter` to format all `logging` entries.
+    handler.setFormatter(formatter)
+    root_logger: logging.Logger = logging.getLogger()
+    root_logger.addHandler(handler)
+    root_logger.setLevel(log_level.upper())

{mm_std-0.3.19.dist-info → mm_std-0.3.21.dist-info}/METADATA

@@ -1,14 +1,15 @@
 Metadata-Version: 2.4
 Name: mm-std
-Version: 0.3.19
+Version: 0.3.21
 Requires-Python: >=3.12
 Requires-Dist: aiohttp-socks~=0.10.1
-Requires-Dist: aiohttp~=3.11.14
+Requires-Dist: aiohttp~=3.11.16
 Requires-Dist: cryptography~=44.0.2
 Requires-Dist: pydantic-settings>=2.8.1
-Requires-Dist: pydantic~=2.11.0
+Requires-Dist: pydantic~=2.11.2
 Requires-Dist: pydash~=8.0.5
 Requires-Dist: python-dotenv~=1.1.0
 Requires-Dist: requests[socks]~=2.32.3
-Requires-Dist: rich~=13.9.4
+Requires-Dist: rich>=13.9.0
+Requires-Dist: structlog>=25.2.0
 Requires-Dist: tomlkit~=0.13.2

{mm_std-0.3.19.dist-info → mm_std-0.3.21.dist-info}/RECORD

@@ -1,4 +1,4 @@
-mm_std/__init__.py,sha256=yxfH7ROIU5jwRQEeFIloTlDPZm_8443PKk50xzmQq7c,2984
+mm_std/__init__.py,sha256=ATaZN6AzmRUJIc8IE4PichCbh45pNncbBidUG7V1m0Q,3044
 mm_std/command.py,sha256=ze286wjUjg0QSTgIu-2WZks53_Vclg69UaYYgPpQvCU,1283
 mm_std/config.py,sha256=4ox4D2CgGR76bvZ2n2vGQOYUDagFnlKEDb87to5zpxE,1871
 mm_std/crypto.py,sha256=jdk0_TCmeU0pPXMyz9xH6kQHSjjZ9GcGClBwQps5vBo,340
@@ -8,7 +8,7 @@ mm_std/env.py,sha256=5zaR9VeIfObN-4yfgxoFeU5IM1GDeZZj9SuYf7t9sOA,125
 mm_std/fs.py,sha256=RwarNRJq3tIMG6LVX_g03hasfYpjYFh_O27oVDt5IPQ,291
 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/log.py,sha256=vQzNJ0oenvuHF9sXDI6CUZDR12BcDURUZVwkpdNle4Q,2983
 mm_std/net.py,sha256=qdRCBIDneip6FaPNe5mx31UtYVmzqam_AoUF7ydEyjA,590
 mm_std/print_.py,sha256=zB7sVbSSF8RffMxvnOdbKCXjCKtKzKV3R68pBri4NkQ,1638
 mm_std/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -20,11 +20,11 @@ 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=xEpyipzp3ZhaPHtdeTE-Ikrt67SUTFKBE6LQPeoeh6Q,1735
-mm_std/concurrency/async_scheduler.py,sha256=qS3QKMA0xpoxCZWjDW1ItAwKMTQ5h8esXMMRA0eXtxE,5644
-mm_std/concurrency/async_task_runner.py,sha256=hO_8umGGKVKfQW_hCzy6Nt0OIBDj7Yfjb8d7CCkmtJU,4643
+mm_std/concurrency/async_scheduler.py,sha256=cTsEY0FJKqlA94Ap-5Yx4KFOc-0QP5lRocn4P2n3cdE,5526
+mm_std/concurrency/async_task_runner.py,sha256=JpofaXCSqQDgQTh1FvaCWxsUsFWNPJGfXpuTlkF7hS0,4988
 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.19.dist-info/METADATA,sha256=DXiV1MyhCD0Hn5tRZYdA9wQPoLutkvLX-d_q_CjJ-Co,415
-mm_std-0.3.19.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mm_std-0.3.19.dist-info/RECORD,,
+mm_std-0.3.21.dist-info/METADATA,sha256=_VWt4WbyHA-fN5KkHKXpSyu1evey3AtLnrJR4Sbdprs,448
+mm_std-0.3.21.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mm_std-0.3.21.dist-info/RECORD,,