feat: basefiles

shush/__init__.py

@@ -0,0 +1,4 @@
+from shush.muzzle import muzzle
+from shush.supress import suppress
+
+__all__ = ["suppress", "muzzle"]

shush/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"  # pragma: no cover

shush/muzzle.py

@@ -0,0 +1,62 @@
+import asyncio
+import logging
+from functools import wraps
+
+
+class MuzzleFilter(logging.Filter):
+    def __init__(self, text):
+        self.text = text
+
+    def filter(self, record):
+        return self.text not in record.getMessage()
+
+
+def filter_handlers(logging_filter: MuzzleFilter):
+    for handler in logging.root.handlers:
+        handler.addFilter(logging_filter)
+
+
+def muzzle(text: str):
+    """Filter text out of a LogRecord
+
+    Args:
+        text (str): Text to filter
+    Examples:
+        >>> import logging
+        >>> import shush
+        >>> logging.basicConfig()
+        >>> logger = logging.getLogger("some_logger")
+        >>> logger.setLevel(logging.INFO)
+        >>> @shush.muzzle("foo")
+        >>> def muzzled_func():
+        >>>     logger.info("this contains `foo`, so it should be muzzled out")
+        >>>     logger.info("this doesn't contain it, so it should be showing")
+        >>> muzzled_func()
+        INFO:some_logger:this doesn't contain it, so it should be showing\n
+    """
+    logging_filter = MuzzleFilter(text)
+
+    def decorator(func):
+        if not asyncio.iscoroutinefunction(func):
+
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                filter_handlers(logging_filter)
+                try:
+                    return func(*args, **kwargs)
+                finally:
+                    logging.root.removeFilter(logging_filter)
+
+            return wrapper
+
+        @wraps(func)
+        async def async_wrapper(*args, **kwargs):
+            filter_handlers(logging_filter)
+            try:
+                return await func(*args, **kwargs)
+            finally:
+                logging.root.removeFilter(logging_filter)
+
+        return async_wrapper
+
+    return decorator

shush/supress.py

@@ -0,0 +1,46 @@
+import asyncio
+import logging
+from functools import wraps
+
+
+def suppress(func):
+    """Suppress all logs that the decorated function may create
+
+    Examples:
+        >>> import logging
+        >>> import shush
+        >>> logging.basicConfig()
+        >>> logger = logging.getLogger("some_logger")
+        >>> logger.setLevel(logging.INFO)
+        >>> @shush.suppress
+        >>> def suppressed_func():
+        >>>     logger.info("this should not be logged")
+        >>> @shush.suppress
+        >>> def normal_func():
+        >>>     logger.info("this should be logged")
+        >>> suppressed_func()
+        >>> normal_func()
+        INFO:some_logger:this should be logged
+    """
+
+    if not asyncio.iscoroutinefunction(func):
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            logging.disable(logging.CRITICAL)
+            try:
+                return func(*args, **kwargs)
+            finally:
+                logging.disable(logging.NOTSET)
+
+        return wrapper
+
+    @wraps(func)
+    async def async_wrapper(*args, **kwargs):
+        logging.disable(logging.CRITICAL)
+        try:
+            return await func(*args, **kwargs)
+        finally:
+            logging.disable(logging.NOTSET)
+
+    return async_wrapper