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

appier/typesf.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"
@@ -48,16 +39,16 @@ from . import common
 from . import storage
 from . import exceptions
 
-class AbstractType(object):
 
+class AbstractType(object):
     def json_v(self, *args, **kwargs):
         return str(self)
 
     def map_v(self, *args, **kwargs):
         return self.json_v()
 
-class Type(AbstractType):
 
+class Type(AbstractType):
     def __init__(self, value):
         cls = self.__class__
         self.loads(value)
@@ -71,14 +62,19 @@ class Type(AbstractType):
     def dumps(self):
         raise exceptions.NotImplementedError()
 
-class File(AbstractType):
 
+class File(AbstractType):
     def __init__(self, file):
-        if isinstance(file, legacy.BYTES): self.build_d(file)
-        elif isinstance(file, dict): self.build_b64(file)
-        elif isinstance(file, tuple): self.build_t(file)
-        elif isinstance(file, File): self.build_i(file)
-        else: self.build_f(file)
+        if isinstance(file, legacy.BYTES):
+            self.build_d(file)
+        elif isinstance(file, dict):
+            self.build_b64(file)
+        elif isinstance(file, tuple):
+            self.build_t(file)
+        elif isinstance(file, File):
+            self.build_i(file)
+        else:
+            self.build_f(file)
 
     def __repr__(self):
         return "<File: %s>" % self.file_name
@@ -89,7 +85,7 @@ class File(AbstractType):
     def __len__(self):
         return self.size
 
-    def build_d(self, file_d, name = "default"):
+    def build_d(self, file_d, name="default"):
         self.build_t((name, None, file_d))
 
     def build_b64(self, file_m):
@@ -180,13 +176,13 @@ class File(AbstractType):
 
         self._load()
 
-    def read(self, size = None):
+    def read(self, size=None):
         engine = self._engine()
-        return engine.read(self, size = size)
+        return engine.read(self, size=size)
 
-    def seek(self, offset = None):
+    def seek(self, offset=None):
         engine = self._engine()
-        return engine.seek(self, offset = offset)
+        return engine.seek(self, offset=offset)
 
     def delete(self):
         engine = self._engine()
@@ -197,19 +193,21 @@ class File(AbstractType):
         return engine.cleanup(self)
 
     def json_v(self, *args, **kwargs):
-        if not self.is_valid(): return None
+        if not self.is_valid():
+            return None
         store = kwargs.get("store", True)
-        if store: self._store()
+        if store:
+            self._store()
         data = self.data_b64 if self.is_stored() else None
         return dict(
-            name = self.file_name,
-            data = data,
-            hash = self.hash,
-            mime = self.mime,
-            etag = self.etag,
-            guid = self.guid,
-            params = self.params,
-            engine = self.engine
+            name=self.file_name,
+            data=data,
+            hash=self.hash,
+            mime=self.mime,
+            etag=self.etag,
+            guid=self.guid,
+            params=self.params,
+            engine=self.engine,
         )
 
     def is_seekable(self):
@@ -227,13 +225,15 @@ class File(AbstractType):
         return self.size <= 0
 
     def _hash(self, data):
-        if not data: return None
+        if not data:
+            return None
         hash = hashlib.sha256(data)
         digest = hash.hexdigest()
         return digest
 
     def _etag(self, data):
-        if not data: return None
+        if not data:
+            return None
         hash = hashlib.md5(data)
         digest = hash.hexdigest()
         return digest
@@ -241,13 +241,13 @@ class File(AbstractType):
     def _guid(self):
         return str(uuid.uuid4())
 
-    def _load(self, force = False):
+    def _load(self, force=False):
         engine = self._engine()
-        engine.load(self, force = force)
+        engine.load(self, force=force)
 
-    def _store(self, force = False):
+    def _store(self, force=False):
         engine = self._engine()
-        engine.store(self, force = force)
+        engine.store(self, force=force)
 
     def _compute(self):
         """
@@ -266,14 +266,17 @@ class File(AbstractType):
         self.etag = self._etag(self.data)
 
     def _engine(self):
-        if not self.engine: return storage.BaseEngine
+        if not self.engine:
+            return storage.BaseEngine
         return getattr(storage, self.engine.capitalize() + "Engine")
 
-class Files(AbstractType):
 
+class Files(AbstractType):
     def __init__(self, files):
-        if isinstance(files, Files): self.build_i(files)
-        else: self.build_f(files)
+        if isinstance(files, Files):
+            self.build_i(files)
+        else:
+            self.build_f(files)
 
     def __repr__(self):
         return "<Files: %d files>" % len(self._files)
@@ -296,10 +299,12 @@ class Files(AbstractType):
     def build_f(self, files):
         self._files = []
         base = self.base()
-        if not type(files) == list: files = [files]
+        if not type(files) == list:
+            files = [files]
         for file in files:
             _file = base(file)
-            if not _file.is_valid(): continue
+            if not _file.is_valid():
+                continue
             self._files.append(_file)
 
     def json_v(self, *args, **kwargs):
@@ -309,10 +314,11 @@ class Files(AbstractType):
         return len(self._files) == 0
 
     def _load(self):
-        for file in self._files: file._load()
+        for file in self._files:
+            file._load()
 
-class ImageFile(File):
 
+class ImageFile(File):
     def build_b64(self, file_m):
         File.build_b64(self, file_m)
         self.width = file_m.get("width", 0)
@@ -338,13 +344,11 @@ class ImageFile(File):
         self._ensure_all()
 
     def json_v(self, *args, **kwargs):
-        if not self.is_valid(): return None
+        if not self.is_valid():
+            return None
         value = File.json_v(self, *args, **kwargs)
         value.update(
-            width = self.width,
-            height = self.height,
-            format = self.format,
-            kwargs = self.kwargs
+            width=self.width, height=self.height, format=self.format, kwargs=self.kwargs
         )
         return value
 
@@ -354,30 +358,46 @@ class ImageFile(File):
         self._ensure_kwargs()
 
     def _ensure_size(self):
-        if hasattr(self, "width") and self.width and\
-            hasattr(self, "height") and self.height: return
+        if (
+            hasattr(self, "width")
+            and self.width
+            and hasattr(self, "height")
+            and self.height
+        ):
+            return
         self.width, self.height = self._size()
 
     def _ensure_mime(self):
-        if hasattr(self, "format") and self.format and\
-            hasattr(self, "mime") and self.mime: return
+        if (
+            hasattr(self, "format")
+            and self.format
+            and hasattr(self, "mime")
+            and self.mime
+        ):
+            return
         self.format, self.mime = self._mime()
 
     def _ensure_kwargs(self):
-        if hasattr(self, "kwargs"): return
+        if hasattr(self, "kwargs"):
+            return
         self.kwargs = dict()
 
     def _size(self):
-        try: return self._size_image()
-        except Exception: return self._size_default()
+        try:
+            return self._size_image()
+        except Exception:
+            return self._size_default()
 
     def _size_image(self):
-        if self.data: return self._size_pil()
-        else: return self._size_default()
+        if self.data:
+            return self._size_pil()
+        else:
+            return self._size_default()
 
     def _size_pil(self):
-        util.ensure_pip("PIL", package = "pillow")
+        util.ensure_pip("PIL", package="pillow")
         import PIL.Image
+
         buffer = legacy.BytesIO(self.data)
         try:
             image = PIL.Image.open(buffer)
@@ -390,16 +410,21 @@ class ImageFile(File):
         return (0, 0)
 
     def _mime(self):
-        try: return self._mime_image()
-        except Exception: return self._mime_default()
+        try:
+            return self._mime_image()
+        except Exception:
+            return self._mime_default()
 
     def _mime_image(self):
-        if self.data: return self._mime_pil()
-        else: return self._mime_default()
+        if self.data:
+            return self._mime_pil()
+        else:
+            return self._mime_default()
 
     def _mime_pil(self):
-        util.ensure_pip("PIL", package = "pillow")
+        util.ensure_pip("PIL", package="pillow")
         import PIL.Image
+
         buffer = legacy.BytesIO(self.data)
         try:
             image = PIL.Image.open(buffer)
@@ -412,15 +437,14 @@ class ImageFile(File):
     def _mime_default(self):
         return None, "application/octet-stream"
 
-class ImageFiles(Files):
 
+class ImageFiles(Files):
     def base(self):
         return ImageFile
 
-def image(width = None, height = None, format = "png", **kwargs):
 
+def image(width=None, height=None, format="png", **kwargs):
     class _ImageFile(ImageFile):
-
         RGB_FORMATS = ("jpg", "jpeg")
         """ The set of format that are considered to be
         RGB based and should be handled with special care """
@@ -431,18 +455,20 @@ def image(width = None, height = None, format = "png", **kwargs):
             # verifies if there's valid data in the current file
             # if that's not the case there's nothing remaining to
             # be done (not going to process the file)
-            if not self.data_b64: return
+            if not self.data_b64:
+                return
 
             # determines if a resize operation is required for the
             # current image data, if that's not the case returns the
             # control flow immediately (nothing to be done)
             need_resize = self.need_resize(
-                width_o = self.width,
-                height_o = self.height,
-                format_o = self.format,
-                kwargs_o = self.kwargs
+                width_o=self.width,
+                height_o=self.height,
+                format_o=self.format,
+                kwargs_o=self.kwargs,
             )
-            if not need_resize: return
+            if not need_resize:
+                return
 
             # decodes the base 64 based data and then runs the resize
             # operation with the current data re-encoding it back to
@@ -468,7 +494,8 @@ def image(width = None, height = None, format = "png", **kwargs):
             # different values from the ones contained in data
             # theses should be update by the "ensure" methods
             for name in ("width", "height", "format"):
-                if name in file_m: del file_m[name]
+                if name in file_m:
+                    del file_m[name]
 
             # runs the rebuilding of the information taking into
             # account the new information from the file
@@ -481,8 +508,10 @@ def image(width = None, height = None, format = "png", **kwargs):
 
             # tries to run the resize operation to ensure that
             # the proper size and format is present in the data
-            try: _data = self.resize(data) if data else data
-            except Exception: _data = data
+            try:
+                _data = self.resize(data) if data else data
+            except Exception:
+                _data = data
 
             # updates the parameters attributes in the instance so
             # that the new file is marked with proper values
@@ -493,15 +522,17 @@ def image(width = None, height = None, format = "png", **kwargs):
             file_t = (name, content_type, _data)
             ImageFile.build_t(self, file_t)
 
-        def resize(self, data = None):
-            util.ensure_pip("PIL", package = "pillow")
+        def resize(self, data=None):
+            util.ensure_pip("PIL", package="pillow")
             import PIL.Image
 
             data = data or self.data
-            if not data: return data
+            if not data:
+                return data
 
             is_resized = True if width or height else False
-            if not is_resized: return data
+            if not is_resized:
+                return data
 
             params = kwargs.get("params", {})
             background = kwargs.get("background", "ffffff")
@@ -522,27 +553,28 @@ def image(width = None, height = None, format = "png", **kwargs):
             return data
 
         def need_resize(
-            self,
-            width_o = None,
-            height_o = None,
-            format_o = None,
-            kwargs_o = None
+            self, width_o=None, height_o=None, format_o=None, kwargs_o=None
         ):
-            if width and not width == width_o: return True
-            if height and not height == height_o: return True
-            if format and not format == format_o: return True
-            if kwargs and not kwargs == kwargs_o: return True
+            if width and not width == width_o:
+                return True
+            if height and not height == height_o:
+                return True
+            if format and not format == format_o:
+                return True
+            if kwargs and not kwargs == kwargs_o:
+                return True
             return False
 
-        def _resize(self, image, size):
-            util.ensure_pip("PIL", package = "pillow")
+        def _resize(self, image, size, resample=None):
+            util.ensure_pip("PIL", package="pillow")
             import PIL.Image
 
             # unpacks the provided tuple containing the size dimension into the
             # with and the height an in case one of these values is not defined
             # an error is raises indicating the problem
             width, height = size
-            if not height and not width: raise AttributeError("invalid values")
+            if not height and not width:
+                raise AttributeError("invalid values")
 
             # retrieves the size of the loaded image and uses the values to calculate
             # the aspect ration of the provided image, this value is going to be
@@ -553,8 +585,10 @@ def image(width = None, height = None, format = "png", **kwargs):
             # in case one of the size dimensions has not been specified
             # it must be calculated from the base values taking into account
             # that the aspect ration should be preserved
-            if not height: height = int(image_height * width / float(image_width))
-            if not width: width = int(image_width * height / float(image_height))
+            if not height:
+                height = int(image_height * width / float(image_width))
+            if not width:
+                width = int(image_width * height / float(image_height))
 
             # re-constructs the size tuple with the new values for the width
             # the height that have been calculated from the ratios
@@ -581,11 +615,17 @@ def image(width = None, height = None, format = "png", **kwargs):
 
             # resizes the already cropped image into the target size using an
             # anti alias based algorithm (default expectations)
-            image = image.resize(size, PIL.Image.ANTIALIAS)
+            if resample == None:
+                resample = (
+                    PIL.Image.ANTIALIAS  # type: ignore
+                    if hasattr(PIL.Image, "ANTIALIAS")
+                    else (PIL.Image.LANCZOS if hasattr(PIL.Image, "LANCZOS") else None)  # type: ignore
+                )
+            image = image.resize(size, resample)
             return image
 
         def _format(self, image, format, background):
-            util.ensure_pip("PIL", package = "pillow")
+            util.ensure_pip("PIL", package="pillow")
             import PIL.Image
 
             # retrieves the reference to the top level class that is
@@ -597,11 +637,13 @@ def image(width = None, height = None, format = "png", **kwargs):
             # an RGB only format, if that's not the case there's nothing
             # remaining to be done (no conversion required)
             format = format.lower()
-            if not format in cls.RGB_FORMATS: return image
+            if not format in cls.RGB_FORMATS:
+                return image
 
             # in case the format/mode of the original image is already
             # RGB there's no need to run the conversion process
-            if image.mode == "RGB": return image
+            if image.mode == "RGB":
+                return image
 
             # creates a new RGB based image with the target size and
             # with the provided background and copies it as the target
@@ -611,33 +653,28 @@ def image(width = None, height = None, format = "png", **kwargs):
 
     return _ImageFile
 
-def images(width = None, height = None, format = "png", **kwargs):
 
-    image_c = image(
-        width = width,
-        height = height,
-        format = format,
-        **kwargs
-    )
+def images(width=None, height=None, format="png", **kwargs):
+    image_c = image(width=width, height=height, format=format, **kwargs)
 
     class _ImageFiles(ImageFiles):
-
         def base(self):
             return image_c
 
     return _ImageFiles
 
+
 class Reference(AbstractType):
     pass
 
-def reference(target, name = None, dumpall = False):
+
+def reference(target, name=None, dumpall=False):
     name = name or "id"
     target_t = type(target)
     is_reference = target_t in legacy.STRINGS
     reserved = ("id", "_target", "_object", "_type", "__dict__")
 
     class _Reference(Reference):
-
         _name = name
         """ The name of the key (join) attribute for the
         reference that is going to be created, this name
@@ -645,25 +682,34 @@ def reference(target, name = None, dumpall = False):
 
         def __init__(self, id):
             self.__start__()
-            if isinstance(id, _Reference): self.build_i(id)
-            elif isinstance(id, self._target): self.build_o(id)
-            else: self.build(id)
+            if isinstance(id, _Reference):
+                self.build_i(id)
+            elif isinstance(id, self._target):
+                self.build_o(id)
+            else:
+                self.build(id)
 
         def __str__(self):
             self.resolve()
             has_str = hasattr(self._object, "__str__")
-            if has_str: return self._object.__str__()
-            else: return str(self._object) or str()
+            if has_str:
+                return self._object.__str__()
+            else:
+                return str(self._object) or str()
 
         def __unicode__(self):
             self.resolve()
             has_unicode = hasattr(self._object, "__unicode__")
-            if has_unicode: return self._object.__unicode__()
-            else: return legacy.UNICODE(self._object) or legacy.UNICODE()
+            if has_unicode:
+                return self._object.__unicode__()
+            else:
+                return legacy.UNICODE(self._object) or legacy.UNICODE()
 
         def __eq__(self, other):
-            if other == None: return self.id in ("", b"", None)
-            if isinstance(other, Reference): return self.equals(other)
+            if other == None:
+                return self.id in ("", b"", None)
+            if isinstance(other, Reference):
+                return self.equals(other)
             return id(self) == id(other)
 
         def __ne__(self, other):
@@ -679,17 +725,20 @@ def reference(target, name = None, dumpall = False):
 
         def __getattr__(self, name):
             is_magic = name.startswith("__") and name.endswith("__")
-            if is_magic: return Reference.__getattr__(name)
+            if is_magic:
+                return Reference.__getattr__(name)
             self.resolve()
             exists = hasattr(self._object, name)
-            if exists: return getattr(self._object, name)
+            if exists:
+                return getattr(self._object, name)
             raise AttributeError("'%s' not found" % name)
 
         def __setattr__(self, name, value):
             # in case the name that is being set is not part of the reserved
             # names for the reference underlying structure the object resolution
             # is triggered to make sure the underlying object exists and is loaded
-            if not name in reserved: self.resolve()
+            if not name in reserved:
+                self.resolve()
 
             # verifies if the reference object exists in the current
             # reference instance, that's the case if the object name is
@@ -697,15 +746,18 @@ def reference(target, name = None, dumpall = False):
             # an attribute with the name referred, for those situations
             # defers the setting of the attribute to the reference object
             exists = "_object" in self.__dict__ and hasattr(self._object, name)
-            if exists: return setattr(self._object, name, value)
+            if exists:
+                return setattr(self._object, name, value)
 
             # otherwise this is a normal attribute setting and the current
             # object's dictionary must be changed so that the new value is set
             self.__dict__[name] = value
 
         def __start__(self):
-            if is_reference: self._target = self.__class__._target()
-            else: self._target = target
+            if is_reference:
+                self._target = self.__class__._target()
+            else:
+                self._target = target
             util.verify(self._target)
             meta = getattr(self._target, name)
             self._type = meta.get("type", legacy.UNICODE)
@@ -716,20 +768,24 @@ def reference(target, name = None, dumpall = False):
 
         @classmethod
         def _target(cls):
-            if is_reference: return common.base().APP.get_model(target)
+            if is_reference:
+                return common.base().APP.get_model(target)
             return target
 
         @classmethod
         def _btype(cls):
-            if is_reference: _target = cls._target()
-            else: _target = target
+            if is_reference:
+                _target = cls._target()
+            else:
+                _target = target
             meta = getattr(_target, name)
             return meta.get("type", legacy.UNICODE)
 
-        def build(self, id, cast = True):
+        def build(self, id, cast=True):
             is_unset = id in ("", b"", None)
             cast = cast and not is_unset
-            if cast: id = self._target.cast(name, id)
+            if cast:
+                id = self._target.cast(name, id)
             self.id = id
             self._object = None
 
@@ -745,19 +801,23 @@ def reference(target, name = None, dumpall = False):
             return self.val()
 
         def json_v(self, *args, **kwargs):
-            if dumpall: return self.resolve()
+            if dumpall:
+                return self.resolve()
             return self.val()
 
         def map_v(self, *args, **kwargs):
             resolve = kwargs.get("resolve", True)
             value = self.resolve() if resolve else self._object
-            if resolve and not value: return value
-            if not value: return self.val()
+            if resolve and not value:
+                return value
+            if not value:
+                return self.val()
             return value.map(*args, **kwargs)
 
         def val(self, *args, **kargs):
             is_empty = self.id in ("", b"", None)
-            if is_empty: return None
+            if is_empty:
+                return None
             return self._type(self.id)
 
         def resolve(self, *args, **kwargs):
@@ -766,7 +826,8 @@ def reference(target, name = None, dumpall = False):
             # verifies if it's valid (value is valid) if that's
             # the case returns the current value immediately
             exists = "_object" in self.__dict__
-            if exists and self._object: return self._object
+            if exists and self._object:
+                return self._object
 
             # verifies if there's an id value currently set in
             # the reference in case it does not exists sets the
@@ -795,9 +856,12 @@ def reference(target, name = None, dumpall = False):
             return _object
 
         def equals(self, other):
-            if not self.__class__ == other.__class__: return False
-            if not self._target == other._target: return False
-            if not self.id == other.id: return False
+            if not self.__class__ == other.__class__:
+                return False
+            if not self._target == other._target:
+                return False
+            if not self.id == other.id:
+                return False
             return True
 
         def is_resolved(self):
@@ -810,17 +874,18 @@ def reference(target, name = None, dumpall = False):
 
     return _Reference
 
+
 class References(AbstractType):
     pass
 
-def references(target, name = None, dumpall = False):
+
+def references(target, name=None, dumpall=False):
     name = name or "id"
     target_t = type(target)
     is_reference = target_t in legacy.STRINGS
-    reference_c = reference(target, name = name, dumpall = dumpall)
+    reference_c = reference(target, name=name, dumpall=dumpall)
 
     class _References(References):
-
         _name = name
         """ The name of the key (join) attribute for the
         reference that is going to be created, this name
@@ -828,8 +893,10 @@ def references(target, name = None, dumpall = False):
 
         def __init__(self, ids):
             self.__start__()
-            if isinstance(ids, _References): self.build_i(ids)
-            else: self.build(ids)
+            if isinstance(ids, _References):
+                self.build_i(ids)
+            else:
+                self.build(ids)
 
         def __len__(self):
             return self.objects.__len__()
@@ -847,8 +914,10 @@ def references(target, name = None, dumpall = False):
             return self.contains(item)
 
         def __start__(self):
-            if is_reference: self._target = self.__class__._target()
-            else: self._target = target
+            if is_reference:
+                self._target = self.__class__._target()
+            else:
+                self._target = target
             util.verify(self._target)
 
         @classmethod
@@ -866,7 +935,8 @@ def references(target, name = None, dumpall = False):
         def build(self, ids):
             is_valid = not ids == None
             is_iterable = util.is_iterable(ids)
-            if is_valid and not is_iterable: ids = [ids]
+            if is_valid and not is_iterable:
+                ids = [ids]
 
             self.ids = ids
             self.objects = []
@@ -883,7 +953,8 @@ def references(target, name = None, dumpall = False):
             ids = ids or []
             self.ids = []
             for id in ids:
-                if id == "" or id == None: continue
+                if id == "" or id == None:
+                    continue
                 object = reference_c(id)
                 object_id = object.id
                 self.ids.append(object_id)
@@ -910,12 +981,12 @@ def references(target, name = None, dumpall = False):
 
         def find(self, *args, **kwargs):
             kwargs = dict(kwargs)
-            kwargs[name] = {"$in" : [self._target.cast(name, _id) for _id in self.ids]}
+            kwargs[name] = {"$in": [self._target.cast(name, _id) for _id in self.ids]}
             return self._target.find(*args, **kwargs)
 
         def paginate(self, *args, **kwargs):
             kwargs = dict(kwargs)
-            kwargs[name] = {"$in" : [self._target.cast(name, _id) for _id in self.ids]}
+            kwargs[name] = {"$in": [self._target.cast(name, _id) for _id in self.ids]}
             return self._target.paginate(*args, **kwargs)
 
         def is_empty(self):
@@ -924,7 +995,8 @@ def references(target, name = None, dumpall = False):
 
         def append(self, id):
             is_object = hasattr(id, self._name)
-            if is_object: id = getattr(id, self._name)
+            if is_object:
+                id = getattr(id, self._name)
             object = reference_c(id)
             self.ids.append(id)
             self.objects.append(object)
@@ -932,7 +1004,8 @@ def references(target, name = None, dumpall = False):
 
         def remove(self, id):
             is_object = hasattr(id, self._name)
-            if is_object: id = getattr(id, self._name)
+            if is_object:
+                id = getattr(id, self._name)
             object = self.objects_m[id]
             self.ids.remove(id)
             self.objects.remove(object)
@@ -940,35 +1013,39 @@ def references(target, name = None, dumpall = False):
 
         def contains(self, id):
             is_object = hasattr(id, self._name)
-            if is_object: id = getattr(id, self._name)
+            if is_object:
+                id = getattr(id, self._name)
             return id in self.objects_m
 
         def is_resolved(self):
-            if not self.objects: return True
+            if not self.objects:
+                return True
             return self.objects[0].is_resolved()
 
     return _References
 
-class Encrypted(AbstractType):
 
+class Encrypted(AbstractType):
     PADDING = ":encrypted"
 
-def encrypted(cipher = "spritz", key = None, encoding = "utf-8"):
+
+def encrypted(cipher="spritz", key=None, encoding="utf-8"):
     key = key or None
 
     class _Encrypted(Encrypted):
-
         def __init__(self, value):
             cls = self.__class__
             util.verify(
-                isinstance(value, legacy.ALL_STRINGS) or\
-                isinstance(value, Encrypted)
+                isinstance(value, legacy.ALL_STRINGS) or isinstance(value, Encrypted)
             )
             self.key = key or common.base().APP.crypt_secret
             self.key = legacy.bytes(self.key)
-            if isinstance(value, Encrypted): self.build_i(value)
-            elif value.endswith(cls.PADDING): self.build_e(value)
-            else: self.build(value)
+            if isinstance(value, Encrypted):
+                self.build_i(value)
+            elif value.endswith(cls.PADDING):
+                self.build_e(value)
+            else:
+                self.build(value)
 
         def __str__(self):
             return self.value
@@ -1001,28 +1078,31 @@ def encrypted(cipher = "spritz", key = None, encoding = "utf-8"):
         def json_v(self, *args, **kwargs):
             return self.encrypted
 
-        def _encrypt(self, value, strict = False):
-            if not self.key and not strict: return value
+        def _encrypt(self, value, strict=False):
+            if not self.key and not strict:
+                return value
             cls = self.__class__
-            value = legacy.bytes(value, encoding = encoding)
+            value = legacy.bytes(value, encoding=encoding)
             cipher_i = crypt.Cipher.new(cipher, self.key)
             encrypted = cipher_i.encrypt(value)
             encrypted = base64.b64encode(encrypted)
-            encrypted = legacy.str(encrypted, encoding = encoding)
+            encrypted = legacy.str(encrypted, encoding=encoding)
             return encrypted + cls.PADDING
 
-        def _decrypt(self, value, strict = False):
-            if not self.key and not strict: return value
+        def _decrypt(self, value, strict=False):
+            if not self.key and not strict:
+                return value
             cls = self.__class__
             util.verify(value.endswith(cls.PADDING))
-            value = value[:-len(cls.PADDING)]
+            value = value[: -len(cls.PADDING)]
             value = legacy.bytes(value)
             value = base64.b64decode(value)
             cipher_i = crypt.Cipher.new(cipher, self.key)
             decrypted = cipher_i.decrypt(value)
-            decrypted = legacy.str(decrypted, encoding = encoding)
+            decrypted = legacy.str(decrypted, encoding=encoding)
             return decrypted
 
     return _Encrypted
 
+
 secure = encrypted()