LLNL-PyDV 3.8.0__tar.gz → 3.9.0__tar.gz

{llnl_pydv-3.8.0 → llnl_pydv-3.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: LLNL-PyDV
-Version: 3.8.0
+Version: 3.9.0
 Summary: PyDV: Python Data Visualizer
 License: BSD
 License-File: LICENSE

{llnl_pydv-3.8.0 → llnl_pydv-3.9.0}/pydv/pdv.py

@@ -510,6 +510,9 @@ class Command(cmd.Cmd, object):
     def do_rdsina(self, line):
         self.do_readsina(line)
 
+    def do_rdsinah5(self, line):
+        self.do_readsinahdf5(line)
+
     def do_cur(self, line):
         self.do_curve(line)
 
@@ -636,6 +639,8 @@ class Command(cmd.Cmd, object):
             arg = 'readcsv'
         elif (arg == 'rdsina'):
             arg = 'readsina'
+        elif (arg == 'rdsinah5'):
+            arg = 'readsinahdf5'
         elif (arg == 'convol'):
             arg = 'convolve'
         elif (arg == 'convolb'):
@@ -1110,6 +1115,9 @@ class Command(cmd.Cmd, object):
             elif line[-1].endswith(".json"):
                 self.do_readsina(" ".join(line))
                 return
+            elif line[-1].endswith(".hdf5") or line[-1].endswith(".h5") or line[-1].endswith(".hdf"):
+                self.do_readsinahdf5(" ".join(line))
+                return
 
             if n == 1:
                 self.load(line[0])
@@ -1174,10 +1182,8 @@ class Command(cmd.Cmd, object):
 
     def do_readsina(self, line):
         """
-        Read all curves from Sina data file. PyDV assumes there is only one record in the Sina file, and if there are
-        more than one then PyDV only reads the first. PyDV also assumes there is only one independent variable per
-        curve_set; if there are more than one then PyDV may exhibit undefined behavior. The next available prefix
-        (see the prefix command) is automatically assigned the menu index of the first curve in each data file read.
+        Read all curves from Sina data file. The next available prefix (see the prefix command) is automatically
+        assigned the menu index of the first curve in each data file read.
 
         .. code::
 
@@ -1196,6 +1202,28 @@ class Command(cmd.Cmd, object):
             self.redraw = False
             self.plotter.updateDialogs()
 
+    def do_readsinahdf5(self, line):
+        """
+        Read all curves from Sina hdf5 data file. The next available prefix (see the prefix command) is automatically
+        assigned the menu index of the first curve in each data file read.
+
+        .. code::
+
+            [PyDV]: <readsinahdf5 | rdsinah5> <filename.hdf5>
+
+            Ex:
+                [PyDV]: readsinahdf5 my_file.hdf5
+        """
+
+        try:
+            line = line.split()
+            self.load_sinahdf5(line[0])
+        except:
+            pdvutil.print_own_docstring(self)
+        finally:
+            self.redraw = False
+            self.plotter.updateDialogs()
+
     def do_setxcolumn(self, line):
         """
         Set x column for reading column formatted data files (.gnu or .csv).
@@ -1613,18 +1641,6 @@ class Command(cmd.Cmd, object):
                 [PyDV]: stats a:b
                 [PyDV]: stats c d
         """
-
-        def find_mode(array):
-
-            try:
-                mode = scipy.stats.mode(array, keepdims=True)
-            except:
-                mode = scipy.stats.mode(array)
-            if mode.count[0] == 1 and len(array) != 1:
-                return numpy.nan, numpy.nan
-            else:
-                return mode.mode[0], mode.count[0]
-
         if not line:
             return 0
 
@@ -1638,25 +1654,7 @@ class Command(cmd.Cmd, object):
                     try:
                         curvidx = pdvutil.getCurveIndex(line[i], self.plotlist)
                         cur = self.plotlist[curvidx]
-                        numx, countx = find_mode(cur.x)
-                        numy, county = find_mode(cur.y)
-
-                        print('\nCurve ' + cur.plotname)
-                        print('\n\t         X:\t              Y:')
-                        print(f'\n\tlength:    {len(cur.x):<15.10g}\t{len(cur.y):<15.10g}')
-                        print(f'\tmean:      {numpy.mean(cur.x):<15.10g}\t{numpy.mean(cur.y):<15.10g}')
-                        print(f'\tmedian:    {numpy.median(cur.x):<15.10g}\t{numpy.median(cur.y):<15.10g}')
-                        print(f'\tmode:      {numx:<15.10g}\t{numy:<15.10g}')
-                        print(f'\t    count: {countx:<15.10g}\t{county:<15.10g}')
-                        print(f'\tstd:       {numpy.std(cur.x):<15.10g}\t{numpy.std(cur.y):<15.10g}')
-                        print(f'\tskew:      {scipy.stats.skew(cur.x):<15.10g}\t{scipy.stats.skew(cur.y):<15.10g}')
-                        print(f'\tkurtosis:  {scipy.stats.kurtosis(cur.x):<15.10g}\t{scipy.stats.kurtosis(cur.y):<15.10g}')  # noqae501
-                        print(f'\tmin:       {numpy.min(cur.x):<15.10g}\t{numpy.min(cur.y):<15.10g}')
-                        print(f'\t25%:       {numpy.quantile(cur.x,.25):<15.10g}\t{numpy.quantile(cur.y,.25):<15.10g}')
-                        print(f'\t50%:       {numpy.quantile(cur.x,.50):<15.10g}\t{numpy.quantile(cur.y,.50):<15.10g}')
-                        print(f'\t75%:       {numpy.quantile(cur.x,.75):<15.10g}\t{numpy.quantile(cur.y,.75):<15.10g}')
-                        print(f'\tmax:       {numpy.max(cur.x):<15.10g}\t{numpy.max(cur.y):<15.10g}')
-                        print(f'\tsum:       {numpy.sum(cur.x):<15.10g}\t{numpy.sum(cur.y):<15.10g}')
+                        pydvpy.stats(cur)
 
                     except pdvutil.CurveIndexError:
                         pass
@@ -9470,6 +9468,16 @@ class Command(cmd.Cmd, object):
             self.curvelist += curves
             self.filelist.append((fname, len(curves)))
 
+    def load_sinahdf5(self, fname):
+        """
+        Load a Sina HDF5 data file, add parsed curves to the curvelist
+        """
+
+        curves = pydvpy.readsinahdf5(fname, self.debug)
+        if len(curves) > 0:
+            self.curvelist += curves
+            self.filelist.append((fname, len(curves)))
+
     def loadrc(self):
         """
         Read in a resource definition file

{llnl_pydv-3.8.0 → llnl_pydv-3.9.0}/pydv/pdvplot.py

@@ -233,13 +233,13 @@ class Plotter(QMainWindow):
         # Create or clear table
         if self._tableWidget is None:
             self._tableWidget = QTableWidget(rows, cols, self)
-            self._tableWidget.setEditTriggers(QAbstractItemView.NoEditTriggers)
+            self._tableWidget.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
             self._tableWidget.setHorizontalHeaderLabels(headerLabels)
             self._tableWidget.setAlternatingRowColors(True)
-            self._tableWidget.setSelectionBehavior(QAbstractItemView.SelectRows)
+            self._tableWidget.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
 
             # Setup Right-click menu
-            self._tableWidget.setContextMenuPolicy(Qt.ActionsContextMenu)
+            self._tableWidget.setContextMenuPolicy(Qt.ContextMenuPolicy.ActionsContextMenu)
             deleteCurveAction = QAction("Delete selected curve(s)", self._tableWidget)
             deleteCurveAction.triggered.connect(self.__deleteCurve)
             self._tableWidget.addAction(deleteCurveAction)
@@ -257,7 +257,7 @@ class Plotter(QMainWindow):
             if c.edited:
                 prefix = '*'
             plotnameItem = QTableWidgetItem(self.tr("%s%s" % (prefix, c.plotname)))
-            plotnameItem.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
+            plotnameItem.setTextAlignment(Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignVCenter)
             self._tableWidget.setItem(row, col, plotnameItem)
             col += 1
 
@@ -324,7 +324,7 @@ class Plotter(QMainWindow):
             vbox.addWidget(scroll)
 
             hbox = QHBoxLayout(self._listDialog)
-            hbox.setAlignment(Qt.AlignCenter)
+            hbox.setAlignment(Qt.AlignmentFlag.AlignCenter)
 
             # Dismiss Button
             okButton = QPushButton(self._listDialog)
@@ -361,13 +361,13 @@ class Plotter(QMainWindow):
         # Create or clear table
         if self._menuTableWidget is None:
             self._menuTableWidget = QTableWidget(rows, cols, self)
-            self._menuTableWidget.setEditTriggers(QAbstractItemView.NoEditTriggers)
+            self._menuTableWidget.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
             self._menuTableWidget.setHorizontalHeaderLabels(headerLabels)
             self._menuTableWidget.setAlternatingRowColors(True)
-            self._menuTableWidget.setSelectionBehavior(QAbstractItemView.SelectRows)
+            self._menuTableWidget.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
 
             # Setup Right-click menu
-            self._menuTableWidget.setContextMenuPolicy(Qt.ActionsContextMenu)
+            self._menuTableWidget.setContextMenuPolicy(Qt.ContextMenuPolicy.ActionsContextMenu)
             plotCurveAction = QAction("Plot selected curve(s)", self._menuTableWidget)
             plotCurveAction.triggered.connect(self.__plotMenuCurve)
             self._menuTableWidget.addAction(plotCurveAction)
@@ -456,7 +456,7 @@ class Plotter(QMainWindow):
             vbox.addWidget(scroll)
 
             hbox = QHBoxLayout(self._menuDialog)
-            hbox.setAlignment(Qt.AlignCenter)
+            hbox.setAlignment(Qt.AlignmentFlag.AlignCenter)
 
             # Dismiss Button
             okButton = QPushButton(self._menuDialog)
@@ -560,7 +560,7 @@ class Plotter(QMainWindow):
         okButton.setMinimumSize(100, 20)
         okButton.setMaximumSize(100, 20)
         okButton.setText('OK')
-        hbox.addWidget(okButton, Qt.AlignCenter)
+        hbox.addWidget(okButton, Qt.AlignmentFlag.AlignCenter)
         vbox.addLayout(hbox)
 
         copy_dialog.resize(300, 500)

{llnl_pydv-3.8.0 → llnl_pydv-3.9.0}/pydv/pydvpy.py

@@ -66,6 +66,7 @@ import re
 import copy
 from multiprocessing import Pool, cpu_count
 import subprocess
+import h5py
 
 from distutils.version import LooseVersion
 
@@ -566,6 +567,8 @@ def read(fname, gnu=False, xcol=0, verbose=False, pattern=None, matches=None):
         return readcsv(fname=fname, xcol=xcol, verbose=verbose)
     elif str(fname).endswith(".json"):
         return readsina(fname=fname, verbose=verbose)
+    elif str(fname).endswith(".hdf5") or str(fname).endswith(".h5") or str(fname).endswith(".hdf"):
+        return readsinahdf5(fname, verbose=verbose)
     elif gnu or str(fname).endswith(".gnu"):
         return __loadcolumns(fname, xcol)
     elif pdbLoaded:
@@ -743,7 +746,7 @@ def readcsv(fname, xcol=0, verbose=False):
     return curvelist
 
 
-def readsina(fname, verbose=False):
+def readsina(fname, verbose=False, hdf5_path=None):
     """
     Load a Sina JSON data file, add parsed curves to a curvelist.
 
@@ -758,77 +761,97 @@ def readsina(fname, verbose=False):
     :type fname: str
     :param verbose: prints the error stacktrace when True
     :type verbose: bool
+    :param hdf5_path: File path for HDF5 sina file. Should not be set by user, only used internally, defaults to None.
+    :type hdf5_path: str, optional.
     :returns: list: the list of curves from the sina file
     """
-    curves = {}
-    listed_order = []
-    try:
-        # Try to load the order in which the user wants to load the curves into PyDV
-        with open(fname, 'r') as fp:
-            try:
-                order_options = json.load(fp)['records'][0]['data']['SINA_timeplot_order']['value']
-            except:
-                order_options = []
-
-        # Load the curve data from the curve_sets
-        with open(fname, 'r') as fp:
+    def add_curve_set(curve_sets, record_id, order_options, library=''):
+
+        curves = {}
+        listed_order = []
+        for curve_set_name, curve_set in curve_sets.items():
+            for name_ind, v_ind in curve_set['independent'].items():
+                independent_name = name_ind
+                independent_value = v_ind['value']
+                for name, v in curve_set['dependent'].items():
+                    # TODO: Save the name x and y names with the curves
+                    dependent_variable_name = name
+                    if order_options:
+                        full_name = curve_set_name + '__SINA_DEP__' + dependent_variable_name
+                    else:
+                        full_name = curve_set_name + '__SINA_DEP__' + dependent_variable_name + \
+                            '__SINA_INDEP__' + independent_name
+                    dependent_variable_value = v['value']
+                    curve_name = dependent_variable_name + ' vs ' + independent_name + " (" + \
+                        curve_set_name + ")"
+                    if library != '':
+                        curve_name += ' ' + library
+                        full_name += '__LIBRARY__' + library
+                    c = makecurve(x=independent_value,
+                                  y=dependent_variable_value,
+                                  name=curve_name,
+                                  filename=fname if hdf5_path is None else hdf5_path,
+                                  xlabel=independent_name,
+                                  ylabel=dependent_variable_name,
+                                  title=curve_name,
+                                  record_id=record_id)
+                    c.step = False
+                    c.xticks_labels = {}
+                    if verbose:
+                        print(f"Appended curve: {curve_name}, len x,y: {len(c.x)},{len(c.y)}")
+                    curves[full_name] = c
+                    listed_order.append(full_name)
+
+        if order_options:
             try:
-                sina_file = json.load(fp)
-                record_id = sina_file['records'][0]['id']
-                curve_sets = sina_file['records'][0]['curve_sets']
-                library_data = sina_file['records'][0].get('library_data', {})
-
-                def add_curve_set(curve_sets, curves, listed_order, library=''):
-                    for curve_set_name, curve_set in curve_sets.items():
-                        for name_ind, v_ind in curve_set['independent'].items():
-                            independent_name = name_ind
-                            independent_value = v_ind['value']
-                            for name, v in curve_set['dependent'].items():
-                                # TODO: Save the name x and y names with the curves
-                                dependent_variable_name = name
-                                if order_options:
-                                    full_name = curve_set_name + '__SINA_DEP__' + dependent_variable_name
-                                else:
-                                    full_name = curve_set_name + '__SINA_DEP__' + dependent_variable_name + \
-                                        '__SINA_INDEP__' + independent_name
-                                dependent_variable_value = v['value']
-                                curve_name = dependent_variable_name + ' vs ' + independent_name + " (" + \
-                                    curve_set_name + ")"
-                                if library != '':
-                                    curve_name += ' ' + library
-                                    full_name += '__LIBRARY__' + library
-                                c = makecurve(x=independent_value,
-                                              y=dependent_variable_value,
-                                              name=curve_name,
-                                              filename=fname,
-                                              xlabel=independent_name,
-                                              ylabel=dependent_variable_name,
-                                              title=curve_name,
-                                              record_id=record_id)
-                                c.step = False
-                                c.xticks_labels = {}
-                                if verbose:
-                                    print("Appended curve: {}, len x,y: {},{}"
-                                          .format(curve_name, len(c.x), len(c.y)))
-                                curves[full_name] = c
-                                listed_order.append(full_name)
-                    return curves, listed_order
-
-                curves, listed_order = add_curve_set(curve_sets, curves, listed_order)
-
-                for library in library_data:
-                    if 'curve_sets' in library_data[library]:
-                        curve_sets = library_data[library]['curve_sets']
-                        curves, listed_order = add_curve_set(curve_sets, curves, listed_order, library=library)
+                curves_lst_temp = [curves[name] for name in order_options]
             except KeyError:
-                print('readsina: Sina file {} is malformed'.format(fname))
+                print('readsina: mismatch between dependent variable names in the curve_sets and the '
+                      'ordering specified in SINA_timeplot_order. Using default ordering instead.')
+                curves_lst_temp = [curves[name] for name in listed_order]
                 if verbose:
-                    traceback.print_exc(file=sys.stdout)
-                return []
+                    traceback.print_exc(File=sys.stdout)
+        else:
+            curves_lst_temp = [curves[name] for name in listed_order]
+
+        return curves_lst_temp
+
+    def cycle_thru_recs(sina_file):
+        curves_lst = []
+
+        for rec in sina_file['records']:
 
-        # Try to load the order in which the user wants to load the curves into PyDV
-        if not order_options:
-            order_options = listed_order
+            record_id = rec.get('id', rec.get("local_id", ""))
+            curve_sets = rec.get('curve_sets', {})
+            library_data = rec.get('library_data', {})
+            order_options = rec.get('data', {}).get('SINA_timeplot_order', {}).get('value', [])
+
+            curves_lst_temp = add_curve_set(curve_sets, record_id, order_options)
+            curves_lst.extend(curves_lst_temp)
+
+            for library in library_data:
+                if 'curve_sets' in library_data[library]:
+                    curve_sets = library_data[library].get('curve_sets', {})
+                    order_options = library_data[library].get('data',
+                                                              {}).get('SINA_timeplot_order',
+                                                                      {}).get('value', [])
+                    curves_lst_temp = add_curve_set(curve_sets, record_id, order_options, library=library)
+                    curves_lst.extend(curves_lst_temp)
+        return curves_lst
+
+    try:
+        # Load the curve data from the curve_sets
+        try:
+            if not isinstance(fname, dict):
+                with open(fname, 'r') as fp:
+                    curves_lst = cycle_thru_recs(json.load(fp))
+            else:
+                curves_lst = cycle_thru_recs(fname)
+        except KeyError:
+            print('readsina: Sina file {} is malformed'.format(fname))
+            if verbose:
+                traceback.print_exc(file=sys.stdout)
+            return []
 
     except IOError:
         print('readsina: could not load file: {}'.format(fname))
@@ -836,17 +859,75 @@ def readsina(fname, verbose=False):
             traceback.print_exc(file=sys.stdout)
         return []
 
-    try:
-        curves_lst = [curves[name] for name in order_options]
-    except KeyError:
-        print('readsina: mismatch between dependent variable names in the curve_sets and the '
-              'ordering specified in SINA_timeplot_order. Using default ordering instead.')
-        if verbose:
-            traceback.print_exc(File=sys.stdout)
-        curves_lst = [curves[name] for name in listed_order]
     return curves_lst
 
 
+def readsinahdf5(hdf5_path, verbose=False):
+    # def load_document_hdf5(hdf5_path): Taken from sina/utils.py
+    """
+    Retrieves records and relationships from HDF5
+    """
+    reconstructed_doc = {}
+
+    def coerce_numpy_to_json(val):
+        # There's no single quick way to do this when numpy and hdf5 combine,
+        # so we have a manual method...
+        if isinstance(val, bytes):
+            val = val.decode("utf-8")
+        if isinstance(val, h5py.Empty):
+            val = dict()
+        if isinstance(val, np.integer):
+            val = int(val)
+        elif isinstance(val, np.floating):
+            val = float(val)
+        elif isinstance(val, np.ndarray):
+            is_word = len(np.shape(val)) == 1 and isinstance(val[0], bytes)
+            val = [x.decode("utf-8") if isinstance(x, bytes)
+                   else x for x in val.tolist()]
+            if is_word:
+                val = ''.join(val)
+            elif np.shape(val)[0] == 1:
+                val = val[0]
+        return val
+
+    def add_arbitrary_path_to_dict(some_path, val):
+        chunk = reconstructed_doc
+        layers = some_path.split("/")
+        for depth, layer in enumerate(layers):
+            if not layer:
+                continue
+            if layer not in chunk:
+                chunk[layer] = dict()
+            if depth == len(layers) - 1:
+                if isinstance(val, list):
+                    chunk[layer] = [coerce_numpy_to_json(x) for x in val]
+                else:
+                    chunk[layer] = coerce_numpy_to_json(val)
+            else:
+                chunk = chunk[layer]
+
+    def yoink_dataset_or_recurse(path, chunk):
+        if isinstance(chunk, h5py.Group):
+            for key, val in chunk.items():
+                # Recovery for common wonky HDF5 issue
+                if (isinstance(val, h5py.Group) and '0' in val.keys() and key in ("value", "tags")):
+                    add_arbitrary_path_to_dict(path + "/" + key, [chunk[key][x][()] for x in val])
+                else:
+                    yoink_dataset_or_recurse(path + "/" + key, val)
+        else:
+            add_arbitrary_path_to_dict(path, chunk[()])
+    with h5py.File(hdf5_path, 'r') as src:
+        yoink_dataset_or_recurse("", src)
+    # Now we have to (temporarily!) smooth the object->list thing between our hdf5
+    # and JSON entries...
+    reconstructed_doc["records"] = ([x for x in reconstructed_doc["records"].values()]
+                                    if "records" in reconstructed_doc else list())
+    # reconstructed_doc["relationships"] = ([x for x in reconstructed_doc["relationships"].values()]
+    #                                       if "relationships" in reconstructed_doc else list())
+
+    return readsina(reconstructed_doc, hdf5_path=hdf5_path)
+
+
 ########################################################
 ################## Math Functions  #####################  # noqa e266
 ########################################################
@@ -2046,8 +2127,9 @@ def xmax(curvelist, max):
     curves = _convert_to_curvelist(curvelist)
 
     for c in curves:
-        c.x = c.x[np.where(c.x <= float(max))]
-        c.y = c.y[np.where(c.x <= float(max))]
+        mask = np.where(c.x <= float(max))
+        c.x = c.x[mask]
+        c.y = c.y[mask]
 
 
 def xmin(curvelist, min):
@@ -2063,8 +2145,9 @@ def xmin(curvelist, min):
     curves = _convert_to_curvelist(curvelist)
 
     for c in curves:
-        c.x = c.x[np.where(c.x >= float(min))]
-        c.y = c.y[np.where(c.x >= float(min))]
+        mask = np.where(c.x >= float(min))
+        c.x = c.x[mask]
+        c.y = c.y[mask]
 
 
 def xminmax(curvelist, min, max):
@@ -2082,8 +2165,9 @@ def xminmax(curvelist, min, max):
     curves = _convert_to_curvelist(curvelist)
 
     for c in curves:
-        c.x = c.x[np.where(np.logical_and(c.x >= float(min), c.x <= float(max)))]
-        c.y = c.y[np.where(np.logical_and(c.x >= float(min), c.x <= float(max)))]
+        mask = np.where(np.logical_and(c.x >= float(min), c.x <= float(max)))
+        c.x = c.x[mask]
+        c.y = c.y[mask]
 
 
 def ymax(curvelist, max):
@@ -2099,8 +2183,9 @@ def ymax(curvelist, max):
     curves = _convert_to_curvelist(curvelist)
 
     for c in curves:
-        c.x = c.x[np.where(c.y <= float(max))]
-        c.y = c.y[np.where(c.y <= float(max))]
+        mask = np.where(c.y <= float(max))
+        c.x = c.x[mask]
+        c.y = c.y[mask]
 
 
 def ymin(curvelist, min):
@@ -2116,8 +2201,9 @@ def ymin(curvelist, min):
     curves = _convert_to_curvelist(curvelist)
 
     for c in curves:
-        c.x = c.x[np.where(c.y >= float(min))]
-        c.y = c.y[np.where(c.y >= float(min))]
+        mask = np.where(c.y >= float(min))
+        c.x = c.x[mask]
+        c.y = c.y[mask]
 
 
 def yminmax(curvelist, min, max):
@@ -2135,8 +2221,9 @@ def yminmax(curvelist, min, max):
     curves = _convert_to_curvelist(curvelist)
 
     for c in curves:
-        c.x = c.x[np.where(np.logical_and(c.y >= float(min), c.y <= float(max)))]
-        c.y = c.y[np.where(np.logical_and(c.y >= float(min), c.y <= float(max)))]
+        mask = np.where(np.logical_and(c.y >= float(min), c.y <= float(max)))
+        c.x = c.x[mask]
+        c.y = c.y[mask]
 
 
 def yn(curvelist, n):
@@ -3184,7 +3271,7 @@ def fit(c, n=1, logx=False, logy=False):
     if logy:
         y = np.log10(y)
 
-    coeffs = scipy.polyfit(x, y, n)
+    coeffs = np.polyfit(x, y, n)
     if len(coeffs) == 2:
         print("slope = ", coeffs[0], " intercept = ", coeffs[1])
     else:
@@ -3200,7 +3287,7 @@ def fit(c, n=1, logx=False, logy=False):
         oString = "%dth " % n
 
     x = np.array(x)
-    y = scipy.polyval(coeffs, x)
+    y = np.polyval(coeffs, x)
 
     if logx:
         x = 10.0**x
@@ -3324,6 +3411,45 @@ def getnumpoints(curve):
     return len(curve.x)
 
 
+def stats(curve):
+    """
+    Print statistics of the given curve.
+
+    :param curve: The given curve
+    """
+
+    def find_mode(array):
+
+        try:
+            mode = scipy.stats.mode(array, keepdims=True)
+        except:
+            mode = scipy.stats.mode(array)
+        if mode.count[0] == 1 and len(array) != 1:
+            return np.nan, np.nan
+        else:
+            return mode.mode[0], mode.count[0]
+
+    numx, countx = find_mode(curve.x)
+    numy, county = find_mode(curve.y)
+
+    print('\nCurve ' + curve.plotname)
+    print('\n\t         X:\t              Y:')
+    print(f'\n\tlength:    {len(curve.x):<15.10g}\t{len(curve.y):<15.10g}')
+    print(f'\tmean:      {np.mean(curve.x):<15.10g}\t{np.mean(curve.y):<15.10g}')
+    print(f'\tmedian:    {np.median(curve.x):<15.10g}\t{np.median(curve.y):<15.10g}')
+    print(f'\tmode:      {numx:<15.10g}\t{numy:<15.10g}')
+    print(f'\t    count: {countx:<15.10g}\t{county:<15.10g}')
+    print(f'\tstd:       {np.std(curve.x):<15.10g}\t{np.std(curve.y):<15.10g}')
+    print(f'\tskew:      {scipy.stats.skew(curve.x):<15.10g}\t{scipy.stats.skew(curve.y):<15.10g}')
+    print(f'\tkurtosis:  {scipy.stats.kurtosis(curve.x):<15.10g}\t{scipy.stats.kurtosis(curve.y):<15.10g}')  # noqae501
+    print(f'\tmin:       {np.min(curve.x):<15.10g}\t{np.min(curve.y):<15.10g}')
+    print(f'\t25%:       {np.quantile(curve.x,.25):<15.10g}\t{np.quantile(curve.y,.25):<15.10g}')
+    print(f'\t50%:       {np.quantile(curve.x,.50):<15.10g}\t{np.quantile(curve.y,.50):<15.10g}')
+    print(f'\t75%:       {np.quantile(curve.x,.75):<15.10g}\t{np.quantile(curve.y,.75):<15.10g}')
+    print(f'\tmax:       {np.max(curve.x):<15.10g}\t{np.max(curve.y):<15.10g}')
+    print(f'\tsum:       {np.sum(curve.x):<15.10g}\t{np.sum(curve.y):<15.10g}')
+
+
 def getrange(curvelist):
     """
     Get the range of the curve or list of curves.

llnl_pydv-3.9.0/pydv/scripts/date.txt

@@ -0,0 +1 @@
+01.15.2026

llnl_pydv-3.9.0/pydv/scripts/version.txt

@@ -0,0 +1 @@
+3.9.0

{llnl_pydv-3.8.0 → llnl_pydv-3.9.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool]
 [tool.poetry]
 name = "LLNL-PyDV"
-version = "3.8.0"
+version = "3.9.0"
 description = "PyDV: Python Data Visualizer"
 license = "BSD"
 classifiers = [
@@ -64,7 +64,7 @@ build-backend = "poetry.core.masonry.api"
 line-length = 79
 
 [tool.bumpver]
-current_version = "3.8.0"
+current_version = "3.9.0"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message = "bump version {old_version} -> {new_version}"
 commit = true

llnl_pydv-3.8.0/pydv/scripts/date.txt

@@ -1 +0,0 @@
-09.02.2025

llnl_pydv-3.8.0/pydv/scripts/version.txt

@@ -1 +0,0 @@
-3.8.0