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

mm_std/__init__.py

@@ -29,7 +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 configure_logging as configure_logging
 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
@@ -46,6 +46,8 @@ 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 err as err
+from .result import ok as ok
 from .result import try_ok as try_ok
 from .str import number_with_separator as number_with_separator
 from .str import str_contains_any as str_contains_any

mm_std/concurrency/async_scheduler.py

@@ -1,18 +1,17 @@
 import asyncio
+import logging
 from collections.abc import Awaitable, Callable
 from dataclasses import dataclass, field
 from datetime import datetime
 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()
+logger = logging.getLogger(__name__)
 
 
 class AsyncScheduler:
@@ -75,6 +74,7 @@ class AsyncScheduler:
         task = self.tasks[task_id]
         task.running = True
 
+        elapsed = 0.0
         try:
             while self._running:
                 task.last_run = utc_now()
@@ -83,11 +83,11 @@ class AsyncScheduler:
                     await task.func(*task.args, **task.kwargs)
                 except Exception:
                     task.error_count += 1
-                    logger.exception("Error in task", task_id=task_id, error=task.error_count)
+                    logger.exception("Error in task", extra={"task_id": task_id, "error_count": task.error_count})
 
                 # Calculate elapsed time and sleep if needed
                 elapsed = (utc_now() - task.last_run).total_seconds()
-                sleep_time = max(0, task.interval - elapsed)
+                sleep_time = max(0.0, task.interval - elapsed)
                 if sleep_time > 0:
                     try:
                         await asyncio.sleep(sleep_time)
@@ -95,7 +95,7 @@ class AsyncScheduler:
                         break
         finally:
             task.running = False
-            logger.debug("Finished task", task_id=task_id, elapsed=elapsed)
+            logger.debug("Finished task", extra={"task_id": task_id, "elapsed": elapsed})
 
     async def _start_all_tasks(self) -> None:
         """Starts all tasks concurrently using asyncio tasks."""

mm_std/concurrency/async_task_runner.py

@@ -1,13 +1,12 @@
 from __future__ import annotations
 
 import asyncio
+import logging
 from collections.abc import Awaitable
 from dataclasses import dataclass
 from typing import Any
 
-import structlog
-
-logger = structlog.stdlib.get_logger()
+logger = logging.getLogger(__name__)
 
 
 class AsyncTaskRunner:
@@ -101,7 +100,7 @@ class AsyncTaskRunner:
                     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)
+                        logger.exception("Task raised an exception", extra={"task_id": task.task_id})
                     exceptions[task.task_id] = e
 
         # Create asyncio tasks for all runner tasks

mm_std/http_.py

@@ -7,7 +7,6 @@ from urllib.parse import urlencode
 import aiohttp
 import pydash
 import requests
-import rich
 from aiohttp_socks import ProxyConnector
 from requests.auth import AuthBase
 
@@ -212,7 +211,6 @@ async def hrequest_async(
             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():

mm_std/log.py

@@ -2,8 +2,68 @@ import logging
 from logging.handlers import RotatingFileHandler
 from pathlib import Path
 
-import structlog
-from structlog.typing import Processor
+from rich.logging import RichHandler
+
+
+class ExtraFormatter(logging.Formatter):
+    def format(self, record: logging.LogRecord) -> str:
+        base = super().format(record)
+        extras = {
+            key: value
+            for key, value in record.__dict__.items()
+            if key not in logging.LogRecord.__dict__
+            and key
+            not in (
+                "name",
+                "msg",
+                "args",
+                "levelname",
+                "levelno",
+                "pathname",
+                "filename",
+                "module",
+                "exc_info",
+                "exc_text",
+                "stack_info",
+                "lineno",
+                "funcName",
+                "created",
+                "msecs",
+                "relativeCreated",
+                "thread",
+                "threadName",
+                "processName",
+                "process",
+                "message",
+                "taskName",
+                "asctime",
+            )
+        }
+        if extras:
+            extras_str = " | " + " ".join(f"{k}={v}" for k, v in extras.items())
+            return base + extras_str
+        return base
+
+
+def configure_logging(developer_console: bool = False, console_level: int = logging.INFO) -> None:
+    """
+    Configure the root logger with a custom formatter that includes extra fields.
+    """
+    logger = logging.getLogger()
+    logger.setLevel(console_level)
+    logger.handlers.clear()
+
+    console_handler: logging.Handler
+
+    if developer_console:
+        console_handler = RichHandler(rich_tracebacks=True, show_time=True, show_level=True, show_path=False)
+        formatter = ExtraFormatter("{message}", style="{")
+    else:
+        console_handler = logging.StreamHandler()
+        formatter = ExtraFormatter("{asctime} - {name} - {levelname} - {message}", datefmt="%Y-%m-%d %H:%M:%S", style="{")
+    console_handler.setFormatter(formatter)
+
+    logger.addHandler(console_handler)
 
 
 def init_logger(name: str, file_path: str | None = None, file_mkdir: bool = True, level: int = logging.DEBUG) -> logging.Logger:
@@ -23,54 +83,3 @@ 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/result.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import time
 from collections.abc import Callable
-from typing import Any, ClassVar, Literal, NoReturn, TypeVar, Union
+from typing import Any, ClassVar, Literal, NoReturn, TypeGuard, TypeVar, Union
 
 from pydantic_core import core_schema
 
@@ -258,6 +258,16 @@ class UnwrapError(Exception):
         return self._result
 
 
+def ok(result: Result[T]) -> TypeGuard[Ok[T]]:
+    """Used for type narrowing from `Result` to `Ok`."""
+    return isinstance(result, Ok)
+
+
+def err(result: Result[T]) -> TypeGuard[Err]:
+    """Used for type narrowing from `Result` to `Err`."""
+    return isinstance(result, Err)
+
+
 def try_ok[T](fn: Callable[..., Result[T]], *, args: tuple[object], attempts: int, delay: float = 0) -> Result[T]:
     if attempts <= 0:
         raise ValueError("attempts must be more than zero")

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

@@ -1,15 +1,14 @@
 Metadata-Version: 2.4
 Name: mm-std
-Version: 0.3.21
+Version: 0.3.23
 Requires-Python: >=3.12
 Requires-Dist: aiohttp-socks~=0.10.1
 Requires-Dist: aiohttp~=3.11.16
 Requires-Dist: cryptography~=44.0.2
 Requires-Dist: pydantic-settings>=2.8.1
-Requires-Dist: pydantic~=2.11.2
+Requires-Dist: pydantic~=2.11.3
 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.0
-Requires-Dist: structlog>=25.2.0
 Requires-Dist: tomlkit~=0.13.2

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

@@ -1,4 +1,4 @@
-mm_std/__init__.py,sha256=ATaZN6AzmRUJIc8IE4PichCbh45pNncbBidUG7V1m0Q,3044
+mm_std/__init__.py,sha256=bdkBTX7_u4NYtTRdVDHgZUozQlFRBx3TTiMK7Cenup0,3100
 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,25 +6,25 @@ 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=cozBUGZcbKp9sZuEnu7bklwa6lTE0RxEUVo_aNt1_kE,7468
+mm_std/http_.py,sha256=75GX21e3OSVjJsHzUjFoMIfT8Iq4Fe6YHaEr9EWOF4o,7422
 mm_std/json_.py,sha256=Naa6mBE4D0yiQGkPNRrFvndnUH3R7ovw3FeaejWV60o,1196
-mm_std/log.py,sha256=vQzNJ0oenvuHF9sXDI6CUZDR12BcDURUZVwkpdNle4Q,2983
+mm_std/log.py,sha256=0TkTsAlUTt00gjgukvsvnZRIAGELq0MI6Lv8mKP-Wz4,2887
 mm_std/net.py,sha256=qdRCBIDneip6FaPNe5mx31UtYVmzqam_AoUF7ydEyjA,590
 mm_std/print_.py,sha256=zB7sVbSSF8RffMxvnOdbKCXjCKtKzKV3R68pBri4NkQ,1638
 mm_std/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 mm_std/random_.py,sha256=OuUX4VJeSd13NZBya4qrGpR2TfN7_87tfebOY6DBUnI,1113
-mm_std/result.py,sha256=KLnPWjICYFkP6CAhq7Ifs22XSD-PQ9RkG6n1-cZcXkM,7625
+mm_std/result.py,sha256=2cLa0Lb1W7IY1Kxn-r-9GyqDz3colabp00dcvr7AKbU,7917
 mm_std/str.py,sha256=BEjJ1p5O4-uSYK0h-enasSSDdwzkBbiwdQ4_dsrlEE8,3257
 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=xEpyipzp3ZhaPHtdeTE-Ikrt67SUTFKBE6LQPeoeh6Q,1735
-mm_std/concurrency/async_scheduler.py,sha256=cTsEY0FJKqlA94Ap-5Yx4KFOc-0QP5lRocn4P2n3cdE,5526
-mm_std/concurrency/async_task_runner.py,sha256=JpofaXCSqQDgQTh1FvaCWxsUsFWNPJGfXpuTlkF7hS0,4988
+mm_std/concurrency/async_scheduler.py,sha256=TSu2WDJ8vfKZ4-saM3iZdcpGz8yPpSmud-7jJ4XKdJs,5579
+mm_std/concurrency/async_task_runner.py,sha256=EN7tN2enkVYVgDbhSiAr-_W4o9m9wBXCveXGT8aVXII,4994
 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.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,,
+mm_std-0.3.23.dist-info/METADATA,sha256=8i2Wl_kTQ4IApdDBUzpbp8Q6P0RG3V8bffoMp2_9UeE,415
+mm_std-0.3.23.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mm_std-0.3.23.dist-info/RECORD,,