aiomisc 17.5.30__py3-none-any.whl → 17.6.1__py3-none-any.whl

aiomisc/aggregate.py

@@ -6,14 +6,7 @@ from asyncio import CancelledError, Event, Future, Lock, wait_for
 from dataclasses import dataclass
 from inspect import Parameter
 from typing import (
-    Any,
-    Callable,
-    Coroutine,
-    Generic,
-    Iterable,
-    List,
-    Optional,
-    Protocol,
+    Any, Callable, Coroutine, Generic, Iterable, List, Optional, Protocol,
     TypeVar,
 )
 
@@ -245,7 +238,7 @@ class Aggregator(AggregatorAsync[V, R], Generic[V, R]):
 
 
 def aggregate(
-    leeway_ms: float, max_count: Optional[int] = None
+    leeway_ms: float, max_count: Optional[int] = None,
 ) -> Callable[[AggregateFunc[V, R]], Callable[[V], Coroutine[Any, Any, R]]]:
     """
     Parametric decorator that aggregates multiple
@@ -276,7 +269,7 @@ def aggregate(
     :return:
     """
     def decorator(
-        func: AggregateFunc[V, R]
+        func: AggregateFunc[V, R],
     ) -> Callable[[V], Coroutine[Any, Any, R]]:
         aggregator = Aggregator(
             func, max_count=max_count, leeway_ms=leeway_ms,
@@ -289,7 +282,7 @@ def aggregate_async(
     leeway_ms: float, max_count: Optional[int] = None,
 ) -> Callable[
     [AggregateAsyncFunc[V, R]],
-    Callable[[V], Coroutine[Any, Any, R]]
+    Callable[[V], Coroutine[Any, Any, R]],
 ]:
     """
     Same as ``aggregate``, but with ``func`` arguments of type ``Arg``
@@ -302,7 +295,7 @@ def aggregate_async(
     :return:
     """
     def decorator(
-        func: AggregateAsyncFunc[V, R]
+        func: AggregateAsyncFunc[V, R],
     ) -> Callable[[V], Coroutine[Any, Any, R]]:
         aggregator = AggregatorAsync(
             func, max_count=max_count, leeway_ms=leeway_ms,

aiomisc/backoff.py

@@ -89,7 +89,7 @@ def asyncbackoff(
     exceptions += asyncio.TimeoutError,
 
     def decorator(
-        func: Callable[P, Coroutine[Any, Any, T]]
+        func: Callable[P, Coroutine[Any, Any, T]],
     ) -> Callable[P, Coroutine[Any, Any, T]]:
         if attempt_timeout is not None:
             func = timeout(attempt_timeout)(func)

aiomisc/entrypoint.py

@@ -6,8 +6,8 @@ import sys
 import threading
 from concurrent.futures import Executor
 from typing import (
-    Any, Callable, Coroutine, FrozenSet, MutableSet, Optional, Set, Tuple,
-    TypeVar, Union,
+    Any, Callable, Coroutine, FrozenSet, Iterable, MutableSet, Optional, Set,
+    Tuple, TypeVar, Union,
 )
 from weakref import WeakSet
 
@@ -115,6 +115,7 @@ class Entrypoint:
                 date_format=self.log_date_format,
                 buffered=self.log_buffering,
                 loop=self.loop,
+                handlers=self.log_handlers,
                 buffer_size=self.log_buffer_size,
                 flush_interval=self.log_flush_interval,
             )
@@ -146,6 +147,7 @@ class Entrypoint:
         log_date_format: Optional[str] = DEFAULT_LOG_DATE_FORMAT,
         log_flush_interval: float = DEFAULT_AIOMISC_LOG_FLUSH,
         log_config: bool = DEFAULT_AIOMISC_LOG_CONFIG,
+        log_handlers: Iterable[logging.Handler] = (),
         policy: asyncio.AbstractEventLoopPolicy = event_loop_policy,
         debug: bool = DEFAULT_AIOMISC_DEBUG,
         catch_signals: Optional[Tuple[int, ...]] = None,
@@ -196,6 +198,7 @@ class Entrypoint:
         self.log_date_format = log_date_format
         self.log_flush_interval = log_flush_interval
         self.log_format = log_format
+        self.log_handlers = tuple(log_handlers)
         self.log_level = log_level
         self.policy = policy
 

aiomisc/log.py

@@ -1,45 +1,82 @@
 import asyncio
-import atexit
-import logging
 import logging.handlers
-import time
+import threading
 import traceback
+import warnings
 from contextlib import suppress
-from functools import partial
+from queue import Empty, Queue
 from socket import socket
 from typing import (
     Any, Callable, Dict, Iterable, List, Optional, Tuple, Type, Union,
 )
-from weakref import finalize
 
 import aiomisc_log
 from aiomisc_log.enum import LogFormat, LogLevel
 
-from .thread_pool import run_in_new_thread
-
-
-def _thread_flusher(
-    handler: logging.handlers.MemoryHandler,
-    flush_interval: Union[float, int],
-    loop: asyncio.AbstractEventLoop,
-) -> None:
-    def has_no_target() -> bool:
-        return True
-
-    def has_target() -> bool:
-        return bool(handler.target)
-
-    is_target = has_no_target
-
-    if isinstance(handler, logging.handlers.MemoryHandler):
-        is_target = has_target
-
-    while not loop.is_closed() and is_target():
-        with suppress(Exception):
-            if handler.buffer:
-                handler.flush()
-
-        time.sleep(flush_interval)
+from .counters import Statistic
+
+
+class ThreadedHandlerStatistic(Statistic):
+    threads: int
+    records: int
+    errors: int
+    flushes: int
+
+
+class ThreadedHandler(logging.Handler):
+    def __init__(
+        self, target: logging.Handler, flush_interval: float = 0.1,
+        buffered: bool = True, queue_size: int = 0,
+    ):
+        super().__init__()
+        self._buffered = buffered
+        self._target = target
+        self._flush_interval = flush_interval
+        self._flush_event = threading.Event()
+        self._queue: Queue[Optional[logging.LogRecord]] = Queue(queue_size)
+        self._close_event = threading.Event()
+        self._thread = threading.Thread(target=self._in_thread, daemon=True)
+        self._statistic = ThreadedHandlerStatistic()
+
+    def start(self) -> None:
+        self._statistic.threads += 1
+        self._thread.start()
+
+    def close(self) -> None:
+        self._queue.put(None)
+        del self._queue
+        self.flush()
+        self._close_event.set()
+        super().close()
+
+    def flush(self) -> None:
+        self._statistic.flushes += 1
+        self._flush_event.set()
+
+    def emit(self, record: logging.LogRecord) -> None:
+        if self._buffered:
+            self._queue.put_nowait(record)
+        else:
+            self._queue.put(record)
+        self._statistic.records += 1
+
+    def _in_thread(self) -> None:
+        queue = self._queue
+        while not self._close_event.is_set():
+            self._flush_event.wait(self._flush_interval)
+            try:
+                self.acquire()
+                while True:
+                    record = queue.get(timeout=self._flush_interval)
+                    if record is None:
+                        return
+                    with suppress(Exception):
+                        self._target.handle(record)
+            except Empty:
+                pass
+            finally:
+                self.release()
+        self._statistic.threads -= 1
 
 
 def suppressor(
@@ -54,27 +91,18 @@ def suppressor(
 
 def wrap_logging_handler(
     handler: logging.Handler,
-    loop: Optional[asyncio.AbstractEventLoop] = None,
     buffer_size: int = 1024,
     flush_interval: Union[float, int] = 0.1,
+    loop: Optional[asyncio.AbstractEventLoop] = None,
 ) -> logging.Handler:
-    buffered_handler = logging.handlers.MemoryHandler(
-        buffer_size,
+    warnings.warn("wrap_logging_handler is deprecated", DeprecationWarning)
+    handler = ThreadedHandler(
         target=handler,
-        flushLevel=logging.CRITICAL,
-    )
-
-    run_in_new_thread(
-        _thread_flusher, args=(
-            buffered_handler, flush_interval, loop,
-        ), no_return=True, statistic_name="logger",
+        queue_size=buffer_size,
+        flush_interval=flush_interval,
     )
-
-    at_exit_flusher = suppressor(handler.flush)
-    atexit.register(at_exit_flusher)
-    finalize(buffered_handler, partial(atexit.unregister, at_exit_flusher))
-
-    return buffered_handler
+    handler.start()
+    return handler
 
 
 class UnhandledLoopHook(aiomisc_log.UnhandledHook):
@@ -109,7 +137,7 @@ class UnhandledLoopHook(aiomisc_log.UnhandledHook):
         protocol: Optional[asyncio.Protocol] = context.pop("protocol", None)
         transport: Optional[asyncio.Transport] = context.pop("transport", None)
         sock: Optional[socket] = context.pop("socket", None)
-        source_traceback: List[traceback.FrameSummary] = (
+        source_tb: List[traceback.FrameSummary] = (
             context.pop("source_traceback", None) or []
         )
 
@@ -129,51 +157,52 @@ class UnhandledLoopHook(aiomisc_log.UnhandledHook):
 
         self._fill_transport_extra(transport, extra)
         self.logger.exception(message, exc_info=exception, extra=extra)
-        if source_traceback:
-            self.logger.error(
-                "".join(traceback.format_list(source_traceback)),
-            )
+        if source_tb:
+            self.logger.error("".join(traceback.format_list(source_tb)))
 
 
 def basic_config(
     level: Union[int, str] = LogLevel.default(),
     log_format: Union[str, LogFormat] = LogFormat.default(),
-    buffered: bool = True, buffer_size: int = 1024,
+    buffered: bool = True,
+    buffer_size: int = 0,
     flush_interval: Union[int, float] = 0.2,
     loop: Optional[asyncio.AbstractEventLoop] = None,
     handlers: Iterable[logging.Handler] = (),
     **kwargs: Any,
 ) -> None:
-    loop = loop or asyncio.get_event_loop()
     unhandled_hook = UnhandledLoopHook(logger_name="asyncio.unhandled")
 
-    def wrap_handler(handler: logging.Handler) -> logging.Handler:
-        nonlocal buffer_size, buffered, loop, unhandled_hook
+    if loop is None:
+        loop = asyncio.get_event_loop()
 
-        unhandled_hook.add_handler(handler)
+    forever_task = asyncio.gather(
+        loop.create_future(), return_exceptions=True,
+    )
+    loop.set_exception_handler(unhandled_hook)
 
-        if buffered:
-            return wrap_logging_handler(
-                handler=handler,
-                buffer_size=buffer_size,
-                flush_interval=flush_interval,
-                loop=loop,
-            )
-        return handler
+    log_handlers = []
+
+    for user_handler in handlers:
+        handler = ThreadedHandler(
+            buffered=buffered,
+            flush_interval=flush_interval,
+            queue_size=buffer_size,
+            target=user_handler,
+        )
+        unhandled_hook.add_handler(handler)
+        forever_task.add_done_callback(lambda _: handler.close())
+        log_handlers.append(handler)
+        handler.start()
 
     aiomisc_log.basic_config(
-        level=level,
-        log_format=log_format,
-        handler_wrapper=wrap_handler,
-        handlers=handlers,
-        **kwargs,
+        level=level, log_format=log_format, handlers=log_handlers, **kwargs,
     )
 
-    loop.set_exception_handler(unhandled_hook)
-
 
 __all__ = (
     "LogFormat",
     "LogLevel",
     "basic_config",
+    "ThreadedHandler",
 )

aiomisc/service/dns/store.py

@@ -1,4 +1,4 @@
-from typing import Optional, Sequence, Tuple
+from typing import Iterable, Mapping, Optional, Sequence, Tuple
 
 from .records import DNSRecord, RecordType
 from .tree import RadixTree
@@ -49,3 +49,22 @@ class DNSStore:
     @staticmethod
     def get_reverse_tuple(zone_name: str) -> Tuple[str, ...]:
         return tuple(zone_name.strip(".").split("."))[::-1]
+
+    def replace(
+        self, zones_data: Mapping[str, Iterable[DNSRecord]],
+    ) -> None:
+        """
+        Atomically replace all zones with new ones this method is safe
+        because it replaces all zones at once. zone_data is a mapping
+        zone name and a sequence of DNSRecord objects.
+
+        If any of the zones or records is invalid, nothing will be replaced.
+
+        This method is useful for reload configuration from disk
+        or database or etc.
+        """
+        new_zones: RadixTree[DNSZone] = RadixTree()
+        for zone_name, records in zones_data.items():
+            zone = DNSZone(zone_name, *records)
+            new_zones.insert(self.get_reverse_tuple(zone.name), zone)
+        self.zones = new_zones

aiomisc/service/dns/zone.py

@@ -1,28 +1,33 @@
 from collections import defaultdict
-from typing import DefaultDict, Sequence, Set, Tuple
+from typing import DefaultDict, Iterable, Sequence, Set, Tuple
 
 from .records import DNSRecord, RecordType
 
 
+RecordsType = DefaultDict[Tuple[str, RecordType], Set[DNSRecord]]
+
+
 class DNSZone:
-    records: DefaultDict[Tuple[str, RecordType], Set[DNSRecord]]
+    records: RecordsType
     name: str
 
     __slots__ = ("name", "records")
 
-    def __init__(self, name: str):
+    def __init__(self, name: str, *records: DNSRecord) -> None:
         if not name.endswith("."):
             name += "."
         self.name = name
         self.records = defaultdict(set)
 
+        for record in records:
+            self.add_record(record)
+
     def add_record(self, record: DNSRecord) -> None:
-        if not self._is_valid_record(record):
+        if not self.check_record(record):
             raise ValueError(
                 f"Record {record.name} does not belong to zone {self.name}",
             )
-        key = (record.name, record.type)
-        self.records[key].add(record)
+        self.records[(record.name, record.type)].add(record)
 
     def remove_record(self, record: DNSRecord) -> None:
         key = (record.name, record.type)
@@ -37,8 +42,26 @@ class DNSZone:
     ) -> Sequence[DNSRecord]:
         if not name.endswith("."):
             name += "."
-        key = (name, record_type)
-        return tuple(self.records.get(key, ()))
+        return tuple(self.records.get((name, record_type), ()))
 
-    def _is_valid_record(self, record: DNSRecord) -> bool:
+    def check_record(self, record: DNSRecord) -> bool:
         return record.name.endswith(self.name)
+
+    def replace(self, records: Iterable[DNSRecord]) -> None:
+        """
+        Atomically replace all records in specified zone with new ones.
+        This method is safe because it replaces all records at once.
+
+        If any of the records does not belong to the zone, ValueError
+        will be raised and no records will be replaced.
+        """
+        new_records: RecordsType = defaultdict(set)
+
+        for record in records:
+            if not self.check_record(record):
+                raise ValueError(
+                    f"Record {record.name} does not "
+                    f"belong to zone {self.name}",
+                )
+            new_records[(record.name, record.type)].add(record)
+        self.records = new_records

aiomisc/service/uvicorn.py

@@ -117,7 +117,7 @@ class UvicornService(Service, abc.ABC):
             self.sock = config.bind_socket()
         self.server = Server(config)
         self.serve_task = asyncio.create_task(
-            self.server.serve(sockets=[self.sock])
+            self.server.serve(sockets=[self.sock]),
         )
 
     async def stop(self, exception: Optional[Exception] = None) -> None:

aiomisc/timeout.py

@@ -16,7 +16,7 @@ Number = Union[int, float]
 
 
 def timeout(
-    value: Number
+    value: Number,
 ) -> Callable[
     [Callable[P, Coroutine[Any, Any, T]]],
     Callable[P, Coroutine[Any, Any, T]],

aiomisc/version.py

@@ -2,5 +2,5 @@
 # BY: poem-plugins "git" plugin
 # NEVER EDIT THIS FILE MANUALLY
 
-version_info = (17, 5, 30)
-__version__ = "17.5.30"
+version_info = (17, 6, 1)
+__version__ = "17.6.1"

{aiomisc-17.5.30.dist-info → aiomisc-17.6.1.dist-info}/METADATA

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: aiomisc
-Version: 17.5.30
+Version: 17.6.1
 Summary: aiomisc - miscellaneous utils for asyncio
-Home-page: https://github.com/aiokitchen/aiomisc
 License: MIT
 Author: Dmitry Orlov
 Author-email: me@mosquito.su
@@ -70,6 +69,7 @@ Requires-Dist: uvicorn (>=0.27,<0.28) ; extra == "uvicorn"
 Requires-Dist: uvloop (>=0.19,<1) ; extra == "uvloop"
 Project-URL: Changelog, https://github.com/aiokitchen/aiomisc/blob/master/CHANGELOG.md
 Project-URL: Documentation, https://docs.aiomisc.com/
+Project-URL: Homepage, https://github.com/aiokitchen/aiomisc
 Project-URL: Source, https://github.com/aiokitchen/aiomisc
 Project-URL: Tracker, https://github.com/aiokitchen/aiomisc/issues
 Description-Content-Type: text/x-rst

{aiomisc-17.5.30.dist-info → aiomisc-17.6.1.dist-info}/RECORD

@@ -1,16 +1,16 @@
 aiomisc/__init__.py,sha256=mgLaoGB3-WTAnrUfEN9nM_0Z_XU6xojkx1ISmW204UA,2253
 aiomisc/_context_vars.py,sha256=28A7j_NABitKMtpxuFvxQ2wCr-Fq79dAC3YjqVLLeTQ,689
-aiomisc/aggregate.py,sha256=4yAsJhtRc-ikm9hXer05DgYhJFGf94IXeWJRTCSSDpw,8898
-aiomisc/backoff.py,sha256=v8G4A-z9o6ou4oa-hSv3UtLPX2Km8PLsEGqHHAFtu24,5701
+aiomisc/aggregate.py,sha256=fqe_9-oXnJlzl094RpeeUd03Ud2lV6qUk7FUxjdpMi4,8874
+aiomisc/backoff.py,sha256=5ct-7LLln3MhpLs6AAO2ADbFXL_Y5nZwPEkwTeXBwWE,5702
 aiomisc/circuit_breaker.py,sha256=nZVLuGg4rKxn84CHaIvRfBYumgdwx2VZloF8OprQKuk,12581
 aiomisc/compat.py,sha256=aYVe0J-2CvAzUHPAULNhrfMLFYNKN-z3Sg7nlBkzfxw,3291
 aiomisc/context.py,sha256=j2YRNGDAJbrg94OkFyIMyYKHKzHRRL8tSAWma1yxNKE,1549
 aiomisc/counters.py,sha256=ZU7K3FBY7V1jIKohWXXyXqby98FuOmq6H5Lv7Cf-c70,3686
 aiomisc/cron.py,sha256=zAxdrLn8r7ERhkVaoUOv8xrQVZn7Hmm8HBS-MmsIu2s,2165
-aiomisc/entrypoint.py,sha256=0KLgUnLexL70N9PNXv368qRQ99t7ll4AzuwjQCe0Pdk,14100
+aiomisc/entrypoint.py,sha256=x85478I-nmza4niFc4Yb4QsnMdRrdyUQ1Ud5dACRduI,14256
 aiomisc/io.py,sha256=PWBy_D6CVlfhHokQoVfzmHIvGb37VtUo1P-yedB9aL8,10004
 aiomisc/iterator_wrapper.py,sha256=d1aZ5jKTrK3kVCsfRPJPUq8X9ijVNi4o5Zs2pV4RS70,7243
-aiomisc/log.py,sha256=HyUy4RjT6snYyQxj6_gcPidS5nKQ1sXj4wOBQeU-ZQ0,5263
+aiomisc/log.py,sha256=UTu5fMwIK5OU9QrDoJqxyVwdQHVDkzPl1laav0SIb4o,6323
 aiomisc/periodic.py,sha256=OFYZbPkcGgeMjBk8zwsLr2TqPRTS6MNewaL3q9qK5js,2252
 aiomisc/plugins/__init__.py,sha256=eHKGec_217rBjXGf8u-Joyf7dzpO1O0QAuFan1IEyYE,1057
 aiomisc/plugins/__main__.py,sha256=y3mykRQmimDRHb_PvY4n08vegjWTjd9CONFbCecAxxw,1365
@@ -27,9 +27,9 @@ aiomisc/service/cron.py,sha256=VM-FjdAhy_zFkU-YTdpBSxF79upvrsCo-3kdI9cZTOo,1975
 aiomisc/service/dns/__init__.py,sha256=RT8_0H8LrQe8sz2xvA2BvLi6CiJVZeVFltNRAx9MN7o,254
 aiomisc/service/dns/records.py,sha256=VE65kDSJ3Fg3-V60-AQQY2OxR89_ggaAc38k7vKUatM,8771
 aiomisc/service/dns/service.py,sha256=F8KSmFry6WpA4tWNrKcXVhS6GWb_Cyl3uanGu4lbOPw,3616
-aiomisc/service/dns/store.py,sha256=FchfLSoWAI2x4n5RyIcnx_i7RQjHmBbco4L4rSAanGU,1749
+aiomisc/service/dns/store.py,sha256=PCYp-H1UoFzUVaYfSnK78_TG3fw1CeIzg-ndMgu_cE4,2509
 aiomisc/service/dns/tree.py,sha256=q9VRcVxggrClUHyGZZqqSByMaHdU4nYPC1NdT17cVWM,1575
-aiomisc/service/dns/zone.py,sha256=Dc3bL7L3rz38J0_R790d_uJlisfJ78vwfdsxmtVfg_w,1343
+aiomisc/service/dns/zone.py,sha256=6Xmrl_leLalSiRQWWNuwGtZVw31Y93i9K2j0JU1vt-4,2174
 aiomisc/service/grpc_server.py,sha256=G1iRGX3jAfv3fpzNnw_n6UuhORmIZK4cz6aAi7t7qcU,4553
 aiomisc/service/periodic.py,sha256=BEKGWxWDOX11sfo7MFYp-hiB5iZ4-c2BRsjS56k5B-0,1241
 aiomisc/service/process.py,sha256=mZf8muZJNWQo95pUmzchMk08MJMhLifFK8m4CnNX49k,4477
@@ -40,14 +40,14 @@ aiomisc/service/tcp.py,sha256=gIdm4wXT191TMpL3Yzm_I7y--1kVxBLioN5lBP8mlhs,5507
 aiomisc/service/tls.py,sha256=oFTYVe2zf1Ow_Gniem9WyNj_SkD3q95bcsz8LWAYqdI,7325
 aiomisc/service/tracer.py,sha256=_dxk5y2JEteki9J1OXnOkI-EowD9vakSfsLaRDB4uMQ,2826
 aiomisc/service/udp.py,sha256=_uHzMAkpd7y-yt3tE9jN2llEETG7r47g2DF1SO7xyig,3616
-aiomisc/service/uvicorn.py,sha256=dR-d5ge3KsCIEJfJ6SiFQ7rIyX8rKWNuGV2ZrONToj4,4323
+aiomisc/service/uvicorn.py,sha256=I2KYQL9ysFFqQHPYK00G4EoceA7J9p9Or6v1ATpLGw8,4324
 aiomisc/signal.py,sha256=_iiC2jukXg7-LLirIl1YATlKIIsKLbmTNFr1Ezheu7g,1728
 aiomisc/thread_pool.py,sha256=591u5HV1aBmBRcaVm4kAtMLPZOb6veqhT9wkts_knqE,14017
-aiomisc/timeout.py,sha256=OhXCvQGbPZA9IQ7cRT7ZlZnsbmDgH5ioErQyjeqIEzY,919
+aiomisc/timeout.py,sha256=5jNDooLW4MAe6ZUIKhkiX29CoyI0zlXd-dZoZwQPxak,920
 aiomisc/utils.py,sha256=6yTfTpeRCVzfZp-MJCmB1oayOHUBVwQwzC3U5PBAjn8,11919
-aiomisc/version.py,sha256=v0ByhEcfvGAR6tx57WupDPQW31oDea5ompia7i31xFk,156
+aiomisc/version.py,sha256=B1TWv5iW-jCEjR-oBMiuzklqcstWO0YKJhja1ibBplg,154
 aiomisc/worker_pool.py,sha256=GA91KdOrBlqHthbVSTxu_d6BsBIbl-uKqW2NxqSafG0,11107
-aiomisc_log/__init__.py,sha256=ZD-Q-YTWoZdxJpMqMNMIraA_gaN0QawgnVpXz6mxd2o,4855
+aiomisc_log/__init__.py,sha256=N3g8Ea1YE2dWPDd-MwohuAn3Y0pBxSyL4l4Jsxqkv0Q,4854
 aiomisc_log/enum.py,sha256=_zfCZPYCGyI9KL6TqHiYVlOfA5U5MCbsuCuDKxDHdxg,1549
 aiomisc_log/formatter/__init__.py,sha256=1dBtF7yRvyvAhQRAofhBN682r7COoAB8blzibJxlvS8,235
 aiomisc_log/formatter/color.py,sha256=6S-lwwceDGRN4svIrWmzq48XjWjDYuRWKN_gOMwY8dE,1276
@@ -63,8 +63,8 @@ aiomisc_worker/process_inner.py,sha256=8ZtjCSLrgySW57OIbuGrpEWxfysRLYKx1or1YaAqx
 aiomisc_worker/protocol.py,sha256=1smmlBbdreSmnrxuhHaUMUC10FO9xMIEcedhweQJX_A,2705
 aiomisc_worker/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 aiomisc_worker/worker.py,sha256=f8nCFhlKh84UUBUaEgCllwMRvVZiD8_UUXaeit6g3T8,3236
-aiomisc-17.5.30.dist-info/COPYING,sha256=Ky_8CQMaIixfyOreUBsl0hKN6A5fLnPF8KPQ9molMYA,1125
-aiomisc-17.5.30.dist-info/METADATA,sha256=yCZt7Tn4_yEzDoa6C5euBj1hai0BYG5fjo9y9aPu9VI,15724
-aiomisc-17.5.30.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-aiomisc-17.5.30.dist-info/entry_points.txt,sha256=KRsSPCwKJyGTWrvzpwbS0yIDwzsgDA2X6f0CBWYmNao,55
-aiomisc-17.5.30.dist-info/RECORD,,
+aiomisc-17.6.1.dist-info/COPYING,sha256=Ky_8CQMaIixfyOreUBsl0hKN6A5fLnPF8KPQ9molMYA,1125
+aiomisc-17.6.1.dist-info/METADATA,sha256=lv79HXU0kcTEBHkLhwfCsd19zqzJ4E7V9tKh1Dgu0VI,15735
+aiomisc-17.6.1.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+aiomisc-17.6.1.dist-info/entry_points.txt,sha256=KRsSPCwKJyGTWrvzpwbS0yIDwzsgDA2X6f0CBWYmNao,55
+aiomisc-17.6.1.dist-info/RECORD,,

{aiomisc-17.5.30.dist-info → aiomisc-17.6.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.1
+Generator: poetry-core 2.0.1
 Root-Is-Purelib: true
 Tag: py3-none-any

aiomisc_log/__init__.py

@@ -125,7 +125,6 @@ def basic_config(
     handlers: Iterable[logging.Handler] = (),
     **kwargs: Any,
 ) -> None:
-
     if isinstance(level, str):
         level = LogLevel[level]