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