From 713a0961e17b875c77ada39e98c6bee9309f5525 Mon Sep 17 00:00:00 2001
From: Samuel Gaist <samuel.gaist@idiap.ch>
Date: Mon, 6 May 2019 12:30:58 +0200
Subject: [PATCH] [dataformat] Pre-commit cleanup

---
 beat/backend/python/dataformat.py | 112 +++++++++++++-----------------
 1 file changed, 47 insertions(+), 65 deletions(-)

diff --git a/beat/backend/python/dataformat.py b/beat/backend/python/dataformat.py
index 54347ef..1af4fee 100644
--- a/beat/backend/python/dataformat.py
+++ b/beat/backend/python/dataformat.py
@@ -70,21 +70,20 @@ class Storage(utils.Storage):
 
     def __init__(self, prefix, name):
 
-        if name.count('/') != 2:
+        if name.count("/") != 2:
             raise RuntimeError("invalid dataformat name: `%s'" % name)
 
-        self.username, self.name, self.version = name.split('/')
+        self.username, self.name, self.version = name.split("/")
         self.fullname = name
         self.prefix = prefix
 
-        path = utils.hashed_or_simple(self.prefix, 'dataformats', name, suffix='.json')
+        path = utils.hashed_or_simple(self.prefix, "dataformats", name, suffix=".json")
         path = path[:-5]
         super(Storage, self).__init__(path)
 
-
     def hash(self):
         """The 64-character hash of the database declaration JSON"""
-        return super(Storage, self).hash('#description')
+        return super(Storage, self).hash("#description")
 
 
 # ----------------------------------------------------------
@@ -165,23 +164,24 @@ class DataFormat(object):
             if self._name is not None:  # registers it into the cache, even if failed
                 dataformat_cache[self._name] = self
 
-
     def _load(self, data, dataformat_cache):
         """Loads the dataformat"""
 
         if isinstance(data, dict):
-            self._name = 'analysis:result'
+            self._name = "analysis:result"
             self.data = data
         else:
             self._name = data
             self.storage = Storage(self.prefix, data)
             json_path = self.storage.json.path
             if not self.storage.exists():
-                self.errors.append('Dataformat declaration file not found: %s' % json_path)
+                self.errors.append(
+                    "Dataformat declaration file not found: %s" % json_path
+                )
                 return
 
-            with open(json_path, 'rb') as f:
-                self.data = simplejson.loads(f.read().decode('utf-8'))
+            with open(json_path, "rb") as f:
+                self.data = simplejson.loads(f.read().decode("utf-8"))
 
         dataformat_cache[self._name] = self  # registers itself into the cache
 
@@ -189,17 +189,20 @@ class DataFormat(object):
 
         # remove reserved fields
         def is_reserved(x):
-            '''Returns if the field name is a reserved name'''
-            return (x.startswith('__') and x.endswith('__')) or \
-                    x in ('#description', '#schema_version')
+            """Returns if the field name is a reserved name"""
+            return (x.startswith("__") and x.endswith("__")) or x in (
+                "#description",
+                "#schema_version",
+            )
 
         for key in list(self.resolved):
-            if is_reserved(key): del self.resolved[key]
+            if is_reserved(key):
+                del self.resolved[key]
 
         def maybe_load_format(name, obj, dataformat_cache):
             """Tries to load a given dataformat from its relative path"""
 
-            if isinstance(obj, six.string_types) and obj.find('/') != -1:  # load it
+            if isinstance(obj, six.string_types) and obj.find("/") != -1:  # load it
 
                 if obj in dataformat_cache:  # reuse
 
@@ -209,8 +212,9 @@ class DataFormat(object):
                     self.referenced[obj] = dataformat_cache[obj]
 
                 else:  # load it
-                    self.referenced[obj] = DataFormat(self.prefix, obj, (self, name),
-                            dataformat_cache)
+                    self.referenced[obj] = DataFormat(
+                        self.prefix, obj, (self, name), dataformat_cache
+                    )
 
                 return self.referenced[obj]
 
@@ -226,22 +230,22 @@ class DataFormat(object):
 
         # now checks that every referred dataformat is loaded, resolves it
         for field, value in self.data.items():
-            if field in ('#description', '#schema_version'):
+            if field in ("#description", "#schema_version"):
                 continue  # skip the description and schema version meta attributes
             self.resolved[field] = maybe_load_format(field, value, dataformat_cache)
 
         # at this point, there should be no more external references in
         # ``self.resolved``. We treat the "#extends" property, which requires a
         # special handling, given its nature.
-        if '#extends' in self.resolved:
+        if "#extends" in self.resolved:
 
-            ext = self.data['#extends']
+            ext = self.data["#extends"]
             self.referenced[ext] = maybe_load_format(self._name, ext, dataformat_cache)
-            basetype = self.resolved['#extends']
+            basetype = self.resolved["#extends"]
             tmp = self.resolved
             self.resolved = basetype.resolved
             self.resolved.update(tmp)
-            del self.resolved['#extends']  # avoids infinite recursion
+            del self.resolved["#extends"]  # avoids infinite recursion
 
     @property
     def name(self):
@@ -249,29 +253,25 @@ class DataFormat(object):
         from the hierarchy it belongs.
         """
         if self.parent and self._name is None:
-            return self.parent[0].name + '.' + self.parent[1] + '_type'
+            return self.parent[0].name + "." + self.parent[1] + "_type"
         else:
-            return self._name or '__unnamed_dataformat__'
-
+            return self._name or "__unnamed_dataformat__"
 
     @name.setter
     def name(self, value):
         self._name = value
         self.storage = Storage(self.prefix, value)
 
-
     @property
     def schema_version(self):
         """Returns the schema version"""
-        return self.data.get('#schema_version', 1)
-
+        return self.data.get("#schema_version", 1)
 
     @property
     def extends(self):
         """If this dataformat extends another one, this is it, otherwise ``None``
         """
-        return self.data.get('#extends')
-
+        return self.data.get("#extends")
 
     @property
     def type(self):
@@ -305,16 +305,14 @@ class DataFormat(object):
         if self.resolved is None:
             raise RuntimeError("Cannot prototype while not properly initialized")
 
-        classname = re.sub(r'[-/]', '_', self.name)
-        if not isinstance(classname, str): classname = str(classname)
+        classname = re.sub(r"[-/]", "_", self.name)
+        if not isinstance(classname, str):
+            classname = str(classname)
 
-        def init(self, **kwargs): baseformat.__init__(self, **kwargs)
+        def init(self, **kwargs):
+            baseformat.__init__(self, **kwargs)
 
-        attributes = dict(
-                __init__=init,
-                _name=self.name,
-                _format=self.resolved,
-                )
+        attributes = dict(__init__=init, _name=self.name, _format=self.resolved)
 
         # create the converters for the class we're about to return
         for k, v in self.resolved.items():
@@ -324,7 +322,7 @@ class DataFormat(object):
                 if isinstance(v[-1], DataFormat):
                     attributes[k][-1] = v[-1].type
                 else:
-                    if v[-1] in ('string', 'str'):
+                    if v[-1] in ("string", "str"):
                         attributes[k][-1] = str
                     else:
                         attributes[k][-1] = numpy.dtype(v[-1])
@@ -333,35 +331,27 @@ class DataFormat(object):
                 attributes[k] = v.type
 
             else:  # it is a simple type
-                if v in ('string', 'str'):
+                if v in ("string", "str"):
                     attributes[k] = str
                 else:
                     attributes[k] = numpy.dtype(v)
 
-        return type(
-                classname,
-                (baseformat,),
-                attributes,
-                )
-
+        return type(classname, (baseformat,), attributes)
 
     @property
     def valid(self):
         """A boolean that indicates if this dataformat is valid or not"""
         return not bool(self.errors)
 
-
     @property
     def description(self):
         """The short description for this object"""
-        return self.data.get('#description', None)
-
+        return self.data.get("#description", None)
 
     @description.setter
     def description(self, value):
         """Sets the short description for this object"""
-        self.data['#description'] = value
-
+        self.data["#description"] = value
 
     @property
     def documentation(self):
@@ -374,7 +364,6 @@ class DataFormat(object):
             return self.storage.doc.load()
         return None
 
-
     @documentation.setter
     def documentation(self, value):
         """Sets the full-length description for this object"""
@@ -382,12 +371,11 @@ class DataFormat(object):
         if not self._name:
             raise RuntimeError("dataformat has no name")
 
-        if hasattr(value, 'read'):
+        if hasattr(value, "read"):
             self.storage.doc.save(value.read())
         else:
             self.storage.doc.save(value)
 
-
     def hash(self):
         """Returns the hexadecimal hash for its declaration"""
 
@@ -396,7 +384,6 @@ class DataFormat(object):
 
         return self.storage.hash()
 
-
     def validate(self, data):
         """Validates a piece of data provided by the user
 
@@ -421,13 +408,12 @@ class DataFormat(object):
 
         obj = self.type()
         if isinstance(data, dict):
-            obj.from_dict(data, casting='safe', add_defaults=False)
+            obj.from_dict(data, casting="safe", add_defaults=False)
         elif isinstance(data, six.string_types):
             obj.unpack(data)
         else:
             obj.unpack_from(data)
 
-
     def isparent(self, other):
         """Tells if the other object extends self (directly or indirectly).
 
@@ -451,7 +437,6 @@ class DataFormat(object):
 
         return False
 
-
     def json_dumps(self, indent=4):
         """Dumps the JSON declaration of this object in a string
 
@@ -467,14 +452,11 @@ class DataFormat(object):
 
         """
 
-        return simplejson.dumps(self.data, indent=indent,
-            cls=utils.NumpyJSONEncoder)
-
+        return simplejson.dumps(self.data, indent=indent, cls=utils.NumpyJSONEncoder)
 
     def __str__(self):
         return self.json_dumps()
 
-
     def write(self, storage=None):
         """Writes contents to prefix location
 
@@ -493,7 +475,6 @@ class DataFormat(object):
 
         storage.save(str(self), self.description)
 
-
     def export(self, prefix):
         """Recursively exports itself into another prefix
 
@@ -523,8 +504,9 @@ class DataFormat(object):
             raise RuntimeError("dataformat is not valid")
 
         if prefix == self.prefix:
-            raise RuntimeError("Cannot export dataformat to the same prefix ("
-                               "%s)" % prefix)
+            raise RuntimeError(
+                "Cannot export dataformat to the same prefix (" "%s)" % prefix
+            )
 
         for k in self.referenced.values():
             k.export(prefix)
-- 
GitLab