brukerapi 0.1.9__py3-none-any.whl → 0.2.0__py3-none-any.whl

brukerapi/jcampdx.py

@@ -1,32 +1,50 @@
-import numpy as np
-from .exceptions import *
-from pathlib import Path
+import json
 import re
-import ast
 from collections import OrderedDict
-import json
+from pathlib import Path
 
-SUPPORTED_VERSIONS = ['4.24', '5.0', '5.00 Bruker JCAMP library', '5.00 BRUKER JCAMP library', '5.01']
+import numpy as np
+
+from .exceptions import InvalidJcampdxFile, JcampdxFileError, JcampdxVersionError, ParameterNotFound
+
+SUPPORTED_VERSIONS = ["4.24", "5.0", "5.00 Bruker JCAMP library", "5.00 BRUKER JCAMP library", "5.01"]
 GRAMMAR = {
-        'COMMENT_LINE' : '\$\$[^\n]*\n',
-        'PARAMETER': '##',
-        'USER_DEFINED' : '\$',
-        'TRAILING_EOL' : '\n$',
-        'DATA_LABEL' : '\(XY..XY\)',
-        'DATA_DELIMETERS':', |\n',
-        'SIZE_BRACKET': '^\([^\(\)<>]*\)(?!$)',
-        'LIST_DELIMETER': ', ',
-        'EQUAL_SIGN': '=',
-        'SINGLE_NUMBER':'-?[\d.]+(?:e[+-]?\d+)?',
-        'PARALLEL_BRACKET': '\) ',
-        'GEO_OBJ': '\(\(\([\s\S]*\)[\s\S]*\)[\s\S]*\)',
-        'HEADER':'TITLE|JCAMPDX|JCAMP-DX|DATA TYPE|DATATYPE|ORIGIN|OWNER',
-        'VERSION_TITLE':'JCAMPDX|JCAMP-DX'
-    }
+    "COMMENT_LINE": r"\$\$[^\n]*\n",
+    "PARAMETER": "##",
+    "USER_DEFINED": r"\$",
+    "TRAILING_EOL": r"\n$",
+    "DATA_LABEL": r"\(XY..XY\)",
+    "DATA_DELIMETERS": r", |\n",
+    "SIZE_BRACKET": r"^\([^\(\)<>]*\)(?!$)",
+    "LIST_DELIMETER": ", ",
+    "EQUAL_SIGN": "=",
+    "SINGLE_NUMBER": r"-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?",
+    "PARALLEL_BRACKET": r"\) ",
+    "GEO_OBJ": r"\(\(\([\s\S]*\)[\s\S]*\)[\s\S]*\)",
+    "HEADER": "TITLE|JCAMPDX|JCAMP-DX|DATA TYPE|DATATYPE|ORIGIN|OWNER",
+    "VERSION_TITLE": "JCAMPDX|JCAMP-DX",
+}
+
 MAX_LINE_LEN = 78
 
+# Precompile all regexes
+_COMPILED_GRAMMAR = {k: re.compile(v) if k not in ["LIST_DELIMETER", "EQUAL_SIGN"] else v for k, v in GRAMMAR.items()}
+
+# Example usage:
+_COMMENT_RE = _COMPILED_GRAMMAR["COMMENT_LINE"]
+_USER_DEFINED_RE = _COMPILED_GRAMMAR["USER_DEFINED"]
+_TRAILING_EOL_RE = _COMPILED_GRAMMAR["TRAILING_EOL"]
+_DATA_LABEL_RE = _COMPILED_GRAMMAR["DATA_LABEL"]
+_SIZE_BRACKET_RE = _COMPILED_GRAMMAR["SIZE_BRACKET"]
+_SINGLE_NUMBER_RE = _COMPILED_GRAMMAR["SINGLE_NUMBER"]
+_PARALLEL_BRACKET_RE = _COMPILED_GRAMMAR["PARALLEL_BRACKET"]
+_GEO_OBJ_RE = _COMPILED_GRAMMAR["GEO_OBJ"]
+_HEADER_RE = _COMPILED_GRAMMAR["HEADER"]
+_VERSION_TITLE_RE = _COMPILED_GRAMMAR["VERSION_TITLE"]
+_PARAMETER_RE = _COMPILED_GRAMMAR["PARAMETER"]
 
-class Parameter(object):
+
+class Parameter:
     """
     Data model of a single jcamp-dx parameter.
 
@@ -48,6 +66,7 @@ class Parameter(object):
 
     The value is parsed once it is requested. Parse methods are different for individual subclasses.
     """
+
     def __init__(self, key_str, size_str, val_str, version):
         """
         :param key_str: key part of the parameter e.g. ##$ACQ_ReceiverSelect
@@ -61,18 +80,17 @@ class Parameter(object):
         self.version = version
 
     def __str__(self):
+        str_ = f"{self.key_str}"
 
-        str_ = '{}'.format(self.key_str)
-
-        if self.version == '4.24':
-            str_ += '='
+        if self.version == "4.24":
+            str_ += "="
         else:
-            str_ += '= '
+            str_ += "= "
 
-        if self.size_str != '':
-            str_ += '{}\n'.format(self.size_str)
+        if self.size_str != "":
+            str_ += f"{self.size_str}\n"
 
-        str_ += '{}'.format(self.val_str)
+        str_ += f"{self.val_str}"
 
         return str_
 
@@ -80,64 +98,56 @@ class Parameter(object):
         return self.key_str
 
     def to_dict(self):
-
-        result = {'value': self._encode_parameter(self.value)}
+        result = {"value": self._encode_parameter(self.value)}
 
         if self.size:
-            result['size'] = self._encode_parameter(self.size)
+            result["size"] = self._encode_parameter(self.size)
 
         return result
 
     def _encode_parameter(self, var):
-        if isinstance(var, np.integer) or isinstance(var, np.int32):
+        if isinstance(var, (np.integer, np.int32)):
             return int(var)
-        elif isinstance(var, np.floating):
+        if isinstance(var, np.floating):
             return float(var)
-        elif isinstance(var, np.ndarray):
+        if isinstance(var, np.ndarray):
             return var.tolist()
-        elif isinstance(var, np.dtype):
+        if isinstance(var, np.dtype):
             return var.name
-        elif isinstance(var, list):
+        if isinstance(var, list):
             return [self._encode_parameter(var_) for var_ in var]
-        elif isinstance(var, tuple):
+        if isinstance(var, tuple):
             return self._encode_parameter(list(var))
-        else:
-            return var
-
+        return var
 
     @property
     def key(self):
-        return re.sub('##', '', re.sub('\$', '', self.key_str)).rstrip()
+        return self.key_str.replace("##", "").replace("$", "").rstrip()
 
     @key.setter
     def key(self, key):
-        #Throw error
+        # Throw error
         pass
 
     @property
     def user_defined(self):
-        if re.search(GRAMMAR['USER_DEFINED'], self.key_str):
-            return True
-        else:
-            return False
+        return bool(_USER_DEFINED_RE.search(self.key_str))
 
     @property
     def tuple(self):
         value = self.value
-        if isinstance(value, int) or isinstance(value, float):
+        if isinstance(value, (int, float)):
             return (value,)
-        else:
-            return tuple(value)
+        return tuple(value)
 
     @property
     def list(self):
         value = self.value
         if isinstance(value, list):
             return value
-        elif isinstance(value, float) or isinstance(value, int) or isinstance(value, str):
+        if isinstance(value, (float, int, str)):
             return [value]
-        else:
-            return list(value)
+        return list(value)
 
     @property
     def nested(self):
@@ -157,9 +167,7 @@ class Parameter(object):
         value = self.list
         if isinstance(value[0], list):
             return value
-        else:
-            return [value]
-
+        return [value]
 
     @property
     def array(self):
@@ -170,10 +178,7 @@ class Parameter(object):
         value = self.value
         if isinstance(value, np.ndarray):
             return value.shape
-        else:
-            raise AttributeError
-
-
+        raise AttributeError
 
     @classmethod
     def pack_key(cls, value, usr_defined):
@@ -182,31 +187,25 @@ class Parameter(object):
         val_str = value
 
         if usr_defined:
-            val_str = '$' + val_str
+            val_str = "$" + val_str
 
-        return '##' + val_str
+        return "##" + val_str
 
 
 class GenericParameter(Parameter):
     def __init__(self, version, key, size_bracket, value):
-        super(GenericParameter, self).__init__(version, key, size_bracket, value)
+        super().__init__(version, key, size_bracket, value)
 
     @classmethod
     def from_values(cls, version, key, size, value, user_defined):
-
-        key_str = key
-        size_str = size
-        value_str = value
-
-        super(GenericParameter, cls).__init__(version, key_str, size_str, value_str)
+        return cls(version, key, size, value)
 
     @property
-    def value(self, **kwargs):
-
-        val_str = re.sub('\n', '', self.val_str)
+    def value(self):
+        val_str = self.val_str.replace("\n", "")
 
         # unwrap wrapped list
-        if re.match('@[0-9]*\*',val_str) is not None:
+        if re.match(r"@[0-9]*\*", val_str) is not None:
             val_str = self._unwrap_list(val_str)
 
         val_str_list = GenericParameter.split_parallel_lists(val_str)
@@ -219,12 +218,10 @@ class GenericParameter(Parameter):
                 value.append(GenericParameter.parse_value(val_str))
 
         if isinstance(value, np.ndarray) and self.size:
-            if not 'str' in value.dtype.name:
-                return np.reshape(value, self.size, order='C')
-            else:
-                return value
-        else:
+            if "str" not in value.dtype.name:
+                return np.reshape(value, self.size, order="C")
             return value
+        return value
 
     @value.setter
     def value(self, value):
@@ -246,7 +243,7 @@ class GenericParameter(Parameter):
             val_str = value
 
         self.size = size
-        self.val_str= val_str
+        self.val_str = val_str
 
     def primed_dict(self, index):
         nested_list = self.nested
@@ -265,20 +262,17 @@ class GenericParameter(Parameter):
 
         return sub_list
 
-
-
-
     @property
     def size(self):
         size_str = self.size_str[1:-2]
 
-        if size_str == '':
+        if size_str == "":
             return None
 
-        #"(3,3)\n" -> 3,3
+        # "(3,3)\n" -> 3,3
         if ".." in size_str:
             try:
-                size_str = np.array(size_str.split(".."), dtype='int32')
+                size_str = np.array(size_str.split(".."), dtype="int32")
                 size = range(size_str[0], size_str[1])
             except ValueError:
                 # size bracket is returned as string
@@ -287,7 +281,7 @@ class GenericParameter(Parameter):
 
         elif "," in size_str:
             size_str = size_str.split(",")
-            size = tuple(np.array(size_str, dtype='int32'))
+            size = tuple(np.array(size_str, dtype="int32"))
         else:
             size = (int(size_str),)
 
@@ -296,55 +290,55 @@ class GenericParameter(Parameter):
     @size.setter
     def size(self, size):
         if size is None:
-            self.size_str = ''
+            self.size_str = ""
             return
 
         if isinstance(size, tuple):
             # (1,3,3) -> "( 1,3,3 )"
             if len(size) > 1:
-                size_str = '( {} )'.format(str(size)[1:-1])
-            #(1,) -> "( 1 )"
+                size_str = f"( {str(size)[1:-1]} )"
+            # (1,) -> "( 1 )"
             else:
-                size_str = '( {} )'.format(str(size)[1:-2])
+                size_str = f"( {str(size)[1:-2]} )"
         elif isinstance(size, range):
-            size_str = '({size.start}..{size.stop})'.format(size.start, size.stop)
+            size_str = "({size.start}..{size.stop})"
         elif isinstance(size, int):
-            size_str = '( {} )'.format(str(size))
+            size_str = f"( {size!s} )"
         else:
-            size_str = '({})'.format(size)
+            size_str = f"({size})"
 
         self.size_str = size_str
 
     @classmethod
     def parse_value(cls, val_str, size_bracket=None):
         # remove \n
-        val_str = re.sub('\n','', val_str)
+        val_str = val_str.replace("\n", "")
 
         # sharp string
-        if val_str.startswith('<') and val_str.endswith('>'):
-
-            val_strs = re.findall('<[^<>]*>', val_str)
+        if val_str.startswith("<") and val_str.endswith(">"):
+            val_strs = re.findall("<[^<>]*>", val_str)
 
             if len(val_strs) == 1:
                 return val_strs[0]
-            else:
-                return np.array(val_strs)
-
+            return np.array(val_strs)
 
         # int/float
-        if len(re.findall(GRAMMAR['SINGLE_NUMBER'],val_str))==1:
+        if _SINGLE_NUMBER_RE.fullmatch(val_str):
             try:
-                value = ast.literal_eval(val_str)
+                try:
+                    value = int(val_str)
+                except ValueError:
+                    value = float(val_str)
 
                 # if value is int, or float, return, tuple will be parsed as list later on
-                if isinstance(value, float) or isinstance(value, int):
+                if isinstance(value, (float, int)):
                     return value
             except (ValueError, SyntaxError):
                 pass
 
         # list
-        if val_str.startswith('(') and val_str.endswith(''):
-            val_strs = re.split(GRAMMAR['LIST_DELIMETER'], val_str[1:-1])
+        if val_str.startswith("(") and val_str.endswith(""):
+            val_strs = val_str[1:-1].split(", ")
             value = []
 
             for val_str in val_strs:
@@ -352,27 +346,25 @@ class GenericParameter(Parameter):
 
             return value
 
-        val_strs = re.split(' ', val_str)
+        val_strs = val_str.split(" ")
 
         if len(val_strs) > 1:
             # try casting into int, or float array, if both of casts fail, it should be string array
             try:
-                return np.array(val_strs).astype('int')
+                return np.array(val_strs).astype("int")
             except ValueError:
                 pass
 
             try:
-                return np.array(val_strs).astype('float')
+                return np.array(val_strs).astype("float")
             except ValueError:
                 pass
 
             return np.array(val_strs)
-        else:
-            return val_strs[0]
+        return val_strs[0]
 
     @classmethod
     def serialize_value(cls, value):
-
         if isinstance(value, float):
             val_str = cls.serialize_float(value)
         elif isinstance(value, int):
@@ -388,65 +380,60 @@ class GenericParameter(Parameter):
     @classmethod
     def serialize_float(cls, value, version):
         if version == 4.24:
-            return "{:.6e}".format(value)
-        else:
-            return str(value)
+            return f"{value:.6e}"
+        return str(value)
 
     @classmethod
     def serialize_list(cls, value):
-
         if isinstance(value[0], list):
-
-            val_str = ''
+            val_str = ""
 
             for value_ in value:
                 val_str += cls.serialize_list(value_)
-                val_str += ' '
+                val_str += " "
 
             return val_str
 
-
-        val_str = '('
+        val_str = "("
 
         for item in value:
             val_str += cls.serialize_value(item)
-            val_str += ', '
+            val_str += ", "
 
-        return val_str[:-2] + ')'
+        return val_str[:-2] + ")"
 
     @classmethod
     def serialize_nested_list(cls, values):
-        val_str = ''
+        val_str = ""
 
         for value in values:
             val_str += GenericParameter.serialize_list(value)
-            val_str += ' '
+            val_str += " "
 
         return val_str[0:-1]
 
     @classmethod
     def serialize_ndarray(cls, value):
-        val_str = ''
+        val_str = ""
 
         for value_ in value:
             val_str_ = str(value_)
             val_str += val_str_
-            val_str += ' '
+            val_str += " "
 
         return val_str[:-1]
 
     @classmethod
     def split_parallel_lists(cls, val_str):
-        lst = re.split(GRAMMAR['PARALLEL_BRACKET'], val_str)
+        lst = _PARALLEL_BRACKET_RE.split(val_str)
 
         if len(lst) == 1:
             return lst[0]
 
         def restore_right_bra(string):
-            if string.endswith(')'):
+            if string.endswith(")"):
                 return string
-            else:
-                return string + ')'
+            return string + ")"
 
         for i in range(len(lst)):
             lst[i] = restore_right_bra(lst[i])
@@ -454,17 +441,16 @@ class GenericParameter(Parameter):
         return lst
 
     def _unwrap_list(self, val_str):
-
-        while re.search('@[0-9]*\*\(\d*\.?\d*\)', val_str):
-            match = re.search('@[0-9]*\*\(\d*\.?\d*\)', val_str)
-            left = val_str[0:match.start()]
-            right = val_str[match.end():]
-            sub = val_str[match.start():match.end()]
-            size, value = re.split('\*', sub)
+        while re.search(r"@[0-9]*\*\(-?\d*\.?\d*\)", val_str):
+            match = re.search(r"@[0-9]*\*\(-?\d*\.?\d*\)", val_str)
+            left = val_str[0 : match.start()]
+            right = val_str[match.end() :]
+            sub = val_str[match.start() : match.end()]
+            size, value = re.split(r"\*", sub)
             size = int(size[1:])
-            middle = ''
-            for i in range(size):
-                middle += '{} '.format(value[1:-1])
+            middle = ""
+            for _ in range(size):
+                middle += f"{value[1:-1]} "
             val_str = left + middle[0:-1] + right
 
         return val_str
@@ -472,7 +458,7 @@ class GenericParameter(Parameter):
 
 class HeaderParameter(Parameter):
     def __init__(self, key_str, size_str, val_str, version):
-        super(HeaderParameter, self).__init__(key_str, size_str, val_str, version)
+        super().__init__(key_str, size_str, val_str, version)
 
     @property
     def value(self):
@@ -489,7 +475,7 @@ class HeaderParameter(Parameter):
 
 class GeometryParameter(Parameter):
     def __init__(self, key_str, size_str, val_str, version):
-        super(GeometryParameter, self).__init__(key_str, size_str, val_str, version)
+        super().__init__(key_str, size_str, val_str, version)
 
     @property
     def value(self):
@@ -506,7 +492,7 @@ class GeometryParameter(Parameter):
     #     :return: 4x4 3D Affine Transformation Matrix
     #     """
     #     # TODO support for multiple slice packages
-    #     match = re.match('\(\(\([^\)]*\)', self.val_str)
+    #     match = re.match(r'\(\(\([^\)]*\)', self.val_str)
     #     affine_str = self.val_str[match.start() + 3: match.end() - 1]
     #     orient, shift = affine_str.split(', ')
     #
@@ -519,7 +505,6 @@ class GeometryParameter(Parameter):
     #     return affine
 
     def to_dict(self):
-
         # result = {'affine': self._encode_parameter(self.affine)}
         result = {}
         return result
@@ -527,11 +512,11 @@ class GeometryParameter(Parameter):
 
 class DataParameter(Parameter):
     def __init__(self, version, key, size_bracket, value):
-        super(DataParameter, self).__init__(version, key, size_bracket, value)
+        super().__init__(version, key, size_bracket, value)
 
     @property
     def value(self):
-        val_list = re.split(GRAMMAR['DATA_DELIMETERS'], self.val_str)
+        val_list = self.val_str.replace("\n", ",").split(", ")
         data = [GenericParameter.parse_value(x) for x in val_list]
         return np.reshape(data, (2, -1))
 
@@ -540,11 +525,11 @@ class DataParameter(Parameter):
         val_str = ""
 
         for i in range(len(value)):
-            val_str += "{:.6e}".format(value[i])
+            val_str += f"{value[i]:.6e}"
             if np.mod(i, 2) == 0:
-                val_str += ', '
+                val_str += ", "
             else:
-                val_str += '\n'
+                val_str += "\n"
 
         self.value = val_str
 
@@ -554,10 +539,10 @@ class DataParameter(Parameter):
 
     @size.setter
     def size(self, value):
-        self.size_str = '({})'.format(value)
+        self.size_str = f"({value})"
 
 
-class JCAMPDX(object):
+class JCAMPDX:
     """Representation of a single jcamp-dx file.
 
     It's main component is a dictionary of parameters.
@@ -569,17 +554,19 @@ class JCAMPDX(object):
 
         from bruker.jcampdx import JCAMPDX
 
-        visu_pars = JCAMPDX('path/visu_pars')
-        size = visu_pars.get_value('VisuCoreSize')
+        visu_pars = JCAMPDX("path/visu_pars")
+        size = visu_pars.get_value("VisuCoreSize")
 
     """
 
-    def __init__(self, path, load=True, **kwargs):
+    def __init__(self, path, load=None, **kwargs):
         """JCAMPDX constructor
 
         JCAMPDX object is constructed by passing a path to a valid jcamp-dx file. It is possible to construct an
         empty object.
         """
+        if load is None:
+            load = True
 
         # If path is directory
         self.path = Path(path)
@@ -601,21 +588,18 @@ class JCAMPDX(object):
         return self.path.name
 
     def __str__(self, file=None):
-
-
         if self.params == {}:
             return self.type
 
-        jcampdx_serial = ''
+        jcampdx_serial = ""
 
         for param in self.params.values():
-
             param_str = str(param)
 
             if len(param_str) > 78:
                 param_str = JCAMPDX.wrap_lines(param_str)
 
-            jcampdx_serial += '{}\n'.format(param_str)
+            jcampdx_serial += f"{param_str}\n"
 
         return jcampdx_serial[0:-1] + "\n##END= "
 
@@ -633,6 +617,9 @@ class JCAMPDX(object):
     def __getitem__(self, key):
         return self.params[key]
 
+    def __contains__(self, item):
+        return item in self.params
+
     def __delitem__(self, key):
         del self.params[key]
 
@@ -646,7 +633,7 @@ class JCAMPDX(object):
         self.params = {}
 
     def to_dict(self):
-        parameters =  {}
+        parameters = {}
 
         for param in self.params.items():
             parameters[param[0]] = param[1].to_dict()
@@ -661,34 +648,27 @@ class JCAMPDX(object):
         :param names: *list* names of properties to be exported
         """
         if path:
-            with open(path, 'w') as json_file:
-                    json.dump(self.to_dict(), json_file, indent=4)
+            with open(path, "w") as json_file:
+                json.dump(self.to_dict(), json_file, indent=4)
         else:
             return json.dumps(self.to_dict(), indent=4)
+        return None
 
     @property
     def version(self):
-        try:
-            return self.params['JCAMPDX'].value
-        except KeyError:
-            pass
-
-        try:
-            self.params['JCAMP-DX'].value
-        except KeyError:
-            pass
-
-        try:
-            _, version = JCAMPDX.load_parameter(self.path, 'JCAMPDX')
-            return version.value
-        except (InvalidJcampdxFile, ParameterNotFound):
-            pass
+        if "JCAMPDX" in self.params:
+            return self.params["JCAMPDX"]
 
         try:
-            _, version = JCAMPDX.load_parameter(self.path, 'JCAMP-DX')
-            return version.value
-        except (InvalidJcampdxFile, ParameterNotFound):
-            pass
+            with self.path.open("r") as f:
+                for _ in range(10):
+                    line = f.readline()
+                    if line.startswith("##JCAMPDX="):
+                        return line.strip().split("=", 1)[1]
+                    if line.startswith("##JCAMP-DX="):
+                        return line.strip().split("=", 1)[1]
+        except (UnicodeDecodeError, OSError) as e:
+            raise InvalidJcampdxFile from e
 
         raise InvalidJcampdxFile(self.path)
 
@@ -702,6 +682,7 @@ class JCAMPDX(object):
     """
     PUBLIC INTERFACE
     """
+
     def get_parameters(self):
         return self.params
 
@@ -715,33 +696,37 @@ class JCAMPDX(object):
         return self.params[key].value
 
     def get_list(self, key):
-        """Idea is to ensure, that a parameter will be a list even if parameter only contains one entry
-        """
+        """Idea is to ensure, that a parameter will be a list even if parameter only contains one entry"""
         value = self.get_value(key)
         if isinstance(value, list):
             return value
-        elif isinstance(value, np.ndarray):
+        if isinstance(value, np.ndarray):
             return list(value)
-        else:
-            return [value, ]
+        return [
+            value,
+        ]
 
     def get_nested_list(self, key):
         value = self.get_value(key)
         if not isinstance(value, list):
-            value =[value,]
+            value = [
+                value,
+            ]
 
         if not isinstance(value[0], list):
-            value = [value, ]
+            value = [
+                value,
+            ]
 
         return value
 
-    def set_nested_list(self,key, value):
+    def set_nested_list(self, key, value):
         self.params[key].value = value
 
     def get_int(self, key):
         return int(self.get_value(key))
 
-    def set_int(self,key, value):
+    def set_int(self, key, value):
         self.params[key].value = value
 
     def get_float(self, key):
@@ -750,13 +735,12 @@ class JCAMPDX(object):
     def get_tuple(self, key):
         value = self.get_value(key)
 
-        if isinstance(value, int) or isinstance(value, float):
+        if isinstance(value, (int, float)):
             return (value,)
-        else:
-            return tuple(value)
+        return tuple(value)
 
-    def get_array(self, key, dtype=None, shape=(-1,), order='C'):
-        parameter=self.get_parameter(key)
+    def get_array(self, key, dtype=None, shape=(-1,), order="C"):
+        parameter = self.get_parameter(key)
         value = parameter.value
         size = parameter.size
 
@@ -771,17 +755,19 @@ class JCAMPDX(object):
 
         return np.reshape(value, shape, order=order)
 
-    def set_array(self, key, value, file=None , order='C'):
-
-        parameter = self.get_parameter(key, file)
+    def set_array(self, key, value, file=None, order="C"):
+        self.get_parameter(key, file)
 
-        value = np.reshape(value,(-1,), order=order)
+        value = np.reshape(value, (-1,), order=order)
         self.__setattr__(key, value.tolist())
 
-    def get_str(self, key, strip_sharp=True):
+    def get_str(self, key, strip_sharp=None):
+        if strip_sharp is None:
+            strip_sharp = True
+
         value = str(self.get_value(key))
 
-        if strip_sharp and value.startswith('<') and value.endswith('>'):
+        if strip_sharp and value.startswith("<") and value.endswith(">"):
             value = value[1:-1]
 
         return value
@@ -796,22 +782,21 @@ class JCAMPDX(object):
         with open(path) as f:
             try:
                 content = f.read()
-            except:
-                raise InvalidJcampdxFile(path)
+            except (UnicodeDecodeError, OSError) as e:
+                raise InvalidJcampdxFile(path) from e
 
-        match = re.search('##{}[^\#\$]+|##\${}[^\#\$]+'.format(key,key), content)
+        match = re.search(rf"##{key}[^\#\$]+|##\${key}[^\#\$]+", content)
 
-        if match == None:
+        if match is None:
             raise ParameterNotFound(key, path)
 
-        line = content[match.start():match.end()-1] # strip trailing EOL
+        line = content[match.start() : match.end() - 1]  # strip trailing EOL
         key, parameter = JCAMPDX.handle_jcampdx_line(line, None)
 
         return key, parameter
 
     @classmethod
     def read_jcampdx(cls, path):
-
         path = Path(path)
 
         params = {}
@@ -819,25 +804,26 @@ class JCAMPDX(object):
         with path.open() as f:
             try:
                 content = f.read()
-            except:
-                raise JcampdxFileError('file {} is not a text file'.format(path))
+            except (UnicodeDecodeError, OSError) as e:
+                raise JcampdxFileError(f"file {path} is not a text file") from e
 
         # remove all comments
-        content = re.sub(GRAMMAR['COMMENT_LINE'], '', content)
+        content = _COMMENT_RE.sub("", content)
 
         # split into individual entries
-        content = re.split(GRAMMAR['PARAMETER'], content)[1:-1]
+        content = _PARAMETER_RE.split(content)[1:-1]
 
         # strip trailing EOL
-        content = [re.sub(GRAMMAR['TRAILING_EOL'],'',x) for x in content]
+        content = [_TRAILING_EOL_RE.sub("", x) for x in content]
 
         # ASSUMPTION the jcampdx version string is in the second row
         try:
             version_line = content[1]
-            if re.search(GRAMMAR['VERSION_TITLE'], version_line) is None:
-                raise JcampdxFileError('file {} is not a JCAMP-DX file'.format(path))
-        except:
-            raise JcampdxFileError('file {} is not a text file'.format(path))
+        except IndexError:
+            raise JcampdxFileError(f"file {path} is too short or not a text file") from IndexError
+
+        if re.search(GRAMMAR["VERSION_TITLE"], version_line) is None:
+            raise JcampdxFileError(f"file {path} is not a JCAMP-DX file")
 
         _, _, version = JCAMPDX.divide_jcampdx_line(version_line)
 
@@ -846,18 +832,19 @@ class JCAMPDX(object):
 
         for line in content:
             # Restore the ##
-            key, parameter = JCAMPDX.handle_jcampdx_line('##{}'.format(line), version)
+            key, parameter = JCAMPDX.handle_jcampdx_line(f"##{line}", version)
             params[key] = parameter
         return params
 
     @classmethod
     def handle_jcampdx_line(cls, line, version):
         key_str, size_str, val_str = cls.divide_jcampdx_line(line)
-        if re.search(GRAMMAR['GEO_OBJ'], line) is not None:
+
+        if _GEO_OBJ_RE.search(line) is not None:
             parameter = GeometryParameter(key_str, size_str, val_str, version)
-        elif re.search(GRAMMAR['DATA_LABEL'], line):
+        elif _DATA_LABEL_RE.search(line):
             parameter = DataParameter(key_str, size_str, val_str, version)
-        elif re.search(GRAMMAR['HEADER'],key_str):
+        elif _HEADER_RE.search(key_str):
             parameter = HeaderParameter(key_str, size_str, val_str, version)
         else:
             parameter = GenericParameter(key_str, size_str, val_str, version)
@@ -872,11 +859,11 @@ class JCAMPDX(object):
 
     @classmethod
     def split_key_value_pair(cls, line):
-        # ASSUMPTION the first occurence of = in jcampdx line divides key and value pair
+        # ASSUMPTION the first occurrence of = in jcampdx line divides key and value pair
         # example:
-        match = re.search(GRAMMAR['EQUAL_SIGN'], line)
-        key = line[0:match.start()]
-        val_str = line[match.end():].lstrip()
+        match = re.search(GRAMMAR["EQUAL_SIGN"], line)
+        key = line[0 : match.start()]
+        val_str = line[match.end() :].lstrip()
         return key, val_str
 
     @classmethod
@@ -891,36 +878,35 @@ class JCAMPDX(object):
         :return value: value string without bracket in case, size bracket is found, otherwise returns unmodified val_str
         :return size: size bracket str
         """
-        match = re.search(GRAMMAR['SIZE_BRACKET'], val_str)
+        match = re.search(GRAMMAR["SIZE_BRACKET"], val_str)
 
         if match is None:
-            return val_str, ''
-        else:
-            size_bracket = val_str[match.start():match.end()]
-            val_str = val_str[match.end():].lstrip()
+            return val_str, ""
+        size_bracket = val_str[match.start() : match.end()]
+        val_str = val_str[match.end() :].lstrip()
 
         return val_str, size_bracket
 
     @classmethod
     def wrap_lines(cls, line):
-        line_wraps = re.split('\n', line)
+        line_wraps = re.split(r"\n", line)
         tail = line_wraps[-1]
 
-        tail_bits = re.split('\s', tail)
+        tail_bits = re.split(r"\s", tail)
 
         lines = 1
-        tail = ''
+        tail = ""
 
         for tail_bit in tail_bits:
             if len(tail + tail_bit) > lines * MAX_LINE_LEN:
-                tail += '\n'
+                tail += "\n"
                 lines += 1
             tail += tail_bit
-            tail += ' '
+            tail += " "
 
         line_wraps[-1] = tail[:-1]
 
-        return '\n'.join(line_wraps)
+        return "\n".join(line_wraps)
 
     def write(self, path):
         """
@@ -928,5 +914,5 @@ class JCAMPDX(object):
         :param path:
         :return:
         """
-        with Path(path).open('w') as f:
+        with Path(path).open("w") as f:
             f.write(str(self))