itkdb-gtk 0.0.14__tar.gz → 0.0.16.dev0__tar.gz

{itkdb_gtk-0.0.14 → itkdb_gtk-0.0.16.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: itkdb_gtk
-Version: 0.0.14
+Version: 0.0.16.dev0
 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
@@ -9,6 +9,11 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
+Requires-Dist: itkdb>=0.4.0
+Requires-Dist: openpyxl
+Requires-Dist: pyserial
+Requires-Dist: python_dateutil
+Requires-Dist: requests
 
 # Interaction with the ITk PDB.
 
@@ -57,6 +62,9 @@ GUI dialog. One can add comments and attachments to the shipment.
 Allows to upload and enter valueos, comments and defects for those items in the gounding
 and visual instpections tests of the petal core.
 
+## uploadIVfiles.py
+The idea behind this is that we messure the IV on a Ring module and on only one of the to Half modules. The IV of the remaining half modules is derived from the other 2. Eventually the IV test can be uploaded to the DB.
+
 ## dashBoard.py
 This is an launcher application from which we can start most of the other
 applications. It is a very good starting point. There is a Gnome desktop file (ITkDB.desktop)

{itkdb_gtk-0.0.14 → itkdb_gtk-0.0.16.dev0}/README.md

@@ -45,6 +45,9 @@ GUI dialog. One can add comments and attachments to the shipment.
 Allows to upload and enter valueos, comments and defects for those items in the gounding
 and visual instpections tests of the petal core.
 
+## uploadIVfiles.py
+The idea behind this is that we messure the IV on a Ring module and on only one of the to Half modules. The IV of the remaining half modules is derived from the other 2. Eventually the IV test can be uploaded to the DB.
+
 ## dashBoard.py
 This is an launcher application from which we can start most of the other
 applications. It is a very good starting point. There is a Gnome desktop file (ITkDB.desktop)

{itkdb_gtk-0.0.14 → itkdb_gtk-0.0.16.dev0}/itkdb_gtk/ITkDBlogin.py

@@ -92,6 +92,7 @@ class ITkDBlogin(Gtk.Dialog):
 
         if gtk_runs:
             self.create_window()
+            self.present()
             self.run()
 
         else:

{itkdb_gtk-0.0.14 → itkdb_gtk-0.0.16.dev0}/itkdb_gtk/ITkDButils.py

@@ -235,9 +235,13 @@ def set_object_stage(client, SN, stage):
 def get_DB_component(client, SN):
     """Get ta component by its serial number."""
     global db_response
-    db_response = client.get('getComponent', json={'component': SN})
-    return db_response
+    try:
+        db_response = client.get('getComponent', json={'component': SN})
+        return db_response
 
+    except Exception as e:
+        db_response = str(e)
+        return None
 
 def upload_test(client, data, attachments=None):
     """Upload a test to the DB.

{itkdb_gtk-0.0.14 → itkdb_gtk-0.0.16.dev0}/itkdb_gtk/__init__.py

@@ -1,10 +1,9 @@
-from . import dashBoard
-
-__version__ = "0.0.14"
+__version__ = "0.0.16.dev0"
 
 
 def dash_board():
     """Launches the dash board."""
+    from .dashBoard import main
     dashBoard.main()
 
 
@@ -42,3 +41,8 @@ def uploadMultipleTests():
     """Upload multiple tests."""
     from .uploadMultipleTests import main
     main()
+
+def uploadIVfiles():
+    """Upload IV files of single and double modules"""
+    from .uploadIVfiles import main
+    main()

{itkdb_gtk-0.0.14 → itkdb_gtk-0.0.16.dev0}/itkdb_gtk/dashBoard.py

@@ -10,9 +10,10 @@ try:
     import sendShipments
     import uploadMultipleTests
     import GlueWeight
+    import uploadIVfiles
 
 except Exception:
-    from itkdb_gtk import dbGtkUtils, getShipments, groundVITests
+    from itkdb_gtk import dbGtkUtils, getShipments, groundVITests, uploadIVfiles
     from itkdb_gtk import ITkDBlogin, sendShipments, uploadMultipleTests, GlueWeight
 
 import gi
@@ -23,7 +24,13 @@ from gi.repository import Gtk
 
 class DashWindow(dbGtkUtils.ITkDBWindow):
     """Dashboard class."""
-
+    UPLOAD_TEST = 1 
+    CREATE_SHIPMNT = 2
+    RECV_SHIPMNT = 3
+    PETAL_GND = 4
+    GLUE_WEIGHT = 5
+    MOD_IV = 6
+    
     def __init__(self, session):
         """Initialization."""
         super().__init__(title="ITkDB Dashboard", session=session)
@@ -60,6 +67,11 @@ class DashWindow(dbGtkUtils.ITkDBWindow):
         btnWeight.connect("clicked", self.glue_weight)
         grid.attach(btnWeight, 0, irow, 1, 1)
 
+        btnModIV = Gtk.Button(label="Module IV")
+        btnModIV.connect("clicked", self.module_IV)
+        grid.attach(btnModIV, 1, irow, 1, 1)
+
+
         irow += 1
         grid.attach(Gtk.Label(), 0, irow, 1, 1)
 
@@ -84,7 +96,7 @@ class DashWindow(dbGtkUtils.ITkDBWindow):
 
     def upload_test(self, *args):
         """Launch upload test."""
-        bitn = 1
+        bitn = DashWindow.UPLOAD_TEST
         bt = 1 << bitn
         if self.mask & bt:
             return
@@ -95,7 +107,7 @@ class DashWindow(dbGtkUtils.ITkDBWindow):
 
     def create_shipment(self, *args):
         """Launch sendShipment."""
-        bitn = 2
+        bitn = DashWindow.CREATE_SHIPMNT
         bt = 1 << bitn
         if self.mask & bt:
             return
@@ -106,7 +118,7 @@ class DashWindow(dbGtkUtils.ITkDBWindow):
 
     def receive_shipment(self, *args):
         """Launch getShipments."""
-        bitn = 3
+        bitn = DashWindow.RECV_SHIPMNT
         bt = 1 << bitn
         if self.mask & bt:
             return
@@ -117,7 +129,7 @@ class DashWindow(dbGtkUtils.ITkDBWindow):
 
     def petal_gnd(self, *args):
         """Petal GND/VI test."""
-        bitn = 4
+        bitn = DashWindow.PETAL_GND
         bt = 1 << bitn
         if self.mask & bt:
             return
@@ -128,7 +140,7 @@ class DashWindow(dbGtkUtils.ITkDBWindow):
 
     def glue_weight(self, *args):
         """Glue Weight test."""
-        bitn = 5
+        bitn = DashWindow.GLUE_WEIGHT
         bt = 1 << bitn
         if self.mask & bt:
             return
@@ -137,6 +149,17 @@ class DashWindow(dbGtkUtils.ITkDBWindow):
         W = GlueWeight.GlueWeight(self.session)
         W.connect("destroy", self.app_closed, bitn)
 
+    def module_IV(self, *args):
+        """Module IV tests."""
+        bitn = DashWindow.MOD_IV
+        bt = 1 << bitn
+        if self.mask & bt:
+            return
+
+        self.mask |= bt
+        W = uploadIVfiles.IVwindow(self.session)
+        W.connect("destroy", self.app_closed, bitn)
+
     def app_closed(self, *args):
         """Application window closed. Clear mask."""
         bt = 1 << args[1]

{itkdb_gtk-0.0.14 → itkdb_gtk-0.0.16.dev0}/itkdb_gtk/dbGtkUtils.py

@@ -7,6 +7,8 @@ from datetime import datetime
 
 import dateutil.parser
 import gi
+import numpy as np
+
 
 gi.require_version("Gtk", "3.0")
 from gi.repository import Gtk, Gio, GLib
@@ -17,7 +19,7 @@ def is_a_date(txt):
     try:
         dateutil.parser.parse(txt, fuzzy=False)
         return True
-    
+
     except Exception:
         return False
 
@@ -65,6 +67,12 @@ class MyEncoder(json.JSONEncoder):
         if isinstance(o, datetime):
             text = o.astimezone().isoformat()
             return text
+        elif isinstance(o, np.integer):
+            return int(o)
+        elif isinstance(o, np.floating):
+            return float(o)
+        elif isinstance(o, np.ndarray):
+            return o.tolist()
         else:
             return super().default(o)
 
@@ -310,6 +318,8 @@ def add_button_to_container(box, label, tooltip=None, callback=None):
         btn.connect("clicked", callback)
 
     box.pack_start(btn, True, False, 0)
+    
+    return btn
 
 
 class ITkDBWindow(Gtk.Window):
@@ -361,6 +371,9 @@ class ITkDBWindow(Gtk.Window):
 
         # Create main content box
         self.mainBox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
+        self.mainBox.set_property("margin-left", 6)
+        self.mainBox.set_property("margin-right", 6)
+
         self.add(self.mainBox)
 
         # The text view and buffer

{itkdb_gtk-0.0.14 → itkdb_gtk-0.0.16.dev0}/itkdb_gtk/groundVITests.py

@@ -99,6 +99,7 @@ class GroundingTest(dbGtkUtils.ITkDBWindow):
         # Create the Notebook pages
         self.create_test_box("Visual Inspection", "VISUAL_INSPECTION")
         self.create_test_box("Grounding", "GROUNDING_CHECK")
+        self.create_test_box("Pipe bending", "BENDING120")
 
         # The text view
         frame = self.create_text_view()

itkdb_gtk-0.0.16.dev0/itkdb_gtk/untrash_component.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+"""Un trash a trashed component."""
+
+
+def untrash_component(client, SN, reason="Accidentally trashed"):
+    """Un trash given component.
+
+    Args:
+        SN (str): Serial number of component to recover.
+        reason (str): message for the DB
+    Return:
+        dict: PDB response.
+
+    """
+    DTO = {
+        'component': SN,
+        'trashed': False,
+        'reason': reason
+    }
+
+    response = client.post('setComponentTrashed', json=DTO)
+    return response
+
+
+if __name__ == "__main__":
+    import sys
+    from itkdb_gtk import ITkDBlogin
+    dlg = ITkDBlogin.ITkDBlogin()
+    client = dlg.get_client()
+
+    try:
+        response = untrash_component(client, sys.argv[1])
+
+    except Exception as E:
+        print(str(E))

itkdb_gtk-0.0.16.dev0/itkdb_gtk/uploadIVfiles.py

@@ -0,0 +1,484 @@
+#!/usr/bin/env python3
+"""Read IV files and create plots."""
+import os
+import json
+import math
+from pathlib import Path
+
+import gi
+import tempfile
+
+gi.require_version("Gtk", "3.0")
+from gi.repository import Gtk, Gio
+
+
+from matplotlib.backends.backend_gtk3agg import FigureCanvasGTK3Agg as FigureCanvas
+from matplotlib.backends.backend_gtk3 import NavigationToolbar2GTK3 as NavigationToolbar
+import numpy as np
+import matplotlib as mpl
+import matplotlib.pyplot as plt
+
+try:
+    import dbGtkUtils
+    import ITkDBlogin
+    import ITkDButils
+    import uploadTest
+
+except ModuleNotFoundError:
+    from itkdb_gtk import dbGtkUtils, ITkDBlogin, ITkDButils, uploadTest
+
+# Check if Gtk can be open
+gtk_runs, gtk_args = Gtk.init_check()
+
+
+def remove_files(W, flist):
+    for f in flist:
+        os.unlink(f)
+
+def scale_iv(I, T1, T2):
+    """Normalize corrent  to given temperature (T2)
+
+    Args:
+        I (array): Current
+        T1 (float): Original temperature
+        T2 (float): New temperature.
+
+    Return:
+        Array with scaled currents.
+
+    """
+    factor = (T2 / T1) ** 2 * math.exp((-1.2 / 8.62) * (1 / T2 - 1 / T1))
+    return factor * I
+
+
+class IVwindow(dbGtkUtils.ITkDBWindow):
+    """GUI for IV file handling."""
+
+    def __init__(self, session, title="IV window", options=None):
+        """Initialization."""
+        super().__init__(
+            session=session, title=title, show_search=None, gtk_runs=gtk_runs
+        )
+        self.mdata = {}
+        self.mod_type = {}
+        self.mod_SN = {}
+        self.difference = None
+        self.canvas = None
+
+        self.init_window()
+
+    def init_window(self):
+        """Prepare the Gtk window."""
+        self.hb.props.title = "IV data"
+
+        button = Gtk.Button()
+        icon = Gio.ThemedIcon(name="view-refresh-symbolic")
+        image = Gtk.Image.new_from_gicon(icon, Gtk.IconSize.BUTTON)
+        button.add(image)
+        button.set_tooltip_text("Click to refresh canvas.")
+        button.connect("clicked", self.on_refresh)
+        self.hb.pack_end(button)
+
+        # Button to upload
+        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 test")
+        button.connect("clicked", self.upload_test)
+        self.hb.pack_end(button)
+
+        # File entry and search button
+        self.single_file = Gtk.FileChooserButton()
+        self.single_file.connect("file-set", self.on_single_file_set)
+
+        self.double_file = Gtk.FileChooserButton()
+        self.double_file.connect("file-set", self.on_double_file_set)
+
+        self.single_SN = Gtk.Label(label="(None)")
+        self.double_SN = Gtk.Label(label="(None)")
+
+        grid = Gtk.Grid(column_spacing=5, row_spacing=1)
+
+        grid.attach(Gtk.Label(label="Files"), 1, 0, 1, 1)
+        grid.attach(Gtk.Label(label="Serial No."), 2, 0, 1, 1)
+
+        grid.attach(Gtk.Label(label="Single Data File"), 0, 1, 1, 1)
+        grid.attach(self.single_file, 1, 1, 1, 1)
+        grid.attach(self.single_SN, 2, 1, 1, 1)
+
+        grid.attach(Gtk.Label(label="Double Data File"), 0, 2, 1, 1)
+        grid.attach(self.double_file, 1, 2, 1, 1)
+        grid.attach(self.double_SN, 2, 2, 1, 1)
+
+        btn = Gtk.Button(label="Compute difference")
+        btn.connect("clicked", self.on_difference)
+        grid.attach(btn, 1, 3, 1, 1)
+
+        self.mainBox.pack_start(grid, False, True, 0)
+
+        self.fig = mpl.figure.Figure()
+        self.fig.tight_layout()
+        sw = Gtk.ScrolledWindow()  # Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
+
+        # A scrolled window border goes outside the scrollbars and viewport
+        sw.set_border_width(10)
+        sw.set_size_request(310, 310)
+
+        self.canvas = FigureCanvas(self.fig)  # a Gtk.DrawingArea
+        self.canvas.set_size_request(400, 300)
+        sw.add(self.canvas)
+        self.mainBox.pack_start(sw, True, True, 0)
+
+        # Create toolbar
+        toolbar = NavigationToolbar(self.canvas)
+        self.mainBox.pack_start(toolbar, False, False, 0)
+
+        # The text view
+        frame = self.create_text_view()
+        self.mainBox.pack_start(frame, True, True, 5)
+
+        self.show_all()
+
+    def upload_test(self, *args):
+        """Upload available tests."""
+        test = ITkDButils.get_test_skeleton(
+            self.session, "MODULE", self.mdata["double"]["TestType"]
+        )
+        mdata = self.mdata["double"]
+        V = mdata["curve"]["V"]
+        I = np.abs(mdata["curve"]["I"])
+
+        indx = np.where(V == 500)[0]
+        i_500 = I[indx][0]
+
+        indx = np.where(V == 700)
+        rms = np.std(I[indx])
+
+        test["component"] = self.mod_SN["double"]
+        test["institution"] = mdata["Institute"]
+        test["runNumber"] = mdata["RunNumber"]
+        test["date"] = ITkDButils.get_db_date(
+            "{} {}".format(mdata["Date"], mdata["Time"])
+        )
+        test["passed"] = True
+        test["problems"] = False
+        test["properties"]["VBIAS_SMU"] = mdata["Vbias_SMU"]
+        test["properties"]["RSERIES"] = mdata["Rseries"]
+        test["properties"]["TEST_DMM"] = mdata["Test_DMM"]
+        test["properties"]["RSHUNT"] = mdata["Rshunt"]
+        test["properties"]["RUNNUMBER"] = mdata["RunNumber"]
+        test["properties"]["COMMENTS"] = mdata["Comments"]
+        test["properties"]["ALGORITHM_VERSION"] = "0.0.0"
+        test["properties"]["SOFTWARE_TYPE_VERSION"] = "pyProbe"
+        test["properties"]["MODULE_STAGE"] = mdata["Module_Stage"]
+        test["results"]["TEMPERATURE"] = mdata["Temperature"]
+        test["results"]["HUMIDITY"] = mdata["Humidity"]
+        test["results"]["VBD"] = mdata["curve"]["V"][-1]
+        test["results"]["I_500V"] = i_500
+        test["results"]["VOLTAGE"] = V
+        test["results"]["CURRENT"] = I
+        test["results"]["RMS_STABILITY"] = 0.0
+        test["results"]["SHUNT_VOLTAGE"] = np.zeros(V.shape)
+
+        # write attachment.
+        items = [
+            "Type",
+            "Wafer",
+            "Module_SN",
+            "Module_Stage",
+            "Date",
+            "Time",
+            "Institute",
+            "TestType",
+            "Vbias_SMU",
+            "Rseries",
+            "Test_DMM",
+            "Rshunt",
+            "Software type and version, fw version",
+            "RunNumber",
+            "Temperature",
+            "Humidity",
+            "Comments",
+        ]
+        fnam = "{}_{}_IV_{}-".format(self.mod_SN["double"], mdata["Module_Stage"], mdata["RunNumber"])
+        data_out = tempfile.NamedTemporaryFile('w', prefix=fnam, suffix=".dat", delete=False)
+        data_out.write("{}\n".format(fnam))
+        for key in items:
+            if key == "Module_SN":
+                data_out.write("{}: {}\n".format(key, self.mod_SN["double"]))
+            else:
+                data_out.write("{}: {}\n".format(key, mdata[key]))
+
+        for il, label in enumerate(mdata["curve"]["labels"]):
+            if il:
+                data_out.write('\t')
+            data_out.write(label)
+        data_out.write("\n")
+
+        ndata = len(mdata["curve"]["V"])
+        for i in range(ndata):
+            data_out.write("{:.2f}\t{:.2f}\t{:.2f}\n".format(V[i], self.difference[i], 0.0))
+
+        print(data_out.name)
+        data_out.close()
+
+        js_out = tempfile.NamedTemporaryFile('w', prefix="payload-", suffix=".json", delete=False)
+        js_out.write(json.dumps(test, indent=3, cls=dbGtkUtils.MyEncoder))
+        js_out.close()
+
+        attachment = ITkDButils.Attachment(data_out.name, "resultsFile", fnam)
+        uploadW = uploadTest.UploadTest(self.session, js_out.name, attachment)
+        uploadW.connect("destroy", remove_files, [data_out.name, js_out.name])
+
+    def on_refresh(self, *args):
+        """Refresh canvas."""
+        if self.fig and self.canvas:
+            self.fig.tight_layout()
+            self.canvas.draw()
+
+    def find_module(self, SN):
+        """Find module (SN) on database
+
+        Args:
+        ----
+            SN (str): Module Serial number
+        """
+        md = ITkDButils.get_DB_component(self.session, SN)
+        if md is None:
+            dbGtkUtils.complain(
+                "Could not find {}".format(SN), str(ITkDButils.get_db_response())
+            )
+
+        return md
+
+    def on_single_file_set(self, *args):
+        """File chosen."""
+        fnam = self.single_file.get_filename()
+        if fnam is None or not Path(fnam).exists():
+            dbGtkUtils.complain("Could not find data file", fnam, parent=self)
+
+        mdata = self.read_file(fnam)
+
+        SN = mdata["Module_SN"]
+        self.write_message("Reading data for module {}\n".format(SN))
+        md = self.find_module(SN)
+        if md is None:
+            self.write_message("...object does not exist.\n")
+            self.single_file.unselect_all()
+            return
+
+        # All good
+        self.mod_SN["single"] = SN
+        self.mdata["single"] = mdata
+        self.mod_type["single"] = md["type"]["code"]
+        print(self.mod_type["single"])
+
+        self.single_SN.set_text("{} - {}".format(SN, md["type"]["name"]))
+        self.show_curve(
+            131,
+            mdata["curve"]["V"],
+            mdata["curve"]["I"],
+            self.mod_type["single"][0:4],
+            mdata["curve"]["labels"][0],
+            mdata["curve"]["labels"][1],
+        )
+
+    def on_double_file_set(self, *args):
+        "File chosen for the 'double module'"
+        fnam = self.double_file.get_filename()
+        if fnam is None or not Path(fnam).exists():
+            dbGtkUtils.complain("Could not find data file", fnam, parent=self)
+
+        mdata = self.read_file(fnam)
+
+        # Check SN in data file
+        SN = mdata["Module_SN"]
+        halfM_SN = SN
+        if "single" in self.mod_SN:
+            if self.mod_SN["single"] == SN:
+                dbGtkUtils.complain("Wrong module SN", "{} already used.".format(SN))
+                self.double_file.unselect_all()
+                return
+
+        # Check that it exists in the DB
+        self.write_message("Reading data for module {}\n".format(SN))
+        md = self.find_module(SN)
+        if md is None:
+            self.write_message("...object does not exist.\n")
+            self.double_file.unselect_all()
+            return
+
+        found_child = False
+        if md["type"]["name"].find("Ring"):
+            self.write_message("...This is a Ring module. Searching children in DB\n")
+            for child in md["children"]:
+                if child["component"]:
+                    ctype = child["type"]["code"]
+                    if ctype.find("MODULE")<0:
+                        continue
+
+                    cSN = child["component"]["serialNumber"]
+                    if cSN == self.mod_SN["single"]:
+                        continue
+
+                    halfM_SN = cSN
+                    found_child = True
+                    self.write_message("...found {}\n".format(halfM_SN))
+                    break
+
+
+            if not found_child:
+                self.write_message("Requesting a Half Module SN\n")
+                halfM_SN = dbGtkUtils.get_a_value("Give Half Module SN", "Serial Number")
+
+            md = ITkDButils.get_DB_component(self.session, halfM_SN)
+            if md is None:
+                dbGtkUtils.complain(
+                    "Could not find {}".format(halfM_SN),
+                    str(ITkDButils.get_db_response()),
+                )
+                self.double_file.unselect_all()
+                return
+
+            self.write_message("... {}".format(halfM_SN))
+
+        if "single" in self.mod_type:
+            if self.mod_type["single"] == md["type"]["code"]:
+                dbGtkUtils.complain(
+                    "Wrong module type.",
+                    "Module type cannot be {}".format(self.mod_type["single"]),
+                )
+
+                self.double_file.unselect_all()
+                return
+
+        self.mod_SN["double"] = halfM_SN
+        self.mod_type["double"] = md["type"]["code"]
+        self.mdata["double"] = mdata
+
+        self.double_SN.set_text("{} - {}".format(SN, md["type"]["name"]))
+        self.show_curve(
+            133,
+            mdata["curve"]["V"],
+            mdata["curve"]["I"],
+            "Double",
+            mdata["curve"]["labels"][0],
+            None,
+        )
+
+        # Compute difference if single already available
+        if "single" in self.mdata:
+            self.on_difference()
+
+    def on_difference(self, *args):
+        """Compute difference."""
+        if "single" not in self.mdata or "double" not in self.mdata:
+            dbGtkUtils.complain(
+                "Data needed", "Check if single oand doubel module data are available"
+            )
+            return
+
+        single_I = scale_iv(
+            self.mdata["single"]["curve"]["I"],
+            self.mdata["single"]["Temperature"] + 273.0,
+            self.mdata["double"]["Temperature"] + 273.0,
+        )
+
+        self.difference = self.mdata["double"]["curve"]["I"] - single_I
+
+        self.show_curve(
+            132,
+            self.mdata["double"]["curve"]["V"],
+            self.difference,
+            self.mod_type["double"][0:4],
+            self.mdata["double"]["curve"]["labels"][0],
+            None,
+        )
+
+    def show_curve(self, subplot, X, Y, title=None, xlabel="X", ylabel="Y"):
+        """Shows data"""
+        ax = self.fig.add_subplot(subplot)
+        if xlabel:
+            ax.set_xlabel(xlabel)
+
+        if ylabel:
+            ax.set_ylabel(ylabel)
+
+        if title:
+            ax.set_title(title)
+
+        ax.plot(X, Y)
+        ax.grid()
+        self.on_refresh()
+
+    @staticmethod
+    def read_file(fnam):
+        """Read a data file. Return dictionary with all teh data."""
+        labels = []
+        metadata = {}
+        with open(fnam, "r", encoding="utf-8") as ifile:
+            first = True
+            for line in ifile:
+                if first:
+                    first = False
+                    ipos = line.rfind('.')
+                    metadata["fname"] = line[:ipos]
+                    continue
+
+                if line.find("Voltage [V]") >= 0:
+                    labels = line.split("\t")
+                    break
+
+                rc = line.find(":")
+                if rc >= 0:
+                    key = line[:rc].strip()
+                    val = line[rc + 1 :].strip()
+                    if key in ["Temperature", "Humidity"]:
+                        metadata[key] = float(val)
+                    else:
+                        metadata[key] = val
+
+            V = []
+            I = []
+            for line in ifile:
+                data = [float(s) for s in line.split()]
+                V.append(data[0])
+                I.append(data[1])
+
+            metadata["curve"] = {
+                "V": np.array(V),
+                "I": np.array(I),
+                "labels": labels[0:2],
+            }
+            return metadata
+
+
+if __name__ == "__main__":
+    import sys
+
+    # 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
+
+    # Start the Application
+    win = IVwindow(client)
+    win.show_all()
+    win.set_accept_focus(True)
+    win.present()
+    win.connect("destroy", Gtk.main_quit)
+
+    try:
+        Gtk.main()
+    except KeyboardInterrupt:
+        print("Arrggggg !!!")
+
+    dlg.die()
+    print("Bye !!")
+    sys.exit()

{itkdb_gtk-0.0.14 → itkdb_gtk-0.0.16.dev0}/itkdb_gtk/uploadPetalInformation.py

@@ -261,7 +261,7 @@ class AVSPanel(Gtk.Window):
         replace_in_container(self.test_panel[key], scrolled)
 
     def check_register_petal(self, SN):
-        """Register teal core in DB.
+        """Register petal core in DB.
 
         Args:
         ----

{itkdb_gtk-0.0.14 → itkdb_gtk-0.0.16.dev0}/itkdb_gtk/uploadTest.py

@@ -88,7 +88,7 @@ class UploadTest(dbGtkUtils.ITkDBWindow):
         ----
             session: ITkDB session
             payload: path of test file
-            attachment: an Attachment object.
+            attachment: an Attachment object or list of attachments.
 
         """
         self.payload = payload
@@ -101,7 +101,12 @@ class UploadTest(dbGtkUtils.ITkDBWindow):
                 if attachment.path is not None:
                     self.attachments.append(attachment)
             else:
-                print("Wrong attachment: {}".format(attachment))
+                try:
+                    for att in attachment:
+                        self.attachments.append(att)
+
+                except TypeError:
+                    print("Wrong attachment: {}".format(attachment))
 
         global gtk_runs
         if gtk_runs:
@@ -168,15 +173,15 @@ class UploadTest(dbGtkUtils.ITkDBWindow):
         # The "Add attachment" button.
         box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
         self.mainBox.pack_start(box, False, False, 0)
-        dbGtkUtils.add_button_to_container(box, "Attachments",
+        self.btn_attch = dbGtkUtils.add_button_to_container(box, "Attachments",
                                            "Click to edit attachments.",
                                            self.edit_attachments)
 
-        dbGtkUtils.add_button_to_container(box, "Comments",
+        self.btn_comments = dbGtkUtils.add_button_to_container(box, "Comments",
                                            "Click to edit comments.",
                                            self.edit_comments)
 
-        dbGtkUtils.add_button_to_container(box, "Defects",
+        self.btn_defects = dbGtkUtils.add_button_to_container(box, "Defects",
                                            "Click to edit defects.",
                                            self.edit_defects)
 
@@ -200,11 +205,21 @@ class UploadTest(dbGtkUtils.ITkDBWindow):
             else:
                 print("Input file does not exists: {}".format(self.payload))
 
-        if len(self.attachments):
-            dC = [A for A in self.attachments]
-            self.attachments.clear()
-            for A in dC:
-                self.append_attachment_to_view(A)
+        #if len(self.attachments):
+        #    dC = [A for A in self.attachments]
+        #    self.attachments.clear()
+        #    for A in dC:
+        #        self.append_attachment_to_view(A)
+
+        if len(self.attachments) > 0:
+            self.btn_attch.set_label("Attachments ({})".format(len(self.attachments)))
+
+        if len(self.comments) > 0:
+            self.btn_comments.set_label("Comments ({})".format(len(self.comments)))
+
+        if len(self.defects) > 0:
+            self.btn_defects.set_label("Defects ({})".format(len(self.defects)))
+
 
     def get_test_institute(self):
         """Select an institue."""
@@ -286,6 +301,10 @@ class UploadTest(dbGtkUtils.ITkDBWindow):
         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)
@@ -296,6 +315,9 @@ class UploadTest(dbGtkUtils.ITkDBWindow):
         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)
@@ -306,6 +328,9 @@ class UploadTest(dbGtkUtils.ITkDBWindow):
         SD.hide()
         SD.destroy()
 
+        if len(self.defects) > 0:
+            self.btn_defects.set_label("Defects ({})".format(len(self.defects)))
+
     def upload_test_gui(self, *args):
         """Uploads test and attachments."""
         self.upload_test()

{itkdb_gtk-0.0.14 → itkdb_gtk-0.0.16.dev0}/itkdb_gtk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
-Name: itkdb-gtk
-Version: 0.0.14
+Name: itkdb_gtk
+Version: 0.0.16.dev0
 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
@@ -9,6 +9,11 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
+Requires-Dist: itkdb>=0.4.0
+Requires-Dist: openpyxl
+Requires-Dist: pyserial
+Requires-Dist: python_dateutil
+Requires-Dist: requests
 
 # Interaction with the ITk PDB.
 
@@ -57,6 +62,9 @@ GUI dialog. One can add comments and attachments to the shipment.
 Allows to upload and enter valueos, comments and defects for those items in the gounding
 and visual instpections tests of the petal core.
 
+## uploadIVfiles.py
+The idea behind this is that we messure the IV on a Ring module and on only one of the to Half modules. The IV of the remaining half modules is derived from the other 2. Eventually the IV test can be uploaded to the DB.
+
 ## dashBoard.py
 This is an launcher application from which we can start most of the other
 applications. It is a very good starting point. There is a Gnome desktop file (ITkDB.desktop)

{itkdb_gtk-0.0.14 → itkdb_gtk-0.0.16.dev0}/itkdb_gtk.egg-info/SOURCES.txt

@@ -9,17 +9,15 @@ itkdb_gtk/ShowAttachments.py
 itkdb_gtk/ShowComments.py
 itkdb_gtk/ShowDefects.py
 itkdb_gtk/__init__.py
-itkdb_gtk/checkComponent.py
-itkdb_gtk/checkComponentTests.py
-itkdb_gtk/checkJSon.py
 itkdb_gtk/dashBoard.py
 itkdb_gtk/dbGtkUtils.py
 itkdb_gtk/getShipments.py
 itkdb_gtk/groundVITests.py
 itkdb_gtk/readAVSdata.py
 itkdb_gtk/readGoogleSheet.py
-itkdb_gtk/recover_component.py
 itkdb_gtk/sendShipments.py
+itkdb_gtk/untrash_component.py
+itkdb_gtk/uploadIVfiles.py
 itkdb_gtk/uploadMultipleTests.py
 itkdb_gtk/uploadPetalInformation.py
 itkdb_gtk/uploadTest.py

{itkdb_gtk-0.0.14 → itkdb_gtk-0.0.16.dev0}/itkdb_gtk.egg-info/entry_points.txt

@@ -4,5 +4,6 @@ glueWeight = itkdb_gtk:glueWeight
 groundVITests = itkdb_gtk:groundVITests
 itkdb_dashBoard = itkdb_gtk:dash_board
 sendShipments = itkdb_gtk:sendShipments
+uploadIVfiles = itkdb_gtk:uploadIVfiles
 uploadMultipleTests = itkdb_gtk:uploadMultipleTests
 uploadTest = itkdb_gtk:uploadTest

{itkdb_gtk-0.0.14 → itkdb_gtk-0.0.16.dev0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "itkdb_gtk"
-version = "0.0.14"
+version = "0.0.16.dev0"
 authors = [
   { name="Carlos Lacasta", email="carlos.lacasta@cern.ch" },
 ]
@@ -31,6 +31,7 @@ groundVITests = "itkdb_gtk:groundVITests"
 sendShipments = "itkdb_gtk:sendShipments"
 uploadTest = "itkdb_gtk:uploadTest"
 uploadMultipleTests = "itkdb_gtk:uploadMultipleTests"
+uploadIVfiles = "itkdb_gtk:uploadIVfiles"
 
 [tool.setuptools]
 include-package-data = true

itkdb_gtk-0.0.14/itkdb_gtk/checkComponent.py

@@ -1,151 +0,0 @@
-#!/usr/bin/env python3
-"""Check children of DB component."""
-
-try:
-    import readAVSdata
-    import ITkDBlogin
-    import ITkDButils
-
-    from dbGtkUtils import replace_in_container, DictDialog, ask_for_confirmation
-
-except ModuleNotFoundError:
-    from itkdb_gtk import readAVSdata, ITkDBlogin, ITkDButils
-    from itkdb_gtk.dbGtkUtils import replace_in_container, DictDialog, ask_for_confirmation
-
-import json
-
-
-def ascii_complain(main_msg, secondary_msg=None):
-    """Prints an error message
-
-    Args:
-    -----
-        main (): Main message
-        secondary (): Seconday message
-    """
-    print("**Error\n{}".format(main_msg))
-    if secondary_msg:
-        msg = secondary_msg.replace("\n", "\n\t")
-        print("\t{}".format(msg))
-
-
-def find_petal(session, SN, silent=False):
-    """Finds petal with given SN."""
-    try:
-        petal_core = ITkDButils.get_DB_component(session, SN)
-
-    except Exception as E:
-        if not silent:
-            ascii_complain("Could not find Petal Core in DB", str(E))
-
-        petal_core = None
-        return
-
-    try:
-        if petal_core["type"]["code"] != "CORE_AVS":
-            ascii_complain("Wrong component type", "This is not an AVS petal core")
-
-        # print(json.dumps(petal_core, indent=3))
-
-    except KeyError:
-        # Petal is not there
-        petal_core = None
-
-    return petal_core
-
-
-def get_type(child):
-    """Return object type
-
-    Args:
-    -----
-        child (): object
-
-    Returns
-    -------
-        str: object type
-
-    """
-    if child["type"] is not None:
-        ctype = child["type"]["code"]
-    else:
-        ctype = child["componentType"]["code"]
-
-    return ctype
-
-
-def main():
-    """Main entry point."""
-    # ITk_PB authentication
-    dlg = ITkDBlogin.ITkDBlogin()
-    session = dlg.get_client()
-
-    final_stage = {
-        "BT_PETAL_FRONT": "COMPLETED",
-        "BT_PETAL_BACK": "COMPLETED",
-        "COOLING_LOOP_PETAL": "CLINCORE",
-        "THERMALFOAMSET_PETAL": "IN_CORE"
-    }
-
-    # find all cores
-    # Now all the objects
-    payload = {
-        "componentType": ["BT"],
-        "componentType": ["CORE_PETAL"],
-        "type": ["CORE_AVS"],
-    }
-    core_list = session.get("listComponents", json=payload)
-
-    for obj in core_list:
-        SN = obj["serialNumber"]
-        id = obj['alternativeIdentifier']
-        if "PPB" not in id:
-            continue
-        
-        core = find_petal(session, SN)
-        if core is None:
-            print("SN: not a petal core.")
-            continue
-
-        location = core["currentLocation"]['code']
-        stage = core["currentStage"]['code']
-        if stage != "AT_QC_SITE":
-            rc = ITkDButils.set_object_stage(session, SN, "AT_QC_SITE")
-            if rc is not None:
-                print("problems setting stage")
-
-        if "children" not in core:
-            ascii_complain("{}[{}]".format(SN, id), "Not assembled")
-            continue
-
-        print("Petal {} [{}] - {}. {}".format(SN, id, stage, location))
-        clist = []
-        for child in core["children"]:
-            cstage = "Missing"
-            if child["component"] is None:
-                ctype = get_type(child)
-                clist.append((ctype, cstage, None, None))
-
-            else:
-                SN = child["component"]["serialNumber"]
-                ctype = get_type(child)
-                cobj = ITkDButils.get_DB_component(session, child["component"]["id"])
-                cstage = cobj["currentStage"]['code']
-                if cstage != final_stage[ctype]:
-                    rc = ITkDButils.set_object_stage(session, SN, final_stage[ctype])
-                    if rc is not None:
-                        cstage = final_stage[ctype]
-
-                clocation = cobj["currentLocation"]['code']
-                clist.append((ctype, cstage, SN, clocation))
-
-        for item in clist:
-            print("\t{} [{}] - {} at {}".format(item[2], item[0], item[1], item[3]))
-
-        print()
-
-    dlg.die()
-
-
-if __name__ == "__main__":
-    main()

itkdb_gtk-0.0.14/itkdb_gtk/checkComponentTests.py

@@ -1,116 +0,0 @@
-#!/usr/bin/env python3
-"""Check children of DB component."""
-
-try:
-    import ITkDBlogin
-    import ITkDButils
-
-    from dbGtkUtils import replace_in_container, DictDialog, ask_for_confirmation
-
-except ModuleNotFoundError:
-    from itkdb_gtk import ITkDBlogin, ITkDButils
-    from itkdb_gtk.dbGtkUtils import replace_in_container, DictDialog, ask_for_confirmation
-
-import json
-
-
-def ascii_complain(main_msg, secondary_msg=None):
-    """Prints an error message
-
-    Args:
-    -----
-        main (): Main message
-        secondary (): Seconday message
-    """
-    print("**Error\n{}".format(main_msg))
-    if secondary_msg:
-        msg = secondary_msg.replace("\n", "\n\t")
-        print("\t{}".format(msg))
-
-
-def find_petal(session, SN, silent=False):
-    """Finds petal with given SN."""
-    try:
-        petal_core = ITkDButils.get_DB_component(session, SN)
-
-    except Exception as E:
-        if not silent:
-            ascii_complain("Could not find Petal Core in DB", str(E))
-
-        petal_core = None
-        return
-
-    try:
-        if petal_core["type"]["code"] != "CORE_AVS":
-            ascii_complain("Wrong component type", "This is not an AVS petal core")
-
-        # print(json.dumps(petal_core, indent=3))
-
-    except KeyError:
-        # Petal is not there
-        petal_core = None
-
-    return petal_core
-
-
-def get_type(child):
-    """Return object type
-
-    Args:
-    -----
-        child (): object
-
-    Returns
-    -------
-        str: object type
-
-    """
-    if child["type"] is not None:
-        ctype = child["type"]["code"]
-    else:
-        ctype = child["componentType"]["code"]
-
-    return ctype
-
-
-def main():
-    """Main entry point."""
-    # ITk_PB authentication
-    dlg = ITkDBlogin.ITkDBlogin()
-    session = dlg.get_client()
-
-    # find all cores
-    # Now all the objects
-    payload = {
-        "componentType": ["BT"],
-        "componentType": ["CORE_PETAL"],
-        "type": ["CORE_AVS"],
-        "currentLocation": "IFIC"
-    }
-    core_list = session.get("listComponents", json=payload)
-
-    for core in core_list:
-        SN = core["serialNumber"]
-        id = core['alternativeIdentifier']
-        if "PPB" not in id:
-            continue
-
-        location = core["currentLocation"]['code']
-        stage = core["currentStage"]['code']
-        print("Petal {} [{}] - {}. {}".format(SN, id, stage, location))
-
-        # get list of tests
-        test_list = session.get("listTestRunsByComponent", json={"component": SN})
-        for tst in test_list:
-            ttype = tst["testType"]["code"]
-            inst = tst["institution"]["code"]
-            stage = tst["stage"]["code"]
-            print("\t{:<18} {:<16} {:>8} {:>3} {}".format(ttype, stage, inst, tst["runNumber"], tst["date"][:10]))
-
-        print()
-
-    dlg.die()
-
-
-if __name__ == "__main__":
-    main()

itkdb_gtk-0.0.14/itkdb_gtk/checkJSon.py

@@ -1,56 +0,0 @@
-#!/usr/bin/env python3
-"""Check tha a given JSon is valid."""
-from pathlib import Path
-import json
-
-try:
-    import ITkDBlogin
-    import ITkDButils
-except ModuleNotFoundError:
-    from itkdb_gtk import ITkDBlogin, ITkDButils
-
-
-def checkJSOn(session, ifile):
-    """Check teh validity of a JSon test file
-
-    Args:
-        fname (): File or data.
-    """
-    fnam = Path(ifile).expanduser().resolve()
-    with open(fnam, 'r') as fin:
-        user_file = json.load(fin)
-
-    test_type = user_file["testType"]
-    component = ITkDButils.get_DB_component(session, user_file["component"])
-
-    skeleton = ITkDButils.get_test_skeleton(session,
-                                            component["componentType"]["code"],
-                                            test_type)
-
-    for key in skeleton.keys():
-        if key in ["comments", "defects"]:
-            continue
-
-        if key not in user_file:
-            print("Missing key {}".format(key))
-            if key == "institution":
-                sites = session.get("listInstitutions", json={})
-                print(sites)
-
-
-if __name__ == "__main__":
-    import sys
-    dlg = ITkDBlogin.ITkDBlogin()
-    client = dlg.get_client()
-    if client is None:
-        print("Could not connect to DB with provided credentials.")
-        dlg.die()
-        sys.exit()
-
-    try:
-        checkJSOn(client, sys.argv[1])
-
-    except Exception as ex:
-        print(ex)
-
-    dlg.die()