appier 1.31.4__py2.py3-none-any.whl → 1.32.0__py2.py3-none-any.whl

appier/log.py

@@ -2,7 +2,7 @@
 # -*- coding: utf-8 -*-
 
 # Hive Appier Framework
-# Copyright (c) 2008-2022 Hive Solutions Lda.
+# Copyright (c) 2008-2024 Hive Solutions Lda.
 #
 # This file is part of Hive Appier Framework.
 #
@@ -22,16 +22,7 @@
 __author__ = "João Magalhães <joamag@hive.pt>"
 """ The author(s) of the module """
 
-__version__ = "1.0.0"
-""" The version of the module """
-
-__revision__ = "$LastChangedRevision$"
-""" The revision number of the module """
-
-__date__ = "$LastChangedDate$"
-""" The last change date of the module """
-
-__copyright__ = "Copyright (c) 2008-2022 Hive Solutions Lda."
+__copyright__ = "Copyright (c) 2008-2024 Hive Solutions Lda."
 """ The copyright for the module """
 
 __license__ = "Apache License, Version 2.0"
@@ -61,12 +52,12 @@ multiple stream handlers, this version of the string
 includes the thread identification number and should be
 used for messages called from outside the main thread """
 
-LOGGING_EXTRA = "[%(name)s] " if config.conf("LOGGING_EXTRA", cast = bool) else ""
+LOGGING_EXTRA = "[%(name)s] " if config.conf("LOGGING_EXTRA", cast=bool) else ""
 """ The extra logging attributes that are going to be applied
 to the format strings to obtain the final on the logging """
 
-LOGGIGN_SYSLOG = "1 %%(asctime)s %%(hostname)s %s %%(process)d %%(thread)d \
-[appierSDID@0 tid=\"%%(thread)d\"] %%(json)s"
+LOGGIGN_SYSLOG = '1 %%(asctime)s %%(hostname)s %s %%(process)d %%(thread)d \
+[appierSDID@0 tid="%%(thread)d"] %%(json)s'
 """ The format to be used for the message sent using the syslog
 logger, should contain extra structured data """
 
@@ -81,34 +72,29 @@ SILENT = logging.CRITICAL + 1
 or an handler, this is used as an utility for debugging
 purposes more that a real feature for production systems """
 
-LEVELS = (
-    "DEBUG",
-    "INFO",
-    "WARNING",
-    "ERROR",
-    "CRITICAL"
-)
+LEVELS = ("DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL")
 """ The sequence of levels from the least sever to the
 most sever this sequence may be used to find all the
 levels that are considered more sever that a level """
 
 LEVEL_ALIAS = {
-    "DEBU" : "DEBUG",
-    "WARN" : "WARNING",
-    "INF" : "INFO",
-    "ERR" : "ERROR",
-    "CRIT" : "CRITICAL"
+    "DEBU": "DEBUG",
+    "WARN": "WARNING",
+    "INF": "INFO",
+    "ERR": "ERROR",
+    "CRIT": "CRITICAL",
 }
 """ Map defining a series of alias that may be used latter
 for proper debug level resolution """
 
-SYSLOG_PORTS = dict(tcp = 601, udp = 514)
+SYSLOG_PORTS = dict(tcp=601, udp=514)
 """ Dictionary that maps the multiple transport protocol
 used by syslog with the appropriate default ports """
 
 LOGGING_FORMAT = LOGGING_FORMAT_T % LOGGING_EXTRA
 LOGGING_FORMAT_TID = LOGGING_FORMAT_TID_T % LOGGING_EXTRA
 
+
 class MemoryHandler(logging.Handler):
     """
     Logging handler that is used to store information in
@@ -116,8 +102,8 @@ class MemoryHandler(logging.Handler):
     long as the execution session is the same.
     """
 
-    def __init__(self, level = logging.NOTSET, max_length = MAX_LENGTH):
-        logging.Handler.__init__(self, level = level)
+    def __init__(self, level=logging.NOTSET, max_length=MAX_LENGTH):
+        logging.Handler.__init__(self, level=level)
         self.max_length = max_length
         self.messages = collections.deque()
         self.messages_l = dict()
@@ -133,12 +119,14 @@ class MemoryHandler(logging.Handler):
     def get_messages_l(self, level):
         # in case the level is not found in the list of levels
         # it's not considered valid and so an empty list is returned
-        try: index = LEVELS.index(level)
-        except Exception: return collections.deque()
+        try:
+            index = LEVELS.index(level)
+        except Exception:
+            return collections.deque()
 
         # retrieves the complete set of levels that are considered
         # equal or more severe than the requested one
-        levels = LEVELS[:index + 1]
+        levels = LEVELS[: index + 1]
 
         # creates the list that will hold the various message
         # lists associated with the current severity level
@@ -149,7 +137,8 @@ class MemoryHandler(logging.Handler):
         # list to the list of message lists
         for level in levels:
             _messages_l = self.messages_l.get(level, None)
-            if _messages_l == None: _messages_l = collections.deque()
+            if _messages_l == None:
+                _messages_l = collections.deque()
             self.messages_l[level] = _messages_l
             messages_l.append(_messages_l)
 
@@ -175,7 +164,8 @@ class MemoryHandler(logging.Handler):
         # the one defined as maximum must pop message from queue
         self.messages.appendleft(message)
         messages_s = len(self.messages)
-        if messages_s > self.max_length: self.messages.pop()
+        if messages_s > self.max_length:
+            self.messages.pop()
 
         # iterates over all the messages list included in the retrieve
         # messages list to add the logging message to each of them
@@ -185,42 +175,42 @@ class MemoryHandler(logging.Handler):
             # specified also for the more general queue
             _messages_l.appendleft(message)
             messages_s = len(_messages_l)
-            if messages_s > self.max_length: _messages_l.pop()
+            if messages_s > self.max_length:
+                _messages_l.pop()
 
     def clear(self):
         self.messages = collections.deque()
         self.messages_l = dict()
 
-    def get_latest(self, count = None, level = None):
+    def get_latest(self, count=None, level=None):
         count = count or 100
         is_level = level and not legacy.is_string(level)
-        if is_level: level = logging.getLevelName(level)
+        if is_level:
+            level = logging.getLevelName(level)
         level = level.upper() if level else level
         level = LEVEL_ALIAS.get(level, level)
         messages = self.messages_l.get(level, []) if level else self.messages
         slice = itertools.islice(messages, 0, count)
         return list(slice)
 
-    def flush_to_file(
-        self,
-        path,
-        count = None,
-        level = None,
-        reverse = True,
-        clear = True
-    ):
-        messages = self.get_latest(level = level, count = count or 65536)
-        if not messages: return
-        if reverse: messages.reverse()
+    def flush_to_file(self, path, count=None, level=None, reverse=True, clear=True):
+        messages = self.get_latest(level=level, count=count or 65536)
+        if not messages:
+            return
+        if reverse:
+            messages.reverse()
         is_path = isinstance(path, legacy.STRINGS)
         file = open(path, "wb") if is_path else path
         try:
             for message in messages:
-                message = legacy.bytes(message, "utf-8", force = True)
+                message = legacy.bytes(message, "utf-8", force=True)
                 file.write(message + b"\n")
         finally:
-            if is_path: file.close()
-        if clear: self.clear()
+            if is_path:
+                file.close()
+        if clear:
+            self.clear()
+
 
 class BaseFormatter(logging.Formatter):
     """
@@ -237,19 +227,20 @@ class BaseFormatter(logging.Formatter):
 
     @classmethod
     def _wrap_record(cls, record):
-        if hasattr(record, "_wrapped"): return
+        if hasattr(record, "_wrapped"):
+            return
         record.hostname = socket.gethostname()
         record.json = json.dumps(
             dict(
-                message = str(record.msg),
-                hostname = record.hostname,
-                lineno = record.lineno,
-                module = record.module,
-                callable = record.funcName,
-                level = record.levelname,
-                thread = record.thread,
-                process = record.process,
-                logger = record.name
+                message=str(record.msg),
+                hostname=record.hostname,
+                lineno=record.lineno,
+                module=record.module,
+                callable=record.funcName,
+                level=record.levelname,
+                thread=record.thread,
+                process=record.process,
+                logger=record.name,
             )
         )
         record._wrapped = True
@@ -257,12 +248,14 @@ class BaseFormatter(logging.Formatter):
     def format(self, record):
         # runs the wrapping operation on the record so that more
         # information becomes available in it (as expected)
-        if self._wrap: self.__class__._wrap_record(record)
+        if self._wrap:
+            self.__class__._wrap_record(record)
 
         # runs the basic format operation on the record so that
         # it gets properly formatted into a plain string
         return logging.Formatter.format(self, record)
 
+
 class ThreadFormatter(BaseFormatter):
     """
     Custom formatter class that changing the default format
@@ -278,14 +271,16 @@ class ThreadFormatter(BaseFormatter):
     def format(self, record):
         # runs the wrapping operation on the record so that more
         # information becomes available in it (as expected)
-        if self._wrap: self.__class__._wrap_record(record)
+        if self._wrap:
+            self.__class__._wrap_record(record)
 
         # retrieves the reference to the current thread and verifies
         # if it represent the current process main thread, then selects
         # the appropriate formating string taking that into account
         current = threading.current_thread()
         is_main = current.name == "MainThread"
-        if not is_main: return self._tidfmt.format(record)
+        if not is_main:
+            return self._tidfmt.format(record)
         return self._basefmt.format(record)
 
     def set_base(self, value, *args, **kwargs):
@@ -294,8 +289,8 @@ class ThreadFormatter(BaseFormatter):
     def set_tid(self, value, *args, **kwargs):
         self._tidfmt = BaseFormatter(value, *args, **kwargs)
 
-class DummyLogger(object):
 
+class DummyLogger(object):
     def debug(self, object):
         pass
 
@@ -311,61 +306,59 @@ class DummyLogger(object):
     def critical(self, object):
         pass
 
-def reload_format(app = None):
+
+def reload_format(app=None):
     global LOGGING_FORMAT
     global LOGGING_FORMAT_TID
 
     app = app or common.base().get_app()
 
     extra = LOGGING_EXTRA
-    if app and not app.is_parent(): extra = "[%(process)d] " + extra
+    if app and not app.is_parent():
+        extra = "[%(process)d] " + extra
 
     LOGGING_FORMAT = LOGGING_FORMAT_T % extra
     LOGGING_FORMAT_TID = LOGGING_FORMAT_TID_T % extra
 
+
 def rotating_handler(
-    path = "appier.log",
-    max_bytes = 1048576,
-    max_log = 5,
-    encoding = None,
-    delay = False
+    path="appier.log", max_bytes=1048576, max_log=5, encoding=None, delay=False
 ):
     return logging.handlers.RotatingFileHandler(
-        path,
-        maxBytes = max_bytes,
-        backupCount = max_log,
-        encoding = encoding,
-        delay = delay
+        path, maxBytes=max_bytes, backupCount=max_log, encoding=encoding, delay=delay
     )
 
+
 def smtp_handler(
-    host = "localhost",
-    port = 25,
-    sender = "no-reply@appier.com",
-    receivers = [],
-    subject = "Appier logging",
-    username = None,
-    password = None,
-    stls = False
+    host="localhost",
+    port=25,
+    sender="no-reply@appier.com",
+    receivers=[],
+    subject="Appier logging",
+    username=None,
+    password=None,
+    stls=False,
 ):
     address = (host, port)
-    if username and password: credentials = (username, password)
-    else: credentials = None
+    if username and password:
+        credentials = (username, password)
+    else:
+        credentials = None
     has_secure = in_signature(logging.handlers.SMTPHandler.__init__, "secure")
-    if has_secure: kwargs = dict(secure = () if stls else None)
-    else: kwargs = dict()
+    if has_secure:
+        kwargs = dict(secure=() if stls else None)
+    else:
+        kwargs = dict()
     return logging.handlers.SMTPHandler(
-        address,
-        sender,
-        receivers,
-        subject,
-        credentials = credentials,
-        **kwargs
+        address, sender, receivers, subject, credentials=credentials, **kwargs
     )
 
+
 def in_signature(callable, name):
     has_full = hasattr(inspect, "getfullargspec")
-    if has_full: spec = inspect.getfullargspec(callable)
-    else: spec = inspect.getargspec(callable)
+    if has_full:
+        spec = inspect.getfullargspec(callable)
+    else:
+        spec = inspect.getargspec(callable)
     args, _varargs, kwargs = spec[:3]
     return (args and name in args) or (kwargs and "secure" in kwargs)

appier/meta.py

@@ -2,7 +2,7 @@
 # -*- coding: utf-8 -*-
 
 # Hive Appier Framework
-# Copyright (c) 2008-2022 Hive Solutions Lda.
+# Copyright (c) 2008-2024 Hive Solutions Lda.
 #
 # This file is part of Hive Appier Framework.
 #
@@ -22,16 +22,7 @@
 __author__ = "João Magalhães <joamag@hive.pt>"
 """ The author(s) of the module """
 
-__version__ = "1.0.0"
-""" The version of the module """
-
-__revision__ = "$LastChangedRevision$"
-""" The revision number of the module """
-
-__date__ = "$LastChangedDate$"
-""" The last change date of the module """
-
-__copyright__ = "Copyright (c) 2008-2022 Hive Solutions Lda."
+__copyright__ = "Copyright (c) 2008-2024 Hive Solutions Lda."
 """ The copyright for the module """
 
 __license__ = "Apache License, Version 2.0"
@@ -40,6 +31,7 @@ __license__ = "Apache License, Version 2.0"
 from . import common
 from . import legacy
 
+
 class Ordered(type):
     """
     Metaclass to be used for classes where the
@@ -49,9 +41,12 @@ class Ordered(type):
 
     def __new__(cls, name, bases, attrs):
         new_cls = super(Ordered, cls).__new__(cls, name, bases, attrs)
-        new_cls._ordered = [(name, attrs.pop(name)) for name, value in\
-            legacy.eager(attrs.items()) if hasattr(value, "creation_counter")]
-        new_cls._ordered.sort(key = lambda item: item[1].creation_counter)
+        new_cls._ordered = [
+            (name, attrs.pop(name))
+            for name, value in legacy.eager(attrs.items())
+            if hasattr(value, "creation_counter")
+        ]
+        new_cls._ordered.sort(key=lambda item: item[1].creation_counter)
         new_cls._ordered = [name for name, value in new_cls._ordered]
         return new_cls
 
@@ -59,11 +54,12 @@ class Ordered(type):
         super(Ordered, cls).__init__(name, bases, attrs)
 
     def __cmp__(self, value):
-        return cmp(self.__name__, value.__name__) #@UndefinedVariable
+        return cmp(self.__name__, value.__name__)  # @UndefinedVariable
 
     def __lt__(self, value):
         return self.__name__.__lt__(value.__name__)
 
+
 class Indexed(type):
     """
     Meta class data type for the indexing of the various route
@@ -78,21 +74,26 @@ class Indexed(type):
         # retrieves the complete set of elements in the current set of attributes
         # that are marked with the "creation counter" and then sorts these same
         # elements according to that value (sorting by order of definition)
-        ordered = [(name, attrs.pop(name)) for name, value in\
-            legacy.eager(attrs.items()) if hasattr(value, "creation_counter")]
-        ordered.sort(key = lambda item: item[1].creation_counter)
+        ordered = [
+            (name, attrs.pop(name))
+            for name, value in legacy.eager(attrs.items())
+            if hasattr(value, "creation_counter")
+        ]
+        ordered.sort(key=lambda item: item[1].creation_counter)
 
         # in case there's no ordered related values there's nothing remaining
         # to be done under this class creation and so the created class must
         # be returned immediately to the caller method
-        if not ordered: return new_cls
+        if not ordered:
+            return new_cls
 
         # retrieves the reference to the current global application instance
         # and verifies if the global (cache) base registered value is defined
         # in case it's not defines it as it's going to be used to avoid the
         # duplicated registration of routes
         app = common.base().App
-        if not hasattr(app, "_BASE_REGISTERED"): app._BASE_REGISTERED = []
+        if not hasattr(app, "_BASE_REGISTERED"):
+            app._BASE_REGISTERED = []
         registered = app._BASE_REGISTERED
 
         # iterates over the complete set of ordered elements to be able to
@@ -102,7 +103,9 @@ class Indexed(type):
             # to be able to register each of them properly
             routes = function._routes if hasattr(function, "_routes") else []
             errors = function._errors if hasattr(function, "_errors") else []
-            exceptions = function._exceptions if hasattr(function, "_exceptions") else []
+            exceptions = (
+                function._exceptions if hasattr(function, "_exceptions") else []
+            )
             customs = function._customs if hasattr(function, "_customs") else []
 
             # iterates over the complete set of routes associated with the current
@@ -121,7 +124,8 @@ class Indexed(type):
                 # that's the situation continues the loop to be able to
                 # avoid duplicated route registration (possible with imports)
                 route_t = (method, url)
-                if route_t in registered: continue
+                if route_t in registered:
+                    continue
                 registered.append(route_t)
 
                 # adds the new route to the application using the provided/unpacked
@@ -130,11 +134,11 @@ class Indexed(type):
                     method,
                     url,
                     function,
-                    asynchronous = asynchronous,
-                    json = json,
-                    opts = opts,
-                    context = new_name,
-                    priority = priority
+                    asynchronous=asynchronous,
+                    json=json,
+                    opts=opts,
+                    context=new_name,
+                    priority=priority,
                 )
 
             for error in errors:
@@ -142,11 +146,11 @@ class Indexed(type):
                 app.add_error(
                     code,
                     function,
-                    scope = scope,
-                    json = json,
-                    opts = opts,
-                    context = new_name,
-                    priority = priority
+                    scope=scope,
+                    json=json,
+                    opts=opts,
+                    context=new_name,
+                    priority=priority,
                 )
 
             for exception in exceptions:
@@ -154,21 +158,17 @@ class Indexed(type):
                 app.add_exception(
                     exception,
                     function,
-                    scope = scope,
-                    json = json,
-                    opts = opts,
-                    context = new_name,
-                    priority = priority
+                    scope=scope,
+                    json=json,
+                    opts=opts,
+                    context=new_name,
+                    priority=priority,
                 )
 
             for custom in customs:
                 key, opts, priority = custom
                 app.add_custom(
-                    key,
-                    function,
-                    opts = opts,
-                    context = new_name,
-                    priority = priority
+                    key, function, opts=opts, context=new_name, priority=priority
                 )
 
         return new_cls

appier/mock.py

@@ -2,7 +2,7 @@
 # -*- coding: utf-8 -*-
 
 # Hive Appier Framework
-# Copyright (c) 2008-2022 Hive Solutions Lda.
+# Copyright (c) 2008-2024 Hive Solutions Lda.
 #
 # This file is part of Hive Appier Framework.
 #
@@ -22,16 +22,7 @@
 __author__ = "João Magalhães <joamag@hive.pt>"
 """ The author(s) of the module """
 
-__version__ = "1.0.0"
-""" The version of the module """
-
-__revision__ = "$LastChangedRevision$"
-""" The revision number of the module """
-
-__date__ = "$LastChangedDate$"
-""" The last change date of the module """
-
-__copyright__ = "Copyright (c) 2008-2022 Hive Solutions Lda."
+__copyright__ = "Copyright (c) 2008-2024 Hive Solutions Lda."
 """ The copyright for the module """
 
 __license__ = "Apache License, Version 2.0"
@@ -40,16 +31,18 @@ __license__ = "Apache License, Version 2.0"
 from . import util
 from . import legacy
 
-class MockObject(object):
 
+class MockObject(object):
     def __init__(self, *args, **kwargs):
         self.model = kwargs
 
     def __getattribute__(self, name):
         try:
             model = object.__getattribute__(self, "model")
-            if name in model: return model[name]
-        except AttributeError: pass
+            if name in model:
+                return model[name]
+        except AttributeError:
+            pass
         return object.__getattribute__(self, name)
 
     def __getitem__(self, key):
@@ -61,8 +54,8 @@ class MockObject(object):
     def __delitem__(self, key):
         self.model.__delitem__(key)
 
-class MockResponse(MockObject):
 
+class MockResponse(MockObject):
     def read(self):
         return self.data
 
@@ -78,8 +71,8 @@ class MockResponse(MockObject):
     def info(self):
         return self.headers
 
-class MockApp(object):
 
+class MockApp(object):
     def get(self, *args, **kwargs):
         return self.method("GET", *args, **kwargs)
 
@@ -102,11 +95,11 @@ class MockApp(object):
         self,
         method,
         location,
-        query = "",
-        data = b"",
-        scheme = "http",
-        address = "127.0.0.1",
-        headers = {}
+        query="",
+        data=b"",
+        scheme="http",
+        address="127.0.0.1",
+        headers={},
     ):
         # creates the dictionary that is going to hold the (initial)
         # response structure and the "encapsulates" the provided data
@@ -116,33 +109,37 @@ class MockApp(object):
 
         # verifies if the location contains a query part (question mark)
         # and if that's the case splits the location in the two parts
-        if "?" in location: location, query = location.split("?", 1)
+        if "?" in location:
+            location, query = location.split("?", 1)
 
         # builds the map that is going to be used as the basis for the
         # construction of the request, this map should be compliant with
         # the WSGI standard and expectancy
         environ = {
-            "REQUEST_METHOD" : method,
-            "PATH_INFO" : location,
-            "QUERY_STRING" : query,
-            "SCRIPT_NAME" : location,
-            "CONTENT_LENGTH" : len(data),
-            "REMOTE_ADDR" : address,
-            "wsgi.input" : input,
-            "wsgi.url_scheme" : scheme
+            "REQUEST_METHOD": method,
+            "PATH_INFO": location,
+            "QUERY_STRING": query,
+            "SCRIPT_NAME": location,
+            "CONTENT_LENGTH": len(data),
+            "REMOTE_ADDR": address,
+            "wsgi.input": input,
+            "wsgi.url_scheme": scheme,
         }
 
         # iterates over the complete set of provided header value to set
         # them with the proper HTTP_ prefix in the environment map
-        for name, value in headers: environ["HTTP_" + name.upper()] = value
+        for name, value in headers:
+            environ["HTTP_" + name.upper()] = value
 
         def start_response(code, headers):
             # splits the provided code string into its component
             # verifying defaulting the status of the code to an
             # empty string in case none is defined (only code)
             code_s = code.split(" ", 1)
-            if len(code_s) == 1: code, status = code_s[0], ""
-            else: code, status = code_s
+            if len(code_s) == 1:
+                code, status = code_s[0], ""
+            else:
+                code, status = code_s
 
             # converts the code into the integer representation
             # so that its type is coherent with specification
@@ -164,6 +161,7 @@ class MockApp(object):
         # "safe" context that replaces the current application's context
         # in a proper way so that at the end of the call it's properly
         # restored as expected by a possible control flow
-        with util.ctx_request(self): result = self.application(environ, start_response)
+        with util.ctx_request(self):
+            result = self.application(environ, start_response)
         response["data"] = b"".join(result)
         return MockResponse(**response)