Merge pull request #222 from pyapp-org/development

Release 4.15

Author: timsavage

HISTORY

@@ -1,3 +1,18 @@
+4.15
+====
+
+Features
+--------
+
+- Command decorators can now be supplied with an alternate loglevel to
+  allow certain commands to use a different level.
+
+Bugfix
+------
+
+- Fix initial log replay so the specified log-level is correctly applied.
+
+
 4.14
 ====
 

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "pyapp"
-version = "4.14"
+version = "4.15"
 description = "A Python application framework - Let us handle the boring stuff!"
 authors = ["Tim Savage <[email protected]>"]
 license = "BSD-3-Clause"

src/pyapp/app/__init__.py

@@ -169,6 +169,7 @@ def my_command(
 from .. import conf, extensions, feature_flags
 from ..app import builtin_handlers
 from ..events import Event
+from ..exceptions import ApplicationExit
 from ..injection import register_factory
 from ..utils.inspect import import_root_module
 from . import init_logger
@@ -342,7 +343,7 @@ def _init_parser(self):
         )
         arg_group.add_argument(
             "--log-level",
-            default=os.environ.get(self.env_loglevel_key, "INFO"),
+            default=os.environ.get(self.env_loglevel_key, "DEFAULT"),
             choices=("DEBUG", "INFO", "WARN", "ERROR", "CRITICAL"),
             help="Specify the log level to be used. "
             f"Defaults to env variable: {_key_help(self.env_loglevel_key)}",
@@ -497,7 +498,11 @@ def configure_logging(self, opts: CommandOptions):
                 logging.config.dictConfig(dict_config)
 
             # Configure root log level
-            logging.root.setLevel(opts.log_level)
+            loglevel = opts.log_level
+            if loglevel == "DEFAULT":
+                handler = self.resolve_handler(opts)
+                loglevel = handler.loglevel
+            logging.root.setLevel(loglevel)
 
             # Replay initial entries and remove
             self._init_logger.replay()
@@ -540,6 +545,8 @@ def logging_shutdown():
 
     def dispatch(self, args: Sequence[str] = None) -> None:
         """Dispatch command to registered handler."""
+        logger.info("Starting %s", self.application_summary)
+
         # Initialisation phase
         _set_running_application(self)
         self.register_factories()
@@ -549,10 +556,6 @@ def dispatch(self, args: Sequence[str] = None) -> None:
         argcomplete.autocomplete(self.parser)
         opts = self.parser.parse_args(args)
 
-        # Set log level from opts
-        logging.root.setLevel(opts.log_level)
-        logger.info("Starting %s", self.application_summary)
-
         # Load settings and configure logger
         self.configure_settings(opts)
         self.configure_feature_flags(opts)
@@ -576,9 +579,14 @@ def dispatch(self, args: Sequence[str] = None) -> None:
             if not self.exception_report(ex, opts):
                 raise
 
+        except ApplicationExit as ex:
+            if ex.message:
+                print(f"\n\n{ex.message}", file=sys.stderr)
+            raise
+
         except KeyboardInterrupt:
             print("\n\nInterrupted.", file=sys.stderr)
-            sys.exit(-2)
+            sys.exit(2)
 
         else:
             # Provide exit code.

src/pyapp/app/arguments.py

@@ -11,6 +11,7 @@
 import argparse
 import asyncio
 import inspect
+import logging
 from enum import Enum
 from typing import (
     Any,
@@ -46,9 +47,7 @@
 
 
 class ParserBase:
-    """
-    Base class for handling parsers.
-    """
+    """Base class for handling parsers."""
 
     def __init__(self, parser: argparse.ArgumentParser):
         self.parser = parser
@@ -60,8 +59,7 @@ def argument(self, *name_or_flags, **kwargs) -> argparse.Action:
         return self.parser.add_argument(*name_or_flags, **kwargs)
 
     def argument_group(self, *, title: str = None, description: str = None):
-        """
-        Add an argument group to proxy
+        """Add an argument group to proxy.
 
         See: https://docs.python.org/3.6/library/argparse.html#argument-groups
 
@@ -70,8 +68,7 @@ def argument_group(self, *, title: str = None, description: str = None):
 
 
 class CommandProxy(ParserBase):
-    """
-    Proxy object that wraps a handler.
+    """Proxy object that wraps a handler.
 
     .. versionupdated:: 4.4
         Determine arguments from handler signature.
@@ -80,15 +77,14 @@ class CommandProxy(ParserBase):
 
     __slots__ = ("__name__", "handler", "_args", "_require_namespace")
 
-    def __init__(self, handler: Handler, parser: argparse.ArgumentParser):
-        """
-        Initialise proxy
+    def __init__(self, handler: Handler, parser: argparse.ArgumentParser, loglevel: int = logging.INFO):
+        """Initialise proxy.
 
         :param handler: Callable object that accepts a single argument.
-
         """
         super().__init__(parser)
         self.handler = handler
+        self.loglevel = loglevel
 
         # Copy details
         self.__doc__ = handler.__doc__
@@ -108,9 +104,7 @@ def __init__(self, handler: Handler, parser: argparse.ArgumentParser):
         self._extract_args(handler)
 
     def _extract_args(self, func):
-        """
-        Extract args from signature and turn into command line args
-        """
+        """Extract args from signature and turn into command line args."""
         sig = inspect.signature(func)
 
         # Backwards compatibility
@@ -144,26 +138,21 @@ def __call__(self, opts: argparse.Namespace):
 
 
 class AsyncCommandProxy(CommandProxy):
-    """
-    Proxy object that wraps an async handler.
+    """Proxy object that wraps an async handler.
 
-    Will handle starting a event loop.
+    Will handle starting an event loop.
     """
 
     def __call__(self, opts: argparse.Namespace):
         return async_run(super().__call__(opts))
 
 
 class ArgumentType(abc.ABC):
-    """
-    Custom argument type
-    """
+    """Custom argument type."""
 
     @abc.abstractmethod
     def __call__(self, value: str) -> Any:
-        """
-        Construct a value from type
-        """
+        """Construct a value from type."""
 
 
 class Argument:
@@ -417,9 +406,7 @@ def register_with_proxy(self, proxy: CommandProxy) -> argparse.Action:
 
 
 class CommandGroup(ParserBase):
-    """
-    Group of commands.
-    """
+    """Group of commands."""
 
     def __init__(
         self,
@@ -436,9 +423,7 @@ def __init__(
 
     @cached_property
     def handler_dest(self) -> str:
-        """
-        Destination of handler
-        """
+        """Destination of handler."""
         return f":handler:{self._prefix or ''}"
 
     def _add_handler(self, handler, name, aliases):
@@ -454,8 +439,7 @@ def _add_handler(self, handler, name, aliases):
     def create_command_group(
         self, name: str, *, aliases: Sequence[str] = (), help_text: str = None
     ) -> "CommandGroup":
-        """
-        Create a command group
+        """Create a command group.
 
         :param name: Name of the command group
         :param aliases: A sequence a name aliases for this command group.
@@ -481,19 +465,23 @@ def command(
         name: str = None,
         aliases: Sequence[str] = (),
         help_text: str = None,
+        loglevel: int = logging.INFO
     ) -> CommandProxy:
-        """
-        Decorator for registering handlers.
+        """Decorator for registering handlers.
 
         :param handler: Handler function
         :param name: Optional name to use for CLI; defaults to the function name.
         :param aliases: A sequence a name aliases for this command.
         :param help_text: Information provided to the user if help is invoked;
             default is taken from the handlers doc string.
+        :param loglevel: The default log-level when using this command.
 
         .. versionchanged:: 4.3
             Async handlers supported.
 
+        .. versionchanged:: 4.15
+            Add loglevel option to allow per-command log levels to be set.
+
         """
 
         def inner(func: Handler) -> CommandProxy:
@@ -520,8 +508,7 @@ def inner(func: Handler) -> CommandProxy:
         return inner(handler) if handler else inner
 
     def default(self, handler: Handler):
-        """
-        Decorator for registering a default handler.
+        """Decorator for registering a default handler.
 
         .. versionchanged:: 4.3
             Async handlers supported.
@@ -534,21 +521,19 @@ def default(self, handler: Handler):
         return handler
 
     def default_handler(self, _: argparse.Namespace) -> int:
-        """
-        Handler called if no handler is specified
-        """
+        """Handler called if no handler is specified."""
         print("No command specified!")
         self.parser.print_usage()
         return 1
 
-    def dispatch_handler(self, opts: argparse.Namespace) -> int:
-        """
-        Resolve the correct handler and call it with supplied options namespace.
-        """
+    def resolve_handler(self, opts: argparse.Namespace) -> Handler:
+        """Resolve a command handler."""
         handler_name = getattr(opts, self.handler_dest, None)
-
         if self._prefix:
             handler_name = f"{self._prefix}:{handler_name}"
-        handler = self._handlers.get(handler_name, self._default_handler)
+        return self._handlers.get(handler_name, self._default_handler)
 
+    def dispatch_handler(self, opts: argparse.Namespace) -> int:
+        """Resolve the correct handler and call it with supplied options namespace."""
+        handler = self.resolve_handler(opts)
         return handler(opts)

src/pyapp/app/init_logger.py

@@ -25,7 +25,9 @@ def replay(self):
         """Replay stored log records"""
 
         for record in self._store:
-            logging.getLogger(record.name).handle(record)
+            logger = logging.getLogger(record.name)
+            if logger.isEnabledFor(record.levelno):
+                logger.handle(record)
         self._store.clear()
 
     def emit(self, record: logging.LogRecord) -> None:

src/pyapp/exceptions.py

@@ -5,6 +5,22 @@
 Collection of standard exceptions.
 
 """
+from typing import Optional
+
+
+class ApplicationExit(SystemExit):
+    """Exception used to directly exit a PyApp application.
+
+    Will be caught by the CliApplication instance."""
+    def __init__(self, status_code: int, message: Optional[str] = None):
+        super().__init__(status_code)
+        self.status_code = status_code
+        self.message = message
+
+    def __str__(self):
+        if self.message:
+            return self.message
+        return f"Application exit: {self.status_code}"
 
 
 class InvalidConfiguration(Exception):

tests/unit/app/test_app.py

@@ -62,7 +62,7 @@ def test_dispatch__keyboard_interrupt(self):
         with pytest.raises(SystemExit) as ex:
             target.dispatch(args=("cheeky",))
 
-        assert ex.value.code == -2
+        assert ex.value.code == 2
 
     def test_dispatch__return_status(self):
         target = tests.unit.sample_app.__main__.app