black -S xija

Author: taldcroft

pyproject.toml

@@ -0,0 +1,19 @@
+[tool.black]
+include = '\.pyi?$'
+exclude = '''
+/(
+    \.git
+  | \.hg
+  | \.mypy_cache
+  | \.tox
+  | \.venv
+  | _build
+  | buck-out
+  | build
+  | dist
+  | docs
+)/
+'''
+
+[tool.isort]
+profile = "black"

xija/__init__.py

@@ -7,19 +7,21 @@
 
 __version__ = ska_helpers.get_version(__package__)
 
+
 def test(*args, **kwargs):
     """Run py.test unit tests.
 
     Parameters
     ----------
     *args :
-        
+
     **kwargs :
-        
+
 
     Returns
     -------
 
     """
     import testr
+
     return testr.test(*args, **kwargs)

xija/clogging.py

@@ -9,18 +9,25 @@ def emit(self, record):
         pass
 
 
-def config_logger(name, format='%(message)s', datefmt=None,
-                  stream=sys.stdout, level=logging.INFO,
-                  filename=None, filemode='w', filelevel=None,
-                  propagate=False):
+def config_logger(
+    name,
+    format='%(message)s',
+    datefmt=None,
+    stream=sys.stdout,
+    level=logging.INFO,
+    filename=None,
+    filemode='w',
+    filelevel=None,
+    propagate=False,
+):
     """Do basic configuration for the logging system. Similar to
     logging.basicConfig but the logger ``name`` is configurable and both a file
     output and a stream output can be created. Returns a logger object.
-    
+
     The default behaviour is to create a StreamHandler which writes to
     sys.stdout, set a formatter using the "%(message)s" format string, and
     add the handler to the ``name`` logger.
-    
+
     A number of optional keyword arguments may be specified, which can alter
     the default behaviour.
 

xija/component/base.py

@@ -21,8 +21,10 @@ class Param(dict):
     -------
 
     """
-    def __init__(self, comp_name, name, val, min=-1e38, max=1e38,
-                 fmt="{:.4g}", frozen=False):
+
+    def __init__(
+        self, comp_name, name, val, min=-1e38, max=1e38, fmt="{:.4g}", frozen=False
+    ):
         dict.__init__(self)
         self.comp_name = comp_name
         self.name = name
@@ -42,6 +44,7 @@ def __getattr__(self, attr):
 
 class ModelComponent(object):
     """Model component base class"""
+
     def __init__(self, model):
         # This class overrides __setattr__ with a method that requires
         # the `pars` and `pars_dict` attrs to be visible.  So do this
@@ -64,8 +67,7 @@ def model_plotdate(self):
             self._model_plotdate = cxctime2plotdate(self.model.times)
         return self._model_plotdate
 
-    def add_par(self, name, val=None, min=-1e38, max=1e38, fmt="{:.4g}",
-                frozen=False):
+    def add_par(self, name, val=None, min=-1e38, max=1e38, fmt="{:.4g}", frozen=False):
         param = Param(self.name, name, val, min=min, max=max, fmt=fmt, frozen=frozen)
         self.pars_dict[name] = param
         self.pars.append(param)
@@ -104,8 +106,7 @@ def get_par(self, name):
             if par.name == name:
                 return par
         else:
-            raise ValueError('No par named "{}" in {}',
-                             self.__class__.__name__)
+            raise ValueError('No par named "{}" in {}', self.__class__.__name__)
 
     @property
     def name(self):
@@ -136,28 +137,34 @@ def dvals(self):
             if self.data is None:
                 dvals = self.get_dvals_tlm()
             elif isinstance(self.data, np.ndarray):
-                dvals = self.model.interpolate_data(self.data, self.data_times,
-                                                    str(self))
-            elif isinstance(self.data, (six.integer_types, float, np.integer, np.floating,
-                                        bool, str)):
+                dvals = self.model.interpolate_data(
+                    self.data, self.data_times, str(self)
+                )
+            elif isinstance(
+                self.data,
+                (six.integer_types, float, np.integer, np.floating, bool, str),
+            ):
                 if isinstance(self.data, six.string_types):
                     dtype = 'S{}'.format(len(self.data))
                 else:
                     dtype = type(self.data)
                 dvals = np.empty(self.model.n_times, dtype=dtype)
                 dvals[:] = self.data
             else:
-                raise ValueError("Data value '{}' and type '{}' for '{}' component "
-                                 "not allowed ".format(self.data, type(self.data).__name__, self))
+                raise ValueError(
+                    "Data value '{}' and type '{}' for '{}' component "
+                    "not allowed ".format(self.data, type(self.data).__name__, self)
+                )
             self._dvals = dvals
         return self._dvals
 
 
 class TelemData(ModelComponent):
     times = property(lambda self: self.model.times)
 
-    def __init__(self, model, msid, mval=True, data=None,
-                 fetch_attr='vals', units=None):
+    def __init__(
+        self, model, msid, mval=True, data=None, fetch_attr='vals', units=None
+    ):
         super(TelemData, self).__init__(model)
         self.msid = msid
         self.n_mvals = 1 if mval else 0
@@ -173,8 +180,9 @@ def get_dvals_tlm(self):
     def plot_data__time(self, fig, ax):
         lines = ax.get_lines()
         if not lines:
-            plot_cxctime(self.model.times, self.dvals, ls='-', color='#386cb0',
-                         fig=fig, ax=ax)
+            plot_cxctime(
+                self.model.times, self.dvals, ls='-', color='#386cb0', fig=fig, ax=ax
+            )
             ax.grid()
             ax.set_title('{}: data'.format(self.name))
             ylabel = '%s' % self.name
@@ -226,11 +234,23 @@ class Node(TelemData):
     -------
 
     """
-    def __init__(self, model, msid, sigma=-10, quant=None,
-                 predict=True, mask=None, name=None, data=None,
-                 fetch_attr='vals', units='degC'):
-        TelemData.__init__(self, model, msid, data=data,
-                           fetch_attr=fetch_attr, units=units)
+
+    def __init__(
+        self,
+        model,
+        msid,
+        sigma=-10,
+        quant=None,
+        predict=True,
+        mask=None,
+        name=None,
+        data=None,
+        fetch_attr='vals',
+        units='degC',
+    ):
+        TelemData.__init__(
+            self, model, msid, data=data, fetch_attr=fetch_attr, units=units
+        )
         self._sigma = sigma
         self.quant = quant
         self.predict = predict
@@ -254,8 +274,9 @@ def randx(self):
         """
         if not hasattr(self, '_randx'):
             dx = self.quant or 1.0
-            self._randx = np.random.uniform(low=-dx / 2.0, high=dx / 2.0,
-                                            size=self.model.n_times)
+            self._randx = np.random.uniform(
+                low=-dx / 2.0, high=dx / 2.0, size=self.model.n_times
+            )
         return self._randx
 
     @property
@@ -278,17 +299,28 @@ def calc_stat(self):
         resids = self.resids
         if self.mask is not None:
             resids = resids[self.mask.mask]
-        return np.sum(resids ** 2 / self.sigma ** 2)
+        return np.sum(resids**2 / self.sigma**2)
 
     def plot_data__time(self, fig, ax):
         lines = ax.get_lines()
         if not lines:
-            plot_cxctime(self.model.times, self.mvals, ls='-', color='#d92121', fig=fig, ax=ax)
-            plot_cxctime(self.model.times, self.dvals, ls='-', color='#386cb0', fig=fig, ax=ax)
+            plot_cxctime(
+                self.model.times, self.mvals, ls='-', color='#d92121', fig=fig, ax=ax
+            )
+            plot_cxctime(
+                self.model.times, self.dvals, ls='-', color='#386cb0', fig=fig, ax=ax
+            )
             # Overplot bad time regions in cyan
             for i0, i1 in self.model.bad_times_indices:
-                plot_cxctime(self.model.times[i0:i1], self.dvals[i0:i1], '-c',
-                             fig=fig, ax=ax, linewidth=5, alpha=0.5)
+                plot_cxctime(
+                    self.model.times[i0:i1],
+                    self.dvals[i0:i1],
+                    '-c',
+                    fig=fig,
+                    ax=ax,
+                    linewidth=5,
+                    alpha=0.5,
+                )
             ax.grid()
             ax.set_title('{}: model (red) and data (blue)'.format(self.name))
             ax.set_ylabel('Temperature (%s)' % self.units)
@@ -304,11 +336,20 @@ def plot_resid__time(self, fig, ax):
             resids[i0:i1] = np.nan
 
         if not lines:
-            plot_cxctime(self.model.times, resids, ls='-', color='#386cb0', fig=fig, ax=ax)
+            plot_cxctime(
+                self.model.times, resids, ls='-', color='#386cb0', fig=fig, ax=ax
+            )
             # Overplot bad time regions in cyan
             for i0, i1 in self.model.bad_times_indices:
-                plot_cxctime(self.model.times[i0:i1], resids[i0:i1], '-c',
-                             fig=fig, ax=ax, linewidth=5, alpha=0.5)
+                plot_cxctime(
+                    self.model.times[i0:i1],
+                    resids[i0:i1],
+                    '-c',
+                    fig=fig,
+                    ax=ax,
+                    linewidth=5,
+                    alpha=0.5,
+                )
             ax.grid()
             ax.set_title('{}: residuals (data - model)'.format(self.name))
             ax.set_ylabel('Temperature (%s)' % self.units)
@@ -326,8 +367,14 @@ def plot_resid__data(self, fig, ax):
             resids[i0:i1] = np.nan
 
         if not lines:
-            ax.plot(self.dvals + self.randx, resids, 'o',
-                    markersize=0.25, color='#386cb0', markeredgecolor='#386cb0')
+            ax.plot(
+                self.dvals + self.randx,
+                resids,
+                'o',
+                markersize=0.25,
+                color='#386cb0',
+                markeredgecolor='#386cb0',
+            )
             ax.grid()
             ax.set_title('{}: residuals (data - model) vs data'.format(self.name))
             ax.set_ylabel('Residuals (%s)' % self.units)
@@ -352,17 +399,19 @@ class Coupling(ModelComponent):
     -------
 
     """
+
     def __init__(self, model, node1, node2, tau):
         ModelComponent.__init__(self, model)
         self.node1 = self.model.get_comp(node1)
         self.node2 = self.model.get_comp(node2)
         self.add_par('tau', tau, min=2.0, max=200.0)
 
     def update(self):
-        self.tmal_ints = (tmal.OPCODES['coupling'],
-                          self.node1.mvals_i,  # y1 index
-                          self.node2.mvals_i   # y2 index
-                          )
+        self.tmal_ints = (
+            tmal.OPCODES['coupling'],
+            self.node1.mvals_i,  # y1 index
+            self.node2.mvals_i,  # y2 index
+        )
         self.tmal_floats = (self.tau,)
 
     def __str__(self):
@@ -377,6 +426,7 @@ class Delay(ModelComponent):
     ``delay`` ksec. Conversely for a negative delay the values at the end will
     be constant for ``delay`` ksec.
     """
+
     def __init__(self, model, node, delay=0):
         super().__init__(model)
         self.node = self.model.get_comp(node)
@@ -388,17 +438,16 @@ def __str__(self):
 
 class HeatSink(ModelComponent):
     """Fixed temperature external heat bath"""
+
     def __init__(self, model, node, T=0.0, tau=20.0):
         ModelComponent.__init__(self, model)
         self.node = self.model.get_comp(node)
         self.add_par('T', T, min=-100.0, max=100.0)
         self.add_par('tau', tau, min=2.0, max=200.0)
 
     def update(self):
-        self.tmal_ints = (tmal.OPCODES['heatsink'],
-                          self.node.mvals_i)  # dy1/dt index
-        self.tmal_floats = (self.T,
-                            self.tau)
+        self.tmal_ints = (tmal.OPCODES['heatsink'], self.node.mvals_i)  # dy1/dt index
+        self.tmal_floats = (self.T, self.tau)
 
     def __str__(self):
         return 'heatsink__{0}'.format(self.node)
@@ -425,6 +474,7 @@ class HeatSinkRef(ModelComponent):
     -------
 
     """
+
     def __init__(self, model, node, T=0.0, tau=20.0, T_ref=20.0):
         ModelComponent.__init__(self, model)
         self.node = self.model.get_comp(node)
@@ -433,10 +483,8 @@ def __init__(self, model, node, T=0.0, tau=20.0, T_ref=20.0):
         self.add_par('T_ref', T_ref, min=-100, max=100)
 
     def update(self):
-        self.tmal_ints = (tmal.OPCODES['heatsink'],
-                          self.node.mvals_i)  # dy1/dt index
-        self.tmal_floats = (self.P * self.tau + self.T_ref,
-                            self.tau)
+        self.tmal_ints = (tmal.OPCODES['heatsink'], self.node.mvals_i)  # dy1/dt index
+        self.tmal_floats = (self.P * self.tau + self.T_ref, self.tau)
 
     def __str__(self):
         return 'heatsink__{0}'.format(self.node)
@@ -473,6 +521,7 @@ class AcisFPtemp(Node):
     -------
 
     """
+
     def __init__(self, model, mask=None):
         Node.__init__(self, model, 'fptemp_11', mask=mask)