itkdb-gtk 0.0.16.dev7__py3-none-any.whl → 0.0.16.dev20__py3-none-any.whl

itkdb_gtk/WireBondGui.py

@@ -10,7 +10,7 @@ from gi.repository import Gtk, Gio, GLib
 
 try:
     import itkdb_gtk
-    
+
 except ImportError:
     from pathlib import Path
     cwd = Path(sys.argv[0]).parent.parent
@@ -34,6 +34,380 @@ test_parameters = {
         "Failed Module->Frame": "FAILED_MODULE_TO_FRAME"
 }
 
+# module_param[iring][i_sensor][i_hybrid][i_row]
+module_param = {
+    0: [
+        [
+            [[255, 830], [1343, 1918], [2431, 3006], [3519, 4094]],
+            [[831, 1342], [1919, 2430], [3007, 3518], [4095, 4606]],
+        ]
+    ],
+    1: [
+        [
+            [[271, 974], [1615, 2318], [2959, 3662], [4303, 5006]],
+            [[975, 1614], [2319, 2958], [3663, 4302], [5007, 5646]],
+        ]
+    ],
+    2: [
+        [
+            [[201, 968], [969, 1736], [1737, 2504], [2505, 3272]]
+        ]
+    ],
+    3: [
+        [
+            [[566, 1013], [2358, 2805], [4150, 4597], [5942, 6389]],
+            [[1462, 1909], [3254, 3701], [5046, 5493], [6838, 7285]]
+        ],
+        [
+            [[1014, 1461], [2806, 3253], [4598, 5045], [6390, 6837]],
+            [[1910, 2357], [3702, 4149], [5494, 5941], [7286, 7733]]
+        ]
+    ],
+    4: [
+        [
+            [[318, 829], [1342, 1853], [2366, 2877], [3390, 3901]]
+        ],
+        [
+            [[830, 1341], [1854, 2365], [2878, 3389], [3902, 4413]]
+        ]
+    ],
+    5: [
+        [
+            [[332, 907], [1484, 2059], [2636, 3211], [3788, 4363]]
+        ],
+        [
+            [[908, 1483], [2060, 2635], [3212, 3787], [4364, 4939]]
+        ]
+    ],
+}
+
+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])
+
+                return ichan
+
+    return None
+
+
+def find_holes(chan_list, min_chan=0, max_chan=999999):
+    """Find groups of consecutive channels."""
+    out = sorted(chan_list)
+    nchan = 0
+    last_chan = -1
+    ichan = -1
+    holes = []
+    for chan in out:
+        if chan < min_chan or chan > max_chan:
+            continue
+
+        if last_chan < 0:
+            last_chan = chan
+            continue
+
+        if chan - last_chan > 1:
+            if nchan:
+                holes.append([ichan, nchan])
+            nchan = 0
+            ichan = -1
+        else:
+            if last_chan < max_chan and chan >= max_chan:
+                # WE are in another sensor
+                holes.append([ichan, nchan])
+                nchan = 0
+                ichan = -1
+                last_chan = chan
+                continue
+
+            nchan += 1
+            if ichan < 0:
+                ichan = last_chan
+                nchan += 1
+
+        last_chan = chan
+
+    if nchan:
+        holes.append([ichan, nchan])
+
+    return holes
+
+
+class HybridHoles:
+    """Holes in hybrid bomds.
+
+    Holes are defined by a list [first_chan, n_chan].
+    """
+
+    def __init__(self, param, hid=0):
+        """Initialization.
+
+        Args:
+            param: Hybrid wirebon parameters.
+
+        """
+        self.id = hid
+        self.param = param
+        self.nchan = 0
+        for min_chan, max_chan in param:
+            self.nchan += (max_chan-min_chan+1)
+
+        self.holes = [[] for irow in range(4)]
+        self.channels = [[] for irow in range(4)]
+
+    def add_channel(self, irow, ichan)->bool:
+        """Add a new channel in row.
+
+        Args:
+            irow: rown number
+            ichan: channel number
+
+        Return:
+            True if added, False otherwise.
+        """
+        first_chan = self.param[irow][0]
+        last_chan = self.param[irow][1]
+        if isinstance(ichan, list) or isinstance(ichan, tuple):
+            nadded = 0
+            for ich in ichan:
+                if ich >= first_chan and ich <= last_chan:
+                    self.channels[irow].append(ich)
+                    nadded += 1
+
+            self.channels[irow] = sorted(self.channels[irow])
+            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):
+        """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)
+
+        return nchan
+
+    def get_max_consecutive(self):
+        """Returns the largest 'hole'."""
+        mx_width = []
+
+        for row in self.holes:
+            mxW = -1
+            for h in row:
+                if h[1] > mxW:
+                    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)
+
+            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
+
+
+class SensorHoles:
+    """Holes in sensor."""
+
+    def __init__(self, param, sid=0):
+        """Initialization.
+
+        Args:
+            param: sensor wirebon params
+        """
+        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)
+            self.hybrids.append(H)
+            self.nchan += H.nchan
+
+    def get_n_hyb(self):
+        """Return number of hybrids."""
+        return len(self.hybrids)
+
+    def get_hybrid(self, i):
+        """Return i-th hybrid."""
+        return self.hybrids[i]
+
+    def get_max_consecutive(self):
+        """Max number of consecutive unconnected channels.
+
+        This is ordered by row.
+        """
+        mx_width = [0, 0, 0, 0]
+        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]
+
+        return mx_width
+
+    def get_n_unconnected(self):
+        """Count number of unconnected channels.
+
+        Return a list, one item per row.
+        """
+        nchan = [0, 0, 0, 0]
+        for hyb in self.hybrids:
+            nc = hyb.get_n_unconnected()
+            for i, n in enumerate(nc):
+                nchan[i] += n
+
+        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):
+        """Initialization.
+
+        Args:
+            param: module wirebond params
+        """
+        self.nsensor = len(param)
+        self.nchan = 0
+        self.sensors = []
+        for i, P in enumerate(param):
+            S = SensorHoles(P, sid=i)
+            self.sensors.append(S)
+            self.nchan += S.nchan
+
+    def get_max_consecutive(self):
+        """Max number of consecutive unconnected channels.
+
+        This is ordered by row.
+        """
+        mx_width = [-1, -1, -1, -1]
+        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]
+
+        return mx_width
+
+    def get_sensor_holes(self) -> list:
+        """Return. holesin sensor strips.
+
+        Return a list of [sensor, hybrid, segment, ichan, width]
+        """
+        holes = []
+        for S in self.sensors:
+            for _, ihyb, isegment, ichan, width in S.get_sensor_holes():                
+                holes.append([S.id, ihyb, isegment, ichan, width])
+
+        return holes
+
+    def get_n_unconnected(self) -> list:
+        """Count number of unconnected channels.
+
+        Return a list, one item per row.
+        """
+        nchan = [0, 0, 0, 0]
+        for S in self.sensors:
+            nc = S.get_n_unconnected()
+            for i, n in enumerate(nc):
+                nchan[i] += n
+
+        return nchan
+
+    def get_total_unconnected(self) -> int:
+        """Return total number of unconnected wires."""
+        unc = self.get_n_unconnected()
+        out = 0
+        for v in unc:
+            out += v
+
+        return int(out)
+
+
+def get_module_param(SN):
+    """Get parameters of module type.
+
+    Args:
+        SN: Serial Number
+
+    Returns:
+        list: list with bond numbers.
+    """
+    if len(SN) != 14 or SN[:3]!="20U":
+        raise ValueError("Wrong serial number {}".format(SN))
+
+    if SN[3:5] != "SE":
+        raise ValueError("Cannot handle barrel modules yet.")
+
+    mod_type  = SN[5:7]
+    if mod_type[0] != "M":
+        raise ValueError("Does not seem to be a RingModule: {}".format(SN))
+
+    ring = int(mod_type[-1])
+    param = module_param[ring]
+
+    return param
+
 
 class WireBond(Gtk.Window):
     """Main window."""
@@ -44,6 +418,7 @@ class WireBond(Gtk.Window):
         self.pdb = None
         self.session = session
         self.models = {}
+        self.holes = {}
         self.prepare_window()
 
     def prepare_window(self):
@@ -70,6 +445,15 @@ class WireBond(Gtk.Window):
         button.connect("clicked", self.save_test)
         self.hb.pack_end(button)
 
+        # Button to upload
+        button = Gtk.Button()
+        icon = Gio.ThemedIcon(name="document-open-symbolic")
+        image = Gtk.Image.new_from_gicon(icon, Gtk.IconSize.BUTTON)
+        button.add(image)
+        button.set_tooltip_text("Click to read local data file.")
+        button.connect("clicked", self.read_file)
+        self.hb.pack_end(button)
+
         # Create the main box and add it to the window
         self.mainBox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
         self.mainBox.set_property("margin-left", 6)
@@ -78,7 +462,7 @@ class WireBond(Gtk.Window):
 
         # Data panel
         grid = Gtk.Grid(column_spacing=5, row_spacing=1)
-        for i, tit in enumerate(["Operator", "Bond Machine", "Wire Batch", "SN"]):
+        for i, tit in enumerate(["Operator", "Bond Machine", "Wire Batch", "SN", "Date"]):
             lbl = Gtk.Label(label=tit)
             lbl.set_xalign(0)
             grid.attach(lbl, 0, i, 1, 1)
@@ -87,11 +471,14 @@ class WireBond(Gtk.Window):
         self.machine = dbGtkUtils.new_small_text_entry()
         self.batch = dbGtkUtils.new_small_text_entry()
         self.SN = dbGtkUtils.new_small_text_entry()
+        self.date = dbGtkUtils.TextEntry(small=True)
+        self.date.connect("text_changed", self.new_date)
 
-        grid.attach(self.operator,  1, 0, 1, 1)
-        grid.attach(self.machine,   1, 1, 1, 1)
-        grid.attach(self.batch,     1, 2, 1, 1)
-        grid.attach(self.SN,        1, 3, 1, 1)
+        grid.attach(self.operator,      1, 0, 1, 1)
+        grid.attach(self.machine,       1, 1, 1, 1)
+        grid.attach(self.batch,         1, 2, 1, 1)
+        grid.attach(self.SN,            1, 3, 1, 1)
+        grid.attach(self.date.widget,   1, 4, 1, 1)
 
         self.mainBox.pack_start(grid, True, True, 0)
 
@@ -118,7 +505,7 @@ class WireBond(Gtk.Window):
         #
         self.message_panel = dbGtkUtils.MessagePanel(size=100)
         self.mainBox.pack_start(self.message_panel.frame, True, True, 0)
-        self.write_message("wirebond GUI")
+        self.write_message("wirebond GUI\n")
 
         # The button box
         btnBox = Gtk.ButtonBox(orientation=Gtk.Orientation.HORIZONTAL)
@@ -212,22 +599,30 @@ class WireBond(Gtk.Window):
         """Handles edition in comment."""
         self.text_edited(1, path, text)
 
+
+    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 button_pressed(self, *args):
+        """Button pressed."""
         pass
 
     def add_item(self, *args):
         """Adds a new item in the current model."""
         out = dbGtkUtils.get_a_list_of_values("Add Item", ["Channel", "Comment"])
-        model = self.tree.get_model()
-        n_child = model.iter_n_children()
-        model[-1] = out
-        model.append(["", ""])
+        if len(out) == 2:
+            model = self.tree.get_model()
+            model[-1] = out
+            model.append(["", ""])
 
     def quit(self, *args):
         """Quits the application."""
         if self.pdb:
             self.pdb.die()
-            
+
         self.hide()
         self.destroy()
 
@@ -235,6 +630,116 @@ class WireBond(Gtk.Window):
         """Writes text to Text Viewer."""
         self.message_panel.write_message(text)
 
+    def compute_unconnected(self):
+        """Compute number of unconnected."""
+        param = get_module_param(self.SN.get_text())
+        M = ModuleHoles(param=param)
+
+        for test in test_parameters.values():
+            if test.find("FAILED") < 0:
+                continue
+            if test.find("ROW") < 0:
+                continue
+
+            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)
+
+            # Translate to sensor, hybrids, etc.
+            for S in M.sensors:
+                for H in S.hybrids:
+                    H.add_channel(irow, out)
+                    H.holes[irow] = find_holes(H.channels[irow])
+
+
+        # Now get sensor strips.
+        unconnected = M.get_n_unconnected()
+        mx_consecutive = M.get_max_consecutive()
+        module_holes = M.get_sensor_holes()
+
+        out = {}
+        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]
+            
+        if mxW > 0:
+            self.write_message("Max width: {}". format(mxW))
+            
+        out["MAX_UNCON_SENSOR_CHAN"] = mxW
+        nstrips = 0
+        for v in unconnected:
+            nstrips += v
+
+        out["TOTAL_PERC_UNCON_SENSOR_CHAN"] = nstrips/M.nchan
+
+        return out
+
+    def get_unconnected(self, skeleton):
+        """Fill the test DTO with unconnected information."""
+        out = self.compute_unconnected()
+        for key, val in out.items():
+            skeleton["results"][key] = val
+
+    def read_file(self, *args):
+        """Read local data file."""
+        dialog = Gtk.FileChooserDialog(
+            title="Please choose a file",
+            parent=self,
+            action=Gtk.FileChooserAction.OPEN
+        )
+        dialog.add_buttons(
+            Gtk.STOCK_CANCEL,
+            Gtk.ResponseType.CANCEL,
+            Gtk.STOCK_OPEN,
+            Gtk.ResponseType.OK,
+        )
+        filter_text = Gtk.FileFilter()
+        filter_text.set_name("JSON files")
+        filter_text.add_mime_type("application/json")
+        dialog.add_filter(filter_text)
+
+        response = dialog.run()
+        if response == Gtk.ResponseType.OK:
+            ofile = dialog.get_filename()
+            self.write_message("Loading data from {}\n".format(ofile))
+            with open(ofile, 'r', encoding="utf-8") as data_file:
+                data = json.load(data_file)
+                self.parse(data)
+
+        dialog.hide()
+        dialog.destroy()
+
+    def parse(self, data):
+        """Parses a JSon dictionary."""
+        self.operator.set_text(data["properties"]["OPERATOR"])
+        self.machine.set_text(data["properties"]["BOND_MACHINE"])
+        self.batch.set_text(data["properties"]["BONDWIRE_BATCH"])
+        self.SN.set_text(data["component"])
+        self.date.set_text(data["date"])
+        for key, val in data["results"].items():
+            model = self.models[key]
+            model.clear()
+            for chan, msg in val.items():
+                model.append([chan, msg])
+
+            model.append(["", ""])
+
     def get_list_of_channels(self, data):
         """Creates the lists of channels."""
         for key, model in self.models.items():
@@ -244,11 +749,11 @@ class WireBond(Gtk.Window):
                 chan, comm = model[iter]
                 if len(chan) > 0:
                     out[chan] = comm
-                    
+
                 iter = model.iter_next(iter)
 
             data["results"][key] = out
-            
+
     def save_test(self, *args):
         """Save Test file."""
         dialog = Gtk.FileChooserDialog(
@@ -264,17 +769,17 @@ class WireBond(Gtk.Window):
         filter_text.set_name("JSON files")
         filter_text.add_mime_type("application/json")
         dialog.add_filter(filter_text)
-        
+
         response = dialog.run()
         if response == Gtk.ResponseType.OK:
             ofile = dialog.get_filename()
             data = self.get_test_data()
             with open(ofile, 'w') as of:
                 json.dump(data, of, indent=3)
-                
+
         dialog.hide()
         dialog.destroy()
-            
+
     def get_test_data(self):
         """Get the test data."""
         data = {
@@ -287,7 +792,7 @@ class WireBond(Gtk.Window):
         self.get_test_header(data)
         self.get_list_of_channels(data)
         return data
-    
+
     def get_test_header(self, data):
         """Get Basic test data."""
         SN = self.SN.get_text()
@@ -296,7 +801,7 @@ class WireBond(Gtk.Window):
         batch = self.batch.get_text()
 
         if not SN or len(SN)==0:
-            SN = dbGtkUtils.get_a_value("Module Serial Number", 
+            SN = dbGtkUtils.get_a_value("Module Serial Number",
                                         "Module serial Number is missing")
 
         if len(operator) == 0 or len(machine) == 0 or len(batch) == 0:
@@ -315,7 +820,7 @@ class WireBond(Gtk.Window):
         data["properties"]["BOND_MACHINE"] = machine
         data["properties"]["BONDWIRE_BATCH"] = batch
 
-            
+
     def upload_test(self, *args):
         """Upload test."""
         if self.session is None:
@@ -327,7 +832,7 @@ class WireBond(Gtk.Window):
 
             else:
                 self.session = client
-                
+
         defaults = {
             "institution": "IFIC",
             "runNumber": "1",
@@ -335,19 +840,24 @@ class WireBond(Gtk.Window):
         }
         skeleton = ITkDButils.get_test_skeleton(self.session, "MODULE", "MODULE_WIRE_BONDING", defaults)
 
-        self.get_test_header(skeleton)        
+        self.get_test_header(skeleton)
         self.get_list_of_channels(skeleton)
+        self.get_unconnected(skeleton)
 
         uploadW = UploadTest.UploadTest(self.session, payload=skeleton)
         # uploadW.run()
 
 
-if __name__ == "__main__":
-
-    win = WireBond("WireBond")
+def main():
+    """Main entry."""
+    win = WireBond(title="WireBond")
     win.connect("destroy", Gtk.main_quit)
     try:
         Gtk.main()
 
     except KeyboardInterrupt:
         print("Arrrgggg!!!")
+
+
+if __name__ == "__main__":
+    main()

itkdb_gtk/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.0.16.dev7"
+__version__ = "0.0.16.dev20"
 
 
 def dash_board():
@@ -45,3 +45,8 @@ def uploadModuleIV():
     """Upload IV files of single and double modules"""
     from .UploadModuleIV import main
     main()
+
+def wirebondTest():
+    """Inputs data and eventually upload wirebod test."""
+    from .WireBondGui import main
+    main()

itkdb_gtk/dashBoard.py

@@ -180,7 +180,7 @@ class DashWindow(dbGtkUtils.ITkDBWindow):
             return
 
         self.mask |= bt
-        W = WireBondGui.WireBond(session=self.session)
+        W = WireBondGui.WireBond(session=self.session, title="Wirebond")
         W.connect("destroy", self.app_closed, bitn)
 
     def app_closed(self, *args):

itkdb_gtk/dbGtkUtils.py

@@ -11,8 +11,26 @@ import numpy as np
 
 
 gi.require_version("Gtk", "3.0")
-from gi.repository import Gtk, Gio, GLib
+from gi.repository import Gtk, GObject, Gio, GLib
 
+def parse_date(txt):
+    """Parse a date."""
+    try:
+        return dateutil.parser.parse(txt, fuzzy=False)
+
+    except Exception:
+        return None
+def parse_date_as_string(txt):
+    """Parse data and return DB compatible string."""
+    D = parse_date(txt)
+    if D is None:
+        return D
+
+    out = D.isoformat(timespec='milliseconds')
+    if out[-1] not in ['zZ']:
+        out += 'Z'
+
+    return out
 
 def is_a_date(txt):
     """check tha the input string is a date."""
@@ -34,6 +52,16 @@ def new_small_text_entry():
     style_context.add_provider(provider, Gtk.STYLE_PROVIDER_PRIORITY_SETTINGS)
     return entry
 
+def set_entry_style(container):
+    """Set max entry."""
+    provider = Gtk.CssProvider()
+    style_context = container.get_style_context()
+    font_size = 2.25*style_context.get_property("font-size", 0)
+    css = "{} {{ min-height: {}px; }}".format(container.get_name(), font_size)
+    provider.load_from_data(css.encode())
+    style_context.add_provider(provider, Gtk.STYLE_PROVIDER_PRIORITY_SETTINGS)
+    return container    
+
 def set_combo_iter(combo, txt, col=0):
     """Set scombo active iter to that containing txt in column col."""
     model = combo.get_model()
@@ -47,17 +75,6 @@ def set_combo_iter(combo, txt, col=0):
         iter = model.iter_next(iter)
 
 
-def set_entry_style(container):
-    """Set max entry."""
-    provider = Gtk.CssProvider()
-    print(container.get_name())
-    style_context = container.get_style_context()
-    font_size = 2.25*style_context.get_property("font-size", 0)
-    css = "{} {{ min-height: {}px; }}".format(container.get_name(), font_size)
-    provider.load_from_data(css.encode())
-    style_context.add_provider(provider, Gtk.STYLE_PROVIDER_PRIORITY_SETTINGS)
-
-
 def is_iterable(obj):
     """Tell if an object is iterable. Strings are not considered iterables."""
     if isinstance(obj, Iterable):
@@ -166,11 +183,16 @@ def ask_for_confirmation(main_title, second_text, parent=None):
     return (out == Gtk.ResponseType.OK)
 
 
-class TextEntry(object):
+class TextEntry(GObject.GObject):
     """Create a Gtk text entry/view object."""
+    __gsignals__ = {
+        "text_changed": (GObject.SIGNAL_RUN_FIRST, None, (str,))
+    }
 
-    def __init__(self, n_lines=1):
+    def __init__(self, n_lines=1, small=False):
         """Init."""
+        GObject.GObject.__init__(self)
+        self.tmp_txt = ""
         self.nlines = n_lines
         if self.nlines > 1:
             self.widget = Gtk.Frame()
@@ -184,9 +206,31 @@ class TextEntry(object):
             scrolled.add(self.entry)
 
         else:
-            self.widget = Gtk.Entry()
+            if small:
+                self.widget = new_small_text_entry()
+            else:
+                self.widget = Gtk.Entry()
+                
+            self.widget.connect("focus-in-event", self.on_enter)
+            self.widget.connect("focus-out-event", self.on_leave)
+
             self.entry = self.widget
 
+    def do_my_signal(self, *args):
+        """Signal handler."""
+        pass
+
+    def on_enter(self, *args):
+        """On enter."""
+        self.tmp_txt = self.widget.get_text().strip()
+        return False
+
+    def on_leave(self, *args):
+        """On leave."""
+        val = self.widget.get_text().strip()
+        if val != self.tmp_txt:
+            self.emit("text_changed", val)
+
     def get_text(self):
         """Return the text."""
         if self.nlines > 1:
@@ -197,7 +241,7 @@ class TextEntry(object):
 
         else:
             return self.entry.get_text()
-        
+
     def set_text(self, text):
         """Sets text."""
         if self.nlines > 1:
@@ -306,7 +350,7 @@ def get_a_list_of_values(main_title, labels, defaults=None, second_text=None, pa
             entry.set_text(defaults[i])
         except Exception:
             pass
-        
+
         vbox.pack_start(entry.widget, False, False, 0)
         entries.append(entry)
 
@@ -378,7 +422,7 @@ class MessagePanel(object):
 
         # A scroll window with the text view
         scrolled = Gtk.ScrolledWindow()
-        scrolled.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
+        scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
         scrolled.add(self.text_view)
         box.pack_start(scrolled, True, True, 0)
         self.frame = frame

{itkdb_gtk-0.0.16.dev7.dist-info → itkdb_gtk-0.0.16.dev20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: itkdb_gtk
-Version: 0.0.16.dev7
+Version: 0.0.16.dev20
 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
@@ -10,10 +10,13 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 Requires-Dist: itkdb >=0.4.0
+Requires-Dist: numpy
+Requires-Dist: matplotlib
 Requires-Dist: openpyxl
 Requires-Dist: pyserial
 Requires-Dist: python-dateutil
 Requires-Dist: requests
+Requires-Dist: PyGObject
 
 # Interaction with the ITk PDB.
 

{itkdb_gtk-0.0.16.dev7.dist-info → itkdb_gtk-0.0.16.dev20.dist-info}/RECORD

@@ -13,15 +13,15 @@ itkdb_gtk/UploadModuleIV.py,sha256=JSvfQSjMxCEy_9KtcydIjpSSCBJ6xJbCwo24-xszabk,2
 itkdb_gtk/UploadMultipleTests.py,sha256=hI-LK_WWFCoUI8AQTEfrjoHYdYCbOru9DuBUA-R2id4,19730
 itkdb_gtk/UploadPetalInformation.py,sha256=IsZGa_i6jW8lEUnJOhPFmq-GCemLg_nhlHuQlJQMbjc,22210
 itkdb_gtk/UploadTest.py,sha256=AwMHwuS2PzyuOGsinyoFcuHZ2m_ZsNktHudp2667_Q4,13590
-itkdb_gtk/WireBondGui.py,sha256=NrCsuEMzEA51Xnh92a3T-uT_5Enli2IwK110Jx_zHwA,11760
-itkdb_gtk/__init__.py,sha256=KjtY0r-zuyEgEMa976qv9sMtgJLGjJuXX57cKrQpdPA,838
-itkdb_gtk/dashBoard.py,sha256=Ps_F--V0QgrDWbMD1TwmB9EjPV1EWi8WTVl-mIEDvAM,5742
-itkdb_gtk/dbGtkUtils.py,sha256=6p1qi6nu-nmv6YVy2nCF6vhml9jUf4Oy3kqdgIpZk1s,23911
+itkdb_gtk/WireBondGui.py,sha256=v9oWHIBCU2tbnje2T_3fystPNlks366Dk269pmX9dds,25747
+itkdb_gtk/__init__.py,sha256=uTLh_Z2X49YBX2Bca0JVJxniEw0OiVZY45EEgDDsecM,963
+itkdb_gtk/dashBoard.py,sha256=mguE5QXvCwD4wZgHx5PViRHrY3mgoJh4ijiyz1P2DfA,5760
+itkdb_gtk/dbGtkUtils.py,sha256=xVqRgtg7F7tua41iqHVLFCjgqo4lRVaDD063409i8q0,25120
 itkdb_gtk/readAVSdata.py,sha256=SvHWFoqvlrEDGKeVaQEPGxsjcNY21KItMSVuWE5q05E,19457
 itkdb_gtk/readGoogleSheet.py,sha256=UCSfFCQncc0pWxqfCKTaa0K4HkQmwOI07eErepOMlGU,2682
 itkdb_gtk/untrash_component.py,sha256=fZWanuPww1RLJ-Fduso4EqfLlcBsd5ryJymr1xJZEUM,756
-itkdb_gtk-0.0.16.dev7.dist-info/METADATA,sha256=CQKPlrqgl6PYn4ksasjQH4vPG_UK-CiksY2wIXYbuDY,3081
-itkdb_gtk-0.0.16.dev7.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-itkdb_gtk-0.0.16.dev7.dist-info/entry_points.txt,sha256=n71x6ofqLQm3n5kIwdwI_dBNFLBVbf_G6G2nxyyxwcE,333
-itkdb_gtk-0.0.16.dev7.dist-info/top_level.txt,sha256=KVRrH4OS8ovzNR9bvADE0ABn5bNpSk987tuH0jCfkbU,10
-itkdb_gtk-0.0.16.dev7.dist-info/RECORD,,
+itkdb_gtk-0.0.16.dev20.dist-info/METADATA,sha256=1TRkMOqgjFif1VgkAs-zkAVmaK7UYr-CArc4c3c57aw,3154
+itkdb_gtk-0.0.16.dev20.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+itkdb_gtk-0.0.16.dev20.dist-info/entry_points.txt,sha256=FuSmtQZK5jEzNomHiJqdFZAJZoRueejwoWMg53aZSu0,371
+itkdb_gtk-0.0.16.dev20.dist-info/top_level.txt,sha256=KVRrH4OS8ovzNR9bvADE0ABn5bNpSk987tuH0jCfkbU,10
+itkdb_gtk-0.0.16.dev20.dist-info/RECORD,,

{itkdb_gtk-0.0.16.dev7.dist-info → itkdb_gtk-0.0.16.dev20.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{itkdb_gtk-0.0.16.dev7.dist-info → itkdb_gtk-0.0.16.dev20.dist-info}/entry_points.txt

@@ -7,3 +7,4 @@ sendShipments = itkdb_gtk:sendShipments
 uploadModuleIV = itkdb_gtk:uploadModuleIV
 uploadMultipleTests = itkdb_gtk:uploadMultipleTests
 uploadTest = itkdb_gtk:uploadTest
+wirebondTest = itkdb_gtk:wirebondTest