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

appier/bus.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"
@@ -47,12 +38,13 @@ from . import redisdb
 from . import component
 from . import exceptions
 
-class Bus(component.Component):
 
-    def __init__(self, name = "bus", owner = None, *args, **kwargs):
-        component.Component.__init__(self, name = name, owner = owner, *args, **kwargs)
+class Bus(component.Component):
+    def __init__(self, name="bus", owner=None, *args, **kwargs):
+        component.Component.__init__(self, name=name, owner=owner, *args, **kwargs)
         load = kwargs.pop("load", True)
-        if load: self.load(*args, **kwargs)
+        if load:
+            self.load(*args, **kwargs)
 
     @classmethod
     def new(cls, *args, **kwargs):
@@ -61,30 +53,33 @@ class Bus(component.Component):
     def bind(self, name, method):
         raise exceptions.NotImplementedError()
 
-    def unbind(self, name, method = None):
+    def unbind(self, name, method=None):
         raise exceptions.NotImplementedError()
 
     def trigger(self, name, *args, **kwargs):
         raise exceptions.NotImplementedError()
 
-class MemoryBus(Bus):
 
-    def __init__(self, name = "memory", owner = None, *args, **kwargs):
-        Bus.__init__(self, name = name, owner = owner, *args, **kwargs)
+class MemoryBus(Bus):
+    def __init__(self, name="memory", owner=None, *args, **kwargs):
+        Bus.__init__(self, name=name, owner=owner, *args, **kwargs)
 
     def bind(self, name, method):
         methods = self._events.get(name, [])
         methods.append(method)
         self._events[name] = methods
 
-    def unbind(self, name, method = None):
+    def unbind(self, name, method=None):
         methods = self._events.get(name, [])
-        if method: methods.remove(method)
-        else: del methods[:]
+        if method:
+            methods.remove(method)
+        else:
+            del methods[:]
 
     def trigger(self, name, *args, **kwargs):
         methods = self._events.get(name, [])
-        for method in methods: method(*args, **kwargs)
+        for method in methods:
+            method(*args, **kwargs)
 
     def _load(self, *args, **kwargs):
         Bus._load(self, *args, **kwargs)
@@ -96,7 +91,7 @@ class MemoryBus(Bus):
 
     def _get_state(self):
         state = Bus._get_state(self)
-        state.update(_events = self._events)
+        state.update(_events=self._events)
         return state
 
     def _set_state(self, state):
@@ -106,8 +101,8 @@ class MemoryBus(Bus):
             for method in methods:
                 self.bind(name, method)
 
-class RedisBus(Bus):
 
+class RedisBus(Bus):
     SERIALIZER = pickle
     """ The serializer to be used for the values contained in
     the bus (used on top of the class) """
@@ -116,8 +111,8 @@ class RedisBus(Bus):
     """ The name of the global channel to which all of the agents
     should be subscribed, for global communication """
 
-    def __init__(self, name = "redis", owner = None, *args, **kwargs):
-        Bus.__init__(self, name = name, owner = owner, *args, **kwargs)
+    def __init__(self, name="redis", owner=None, *args, **kwargs):
+        Bus.__init__(self, name=name, owner=owner, *args, **kwargs)
         self._delay = kwargs.pop("delay", True)
 
     def bind(self, name, method):
@@ -127,21 +122,18 @@ class RedisBus(Bus):
         channel = self._to_channel(name)
         self._pubsub.subscribe(channel)
 
-    def unbind(self, name, method = None):
+    def unbind(self, name, method=None):
         methods = self._events.get(name, [])
-        if method: methods.remove(method)
-        else: del methods[:]
+        if method:
+            methods.remove(method)
+        else:
+            del methods[:]
         channel = self._to_channel(name)
         self._pubsub.unsubscribe(channel)
 
     def trigger(self, name, *args, **kwargs):
         channel = self._to_channel(name)
-        data = self._serializer.dumps(
-            dict(
-                args = args,
-                kwargs = kwargs
-            )
-        )
+        data = self._serializer.dumps(dict(args=args, kwargs=kwargs))
         self._redis.publish(channel, data)
 
     def _load(self, *args, **kwargs):
@@ -150,7 +142,9 @@ class RedisBus(Bus):
         self._name = config.conf("BUS_SCOPE", self._name)
         self._name = kwargs.pop("name", self._name)
         self._serializer = kwargs.pop("serializer", self.__class__.SERIALIZER)
-        self._global_channel = kwargs.pop("global_channel", self.__class__.GLOBAL_CHANNEL)
+        self._global_channel = kwargs.pop(
+            "global_channel", self.__class__.GLOBAL_CHANNEL
+        )
         self._events = dict()
         self._open()
 
@@ -161,7 +155,7 @@ class RedisBus(Bus):
 
     def _get_state(self):
         state = Bus._get_state(self)
-        state.update(_events = self._events)
+        state.update(_events=self._events)
         return state
 
     def _set_state(self, state):
@@ -188,35 +182,40 @@ class RedisBus(Bus):
         self._pubsub = None
         self._listener = None
 
-    def _loop(self, safe = True):
+    def _loop(self, safe=True):
         for item in self._pubsub.listen():
             try:
-                if not self.loaded: break
-                self._tick(item, safe = safe)
+                if not self.loaded:
+                    break
+                self._tick(item, safe=safe)
             except Exception as exception:
                 self.logger.critical("Unhandled Redis loop exception raised")
                 self.logger.error(exception)
                 lines = traceback.format_exc().splitlines()
-                for line in lines: self.logger.warning(line)
+                for line in lines:
+                    self.logger.warning(line)
 
-    def _tick(self, item, safe = True):
+    def _tick(self, item, safe=True):
         channel = item.get("channel", None)
         channel = legacy.str(channel)
         type = item.get("type", None)
         data = item.get("data", None)
-        if not type in ("message",): return
-        if ":" in channel: _prefix, name = channel.split(":", 1)
-        else: name = channel
+        if not type in ("message",):
+            return
+        if ":" in channel:
+            _prefix, name = channel.split(":", 1)
+        else:
+            name = channel
         data = self._serializer.loads(data)
         methods = self._events.get(name, []) if self._events else []
         for method in methods:
             if safe:
                 self.owner.schedule(
                     method,
-                    args = data["args"],
-                    kwargs = data["kwargs"],
-                    timeout = -1,
-                    safe = True
+                    args=data["args"],
+                    kwargs=data["kwargs"],
+                    timeout=-1,
+                    safe=True,
                 )
             else:
                 method(*data["args"], **data["kwargs"])
@@ -224,10 +223,10 @@ class RedisBus(Bus):
     def _to_channel(self, name):
         return self._name + ":" + name
 
-class RedisListener(threading.Thread):
 
+class RedisListener(threading.Thread):
     def __init__(self, bus):
-        threading.Thread.__init__(self, name = "RedisListener")
+        threading.Thread.__init__(self, name="RedisListener")
         self.daemon = True
         self._bus = bus
 

appier/cache.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"
@@ -49,12 +40,13 @@ from . import config
 from . import redisdb
 from . import component
 
-class Cache(component.Component):
 
-    def __init__(self, name = "cache", owner = None, *args, **kwargs):
-        component.Component.__init__(self, name = name, owner = owner, *args, **kwargs)
+class Cache(component.Component):
+    def __init__(self, name="cache", owner=None, *args, **kwargs):
+        component.Component.__init__(self, name=name, owner=owner, *args, **kwargs)
         load = kwargs.pop("load", True)
-        if load: self.load(*args, **kwargs)
+        if load:
+            self.load(*args, **kwargs)
 
     def __len__(self):
         return self.length()
@@ -87,9 +79,11 @@ class Cache(component.Component):
     def clear(self):
         pass
 
-    def get(self, key, default = None):
-        try: return self.get_item(key)
-        except KeyError: return default
+    def get(self, key, default=None):
+        try:
+            return self.get_item(key)
+        except KeyError:
+            return default
 
     def get_item(self, key):
         raise KeyError("not found")
@@ -97,25 +91,28 @@ class Cache(component.Component):
     def set(self, *args, **kwargs):
         return self.set_item(*args, **kwargs)
 
-    def set_item(self, key, value, expires = None, timeout = None):
+    def set_item(self, key, value, expires=None, timeout=None):
         self.mark()
 
     def delete_item(self, key):
         self.mark()
 
     def contains(self, key):
-        try: self.get_item(key)
-        except KeyError: return False
+        try:
+            self.get_item(key)
+        except KeyError:
+            return False
         return True
 
     def build_value(self, value, expires, timeout):
-        if timeout: expires = time.time() + timeout
+        if timeout:
+            expires = time.time() + timeout
         return (value, expires)
 
-class MemoryCache(Cache):
 
-    def __init__(self, name = "memory", owner = None, *args, **kwargs):
-        Cache.__init__(self, name = name, owner = owner, *args, **kwargs)
+class MemoryCache(Cache):
+    def __init__(self, name="memory", owner=None, *args, **kwargs):
+        Cache.__init__(self, name=name, owner=owner, *args, **kwargs)
 
     def length(self):
         return self._data.__len__()
@@ -130,7 +127,7 @@ class MemoryCache(Cache):
             return self.get_item(key)
         return value
 
-    def set_item(self, key, value, expires = None, timeout = None):
+    def set_item(self, key, value, expires=None, timeout=None):
         value = self.build_value(value, expires, timeout)
         return self._data.__setitem__(key, value)
 
@@ -145,23 +142,27 @@ class MemoryCache(Cache):
         Cache._unload(self, *args, **kwargs)
         self._data = None
 
-class FileCache(Cache):
 
-    def __init__(self, name = "file", owner = None, *args, **kwargs):
-        Cache.__init__(self, name = name, owner = owner, *args, **kwargs)
+class FileCache(Cache):
+    def __init__(self, name="file", owner=None, *args, **kwargs):
+        Cache.__init__(self, name=name, owner=owner, *args, **kwargs)
 
     def length(self):
-        if not os.path.exists(self.base_path): return 0
+        if not os.path.exists(self.base_path):
+            return 0
         return len(os.listdir(self.base_path))
 
     def clear(self):
-        if not os.path.exists(self.base_path): return
-        shutil.rmtree(self.base_path, ignore_errors = True)
+        if not os.path.exists(self.base_path):
+            return
+        shutil.rmtree(self.base_path, ignore_errors=True)
 
     def get_item(self, key):
         file_path = os.path.join(self.base_path, key)
-        if not os.path.exists(file_path): raise KeyError("not found")
-        if not os.path.exists(file_path + ".expires"): raise KeyError("not found")
+        if not os.path.exists(file_path):
+            raise KeyError("not found")
+        if not os.path.exists(file_path + ".expires"):
+            raise KeyError("not found")
         expires = self._read_file(file_path + ".expires")
         expires = int(expires) if expires else None
         if not expires == None and expires < time.time():
@@ -170,11 +171,11 @@ class FileCache(Cache):
         value = self._read_file(file_path)
         return value
 
-    def set_item(self, key, value, expires = None, timeout = None):
+    def set_item(self, key, value, expires=None, timeout=None):
         file_path = os.path.join(self.base_path, key)
         value, expires = self.build_value(value, expires, timeout)
         expires = str(int(expires)) if expires else None
-        expires_s = legacy.bytes(expires, force = True) if expires else b""
+        expires_s = legacy.bytes(expires, force=True) if expires else b""
         self._write_file(file_path, value)
         self._write_file(file_path + ".expires", expires_s)
 
@@ -190,24 +191,30 @@ class FileCache(Cache):
 
     def _read_file(self, file_path):
         file = open(file_path, "rb")
-        try: data = file.read()
-        finally: file.close()
+        try:
+            data = file.read()
+        finally:
+            file.close()
         return data
 
     def _write_file(self, file_path, data):
         self._ensure_exists()
         file = open(file_path, "wb")
-        try: file.write(data)
-        finally: file.close()
+        try:
+            file.write(data)
+        finally:
+            file.close()
 
     def _ensure_exists(self):
-        if os.path.exists(self.base_path): return
+        if os.path.exists(self.base_path):
+            return
         os.makedirs(self.base_path)
 
     def _ensure_path(self):
-        if self.base_path: return
+        if self.base_path:
+            return
         app_path = common.base().get_base_path()
-        util.verify(not app_path == None, message = "No app path available")
+        util.verify(not app_path == None, message="No app path available")
         cache_path = os.path.join(app_path, "cache")
         cache_path = config.conf("CACHE_PATH", cache_path)
         cache_path = os.path.expanduser(cache_path)
@@ -215,40 +222,40 @@ class FileCache(Cache):
         cache_path = os.path.normpath(cache_path)
         self.base_path = cache_path
 
-class RedisCache(Cache):
 
-    def __init__(self, name = "redis", owner = None, *args, **kwargs):
-        Cache.__init__(self, name = name, owner = owner, *args, **kwargs)
+class RedisCache(Cache):
+    def __init__(self, name="redis", owner=None, *args, **kwargs):
+        Cache.__init__(self, name=name, owner=owner, *args, **kwargs)
 
     def length(self):
-        if self.hash: return self._redis.hlen(self.key)
-        else: return len(self._redis.keys())
+        if self.hash:
+            return self._redis.hlen(self.key)
+        else:
+            return len(self._redis.keys())
 
     def clear(self):
-        if self.hash: self._redis.delete(self.key)
-        else: self._redis.flushdb()
+        if self.hash:
+            self._redis.delete(self.key)
+        else:
+            self._redis.flushdb()
 
     def get_item(self, key):
-        if self.hash: return self._get_item_hash(key)
-        else: return self._get_item(key)
-
-    def set_item(self, key, value, expires = None, timeout = None):
-        if self.hash: return self._set_item_hash(
-            key,
-            value,
-            expires = expires,
-            timeout = timeout
-        )
-        else: return self._set_item(
-            key,
-            value,
-            expires = expires,
-            timeout = timeout
-        )
+        if self.hash:
+            return self._get_item_hash(key)
+        else:
+            return self._get_item(key)
+
+    def set_item(self, key, value, expires=None, timeout=None):
+        if self.hash:
+            return self._set_item_hash(key, value, expires=expires, timeout=timeout)
+        else:
+            return self._set_item(key, value, expires=expires, timeout=timeout)
 
     def delete_item(self, key):
-        if self.hash: self._redis.hdel(self.key, key)
-        else: self._redis.delete(key)
+        if self.hash:
+            self._redis.hdel(self.key, key)
+        else:
+            self._redis.delete(key)
 
     def _load(self, *args, **kwargs):
         Cache._load(self, *args, **kwargs)
@@ -261,37 +268,45 @@ class RedisCache(Cache):
         self._redis = None
 
     def _get_item(self, key):
-        if not self._redis.exists(key): raise KeyError("not found")
+        if not self._redis.exists(key):
+            raise KeyError("not found")
         return self._redis.get(key)
 
     def _get_item_hash(self, key):
-        if not self._redis.hexists(self.key, key): raise KeyError("not found")
+        if not self._redis.hexists(self.key, key):
+            raise KeyError("not found")
         return self._redis.hget(self.key, key)
 
-    def _set_item(self, key, value, expires = None, timeout = None):
+    def _set_item(self, key, value, expires=None, timeout=None):
         self._redis.set(key, value)
-        if expires: timeout = expires - time.time()
-        if timeout and timeout > 0: self._redis.expire(key, int(timeout))
-        elif timeout: self._redis.delete(key)
-
-    def _set_item_hash(self, key, value, expires = None, timeout = None):
+        if expires:
+            timeout = expires - time.time()
+        if timeout and timeout > 0:
+            self._redis.expire(key, int(timeout))
+        elif timeout:
+            self._redis.delete(key)
+
+    def _set_item_hash(self, key, value, expires=None, timeout=None):
         self._redis.hset(self.key, key, value)
-        if expires: timeout = expires - time.time()
-        if timeout and timeout > 0: self._redis.expire(self.key, int(timeout))
-        elif timeout: self._redis.hdel(self.key, key)
+        if expires:
+            timeout = expires - time.time()
+        if timeout and timeout > 0:
+            self._redis.expire(self.key, int(timeout))
+        elif timeout:
+            self._redis.hdel(self.key, key)
 
     @property
-    def key(self, prefix = "cache"):
+    def key(self, prefix="cache"):
         suffix = self.owner.name_i if self.owner else "global"
         return prefix + ":" + suffix
 
-class SerializedCache(object):
 
+class SerializedCache(object):
     SERIALIZER = pickle
     """ The serializer to be used for the values contained in
     the session (used on top of the class) """
 
-    def __init__(self, cache, serializer = None):
+    def __init__(self, cache, serializer=None):
         cls = self.__class__
         self._cache = cache
         self._serializer = serializer or cls.SERIALIZER
@@ -327,6 +342,6 @@ class SerializedCache(object):
         value = self._serializer.loads(data)
         return value
 
-    def set_item(self, key, value, expires = None, timeout = None):
+    def set_item(self, key, value, expires=None, timeout=None):
         data = self._serializer.dumps(value)
-        return self._cache.set_item(key, data, expires = expires, timeout = timeout)
+        return self._cache.set_item(key, data, expires=expires, timeout=timeout)

appier/common.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,32 +22,30 @@
 __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"
 """ The license for the module """
 
+
 def base():
     from . import base
+
     return base
 
+
 def model():
     from . import model
+
     return model
 
+
 def util():
     from . import util
+
     return util
 
+
 def is_devel():
     return base().is_devel()