log21 2.9.1__tar.gz → 2.10.0__tar.gz

{log21-2.9.1/src/log21.egg-info → log21-2.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: log21
-Version: 2.9.1
+Version: 2.10.0
 Summary: A simple logging package that helps you log colorized messages in Windows console.
 Author-email: "CodeWriter21(Mehrad Pooryoussof)" <CodeWriter21@gmail.com>
 License: Apache License 2.0
@@ -92,9 +92,11 @@ pip install git+https://github.com/MPCodeWriter21/log21
 Changes
 -------
 
-### 2.9.1
+### 2.10.0
 
-+ Update `README.md`.
++ Added some exception classes to raise in the "argumentified" functions to show 
+  *parser error* to the user: `ArgumentError`, `IncompatibleArguments`,
+  `RequiredArgument`, `TooFewArguments`
 
 [Full CHANGELOG](https://github.com/MPCodeWriter21/log21/blob/master/CHANGELOG.md)
 

{log21-2.9.1 → log21-2.10.0}/README.md

@@ -61,9 +61,11 @@ pip install git+https://github.com/MPCodeWriter21/log21
 Changes
 -------
 
-### 2.9.1
+### 2.10.0
 
-+ Update `README.md`.
++ Added some exception classes to raise in the "argumentified" functions to show 
+  *parser error* to the user: `ArgumentError`, `IncompatibleArguments`,
+  `RequiredArgument`, `TooFewArguments`
 
 [Full CHANGELOG](https://github.com/MPCodeWriter21/log21/blob/master/CHANGELOG.md)
 

{log21-2.9.1 → log21-2.10.0}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "log21"
 authors = [
-  {name = "CodeWriter21(Mehrad Pooryoussof)", email = "CodeWriter21@gmail.com"}
+    {name = "CodeWriter21(Mehrad Pooryoussof)", email = "CodeWriter21@gmail.com"}
 ]
 description = "A simple logging package that helps you log colorized messages in Windows console."
 readme = {file = "README.md", content-type = "text/markdown"}
@@ -13,20 +13,20 @@ requires-python = ">=3.8"
 keywords = ['python', 'log', 'colorize', 'color', 'logging', 'Python3', 'CodeWriter21']
 license = {text = "Apache License 2.0"}
 classifiers = [
-  "Intended Audience :: Developers",
-  "Programming Language :: Python :: 3",
-  "Programming Language :: Python :: 3.7",
-  "Programming Language :: Python :: 3.10",
-  "Programming Language :: Python :: 3.11",
-  "Operating System :: Unix",
-  "Operating System :: Microsoft :: Windows",
-  "Operating System :: MacOS :: MacOS X"
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Operating System :: Unix",
+    "Operating System :: Microsoft :: Windows",
+    "Operating System :: MacOS :: MacOS X"
 ]
 dependencies = [
-  "webcolors",
-  "docstring-parser"
+    "webcolors",
+    "docstring-parser"
 ]
-version = "2.9.1"
+version = "2.10.0"
 
 [tool.setuptools.packages.find]
 where = ["src"]
@@ -43,11 +43,11 @@ dev = ["yapf", "isort", "docformatter", "pylint", "json5", "pytest"]
 max-line-length = 88
 
 disable = [
-  "too-few-public-methods",
-  "too-many-arguments",
-  "protected-access",
-  "too-many-locals",
-  "fixme",
+    "too-few-public-methods",
+    "too-many-arguments",
+    "protected-access",
+    "too-many-locals",
+    "fixme",
 ]
 
 [tool.pylint.design]

{log21-2.9.1 → log21-2.10.0}/src/log21/Argparse.py

@@ -8,9 +8,10 @@ import sys as _sys
 import types as _types
 import typing as _typing
 import argparse as _argparse
+import collections.abc
 from enum import Enum as _Enum
-from typing import (Tuple as _Tuple, Mapping as _Mapping, Optional as _Optional,
-                    Sequence as _Sequence)
+from typing import (Tuple as _Tuple, Mapping as _Mapping, NoReturn,
+                    Optional as _Optional, Sequence as _Sequence)
 from gettext import gettext as _gettext
 from textwrap import TextWrapper as _TextWrapper
 from collections import OrderedDict as _OrderedDict
@@ -78,7 +79,7 @@ class ColorizingHelpFormatter(_argparse.HelpFormatter):
                 if key in self.colors:
                     self.colors[key] = value
 
-    class _Section(object):
+    class _Section:
 
         def __init__(self, formatter, parent, heading=None):
             self.formatter = formatter
@@ -561,10 +562,32 @@ class _ActionsContainer(_argparse._ActionsContainer):
               and isinstance(func_type, _typing._LiteralGenericAlias)):  # type: ignore
             func_type = Literal(func_type)
 
+        # Handle `Union` and `Optional` as a type (e.g. `Union[int, str]` and
+        # `Optional[int]`)
+        elif (hasattr(_typing, '_UnionGenericAlias')
+              and isinstance(func_type, _typing._UnionGenericAlias)):  # type: ignore
+            # Optional[T] is just Union[T, NoneType]
+            # Optional
+            if (hasattr(_types, 'NoneType') and len(func_type.__args__) == 2
+                    and func_type.__args__[1] is _types.NoneType):
+                action.required = False
+                func_type = func_type.__args__[0]
+            # Union
+            else:
+                func_type = func_type.__args__  # type: ignore
+
         # Handle `List` as a type (e.g. `List[int]`)
         elif (hasattr(_typing, '_GenericAlias')
               and isinstance(func_type, _typing._GenericAlias)  # type: ignore
-              and func_type.__origin__ is list):
+              and getattr(func_type, '__origin__') is list):
+            func_type = func_type.__args__[0]
+            if kwargs.get('nargs') is None:
+                action.nargs = '+'
+
+        # Handle `Sequence` as a type (e.g. `Sequence[int]`)
+        elif (hasattr(_typing, '_GenericAlias')
+              and isinstance(func_type, _typing._GenericAlias)  # type: ignore
+              and getattr(func_type, '__origin__') is collections.abc.Sequence):
             func_type = func_type.__args__[0]
             if kwargs.get('nargs') is None:
                 action.nargs = '+'
@@ -572,25 +595,10 @@ class _ActionsContainer(_argparse._ActionsContainer):
         # Handle `Required` as a type (e.g. `Required[int]`)
         elif (hasattr(_typing, 'Required') and hasattr(_typing, '_GenericAlias')
               and isinstance(func_type, _typing._GenericAlias)  # type: ignore
-              and func_type.__origin__ is _typing.Required
-              ):
+              and getattr(func_type, '__origin__') is _typing.Required):
             func_type = func_type.__args__[0]
             action.required = True
 
-        # Handle `Union` and `Optional` as a type (e.g. `Union[int, str]` and
-        # `Optional[int]`)
-        elif (hasattr(_types, 'NoneType') and hasattr(_typing, '_UnionGenericAlias')
-              and isinstance(func_type, _typing._UnionGenericAlias)):  # type: ignore
-            # Optional[T] is just Union[T, NoneType]
-            # Optional
-            if (len(func_type.__args__) == 2
-                    and func_type.__args__[1] is _types.NoneType):
-                action.required = False
-                func_type = func_type.__args__[0]
-            # Union
-            else:
-                func_type = func_type.__args__  # type: ignore
-
         # Handle Enum as a type
         elif callable(func_type) and isinstance(func_type, type) and issubclass(
                 func_type, _Enum) and action.choices is None and level == 0:
@@ -747,16 +755,15 @@ class ColorizingArgumentParser(_argparse.ArgumentParser, _ActionsContainer):
                 f'%(prog)s: {_gc("r")}error{_gc("lr")}:{_gc("rst")} %(message)s\n'
             ) % args
         )
+        return NoReturn
 
     def _get_formatter(self):
         if hasattr(self.formatter_class, 'colors'):
             return self.formatter_class(prog=self.prog, colors=self.colors)
-        else:
-            return self.formatter_class(prog=self.prog)
+        return self.formatter_class(prog=self.prog)
 
     def _get_value(self, action, arg_string):
-        """Override _get_value to add support for types such as Union and
-        Literal."""
+        """Override _get_value to add support for types such as Union and Literal."""
 
         func_type = self._registry_get('type', action.type, action.type)
         if not callable(func_type) and not isinstance(func_type, tuple):
@@ -842,13 +849,14 @@ class ColorizingArgumentParser(_argparse.ArgumentParser, _ActionsContainer):
         for arg_string in arg_strings:
 
             # for regular arguments, just add them back into the list
-            if not arg_string or arg_string[0] not in self.fromfile_prefix_chars:
+            if not arg_string or arg_string[0] not in (self.fromfile_prefix_chars
+                                                       or ''):
                 new_arg_strings.append(arg_string)
 
             # replace arguments referencing files with the file content
             else:
                 try:
-                    with open(arg_string[1:]) as args_file:
+                    with open(arg_string[1:], encoding='utf-8') as args_file:
                         arg_strings = []
                         for arg_line in args_file.read().splitlines():
                             for arg in self.convert_arg_line_to_args(arg_line):
@@ -1110,7 +1118,11 @@ class ColorizingArgumentParser(_argparse.ArgumentParser, _ActionsContainer):
                         if action.help is not _argparse.SUPPRESS
                     ]
                     self.error(
-                        _gettext(f'one of the arguments {" ".join(names)} is required')
+                        _gettext(
+                            'one of the arguments ' +
+                            ' '.join(name for name in names if name is not None) +
+                            ' is required'
+                        )
                     )
 
         for group in self._action_groups:
@@ -1127,7 +1139,11 @@ class ColorizingArgumentParser(_argparse.ArgumentParser, _ActionsContainer):
                         if action.help is not _argparse.SUPPRESS
                     ]
                     self.error(
-                        _gettext(f'one of the arguments {" ".join(names)} is required')
+                        _gettext(
+                            'one of the arguments ' +
+                            ' '.join(name for name in names if name is not None) +
+                            ' is required'
+                        )
                     )
 
         # return the updated namespace and the extra arguments

{log21-2.9.1 → log21-2.10.0}/src/log21/Argumentify.py

@@ -18,7 +18,8 @@ import log21.Argparse as _Argparse
 __all__ = [
     'argumentify', 'ArgumentifyError', 'ArgumentTypeError', 'FlagGenerationError',
     'RESERVED_FLAGS', 'Callable', 'Argument', 'FunctionInfo', 'generate_flag',
-    'normalize_name', 'normalize_name_to_snake_case'
+    'normalize_name', 'normalize_name_to_snake_case', 'ArgumentError',
+    'IncompatibleArguments', 'RequiredArgument', 'TooFewArguments'
 ]
 
 Callable = _Union[_Callable[..., _Any], _Callable[..., _Coroutine[_Any, _Any, _Any]]]
@@ -76,6 +77,90 @@ class FlagGenerationError(ArgumentifyError, RuntimeError):
         self.arg_name = arg_name
 
 
+class ArgumentError(ArgumentifyError):
+    """Base of errors to raise in the argumentified functions to raise parser errors."""
+
+    def __init__(self, *args, message: _Optional[str] = None):
+        """Initialize the exception.
+
+        :param args: The arguments that have a problem.
+        :param message: The error message to show.
+        """
+        if message is None:
+            if args:
+                if len(args) > 1:
+                    message = "There is a problem with the arguments: " + ', '.join(
+                        f"`{arg}`" for arg in args
+                    )
+                else:
+                    message = "The argument `" + args[0] + "` is invalid."
+        self.message = message
+        self.arguments = args
+
+
+class IncompatibleArguments(ArgumentError):
+    """Raise when the user has used arguments that are incompatible with each other."""
+
+    def __init__(self, *args, message: _Optional[str] = None):
+        """Initialize the exception.
+
+        :param args: The arguments that are incompatible.
+        :param message: The error message to show.
+        """
+        super().__init__(*args, message)
+        if message is None:
+            if args:
+                if len(args) > 1:
+                    message = "You cannot use all these together: " + ', '.join(
+                        f"`{arg}`" for arg in args
+                    )
+                else:
+                    message = "The argument `" + args[0] + "` is not compatible."
+        self.message = message
+
+
+class RequiredArgument(ArgumentError):
+    """Raise this when there is a required argument missing."""
+
+    def __init__(self, *args, message: _Optional[str] = None):
+        """Initialize the exception.
+
+        :param args: The arguments that are required.
+        :param message: The error message to show.
+        """
+        super().__init__(*args, message)
+        if message is None:
+            if args:
+                if len(args) > 1:
+                    message = "These arguments are required: " + ', '.join(
+                        f"`{arg}`" for arg in args
+                    )
+                else:
+                    message = "The argument `" + args[0] + "` is required."
+        self.message = message
+
+
+class TooFewArguments(ArgumentError):
+    """Raise this when there were not enough arguments passed."""
+
+    def __init__(self, *args, message: _Optional[str] = None):
+        """Initialize the exception.
+
+        :param args: The arguments that should be passed.
+        :param message: The error message to show.
+        """
+        super().__init__(*args, message)
+        if message is None:
+            if args:
+                if len(args) > 1:
+                    message = "You should use these arguments: " + ', '.join(
+                        f"`{arg}`" for arg in args
+                    )
+                else:
+                    message = "The argument `" + args[0] + "` should be used."
+        self.message = message
+
+
 def normalize_name_to_snake_case(name: str, sep_char: str = '_') -> str:
     """Returns the normalized name a class.
 
@@ -262,11 +347,10 @@ def _add_arguments(
             'dest': argument.name,
             'help': argument.help
         }
-        if isinstance(argument.annotation, type):
-            config['type'] = argument.annotation
         if argument.annotation == bool:
             config['action'] = 'store_true'
-            config.pop('type')
+        elif argument.annotation:
+            config['type'] = argument.annotation
         if argument.kind == _inspect._ParameterKind.POSITIONAL_ONLY:
             config['required'] = True
         if argument.kind == _inspect._ParameterKind.VAR_POSITIONAL:
@@ -279,8 +363,7 @@ def _add_arguments(
 
 
 def _argumentify_one(func: Callable):
-    """This function argumentifies one function as the entry point of the
-    script.
+    """This function argumentifies one function as the entry point of the script.
 
     :param function: The function to argumentify.
     """
@@ -313,15 +396,18 @@ def _argumentify_one(func: Callable):
             args.extend(getattr(cli_args, argument.name) or [])
         else:
             kwargs[argument.name] = getattr(cli_args, argument.name)
-    result = func(*args, **kwargs)
-    # Check if the result is a coroutine
-    if isinstance(result, (_Coroutine, _Awaitable)):
-        _asyncio.run(result)
+    try:
+        result = func(*args, **kwargs)
+        # Check if the result is a coroutine
+        if isinstance(result, (_Coroutine, _Awaitable)):
+            _asyncio.run(result)
+    except ArgumentError as error:
+        parser.error(error.message)
 
 
 def _argumentify(functions: _Dict[str, Callable]):
-    """This function argumentifies one or more functions as the entry point of
-    the script.
+    """This function argumentifies one or more functions as the entry point of the
+    script.
 
     :param functions: A dictionary of functions to argumentify.
     :raises RuntimeError:
@@ -362,15 +448,18 @@ def _argumentify(functions: _Dict[str, Callable]):
             args.extend(getattr(cli_args, argument.name) or [])
         else:
             kwargs[argument.name] = getattr(cli_args, argument.name)
-    result = function(*args, **kwargs)
-    # Check if the result is a coroutine
-    if isinstance(result, (_Coroutine, _Awaitable)):
-        _asyncio.run(result)
+    try:
+        result = function(*args, **kwargs)
+        # Check if the result is a coroutine
+        if isinstance(result, (_Coroutine, _Awaitable)):
+            _asyncio.run(result)
+    except ArgumentError as error:
+        parser.error(error.message)
 
 
 def argumentify(entry_point: _Union[Callable, _List[Callable], _Dict[str, Callable]]):
-    """This function argumentifies one or more functions as the entry point of
-    the script.
+    """This function argumentifies one or more functions as the entry point of the
+    script.
 
      1 #!/usr/bin/env python
      2 # argumentified.py

{log21-2.9.1 → log21-2.10.0}/src/log21/__init__.py

@@ -16,14 +16,15 @@ from .Manager import Manager
 from .Argparse import ColorizingArgumentParser
 from .TreePrint import TreePrint, tree_format
 from .Formatters import ColorizingFormatter, DecolorizingFormatter, _Formatter
-from .Argumentify import argumentify
+from .Argumentify import (ArgumentError, TooFewArguments, RequiredArgument,
+                          IncompatibleArguments, argumentify)
 from .FileHandler import FileHandler, DecolorizingFileHandler
 from .ProgressBar import ProgressBar
 from .LoggingWindow import LoggingWindow, LoggingWindowHandler
 from .StreamHandler import StreamHandler, ColorizingStreamHandler
 
 __author__ = 'CodeWriter21 (Mehrad Pooryoussof)'
-__version__ = '2.9.1'
+__version__ = '2.10.0'
 __github__ = 'Https://GitHub.com/MPCodeWriter21/log21'
 __all__ = [
     'ColorizingStreamHandler', 'DecolorizingFileHandler', 'ColorizingFormatter',
@@ -35,7 +36,8 @@ __all__ = [
     'debug', 'info', 'warning', 'warn', 'error', 'critical', 'fatal', 'exception',
     'log', 'basic_config', 'basicConfig', 'ProgressBar', 'progress_bar',
     'LoggingWindow', 'LoggingWindowHandler', 'get_logging_window', 'CrashReporter',
-    'console_reporter', 'file_reporter', 'argumentify'
+    'console_reporter', 'file_reporter', 'argumentify', 'ArgumentError',
+    'IncompatibleArguments', 'RequiredArgument', 'TooFewArguments'
 ]
 
 _manager = Manager()

{log21-2.9.1 → log21-2.10.0/src/log21.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: log21
-Version: 2.9.1
+Version: 2.10.0
 Summary: A simple logging package that helps you log colorized messages in Windows console.
 Author-email: "CodeWriter21(Mehrad Pooryoussof)" <CodeWriter21@gmail.com>
 License: Apache License 2.0
@@ -92,9 +92,11 @@ pip install git+https://github.com/MPCodeWriter21/log21
 Changes
 -------
 
-### 2.9.1
+### 2.10.0
 
-+ Update `README.md`.
++ Added some exception classes to raise in the "argumentified" functions to show 
+  *parser error* to the user: `ArgumentError`, `IncompatibleArguments`,
+  `RequiredArgument`, `TooFewArguments`
 
 [Full CHANGELOG](https://github.com/MPCodeWriter21/log21/blob/master/CHANGELOG.md)