itkdb-gtk 0.10.10.dev4__tar.gz → 0.10.10.dev5__tar.gz

{itkdb_gtk-0.10.10.dev4 → itkdb_gtk-0.10.10.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: itkdb_gtk
-Version: 0.10.10.dev4
+Version: 0.10.10.dev5
 Summary: A collection of Gtk based GUI to access ITkDB.
 Author-email: Carlos Lacasta <carlos.lacasta@cern.ch>
 Project-URL: Homepage, https://gitlab.cern.ch/atlas-itk/sw/db/itk-pdb-gtk-gui-utils

itkdb_gtk-0.10.10.dev5/itkdb_gtk/ModuleVisualInspection.py

@@ -0,0 +1,247 @@
+#!/usr/bin/env python3
+"""Module Visual inspection GUI."""
+import sys
+from pathlib import Path
+
+try:
+    import itkdb_gtk
+
+except ImportError:
+    cwd = Path(__file__).parent.parent
+    sys.path.append(cwd.as_posix())
+
+from itkdb_gtk import dbGtkUtils, ITkDBlogin, ITkDButils
+from itkdb_gtk.ShowComments import ShowComments
+from itkdb_gtk.ShowDefects import ShowDefects
+from itkdb_gtk.ShowAttachments import ShowAttachments
+from itkdb_gtk.UploadTest import UploadTest
+
+import gi
+gi.require_version("Gtk", "3.0")
+from gi.repository import Gtk, Gio
+
+HELP_LINK="https://itkdb-gtk.docs.cern.ch/moduleVisualInspection.html"
+
+class ModuleVisualInspection(dbGtkUtils.ITkDBWindow):
+    """Module Visual Inspection."""
+
+    def __init__(self, session, title="Module Visual Inspection", help_link=HELP_LINK):
+        super().__init__(title=title,
+                         session=session,
+                         show_search="Find object with given SN.",
+                         help_link=help_link)
+
+        self.institute = self.pdb_user["institutions"][0]["code"]
+        self.global_image = None
+        self.global_link = None
+        self.data = None
+        self.attachments = []
+        self.comments = []
+        self.defects = []
+
+        # action button in header
+        button = Gtk.Button()
+        icon = Gio.ThemedIcon(name="document-send-symbolic")
+        image = Gtk.Image.new_from_gicon(icon, Gtk.IconSize.BUTTON)
+        button.add(image)
+        button.set_tooltip_text("Click to upload the test.")
+        button.connect("clicked", self.upload_test)
+        self.hb.pack_end(button)
+
+        grid = Gtk.Grid(column_spacing=5, row_spacing=5)
+        self.mainBox.pack_start(grid, False, False, 5)
+
+        irow = 0
+        receiver = self.create_institute_combo(only_user=True)
+        receiver.connect("changed", self.on_institute)
+        receiver.set_tooltip_text("Select the Institute making the test.")
+        dbGtkUtils.set_combo_iter(receiver, self.institute)
+
+        lbl = Gtk.Label(label="Institute")
+        lbl.set_xalign(0)
+        grid.attach(lbl, 0, irow, 1, 1)
+        grid.attach(receiver, 1, irow, 1, 1)
+
+        irow += 1
+        lbl = Gtk.Label(label="Serial Number")
+        lbl.set_xalign(0)
+        grid.attach(lbl, 0, irow, 1, 1)
+
+        self.SN = dbGtkUtils.TextEntry(small=True)
+        self.SN.connect("text_changed", self.SN_ready)
+        self.SN.widget.set_tooltip_text("Enter SN of module.")
+        grid.attach(self.SN.widget, 1, irow, 1, 1)
+
+        irow += 1
+        lbl = Gtk.Label(label="Date")
+        lbl.set_xalign(0)
+        grid.attach(lbl, 0, irow, 1, 1)
+
+        self.date = dbGtkUtils.TextEntry(small=True)
+        grid.attach(self.date.widget, 1, irow, 1, 1)
+        self.date.entry.set_text(ITkDButils.get_db_date())
+        self.date.connect("text_changed", self.new_date)
+
+        irow +=1
+        self.passed = Gtk.Switch()
+        self.passed.props.halign = Gtk.Align.START
+        self.passed.set_active(True)
+        lbl = Gtk.Label(label="Passed")
+        lbl.set_xalign(0)
+        grid.attach(lbl, 0, irow, 1, 1)
+        grid.attach(self.passed, 1, irow, 1, 1)
+
+        irow +=1
+        self.problems = Gtk.Switch()
+        self.problems.props.halign = Gtk.Align.START
+        self.problems.set_active(False)
+        lbl = Gtk.Label(label="Problems")
+        lbl.set_xalign(0)
+        grid.attach(lbl, 0, irow, 1, 1)
+        grid.attach(self.problems, 1, irow, 1, 1)
+
+
+        # The "Add attachment" button.
+        box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
+        self.mainBox.pack_start(box, False, False, 0)
+        self.btn_attch = dbGtkUtils.add_button_to_container(box, "Attachments",
+                                           "Click to edit attachments.",
+                                           self.edit_attachments)
+
+        self.btn_comments = dbGtkUtils.add_button_to_container(box, "Comments",
+                                           "Click to edit comments.",
+                                           self.edit_comments)
+
+        self.btn_defects = dbGtkUtils.add_button_to_container(box, "Defects",
+                                           "Click to edit defects.",
+                                           self.edit_defects)
+
+        self.mainBox.pack_start(self.message_panel.frame, True, True, 5)
+        self.write_message("Module Visual Inspection\n")
+        self.show_all()
+
+        dbGtkUtils.setup_scanner(self.get_qrcode)
+
+    def on_institute(self, combo):
+        """A new recipient has been chosen."""
+        name = self.get_institute_from_combo(combo)
+        if name:
+            self.institute = name
+
+    def new_date(self, entry, value):
+        """new date given at input."""
+        d = dbGtkUtils.parse_date_as_string(value)
+        if d is not None:
+            self.date.set_text(d)
+
+    def SN_ready(self, *args):
+        """SN is ready in the TextEnttry."""
+        SN = self.SN.get_text()
+        # GEt children.
+        module = ITkDButils.get_DB_component(self.session, SN)
+        if module is None:
+            self.write_message(ITkDButils.get_db_response())
+            return
+
+        SN = module["serialNumber"]
+        args[0].set_text(SN)
+
+
+    def edit_attachments(self, *args):
+        """Edit test attachmetns."""
+        SA = ShowAttachments("Test Attachments", self.session, self.attachments, parent=self)
+        response = SA.run()
+        if response == Gtk.ResponseType.OK:
+            self.attachments = SA.attachments
+
+        SA.hide()
+        SA.destroy()
+
+        if len(self.attachments) > 0:
+            self.btn_attch.set_label("Attachments ({})".format(len(self.attachments)))
+
+    def edit_comments(self, *args):
+        """Edit test comments."""
+        SC = ShowComments("Test Comments", self.comments, self)
+        rc = SC.run()
+        if rc == Gtk.ResponseType.OK:
+            self.comments = SC.comments
+
+        SC.hide()
+        SC.destroy()
+
+        if len(self.comments) > 0:
+            self.btn_comments.set_label("Comments ({})".format(len(self.comments)))
+
+    def edit_defects(self, *args):
+        """Edit test defects."""
+        SD = ShowDefects("Test Defects", self.defects, self)
+        rc = SD.run()
+        if rc == Gtk.ResponseType.OK:
+            self.defects = SD.defects
+
+        SD.hide()
+        SD.destroy()
+
+        if len(self.defects) > 0:
+            self.btn_defects.set_label("Defects ({})".format(len(self.defects)))
+
+    def upload_test(self, *args):
+        """Upload the test."""
+        SN = self.SN.get_text()
+        if len(SN) == 0:
+            dbGtkUtils.complain("Invalid Serial Number", SN)
+            return
+
+        defaults = {
+            "component": SN,
+            "institution": self.institute,
+            "passed": self.passed.get_active(),
+            "problems": self.problems.get_active(),
+            "runNumber": "1",
+            "date": self.date.get_text()
+        }
+        self.data = ITkDButils.get_test_skeleton(self.session,
+                                                 "MODULE",
+                                                 "VISUAL_INSPECTION",
+                                                 defaults)
+
+        self.data["comments"] = self.comments
+        self.data["defects"] = self.defects
+        uploadW = UploadTest(self.session, self.data, self.attachments)
+
+
+
+    def get_qrcode(self, fd, state, reader):
+        """Read SN from scanner."""
+        txt = dbGtkUtils.scanner_get_line(reader)
+        self.write_message("SN: {}\n".format(txt))
+        self.SN_ready(txt, self.SN.widget)
+
+
+def main():
+    """Main entry."""
+    # DB login
+    dlg = ITkDBlogin.ITkDBlogin()
+    client = dlg.get_client()
+    if client is None:
+        print("Could not connect to DB with provided credentials.")
+        dlg.die()
+        sys.exit()
+
+    client.user_gui = dlg
+
+    gTest = ModuleVisualInspection(client)
+
+    gTest.present()
+    gTest.connect("destroy", Gtk.main_quit)
+    try:
+        Gtk.main()
+
+    except KeyboardInterrupt:
+        print("Arrrgggg!!!")
+
+    dlg.die()
+
+if __name__ == "__main__":
+    main()

{itkdb_gtk-0.10.10.dev4 → itkdb_gtk-0.10.10.dev5}/itkdb_gtk/UploadMultipleTests.py

@@ -1,6 +1,5 @@
 #!/usr/bin/env python3
 """GUI to upload tests."""
-import argparse
 import fnmatch
 import json
 import os
@@ -64,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):
@@ -113,6 +131,7 @@ class UploadMultipleTests(dbGtkUtils.ITkDBWindow):
         self.tests = []
         self.data = None
         self.tree = None
+        self.def_color = None
 
         self.init_window()
 
@@ -174,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()
@@ -187,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()
@@ -376,7 +412,7 @@ class UploadMultipleTests(dbGtkUtils.ITkDBWindow):
         """Set the test stage."""
         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")
 
@@ -429,7 +465,7 @@ 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_tests_to_view(self, files):
@@ -473,8 +509,8 @@ class UploadMultipleTests(dbGtkUtils.ITkDBWindow):
                                 path = folder / path.name
 
                             if path.exists():
-                                attachments.append(ITkDButils.Attachment(path=path, 
-                                                                         title=att["title"], 
+                                attachments.append(ITkDButils.Attachment(path=path,
+                                                                         title=att["title"],
                                                                          desc=att["description"]))
                             else:
                                 self.write_message("Ignoring atachment {}".format(data["path"]))
@@ -487,10 +523,18 @@ class UploadMultipleTests(dbGtkUtils.ITkDBWindow):
                     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])
+                                  len(comments), comments, len(defects), defects, color])
 
             except Exception as E:
                 self.write_message("Cannot load file {}\n".format(ifile))

{itkdb_gtk-0.10.10.dev4 → itkdb_gtk-0.10.10.dev5}/itkdb_gtk/UploadTest.py

@@ -9,7 +9,6 @@ try:
     import itkdb_gtk
 
 except ImportError:
-    from pathlib import Path
     cwd = Path(__file__).parent.parent
     sys.path.append(cwd.as_posix())
 
@@ -93,6 +92,7 @@ class UploadTest(dbGtkUtils.ITkDBWindow):
         self.attachments = []
         self.comments = []
         self.defects = []
+        self.currentStage = None
         if attachment is not None:
             if isinstance(attachment, ITkDButils.Attachment):
                 if attachment.path is not None:
@@ -219,6 +219,7 @@ class UploadTest(dbGtkUtils.ITkDBWindow):
             except TypeError:
                 self.load_payload(self.payload)
                 self.write_message("Loaded memory payload.\n")
+                self.testF.set_sensitive(False)
 
         if len(self.attachments) > 0:
             self.btn_attch.set_label("Attachments ({})".format(len(self.attachments)))
@@ -293,7 +294,7 @@ class UploadTest(dbGtkUtils.ITkDBWindow):
             self.objStage.set_active(indx)
 
         except Exception:
-            self.write_message("Something went wring with the stages")
+            self.write_message("Something went wrong with the stages\n")
 
 
     def on_test_file(self, fdlg):
@@ -303,7 +304,7 @@ class UploadTest(dbGtkUtils.ITkDBWindow):
 
         # The file exists by definition
         try:
-            self.data = json.loads(open(fnam).read())
+            self.data = json.loads(open(fnam, encoding="UTF-8").read())
             errors, missing = check_data(self.data)
             self.complete_missing(missing, errors)
             self.set_stages()
@@ -326,7 +327,7 @@ class UploadTest(dbGtkUtils.ITkDBWindow):
                     self.write_message("Setting Institution to {}\n".format(self.data["institution"]))
 
             else:
-                dbGtkUtils.complain("Invalid JSON data".format('\n'.join(errors)))
+                dbGtkUtils.complain("Invalid JSON data\n{}".format('\n'.join(errors)))
 
         self.find_attachments()
         self.find_comments()

{itkdb_gtk-0.10.10.dev4 → itkdb_gtk-0.10.10.dev5}/itkdb_gtk/WireBondGui.py

@@ -6,6 +6,7 @@ import re
 import json
 import copy
 from pathlib import Path
+from collections import namedtuple
 import gi
 
 gi.require_version("Gtk", "3.0")
@@ -28,18 +29,6 @@ from itkdb_gtk import ITkDBlogin, ITkDButils, UploadTest
 #valid_channel = re.compile("(^[0-9]+)-([0-9]+)")
 valid_channel = re.compile("^[0-9]+[\\s*\\,\\s,-[0-9]+]*")
 
-def range_to_list(V):
-    """Convert a range (ch1-ch2) to a list."""
-    if '-' not in V:
-        return [V]
-
-    out = []
-    endpoints = list(map(int, V.split('-')))
-    endpoints.sort()
-    for i in range(endpoints[0], endpoints[1]+1):
-        out.append(str(i))
-
-    return out
 
 test_parameters = {
         "Repaired Row 1": "REPAIRED_FRONTEND_ROW1",
@@ -103,21 +92,31 @@ module_param = {
     ],
 }
 
-def wire2strip(mod_par, irow, iwire):
-    """Convert from wirebond index to strip_number."""
-    for sensor in mod_par:
-        for hyb in sensor:
-            rng = hyb[irow]
-            if iwire>= rng[0] and iwire<=rng[1]:
-                if irow % 2:
-                    ichan = 2*(iwire-rng[0]) + 1
-                else:
-                    ichan = 2*(iwire-rng[0])
+def range_to_list(V):
+    """Convert a range (ch1-ch2) to a list."""
+    if '-' not in V and ',' not in V:
+        return [V]
 
-                return ichan
+    out = []
+    values = V.split(',')
+    for V in values:
+        if '-' in V:
+            endpoints = list(map(int, V.split('-')))
+            endpoints.sort()
+            for i in range(endpoints[0], endpoints[1]+1):
+                out.append(str(i))
+        else:
+            out.append(V)
+
+    return out
 
-    return None
+def count_items(items):
+    """Count number of channels from results."""
+    nitems = 0
+    for key in items.keys():
+        nitems += len(range_to_list(key))
 
+    return nitems
 
 def find_holes(chan_list, min_chan=0, max_chan=999999):
     """Find groups of consecutive channels."""
@@ -161,19 +160,41 @@ def find_holes(chan_list, min_chan=0, max_chan=999999):
     return holes
 
 
+def wire2strip(iwire, irow, first_chan):
+    """From bond to strip number."""
+    if irow % 2:
+        istrip = 2*(iwire-first_chan) + 1
+    else:
+        istrip = 2*(iwire-first_chan)
+
+    return istrip
+
+
+class Hole:
+    """A range of consecutive unconnected channels."""
+    def __init__(self, *args):
+        for i, name in enumerate(['sensor', 'hybrid', 'row', 'chan', 'width']):
+            setattr(self, name, args[i])
+
+    def __repr__(self):
+        return "sensor: {} hyb: {} row: {} chan: {} width: {}".format(
+            self.sensor, self.hybrid, self.row, self.chan, self.width
+        )
+
 class HybridHoles:
-    """Holes in hybrid bomds.
+    """Holes in hybrid bonds.
 
     Holes are defined by a list [first_chan, n_chan].
     """
 
-    def __init__(self, param, hid=0):
+    def __init__(self, param, win=None, hid=0):
         """Initialization.
 
         Args:
             param: Hybrid wirebon parameters.
 
         """
+        self.win = win
         self.id = hid
         self.param = param
         self.nchan = 0
@@ -182,12 +203,25 @@ class HybridHoles:
 
         self.holes = [[] for irow in range(4)]
         self.channels = [[] for irow in range(4)]
+        # Sensor strips for each of the strip rows "served" by a hybrid.
+        self.sensor_channels = [[], []]
+        self.sensor_holes = [[], []]
+
+    def ready(self):
+        """Call when all channels are in."""
+        for irow, C in enumerate(self.channels):
+            C.sort()
+            self.holes[irow] = find_holes(C)
+
+        for irow, S in enumerate(self.sensor_channels):
+            S.sort()
+            self.sensor_holes[irow] = find_holes(S)
 
     def add_channel(self, irow, ichan)->bool:
         """Add a new channel in row.
 
         Args:
-            irow: rown number
+            irow: row number
             ichan: channel number
 
         Returns:
@@ -196,102 +230,93 @@ class HybridHoles:
         """
         first_chan = self.param[irow][0]
         last_chan = self.param[irow][1]
+        strip_row = int(irow/2)
+
+
         if isinstance(ichan, list) or isinstance(ichan, tuple):
             nadded = 0
             for ich in ichan:
-                if ich >= first_chan and ich <= last_chan:
+                if first_chan <= ich <= last_chan:
                     self.channels[irow].append(ich)
                     nadded += 1
 
             self.channels[irow] = sorted(self.channels[irow])
+            for iwire in self.channels[irow]:
+                istrip = wire2strip(iwire, irow, first_chan)
+                self.sensor_channels[strip_row].append(istrip)
+
             return nadded>0
-        else:
-            if ichan >= first_chan and ichan <= last_chan:
-                self.channels[irow].append(ichan)
-                return True
-            else:
-                return False
 
-    def get_n_unconnected(self):
+        if first_chan <= ichan <= last_chan:
+            self.channels[irow].append(ichan)
+            istrip = wire2strip(ichan, irow, first_chan)
+            self.sensor_channels[strip_row].append(istrip)
+            return True
+
+        return False
+
+    def get_n_unconnected(self) -> list:
         """Count number of unconnected channels.
 
         Return a list, one item per row.
         """
-        nchan = []
-        for row in self.holes:
-            nch = 0
-            for h in row:
-                nch += h[1]
-
-            nchan.append(nch)
-
+        nchan = [len(C) for C in self.channels]
         return nchan
 
-    def get_max_consecutive(self):
-        """Returns the largest 'hole'."""
+    def get_max_consecutive_from_list(self, holes):
+        """Return max widht of holes."""
         mx_width = []
+        lst_holes = []
+        for irow, row in enumerate(holes):
+            if len(row) == 0:
+                mxW = 0
 
-        for row in self.holes:
-            mxW = -1
-            for h in row:
-                if h[1] > mxW:
-                    mxW = h[1]
+            else:
+                mxW = -1
+                for h in row:
+                    lst_holes.append(Hole(0, self.id, irow, h[0], h[1]))
+                    mxW = max(mxW, h[1])
 
             mx_width.append(mxW)
 
-        return mx_width
-
-    def get_sensor_holes(self):
-        """Compute holes in 'sensor' strips.
-
-        Each hybrid has 2 sensor segments corresponding to
-        rows (1,2) and (3, 4).
-
-        Return a list of [sensor, hybrid, segment, ichan, width]
-        """
-        holes = []
-        channels = [[], []]
-        for irow, row in enumerate(self.channels):
-            isegment = int(irow/2)
-            for ich in row:
-                rng = self.param[irow]
-                if irow % 2:
-                    chan = 2*(ich-rng[0]) + 1
-                else:
-                    chan = 2*(ich-rng[0])
-
-                channels[isegment].append(chan)
+        return mx_width, lst_holes
 
-            channels[isegment] = sorted(channels[isegment])
 
-        for isegment, S in enumerate(channels):
-            H = find_holes(S)
-            if len(H)>0:
-                out = [ [0, self.id, isegment, chan, width] for chan, width in H ]
-                holes.extend(out)
-
-        return holes
+    def get_max_consecutive(self):
+        """Returns the largest 'hole'."""
+        mx_width, _ = self.get_max_consecutive_from_list(self.holes)
+        return mx_width
 
+    def get_max_sensor_consecutive(self):
+        """Return largest hole in sensor."""
+        mx_width, holes = self.get_max_consecutive_from_list(self.sensor_holes)
+        return mx_width, holes
 
 class SensorHoles:
     """Holes in sensor."""
 
-    def __init__(self, param, sid=0):
+    def __init__(self, param, win=None, sid=0):
         """Initialization.
 
         Args:
             param: sensor wirebon params
         """
+        self.win = win
         self.id = sid
         self.param = param
         self.nchan = 0
         self.nhybrid = len(param)
         self.hybrids = []
         for i, P in enumerate(param):
-            H = HybridHoles(P, hid=i)
+            H = HybridHoles(P, hid=i, win=win)
             self.hybrids.append(H)
             self.nchan += H.nchan
 
+    def ready(self):
+        """Call when all channels are in."""
+        for H in self.hybrids:
+            H.ready()
+
     def get_n_hyb(self):
         """Return number of hybrids."""
         return len(self.hybrids)
@@ -305,15 +330,30 @@ class SensorHoles:
 
         This is ordered by row.
         """
-        mx_width = [0, 0, 0, 0]
+        n_strip_row = 2*len(self.hybrids)
+        mx_width = [0 for x in range(n_strip_row)]
         for hyb in self.hybrids:
             mxW = hyb.get_max_consecutive()
             for j in range(4):
-                if mxW[j] > mx_width[j]:
-                    mx_width[j] = mxW[j]
+                mx_width[j] = max(mx_width[j] , mxW[j])
 
         return mx_width
 
+    def get_max_sensor_consecutive(self):
+        """MAx widht of holes in sensor."""
+        mx_width = -1
+        holes = []
+        for hyb in self.hybrids:
+            mxW, hyb_holes = hyb.get_max_sensor_consecutive()
+            for H in hyb_holes:
+                H.sensor = self.id
+
+            holes.extend(hyb_holes)
+            for v in mxW:
+                mx_width = max(mx_width, v)
+
+        return mx_width, holes
+
     def get_n_unconnected(self):
         """Count number of unconnected channels.
 
@@ -327,37 +367,30 @@ class SensorHoles:
 
         return nchan
 
-    def get_sensor_holes(self):
-        """Return holes sensor.
-
-        Return a list of [sensor, hybrid, segment, ichan, width]
-        """
-        holes = []
-        for hyb in self.hybrids:
-            H = hyb.get_sensor_holes()
-            for _, ih, isegment, ichan, width in H:
-                holes.append([self.id, ih, isegment, ichan, width])
-
-        return holes
-
 
 class ModuleHoles:
     """Holes in Modules."""
 
-    def __init__(self, param):
+    def __init__(self, param, win=None):
         """Initialization.
 
         Args:
             param: module wirebond params
         """
+        self.win = win
         self.nsensor = len(param)
         self.nchan = 0
         self.sensors = []
         for i, P in enumerate(param):
-            S = SensorHoles(P, sid=i)
+            S = SensorHoles(P, sid=i, win=win)
             self.sensors.append(S)
             self.nchan += S.nchan
 
+    def ready(self):
+        """Call when all channels are in."""
+        for S in self.sensors:
+            S.ready()
+
     def get_max_consecutive(self):
         """Max number of consecutive unconnected channels.
 
@@ -367,22 +400,21 @@ class ModuleHoles:
         for S in self.sensors:
             mxW = S.get_max_consecutive()
             for j in range(4):
-                if mxW[j] > mx_width[j]:
-                    mx_width[j] = mxW[j]
+                mx_width[j] = max(mx_width[j], mxW[j])
 
         return mx_width
 
-    def get_sensor_holes(self) -> list:
-        """Return. holesin sensor strips.
-
-        Return a list of [sensor, hybrid, segment, ichan, width]
-        """
-        holes = []
+    def get_max_sensor_consecutive(self):
+        """The maximum number of consecutive channels per strip row."""
+        mx_width = -1
+        module_holes =  []
         for S in self.sensors:
-            for _, ihyb, isegment, ichan, width in S.get_sensor_holes():
-                holes.append([S.id, ihyb, isegment, ichan, width])
+            width, holes = S.get_max_sensor_consecutive()
+            module_holes.extend(holes)
+            mx_width = max(mx_width, width)
+
+        return mx_width, module_holes
 
-        return holes
 
     def get_n_unconnected(self) -> list:
         """Count number of unconnected channels.
@@ -575,12 +607,35 @@ class WireBond(dbGtkUtils.ITkDBWindow):
         lut = {}
         module_map = {}
         section = None
+        i_local = 0
+        i_std = 1
+        indx = ["local", "standard"]
+        found_format = False
         with open(fnam, 'r', encoding="UTF-8") as fin:
             for line in fin:
                 line = line.strip()
 
                 # Remove comments.
                 ipos = line.find('#')
+                jpos = line.find("#!")
+                if jpos>=0 and ipos==jpos:
+                    if found_format:
+                        dbGtkUtils.complain("A second format line was found.",
+                                            "Onely one is allowed. stopr map parsing.")
+                        return
+
+                    indx = [x.lower() for x in line[ipos+2:].split()]
+                    try:
+                        i_local = indx.index("local")
+                        i_std = indx.index("standard")
+                        found_format = True
+                    except ValueError:
+                        dbGtkUtils.complain("Wrong format desciption string.",
+                                            "The words 'local' and 'standard' should be there.\n{}".format(line))
+                        return
+
+                    continue
+
                 if ipos >= 0:
                     line = line[:ipos].strip()
 
@@ -602,13 +657,13 @@ class WireBond(dbGtkUtils.ITkDBWindow):
                 if section is None:
                     continue
 
-                values = list(map(str.strip, line.split(',')))
-                if len(values)!=2:
+                values = line.split()
+                if len(values)!=len(indx):
                     dbGtkUtils.complain("Cannot read Lookup table.", "Wrong line format: {}".format(line))
                     return
 
-                v_local = range_to_list(values[0])
-                v_std = range_to_list(values[1])
+                v_local = range_to_list(values[i_local])
+                v_std = range_to_list(values[i_std])
 
                 if len(v_local) != len(v_std):
                     dbGtkUtils.complain("Wrong Lookup table.",
@@ -669,7 +724,7 @@ class WireBond(dbGtkUtils.ITkDBWindow):
             view_model = self.models[param]
             self.tree.set_model(view_model)
         else:
-            self.write_message("Cannot find model for {}".format(param))
+            self.write_message("Cannot find model for {}\n".format(param))
 
     def create_combo(self):
         """Create the combo."""
@@ -813,7 +868,42 @@ class WireBond(dbGtkUtils.ITkDBWindow):
         self.hide()
         self.destroy()
 
-    def compute_unconnected(self):
+    def compute_repaired(self, skeleton):
+        """Compute number of repaired."""
+        nrepaired = 0
+        for key, values in skeleton["results"].items():
+            if key.find("REPAIRED")<0 or key.find("ROW")<0:
+                continue
+
+            nrepaired += len(values)
+
+        if nrepaired>0:
+            skeleton["problems"] = True
+            skeleton["comments"].append("Number of repaired FE bonds: {}".format(nrepaired))
+
+        return nrepaired
+
+    def compute_hybrid_to_pb(self, skeleton):
+        """Compute number of failures and repairs."""
+        n = count_items(skeleton["results"]["REPAIRED_HYBRID_TO_PB"])
+        n = count_items(skeleton["results"]["FAILED_HYBRID_TO_PB"])
+        if n:
+            msg = "Hybrid to PB: {} failing bonds.".format(n)
+            skeleton["comments"].append(msg)
+            skeleton["passed"] = False
+            self.write_message("{}\n".format(msg))
+
+    def compute_module_to_frame(self, skeleton):
+        """Compute number of failures and repairs."""
+        n = count_items(skeleton["results"]["REPAIRED_MODULE_TO_FRAME"])
+        n = count_items(skeleton["results"]["FAILED_MODULE_TO_FRAME"])
+        if n:
+            msg = "Module to test frame: {} failing bonds.".format(n)
+            skeleton["comments"].append(msg)
+            skeleton["passed"] = False
+            self.write_message("{}\n".format(msg))
+
+    def compute_unconnected(self, results):
         """Compute number of unconnected."""
         try:
             param = get_module_param(self.SN.get_text())
@@ -821,9 +911,9 @@ class WireBond(dbGtkUtils.ITkDBWindow):
             dbGtkUtils.complain("Wrong SN number", str(E))
             return None
 
-        M = ModuleHoles(param=param)
+        M = ModuleHoles(param=param, win=self)
 
-        for test in test_parameters.values():
+        for test, values in results.items():
             if test.find("FAILED") < 0:
                 continue
             if test.find("ROW") < 0:
@@ -832,16 +922,7 @@ class WireBond(dbGtkUtils.ITkDBWindow):
             irow = int(test[-1]) - 1
 
             # Get list of all channels with wirebond notation.
-            model = self.models[test]
-            it = model.get_iter_first()
-            out = []
-            while it:
-                chan, _ = model[it]
-                if len(chan) > 0:
-                    out.append(int(chan))
-
-                it = model.iter_next(it)
-
+            out = [int(x) for x in values.keys()]
             # Translate to sensor, hybrids, etc.
             for S in M.sensors:
                 for H in S.hybrids:
@@ -850,41 +931,66 @@ class WireBond(dbGtkUtils.ITkDBWindow):
 
 
         # Now get sensor strips.
+        M.ready()
         unconnected = M.get_n_unconnected()
         mx_consecutive = M.get_max_consecutive()
-        module_holes = M.get_sensor_holes()
+        mx_sensor_width, module_holes = M.get_max_sensor_consecutive()
 
         out = {}
+        out["comments"] = []
+        out["defects"] = []
         for irow in range(4):
             key = "MAX_CONT_UNCON_ROW{}".format(irow+1)
             out[key] = mx_consecutive[irow]
 
-        mxW = 0
         self.write_message("Found {} clusters of unconnected strips in sensor.\n".format(len(module_holes)))
         for H in module_holes:
-            self.write_message("{}\n".format(str(H)))
-            if H[-1] > mxW:
-                mxW = H[-1]
+            self.write_message("{}\n".format(H))
 
-        if mxW > 0:
-            self.write_message("Max width: {}". format(mxW))
+        if mx_sensor_width > 0:
+            self.write_message("Max width of consecutive unconnected strips: {}\n". format(mx_sensor_width))
+
+        out["MAX_UNCON_SENSOR_CHAN"] = mx_sensor_width
+        if mx_sensor_width > 8:
+            out["passed"] = False
+            out["comments"].append("Too many consecutive sensor strips unconnected: {}".format(mx_sensor_width))
 
-        out["MAX_UNCON_SENSOR_CHAN"] = mxW
         nstrips = 0
         for v in unconnected:
             nstrips += v
 
-        out["TOTAL_PERC_UNCON_SENSOR_CHAN"] = nstrips/M.nchan
+        percent = 100*nstrips/M.nchan
+        out["TOTAL_PERC_UNCON_SENSOR_CHAN"] = percent
+        if out["TOTAL_PERC_UNCON_SENSOR_CHAN"] > 1.0:
+            out["passed"] = False
+            out["comments"].append("More than 1%% of channels unconnected: {:.1f}%%".format(percent))
 
         return out
 
     def get_unconnected(self, skeleton):
         """Fill the test DTO with unconnected information."""
-        out = self.compute_unconnected()
+        out = self.compute_unconnected(skeleton["results"])
         if out is None:
             raise ValueError("Wrong SN")
 
         for key, val in out.items():
+            if key in ["passed", "problems"]:
+                skeleton[key] = out[key]
+                continue
+
+            if key == "comments":
+                for C in out[key]:
+                    skeleton[key].append(C)
+
+                continue
+
+            if key == "defects":
+                for D in out[key]:
+                    skeleton[key].append(D)
+
+                continue
+
+
             skeleton["results"][key] = val
 
     def read_file(self, *args):
@@ -921,7 +1027,7 @@ class WireBond(dbGtkUtils.ITkDBWindow):
         try:
             dbGtkUtils.set_combo_iter(self.inst_combo, data["institution"])
         except KeyError:
-            self.write_message("institution value is not in the loaded file.")
+            self.write_message("institution value is not in the loaded file\n.")
 
         self.operator.set_text(data["properties"]["OPERATOR"])
         self.machine.set_text(data["properties"]["BOND_MACHINE"])
@@ -971,12 +1077,8 @@ class WireBond(dbGtkUtils.ITkDBWindow):
                     continue
 
                 for V in values:
-                    if '-' in V:
-                        for i in range_to_list(V):
-                            added_items.append((str(i), comment))
-
-                    elif len(V)>0:
-                        added_items.append((V, comment))
+                    for i in range_to_list(V):
+                        added_items.append((str(i), comment))
 
             for key in range_items:
                 section.pop(key)
@@ -1052,7 +1154,7 @@ class WireBond(dbGtkUtils.ITkDBWindow):
             if len(values) == 4:
                 SN, operator, machine = values
             else:
-                self.write_message("Something went wrong while requesting missing information.")
+                self.write_message("Something went wrong while requesting missing information.\n")
 
         data["component"] = SN
         data["properties"]["OPERATOR"] = operator
@@ -1090,6 +1192,9 @@ class WireBond(dbGtkUtils.ITkDBWindow):
         self.fix_list_of_channels(skeleton)
         try:
             self.get_unconnected(skeleton)
+            self.compute_repaired(skeleton)
+            self.compute_hybrid_to_pb(skeleton)
+            self.compute_module_to_frame(skeleton)
 
         except ValueError:
             return

{itkdb_gtk-0.10.10.dev4 → itkdb_gtk-0.10.10.dev5}/itkdb_gtk/__init__.py

@@ -1,6 +1,6 @@
 """ itkdb-gtk python module
 """
-__version__ = "0.10.10.dev4"
+__version__ = "0.10.10.dev5"
 
 
 def dash_board():
@@ -62,3 +62,8 @@ def panelVisualInspection():
     """Visual inspection of PWB or HYB panels."""
     from .PanelVisualInspection import main
     main()
+
+def moduleVisualInspection():
+    """Visual inspection of Modules."""
+    from .ModuleVisualInspection import main
+    main()

{itkdb_gtk-0.10.10.dev4 → itkdb_gtk-0.10.10.dev5}/itkdb_gtk/dashBoard.py

@@ -22,6 +22,7 @@ from itkdb_gtk import GlueWeight
 from itkdb_gtk import UploadModuleIV
 from itkdb_gtk import WireBondGui
 from itkdb_gtk import PanelVisualInspection
+from itkdb_gtk import ModuleVisualInspection
 
 
 HAS_PETALQC=False
@@ -53,8 +54,9 @@ class DashWindow(dbGtkUtils.ITkDBWindow):
     MOD_IV = 7
     WIRE_BOND = 8
     PANEL_VI = 9
-    PETAL_CORE_METRO = 10
-    PETAL_CORE_THERMAL = 11
+    MODULE_VI = 10
+    PETAL_CORE_METRO = 11
+    PETAL_CORE_THERMAL = 12
 
 
     def __init__(self, session):
@@ -107,9 +109,13 @@ class DashWindow(dbGtkUtils.ITkDBWindow):
         grid.attach(btnWireBond, 1, irow, 1, 1)
 
         irow += 1
-        btnModIV = Gtk.Button(label="Panel Visual Insp.")
-        btnModIV.connect("clicked", self.panel_VI)
-        grid.attach(btnModIV, 0, irow, 1, 1)
+        btnPanelVI = Gtk.Button(label="Panel Visual Insp.")
+        btnPanelVI.connect("clicked", self.panel_VI)
+        grid.attach(btnPanelVI, 1, irow, 1, 1)
+
+        btnModVI = Gtk.Button(label="Module Visual Insp.")
+        btnModVI.connect("clicked", self.module_VI)
+        grid.attach(btnModVI, 0, irow, 1, 1)
 
 
         if HAS_PETALQC:
@@ -242,7 +248,23 @@ class DashWindow(dbGtkUtils.ITkDBWindow):
             return
 
         self.mask |= bt
-        W = PanelVisualInspection.PanelVisualInspection(session=self.session, title="Panel Visual Inspection", help_link=HELP_LINK)
+        W = PanelVisualInspection.PanelVisualInspection(session=self.session,
+                                                        title="Panel Visual Inspection",
+                                                        help_link=HELP_LINK)
+        W.connect("destroy", self.app_closed, bitn)
+        W.show_all()
+
+    def module_VI(self, *args):
+        """Panel VI tests."""
+        bitn = DashWindow.MODULE_VI
+        bt = 1 << bitn
+        if self.mask & bt:
+            return
+
+        self.mask |= bt
+        W = ModuleVisualInspection.ModuleVisualInspection(session=self.session,
+                                                          title="Module Visual Inspection",
+                                                          help_link=HELP_LINK)
         W.connect("destroy", self.app_closed, bitn)
         W.show_all()
 

{itkdb_gtk-0.10.10.dev4 → itkdb_gtk-0.10.10.dev5}/itkdb_gtk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: itkdb_gtk
-Version: 0.10.10.dev4
+Version: 0.10.10.dev5
 Summary: A collection of Gtk based GUI to access ITkDB.
 Author-email: Carlos Lacasta <carlos.lacasta@cern.ch>
 Project-URL: Homepage, https://gitlab.cern.ch/atlas-itk/sw/db/itk-pdb-gtk-gui-utils

{itkdb_gtk-0.10.10.dev4 → itkdb_gtk-0.10.10.dev5}/itkdb_gtk.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ itkdb_gtk/ITkDB.desktop
 itkdb_gtk/ITkDB.svg
 itkdb_gtk/ITkDBlogin.py
 itkdb_gtk/ITkDButils.py
+itkdb_gtk/ModuleVisualInspection.py
 itkdb_gtk/PanelVisualInspection.py
 itkdb_gtk/PetalReceptionTests.py
 itkdb_gtk/SensorUtils.py

{itkdb_gtk-0.10.10.dev4 → itkdb_gtk-0.10.10.dev5}/itkdb_gtk.egg-info/entry_points.txt

@@ -3,6 +3,7 @@ createShipments = itkdb_gtk:createShipments
 getShipments = itkdb_gtk:getShipments
 glueWeight = itkdb_gtk:glueWeight
 itkdb_dashBoard = itkdb_gtk:dash_board
+moduleVisualInspection = itkdb_gtk:moduleVisualInspection
 panelVisualInspection = itkdb_gtk:panelVisualInspection
 petalReceptionTests = itkdb_gtk:petalReceptionTests
 uploadModuleIV = itkdb_gtk:uploadModuleIV

{itkdb_gtk-0.10.10.dev4 → itkdb_gtk-0.10.10.dev5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "itkdb_gtk"
-version = "0.10.10.dev4"
+version = "0.10.10.dev5"
 authors = [
   { name="Carlos Lacasta", email="carlos.lacasta@cern.ch" },
 ]
@@ -38,6 +38,7 @@ uploadModuleIV = "itkdb_gtk:uploadModuleIV"
 wirebondTest = "itkdb_gtk:wirebondTest"
 uploadPetalInformation = "itkdb_gtk:uploadPetalInformation"
 panelVisualInspection = "itkdb_gtk:panelVisualInspection"
+moduleVisualInspection = "itkdb_gtk:moduleVisualInspection"
 
 [tool.setuptools]
 include-package-data = true