Format with ruff

Author: t-sommer

src/sdf/__init__.py

@@ -7,14 +7,14 @@
 
 from . import hdf5
 
-__version__ = '0.3.6'
+__version__ = "0.3.6"
 
-_object_name_pattern = re.compile('[a-zA-Z][a-zA-Z0-9_]*')
+_object_name_pattern = re.compile("[a-zA-Z][a-zA-Z0-9_]*")
 
 
 @define(eq=False)
 class Group:
-    """ SDF Group """
+    """SDF Group"""
 
     name: str = None
     comment: str = None
@@ -41,7 +41,7 @@ def __iter__(self):
 
 @define(eq=False)
 class Dataset:
-    """ SDF Dataset """
+    """SDF Dataset"""
 
     name: str = None
     comment: str = None
@@ -87,7 +87,7 @@ def d(self):
 
 
 def validate(obj: Group | Dataset) -> list[str]:
-    """ Validate an sdf.Group or sdf.Dataset """
+    """Validate an sdf.Group or sdf.Dataset"""
 
     problems = []
 
@@ -102,11 +102,12 @@ def validate(obj: Group | Dataset) -> list[str]:
 
 
 def _validate_group(group, is_root=False):
-
     problems = []
 
     if not is_root and not _object_name_pattern.match(group.name):
-        problems.append("Object names must only contain letters, digits, and underscores (\"_\") and must start with a letter.")
+        problems.append(
+            'Object names must only contain letters, digits, and underscores ("_") and must start with a letter.'
+        )
 
     for child_group in group.groups:
         problems += _validate_dataset(child_group)
@@ -118,62 +119,79 @@ def _validate_group(group, is_root=False):
 
 
 def _validate_dataset(ds: Dataset) -> list[str]:
-
     if type(ds.data) is not np.ndarray:
-        return ['Dataset.data must be a numpy.ndarray']
+        return ["Dataset.data must be a numpy.ndarray"]
 
     elif ds.data.size < 1:
-        return ['Dataset.data must not be empty']
+        return ["Dataset.data must not be empty"]
 
     elif not np.issubdtype(ds.data.dtype, np.float64):
-        return ['Dataset.data.dtype must be numpy.float64']
+        return ["Dataset.data.dtype must be numpy.float64"]
 
     if ds.is_scale:
         if len(ds.data.shape) != 1:
-            return ['Scales must be one-dimensional']
+            return ["Scales must be one-dimensional"]
         if np.any(np.diff(ds.data) <= 0):
-            return ['Scales must be strictly monotonic increasing']
+            return ["Scales must be strictly monotonic increasing"]
     else:
-        if (len(ds.data.shape) >= 1) and (ds.data.shape[0] > 0) and not (len(ds.data.shape) == len(ds.scales)):
-            return ['The number of scales does not match the number of dimensions']
+        if (
+            (len(ds.data.shape) >= 1)
+            and (ds.data.shape[0] > 0)
+            and not (len(ds.data.shape) == len(ds.scales))
+        ):
+            return ["The number of scales does not match the number of dimensions"]
 
     return []
 
 
-def load(filename: str | PathLike, objectname: str = '/', unit: str = None, scale_units: list[str] = None) -> Dataset | Group:
-    """ Load a Dataset or Group from an SDF file """
+def load(
+    filename: str | PathLike,
+    objectname: str = "/",
+    unit: str = None,
+    scale_units: list[str] = None,
+) -> Dataset | Group:
+    """Load a Dataset or Group from an SDF file"""
 
-    if filename.endswith('.mat'):
+    if filename.endswith(".mat"):
         from . import dsres
+
         obj = dsres.load(filename, objectname)
     else:
         obj = hdf5.load(filename, objectname)
 
     if isinstance(obj, Dataset):
-
         # check the unit
         if unit is not None and unit != obj.unit:
-            raise Exception("Dataset '%s' has the wrong unit. Expected '%s' but was '%s'." % (obj.name, unit, obj.unit))
+            raise Exception(
+                "Dataset '%s' has the wrong unit. Expected '%s' but was '%s'."
+                % (obj.name, unit, obj.unit)
+            )
 
         # check the number of the scale units
         if scale_units is not None:
-
             if len(scale_units) != obj.data.ndim:
-                raise Exception("The number of scale units must be equal to the number of dimensions. " +
-                                "Dataset '%s' has %d dimension(s) but %d scale units where given."
-                                % (obj.name, obj.data.ndim, len(scale_units)))
+                raise Exception(
+                    "The number of scale units must be equal to the number of dimensions. "
+                    + "Dataset '%s' has %d dimension(s) but %d scale units where given."
+                    % (obj.name, obj.data.ndim, len(scale_units))
+                )
 
             # check the scale units
             for i, scale_unit in enumerate(scale_units):
                 scale = obj.scales[i]
                 if scale.unit != scale_unit:
-                    raise Exception(("The scale for dimension %d of '%s' has the wrong unit. " +
-                                    "Expected '%s' but was '%s'.") % (i + 1, obj.name, scale_unit, scale.unit))
+                    raise Exception(
+                        (
+                            "The scale for dimension %d of '%s' has the wrong unit. "
+                            + "Expected '%s' but was '%s'."
+                        )
+                        % (i + 1, obj.name, scale_unit, scale.unit)
+                    )
 
     return obj
 
 
 def save(filename: str | PathLike, group: Group):
-    """ Save an SDF group to a file """
+    """Save an SDF group to a file"""
 
     hdf5.save(filename, group)

src/sdf/dsres.py

@@ -7,120 +7,118 @@
 
 # extract strings from the matrix
 def strMatNormal(a):
-    return [''.join(s).rstrip() for s in a]
+    return ["".join(s).rstrip() for s in a]
 
-def strMatTrans(a):
-    return [''.join(s).rstrip() for s in zip(*a)]
 
+def strMatTrans(a):
+    return ["".join(s).rstrip() for s in zip(*a)]
 
-def _split_description(comment: str) -> tuple[str | None, str | None, str | None, dict[str, str]]:
 
+def _split_description(
+    comment: str,
+) -> tuple[str | None, str | None, str | None, dict[str, str]]:
     unit = None
     display_unit = None
     info = dict()
 
-    if comment.endswith(']'):
-        i = comment.rfind('[')
-        unit = comment[i + 1:-1]
+    if comment.endswith("]"):
+        i = comment.rfind("[")
+        unit = comment[i + 1 : -1]
         comment = comment[0:i].strip()
 
     if unit is not None:
-
-        if ':#' in unit:
-            segments = unit.split(':#')
+        if ":#" in unit:
+            segments = unit.split(":#")
             unit = segments[0]
             for segment in segments[1:]:
-                key, value = segment[1:-1].split('=')
+                key, value = segment[1:-1].split("=")
                 info[key] = value
 
-        if '|' in unit:
-            unit, display_unit = unit.split('|')
+        if "|" in unit:
+            unit, display_unit = unit.split("|")
 
     return unit, display_unit, comment, info
 
 
 def load(filename: str | PathLike, objectname: str) -> Dataset | Group:
-
     g_root = _load_mat(filename)
 
-    if objectname == '/':
+    if objectname == "/":
         return g_root
     else:
         obj = g_root
-        segments = objectname.split('/')
+        segments = objectname.split("/")
         for s in segments:
             if s:
                 obj = obj[s]
         return obj
 
 
 def _load_mat(filename: str) -> Group:
-
     mat = scipy.io.loadmat(filename, chars_as_strings=False)
 
     _vars = {}
     _blocks = []
 
     try:
-        fileInfo = strMatNormal(mat['Aclass'])
+        fileInfo = strMatNormal(mat["Aclass"])
     except KeyError:
-        raise Exception('File structure not supported!')
+        raise Exception("File structure not supported!")
 
-    if fileInfo[1] == '1.1':
-        if fileInfo[3] == 'binTrans':
+    if fileInfo[1] == "1.1":
+        if fileInfo[3] == "binTrans":
             # usually files from OpenModelica or Dymola auto saved,
             # all methods rely on this structure since this was the only
             # one understand by earlier versions
-            names = strMatTrans(mat['name'])  # names
-            descr = strMatTrans(mat['description'])  # descriptions
+            names = strMatTrans(mat["name"])  # names
+            descr = strMatTrans(mat["description"])  # descriptions
 
-            cons = mat['data_1']
-            traj = mat['data_2']
+            cons = mat["data_1"]
+            traj = mat["data_2"]
 
-            d = mat['dataInfo'][0, :]
-            x = mat['dataInfo'][1, :]
+            d = mat["dataInfo"][0, :]
+            x = mat["dataInfo"][1, :]
 
-        elif fileInfo[3] == 'binNormal':
+        elif fileInfo[3] == "binNormal":
             # usually files from dymola, save as...,
             # variables are mapped to the structure above ('binTrans')
-            names = strMatNormal(mat['name'])  # names
-            descr = strMatNormal(mat['description'])  # descriptions
+            names = strMatNormal(mat["name"])  # names
+            descr = strMatNormal(mat["description"])  # descriptions
 
-            cons = mat['data_1'].T
-            traj = mat['data_2'].T
+            cons = mat["data_1"].T
+            traj = mat["data_2"].T
 
-            d = mat['dataInfo'][:, 0]
-            x = mat['dataInfo'][:, 1]
+            d = mat["dataInfo"][:, 0]
+            x = mat["dataInfo"][:, 1]
         else:
-            raise Exception('File structure not supported!')
+            raise Exception("File structure not supported!")
 
         c = np.abs(x) - 1  # column
         s = np.sign(x)  # sign
 
         vars = zip(names, descr, d, c, s)
-    elif fileInfo[1] == '1.0':
+    elif fileInfo[1] == "1.0":
         # files generated with dymola, save as..., only plotted ...
         # fake the structure of a 1.1 transposed file
-        names = strMatNormal(mat['names'])  # names
+        names = strMatNormal(mat["names"])  # names
         _blocks.append(0)
-        mat['data_0'] = mat['data'].transpose()
-        del mat['data']
-        _absc = (names[0], '')
+        mat["data_0"] = mat["data"].transpose()
+        del mat["data"]
+        _absc = (names[0], "")
         for i in range(1, len(names)):
-            _vars[names[i]] = ('', 0, i, 1)
+            _vars[names[i]] = ("", 0, i, 1)
     else:
-        raise Exception('File structure not supported!')
+        raise Exception("File structure not supported!")
 
     # build the SDF tree
-    g_root = Group('/')
+    g_root = Group("/")
 
     ds_time = None
 
     for name, desc, d, c, s in vars:
-
         unit, display_unit, comment, info = _split_description(desc)
 
-        path = name.split('.')
+        path = name.split(".")
 
         g_parent = g_root
 
@@ -138,17 +136,36 @@ def _load_mat(filename: str) -> Group:
         else:
             data = traj[c, :] * s
 
-        if 'type' in info:
-            if info['type'] == 'Integer' or 'Boolean':
+        if "type" in info:
+            if info["type"] == "Integer" or "Boolean":
                 data = np.asarray(data, dtype=np.int32)
 
         if d == 0:
-            ds = Dataset(path[-1], comment="Simulation time", unit=unit, display_unit=display_unit, data=data)
+            ds = Dataset(
+                path[-1],
+                comment="Simulation time",
+                unit=unit,
+                display_unit=display_unit,
+                data=data,
+            )
             ds_time = ds
         elif d == 1:
-            ds = Dataset(path[-1], comment=comment, unit=unit, display_unit=display_unit, data=data)
+            ds = Dataset(
+                path[-1],
+                comment=comment,
+                unit=unit,
+                display_unit=display_unit,
+                data=data,
+            )
         else:
-            ds = Dataset(path[-1], comment=comment, unit=unit, display_unit=display_unit, data=data, scales=[ds_time])
+            ds = Dataset(
+                path[-1],
+                comment=comment,
+                unit=unit,
+                display_unit=display_unit,
+                data=data,
+                scales=[ds_time],
+            )
 
         g_parent.datasets.append(ds)
 

src/sdf/examples/excel2sdf.py

@@ -9,11 +9,11 @@
 
 
 # name of the Excel file to import
-filename = 'time_series.xlsx'
+filename = "time_series.xlsx"
 
 # open the workbook
 book = xlrd.open_workbook(filename)
-    
+
 # get the first sheet
 sh = book.sheet_by_index(0)
 
@@ -33,14 +33,14 @@
 u = array(col_u)
 
 # create the datasets
-ds_t = sdf.Dataset(n_t, data=t, unit=u_t, is_scale=True, display_name='Time')
+ds_t = sdf.Dataset(n_t, data=t, unit=u_t, is_scale=True, display_name="Time")
 ds_u = sdf.Dataset(n_u, data=u, unit=u_u, scales=[ds_t])
 
 # create the root group
-g = sdf.Group('/', comment='Imported from ' + filename, datasets=[ds_t, ds_u])
+g = sdf.Group("/", comment="Imported from " + filename, datasets=[ds_t, ds_u])
 
 # change the file extension
-outfile = os.path.splitext(filename)[0] + '.sdf'
+outfile = os.path.splitext(filename)[0] + ".sdf"
 
 # write the SDF file
 sdf.save(outfile, g)