itkdb-gtk 0.10.9.dev3__py3-none-any.whl → 0.10.10__py3-none-any.whl

itkdb_gtk/SensorUtils.py

@@ -1,10 +1,8 @@
 #!/usr/bin/env python3
 """A collection of utilities for sensor data."""
-import io
 from pathlib import Path
-import numpy as np
 import warnings
-import tempfile
+import numpy as np
 from itkdb_gtk import ITkDButils
 
 #
@@ -210,7 +208,7 @@ def LocateMicroDischarge(
         V_BDV_ind = V_BDV_ind[ind]
         if V_avg_BD.shape == (0,):
             return NO_BD_CONST
-        
+
     return NO_BD_CONST
 
 
@@ -260,8 +258,12 @@ def sensor_data_to_json(session, mdata, mod_type, logger=None):
     passed = True
 
     # Find Current @ 500V
-    indx = np.where(V == 500)[0]
-    i_500 = I[indx][0] / area
+    try:
+        indx = np.where(V == 500)[0]
+        i_500 = I[indx][0] / area
+    except IndexError:
+        i_500 = 999
+
     if logger:
         logger.write_message("I @ 500V = {:.2f} nA/cm2\n".format(i_500))
 
@@ -296,7 +298,7 @@ def sensor_data_to_json(session, mdata, mod_type, logger=None):
             )
             if logger:
                 logger.write_message("...{}. FAILED\n".format(txt))
-                
+
             passed = False
     else:
         if MicroDischargeV == NO_BD_CONST:
@@ -388,7 +390,7 @@ def save_sensor_data(fnam, mdata, name=None):
     Args:
         fnam: file name or file object.
         mdata (dict): data as returned by :function:`read_sensor_file`
-        
+
     """
     if hasattr(fnam, "write") and callable(fnam.write):
         data_out = fnam
@@ -396,17 +398,17 @@ def save_sensor_data(fnam, mdata, name=None):
             fnam = name
         else:
             fnam = build_file_name(mdata)
-            
+
     else:
         data_out = open(fnam, 'w', encoding="utf-8")
         fnam = Path(fnam).name
-        
+
     is_module = "Module_SN" in mdata
     if is_module:
         SN = mdata["Module_SN"]
     else:
         SN = mdata["Component"]
-        
+
     if is_module:
         items = [
             "Type",
@@ -446,7 +448,7 @@ def save_sensor_data(fnam, mdata, name=None):
             "Humidity",
             "Comments",
         ]
-    
+
     data_out.write("{}\n".format(fnam))
     for key in items:
         if key == "Module_SN" or key == "Component":
@@ -469,7 +471,7 @@ def save_sensor_data(fnam, mdata, name=None):
     V = np.abs(mdata["curve"]["V"])
     I = np.abs(mdata["curve"]["I"])
     S = np.abs(mdata["curve"]["S"])
-    
+
     ndata = len(V)
     for i in range(ndata):
         data_out.write("{:10.2f}\t{:10.2f}\t{:10.2f}\n".format(V[i], I[i], S[i]))
@@ -487,4 +489,4 @@ def build_file_name(mdata):
         SN = mdata["Component"]
         fnam = "{}-W{}_IV_{}".format(mdata["Batch"], mdata["Wafer"], mdata["RunNumber"])
 
-    return fnam
+    return fnam

itkdb_gtk/ShowAttachments.py

@@ -232,7 +232,9 @@ class ShowAttachments(Gtk.Dialog):
         rc = dlg.run()
         if rc == Gtk.ResponseType.OK:
             path = Path(dlg.fC.get_filename())
-            A = ITkDButils.Attachment(path, dlg.att_title.get_text().strip(), dlg.att_desc.get_text().strip())
+            A = ITkDButils.Attachment(path=path, 
+                                      title=dlg.att_title.get_text().strip(), 
+                                      desc=dlg.att_desc.get_text().strip())
             self.append_attachment_to_view(A)
             self.attachments.append(A)
 

itkdb_gtk/UploadModuleIV.py

@@ -16,7 +16,6 @@ import json
 import tempfile
 import copy
 from pathlib import Path
-import shutil
 
 from matplotlib.backends.backend_gtk3agg import FigureCanvasGTK3Agg as FigureCanvas
 from matplotlib.backends.backend_gtk3 import NavigationToolbar2GTK3 as NavigationToolbar
@@ -56,11 +55,12 @@ def remove_files(W, flist):
 class IVwindow(dbGtkUtils.ITkDBWindow):
     """GUI for IV file handling."""
 
-    def __init__(self, session, title="IV window", options=None, help=None):
+    def __init__(self, session, title="IV window", options=None, help_link=None):
         """Initialization."""
-        super().__init__(
-            session=session, title=title, show_search=None, gtk_runs=gtk_runs, help=help
-        )
+        super().__init__(session=session, title=title,
+                         show_search=None, gtk_runs=gtk_runs,
+                         help_link=help_link
+                         )
         self.mdata = {}
         self.mod_type = {}
         self.mod_SN = {}
@@ -179,7 +179,7 @@ class IVwindow(dbGtkUtils.ITkDBWindow):
         js_out.write(json.dumps(test, indent=3, cls=dbGtkUtils.MyEncoder))
         js_out.close()
 
-        attachment = ITkDButils.Attachment(data_out.name, "resultsFile", fnam)
+        attachment = ITkDButils.Attachment(path=data_out.name, title="resultsFile", desc=fnam)
         uploadW = UploadTest.UploadTest(self.session, js_out.name, attachment)
         uploadW.connect("destroy", remove_files, [data_out.name, js_out.name])
 
@@ -247,7 +247,7 @@ class IVwindow(dbGtkUtils.ITkDBWindow):
             rc = fc.run()
             if rc == Gtk.ResponseType.OK:
                 SensorUtils.save_sensor_data(fc.get_filename(), mdata)
-                
+
             fc.hide()
             fc.destroy()
 
@@ -256,7 +256,7 @@ class IVwindow(dbGtkUtils.ITkDBWindow):
 
         if do_both.get_active():
             self.upload_test(self.mdata["single"], self.mod_type["single"])
-            
+
         dlg.destroy()
 
     def on_refresh(self, *args):

itkdb_gtk/UploadMultipleTests.py

@@ -1,6 +1,5 @@
 #!/usr/bin/env python3
 """GUI to upload tests."""
-import argparse
 import fnmatch
 import json
 import os
@@ -11,7 +10,6 @@ try:
     import itkdb_gtk
 
 except ImportError:
-    from pathlib import Path
     cwd = Path(__file__).parent.parent
     sys.path.append(cwd.as_posix())
 
@@ -65,7 +63,26 @@ def all_files(root, patterns='*', single_level=False, yield_folders=False):
 
 
 class TestList(object):
-    SN, TestType, RunNumber, Date, Institute, Stage, currentStage, Path, Json, Nattch, Attachments, Ncomm, Comments, Ndef, Defects, ALL = range(16)
+    """Enumeration with TreeView model columns."""
+    (
+        SN,
+        TestType,
+        RunNumber,
+        Date,
+        Institute,
+        Stage,
+        currentStage,
+        Path,
+        Json,
+        Nattch,
+        Attachments,
+        Ncomm,
+        Comments,
+        Ndef,
+        Defects,
+        Color,
+        ALL,
+    ) = range(17)
 
 
 def check_data(data):
@@ -103,15 +120,18 @@ def check_data(data):
 class UploadMultipleTests(dbGtkUtils.ITkDBWindow):
     """Collects information to upload a test and its attachments."""
 
-    def __init__(self, session, help=help):
+    def __init__(self, session, help_link=None):
         """Initialization.
 
         Args:
             session: ITkDB session
 
         """
-        super().__init__(session=session, title="Upload Tests", gtk_runs=gtk_runs, help=help)
+        super().__init__(session=session, title="Upload Tests", gtk_runs=gtk_runs, help_link=help_link)
         self.tests = []
+        self.data = None
+        self.tree = None
+        self.def_color = None
 
         self.init_window()
 
@@ -173,7 +193,23 @@ class UploadMultipleTests(dbGtkUtils.ITkDBWindow):
 
     def create_tree_view(self, size=150):
         """Creates the tree vew with the attachments."""
-        model = Gtk.ListStore(str, str, str, str, str, str, str, str, object, int, object, int, object, int, object)
+        model = Gtk.ListStore(str, # SN
+                              str, # test type
+                              str, # runNumber
+                              str, # date
+                              str, # institute
+                              str, # stage
+                              str, # stage
+                              str, # ifile
+                              object, # data
+                              int, # num. attch.
+                              object, # attachments
+                              int, # num. comments
+                              object, # comments
+                              int, # num defects
+                              object, # defects
+                              str # color
+                              )
         self.tree = Gtk.TreeView(model=model)
         self.tree.connect("button-press-event", self.button_pressed)
         scrolled = Gtk.ScrolledWindow()
@@ -186,7 +222,8 @@ class UploadMultipleTests(dbGtkUtils.ITkDBWindow):
         self.tree.append_column(column)
 
         renderer = Gtk.CellRendererText()
-        column = Gtk.TreeViewColumn("Test Type", renderer, text=TestList.TestType)
+        self.def_color = renderer.get_property("foreground-rgba").to_string()
+        column = Gtk.TreeViewColumn("Test Type", renderer, text=TestList.TestType, foreground=TestList.Color)
         self.tree.append_column(column)
 
         renderer = Gtk.CellRendererText()
@@ -224,12 +261,12 @@ class UploadMultipleTests(dbGtkUtils.ITkDBWindow):
         # double click shows attachments
         if event.button == 1 and event.type == Gdk.EventType.DOUBLE_BUTTON_PRESS:
             select = self.tree.get_selection()
-            model, iter = select.get_selected()
-            if not iter:
+            model, lv_iter = select.get_selected()
+            if not lv_iter:
                 return
 
-            self.on_show_json(None, (model, iter, model[iter]))
-            # self.on_show_attachments(None, (model, iter, model[iter]))
+            self.on_show_json(None, (model, lv_iter, model[lv_iter]))
+            # self.on_show_attachments(None, (model, lv_iter, model[lv_iter]))
             return
 
         if event.button != 3:
@@ -237,44 +274,44 @@ class UploadMultipleTests(dbGtkUtils.ITkDBWindow):
 
         # Create popup menu
         select = self.tree.get_selection()
-        model, iter = select.get_selected()
+        model, lv_iter = select.get_selected()
         values = None
-        if iter:
-            values = model[iter]
+        if lv_iter:
+            values = model[lv_iter]
 
-        if not iter:
+        if not lv_iter:
             P = tree.get_path_at_pos(event.x, event.y)
             if P:
                 print(P[0].to_string())
-                iter = model.get_iter(P[0])
-                values = model[iter]
+                lv_iter = model.get_iter(P[0])
+                values = model[lv_iter]
 
         if not values:
             return
 
         menu = Gtk.Menu()
         item_show = Gtk.MenuItem(label="Show JSOn")
-        item_show.connect("activate", self.on_show_json, (model, iter, values))
+        item_show.connect("activate", self.on_show_json, (model, lv_iter, values))
         menu.append(item_show)
 
         item_set_stage = Gtk.MenuItem(label="Set Stage")
-        item_set_stage.connect("activate", self.on_set_stage, (model, iter, values))
+        item_set_stage.connect("activate", self.on_set_stage, (model, lv_iter, values))
         menu.append(item_set_stage)
 
         item_show_att = Gtk.MenuItem(label="Edit Attachments")
-        item_show_att.connect("activate", self.on_show_attachments, (model, iter, values))
+        item_show_att.connect("activate", self.on_show_attachments, (model, lv_iter, values))
         menu.append(item_show_att)
 
         item_show_com = Gtk.MenuItem(label="Edit Comments")
-        item_show_com.connect("activate", self.on_show_comments, (model, iter, values))
+        item_show_com.connect("activate", self.on_show_comments, (model, lv_iter, values))
         menu.append(item_show_com)
 
         item_show_def = Gtk.MenuItem(label="Edit Defects")
-        item_show_def.connect("activate", self.on_show_defects, (model, iter, values))
+        item_show_def.connect("activate", self.on_show_defects, (model, lv_iter, values))
         menu.append(item_show_def)
 
         item_del = Gtk.MenuItem(label="Delete")
-        item_del.connect("activate", self.on_delete_tests, (model, iter, values))
+        item_del.connect("activate", self.on_delete_tests, (model, lv_iter, values))
         menu.append(item_del)
         menu.show_all()
 
@@ -282,17 +319,17 @@ class UploadMultipleTests(dbGtkUtils.ITkDBWindow):
 
     def on_show_json(self, item, data):
         """Test JSon."""
-        model, iter, val = data
+        model, lv_iter, val = data
         payload = val[TestList.Json]
         value, dlg = create_json_data_editor(payload)
         rc = dlg.run()
         if rc == Gtk.ResponseType.OK:
             payload = value.values
-            model.set_value(iter, TestList.Json, payload)
-            model.set_value(iter, TestList.SN, payload["component"])
-            model.set_value(iter, TestList.RunNumber, payload["runNumber"])
-            model.set_value(iter, TestList.Date, handle_test_date(payload["date"]))
-            model.set_value(iter, TestList.Institute, handle_test_date(payload["institution"]))
+            model.set_value(lv_iter, TestList.Json, payload)
+            model.set_value(lv_iter, TestList.SN, payload["component"])
+            model.set_value(lv_iter, TestList.RunNumber, payload["runNumber"])
+            model.set_value(lv_iter, TestList.Date, handle_test_date(payload["date"]))
+            model.set_value(lv_iter, TestList.Institute, handle_test_date(payload["institution"]))
 
 
         dlg.hide()
@@ -300,48 +337,48 @@ class UploadMultipleTests(dbGtkUtils.ITkDBWindow):
 
     def on_show_attachments(self, item, data):
         """Show the attachmetns."""
-        model, iter, val = data
+        model, lv_iter, val = data
 
         SA = ShowAttachments("Test Attachments", self.session, val[TestList.Attachments], parent=self)
         response = SA.run()
         if response == Gtk.ResponseType.OK:
-            model.set_value(iter, TestList.Attachments, SA.attachments)
-            model.set_value(iter, TestList.Nattch, len(SA.attachments))
+            model.set_value(lv_iter, TestList.Attachments, SA.attachments)
+            model.set_value(lv_iter, TestList.Nattch, len(SA.attachments))
 
         SA.hide()
         SA.destroy()
 
     def on_show_comments(self, item, data):
         """Show comments"""
-        model, iter, val = data
+        model, lv_iter, val = data
         SC = ShowComments("Test Comments", val[TestList.Comments], self)
         rc = SC.run()
         if rc == Gtk.ResponseType.OK:
-            model.set_value(iter, TestList.Comments, SC.comments)
-            model.set_value(iter, TestList.Ncomm, len(SC.comments))
+            model.set_value(lv_iter, TestList.Comments, SC.comments)
+            model.set_value(lv_iter, TestList.Ncomm, len(SC.comments))
 
         SC.hide()
         SC.destroy()
 
     def on_show_defects(self, item, data):
         """Show comments"""
-        model, iter, val = data
+        model, lv_iter, val = data
         SD = ShowDefects("Test Defects", val[TestList.Defects], self)
         rc = SD.run()
         if rc == Gtk.ResponseType.OK:
-            model.set_value(iter, TestList.Defects, SD.defects)
-            model.set_value(iter, TestList.Ndef, len(SD.defects))
+            model.set_value(lv_iter, TestList.Defects, SD.defects)
+            model.set_value(lv_iter, TestList.Ndef, len(SD.defects))
 
         SD.hide()
         SD.destroy()
 
     def on_delete_tests(self, item, data):
         """Test edit."""
-        model, iter, val = data
+        model, lv_iter, val = data
         rc = dbGtkUtils.ask_for_confirmation("Remove this test?",
                                              "{} - {}".format(val[TestList.SN], val[TestList.TestType]))
         if rc:
-            model.remove(iter)
+            model.remove(lv_iter)
 
     def get_test_institute(self):
         """Select an institue."""
@@ -373,9 +410,9 @@ class UploadMultipleTests(dbGtkUtils.ITkDBWindow):
 
     def on_set_stage(self, item, data):
         """Set the test stage."""
-        model, iter, val = data
+        model, lv_iter, val = data
         SN = val[TestList.SN]
-        combo, currentStage = self.get_component_stages(SN)
+        combo, _ = self.get_component_stages(SN)
 
         dlg = Gtk.Dialog(title="Add Attachment")
 
@@ -392,9 +429,9 @@ class UploadMultipleTests(dbGtkUtils.ITkDBWindow):
         rc = dlg.run()
         if rc == Gtk.ResponseType.OK:
             new_stage = combo.get_active_text()
-            model[iter][TestList.Stage] = new_stage
-            data = model[iter][TestList.Json]
-            changed = (new_stage != model[iter][TestList.currentStage])
+            model[lv_iter][TestList.Stage] = new_stage
+            data = model[lv_iter][TestList.Json]
+            changed = (new_stage != model[lv_iter][TestList.currentStage])
             data["isRetroactive"] = changed
             if changed:
                 data["stage"] = new_stage
@@ -402,7 +439,7 @@ class UploadMultipleTests(dbGtkUtils.ITkDBWindow):
                 if "stage" in data:
                     del data["stage"]
 
-            model[iter][TestList.Json] = data
+            model[lv_iter][TestList.Json] = data
 
 
         dlg.hide()
@@ -428,66 +465,84 @@ class UploadMultipleTests(dbGtkUtils.ITkDBWindow):
             return combo, currentStage
 
         except Exception:
-            self.write_message("Something went wring with the stages")
+            self.write_message("Something went wrong with the stages\n")
             return [None, None]
 
+    def add_test_data_to_view(self, data, ifile=None, folder=None):
+        """Add a test data to the  tree view."""
+        has_errors = False
+        default_site = None
+    
+        errors, missing = check_data(data)
+        if len(missing) > 0:
+            self.write_message("Some keys are missing in the JSon file.\n")
+            self.write_message("{}\n".format("\n".join(['\t'+line for line in missing])))
+
+            if "institution" in missing and len(missing) == 1:
+                if default_site is None:
+                    site, use_default = self.get_test_institute()
+                    if use_default:
+                        default_site = site
+                else:
+                    site = default_site
+
+                if site:
+                    data["institution"] = site
+                    self.write_message("Setting Institution to {}\n".format(data["institution"]))
+
+            else:
+                has_errors = True
+                dbGtkUtils.complain("Invalid JSON file\n{}".format('\n'.join(errors)),"--")
+
+        if not has_errors:
+            attachments = []
+            if "attachments" in data:
+                for att in data["attachments"]:
+                    path = Path(att["path"])
+                    if path.exists():
+                        path = path.expanduser().resolve()
+                    else:
+                        if folder is not None:
+                            path = folder / path.name
+
+                    if path.exists():
+                        attachments.append(ITkDButils.Attachment(path=path,
+                                                                 title=att["title"],
+                                                                 desc=att["description"]))
+                    else:
+                        self.write_message("Ignoring atachment {}".format(data["path"]))
+
+                # We need to delete this, which is "unofficial"
+                del data["attachments"]
+
+            model = self.tree.get_model()
+            comments = data.get("comments", [])
+            defects = data.get("defects", [])
+            the_date = handle_test_date(data["date"])
+            combo, currentStage = self.get_component_stages(data["component"])
+            if data["passed"]:
+                if data["problems"]:
+                    color = "orange"
+                else:
+                    color = self.def_color
+            else:
+                color = "firebrick"
+
+            model.append([data["component"], data["testType"], data["runNumber"], the_date,
+                            data["institution"], currentStage, currentStage,
+                            ifile, data, len(attachments), attachments,
+                            len(comments), comments, len(defects), defects, color])
+
     def add_tests_to_view(self, files):
         """Add the input fiels to the treeview."""
-        default_site = None
         for ifile in files:
             try:
-                has_errors = False
-                data = json.loads(open(ifile).read())
-                errors, missing = check_data(data)
-                if len(missing):
-                    self.write_message("{}\n".format(Path(ifile).name))
-                    self.write_message("Some keys are missing in the JSon file.\n")
-                    self.write_message("{}\n".format("\n".join(['\t'+line for line in missing])))
-
-                    if "institution" in missing and len(missing) == 1:
-                        if default_site is None:
-                            site, use_default = self.get_test_institute()
-                            if use_default:
-                                default_site = site
-                        else:
-                            site = default_site
-
-                        if site:
-                            data["institution"] = site
-                            self.write_message("Setting Institution to {}\n".format(data["institution"]))
+                self.write_message("{}\n".format(Path(ifile).name))
+                folder = Path(ifile).parent
+
+                data = json.loads(open(ifile, 'r', encoding="UTF-8").read())
+                self.add_test_data_to_view(data, ifile=ifile, folder=folder)
 
-                    else:
-                        has_errors = True
-                        dbGtkUtils.complain("Invalid JSON file\n{}".format('\n'.join(errors)), ifile)
-
-                if not has_errors:
-                    attachments = []
-                    if "attachments" in data:
-                        folder = Path(ifile).parent
-                        for att in data["attachments"]:
-                            path = Path(att["path"])
-                            if path.exists():
-                                path = path.expanduser().resolve()
-                            else:
-                                path = folder / path.name
-
-                            if path.exists():
-                                attachments.append(ITkDButils.Attachment(path, att["title"], att["description"]))
-                            else:
-                                self.write_message("Ignoring atachment {}".format(data["path"]))
-
-                        # We need to delete tis, which is "unofficial"
-                        del data["attachments"]
-
-                    model = self.tree.get_model()
-                    comments = data.get("comments", [])
-                    defects = data.get("defects", [])
-                    the_date = handle_test_date(data["date"])
-                    combo, currentStage = self.get_component_stages(data["component"])
-                    model.append([data["component"], data["testType"], data["runNumber"], the_date,
-                                  data["institution"], currentStage, currentStage,
-                                  ifile, data, len(attachments), attachments,
-                                  len(comments), comments, len(defects), defects])
 
             except Exception as E:
                 self.write_message("Cannot load file {}\n".format(ifile))
@@ -596,32 +651,42 @@ class UploadMultipleTests(dbGtkUtils.ITkDBWindow):
     def upload_test(self):
         """Uploads tests and attachments."""
         model = self.tree.get_model()
-        iter = model.get_iter_first()
-        while iter:
+        lv_iter = model.get_iter_first()
+        ngood = 0
+        nbad = 0
+        while lv_iter:
             past_iter = None
-            values = model[iter]
+            values = model[lv_iter]
             payload = values[TestList.Json]
             payload["comments"] = values[TestList.Comments]
             payload["defects"] = values[TestList.Defects]
 
-            rc = ITkDButils.upload_test(self.session, payload, values[TestList.Attachments])
+            rc = ITkDButils.upload_test(self.session, payload, values[TestList.Attachments], check_runNumber=True)
             if rc:
                 ipos = rc.find("The following details may help:")
                 msg = rc[ipos:]
-                dbGtkUtils.complain("Failed uploading test {}-{}".format(payload["component"], payload["testType"]), msg)
-                self.write_message(msg)
+                dbGtkUtils.complain("Failed uploading test {}-{}".format(payload["component"], payload["testType"]))
+                self.write_message("Failed uploading test {}-{}\n{}\n".format(payload["component"], payload["testType"], msg))
+                nbad += 1
 
             else:
                 self.write_message("Upload {}-{} successfull\n".format(payload["component"], payload["testType"]))
-                past_iter = iter
+                past_iter = lv_iter
+                ngood += 1
 
-            iter = model.iter_next(iter)
+            lv_iter = model.iter_next(lv_iter)
             if past_iter:
                 model.remove(past_iter)
 
+        if nbad>0:
+            dbGtkUtils.complain("Failed to upload all tests", "{} test had errors.\nThey are left in the ListView.")
+        else:
+            dbGtkUtils.complain("All {} tests uploaded succesfully".format(ngood))
+
 
 def main():
-    """Main entry."""
+    """Main entry."""    
+    HELP_LINK="https://itkdb-gtk.docs.cern.ch/uploadMultipleTests.html"
     # DB login
     dlg = ITkDBlogin.ITkDBlogin()
     client = dlg.get_client()
@@ -633,7 +698,7 @@ def main():
     client.user_gui = dlg
 
     # Start GUI
-    UpT = UploadMultipleTests(client)
+    UpT = UploadMultipleTests(client, help_link=HELP_LINK)
 
     if gtk_runs:
         UpT.present()