itkdb-gtk 0.9.0__py3-none-any.whl → 0.10.0__py3-none-any.whl

itkdb_gtk/UploadMultipleTests.py

@@ -103,14 +103,14 @@ def check_data(data):
 class UploadMultipleTests(dbGtkUtils.ITkDBWindow):
     """Collects information to upload a test and its attachments."""
 
-    def __init__(self, session):
+    def __init__(self, session, help=help):
         """Initialization.
 
         Args:
             session: ITkDB session
 
         """
-        super().__init__(session=session, title="Upload Tests", gtk_runs=gtk_runs)
+        super().__init__(session=session, title="Upload Tests", gtk_runs=gtk_runs, help=help)
         self.tests = []
 
         self.init_window()

itkdb_gtk/UploadPetalInformation.py

@@ -3,7 +3,7 @@
 import json
 import sys
 from argparse import ArgumentParser
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
 
 import dateutil.parser
@@ -20,9 +20,7 @@ except ImportError:
     cwd = Path(sys.argv[0]).parent.parent
     sys.path.append(cwd.as_posix())
 
-from itkdb_gtk import readAVSdata, ITkDBlogin, ITkDButils
-from itkdb_gtk.dbGtkUtils import replace_in_container, complain, DictDialog, ask_for_confirmation
-
+from itkdb_gtk import readAVSdata, ITkDBlogin, ITkDButils, dbGtkUtils
 
 def create_scrolled_dictdialog(the_dict, hidden=("component", "testType")):
     """Create a DictDialog within a scrolled window.
@@ -33,7 +31,7 @@ def create_scrolled_dictdialog(the_dict, hidden=("component", "testType")):
         gM: the DictDialog
 
     """
-    gM = DictDialog(the_dict, hidden)
+    gM = dbGtkUtils.DictDialog(the_dict, hidden)
     scrolled = Gtk.ScrolledWindow()
     scrolled.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
     scrolled.add(gM)
@@ -58,28 +56,26 @@ def get_type(child):
     return ctype
 
 
-class AVSPanel(Gtk.Window):
+class AVSPanel(dbGtkUtils.ITkDBWindow):
     """Dialog for interaction with DB."""
 
     def __init__(self, session, options):
         """Initialization."""
-        super().__init__(title="Upload AVS Data")
-        self.db_session = session
+        super().__init__(session=session, title="Upload AVS Data", show_search="Click to search SN in DB")
         self.test_uploaded = {}
         self.test_list = []
         self.test_index = {}
         self.test_panel = {}
         self.test_map = {}
         self.petal_core = None
+        self.alias = None
         self.petal_weight = -1
+        self.DESY_comp = {}
         # self.set_position(Gtk.WindowPosition.CENTER_ALWAYS)
 
         #
         # Prepare HeaderBar
-        hb = Gtk.HeaderBar()
-        hb.set_show_close_button(True)
-        hb.props.title = "DB Upload Petal Data"
-        self.set_titlebar(hb)
+        self.hb.props.title = "DB Upload Petal Data"
 
         button = Gtk.Button()
         icon = Gio.ThemedIcon(name="document-send-symbolic")
@@ -87,7 +83,7 @@ class AVSPanel(Gtk.Window):
         button.add(image)
         button.set_tooltip_text("Click to upload test shown in notebook.")
         button.connect("clicked", self.upload_current_test)
-        hb.pack_end(button)
+        self.hb.pack_end(button)
 
         button = Gtk.Button()
         icon = Gio.ThemedIcon(name="emblem-documents-symbolic")
@@ -95,24 +91,7 @@ class AVSPanel(Gtk.Window):
         button.add(image)
         button.set_tooltip_text("Click to upload AVS files.")
         button.connect("clicked", self.upload_avs_files)
-        hb.pack_end(button)
-
-        button = Gtk.Button()
-        icon = Gio.ThemedIcon(name="system-search-symbolic")
-        image = Gtk.Image.new_from_gicon(icon, Gtk.IconSize.BUTTON)
-        button.add(image)
-        button.set_tooltip_text("Click to search SN in data base.")
-        button.connect("clicked", self.query_db)
-        hb.pack_end(button)
-
-        self.userLabel = Gtk.Label()
-        self.userLabel.set_text(session.user.name)
-        hb.pack_start(self.userLabel)
-
-        #
-        # Crete man contentt box
-        self.mainBox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
-        self.add(self.mainBox)
+        self.hb.pack_end(button)
 
         # PS file entry and search button
         self.btnPSF = Gtk.FileChooserButton()
@@ -139,11 +118,20 @@ class AVSPanel(Gtk.Window):
         grid = Gtk.Grid(column_spacing=5, row_spacing=1)
         self.mainBox.pack_start(grid, False, True, 0)
 
+        self.btn_state = Gtk.Button(label="Undef")
+        self.btn_state.set_name("btnState")
+
         grid.attach(Gtk.Label(label="Serial No."), 0, 0, 1, 1)
         grid.attach(self.SN, 1, 0, 1, 1)
+        grid.attach(self.btn_state, 2, 0, 1, 1)
+        
 
         grid.attach(Gtk.Label(label="Prod. Sheet"), 0, 1, 1, 1)
         grid.attach(self.btnPSF, 1, 1, 1, 1)
+        
+        btn = Gtk.Button(label="Reset")
+        btn.connect("clicked", self.on_reset)
+        grid.attach(btn, 2, 1, 1, 1)
 
         grid.attach(Gtk.Label(label="FAT file"), 0, 2, 1, 1)
         grid.attach(self.btnFAT, 1, 2, 1, 1)
@@ -164,32 +152,32 @@ class AVSPanel(Gtk.Window):
 
         self.manufacture = self.create_test_window(
             ITkDButils.get_test_skeleton(
-                self.db_session, "CORE_PETAL", "MANUFACTURING", defaults),
+                self.session, "CORE_PETAL", "MANUFACTURING", defaults),
             "manufacture", "Manufacture")
 
         self.weights = self.create_test_window(
             ITkDButils.get_test_skeleton(
-                self.db_session, "CORE_PETAL", "WEIGHING", defaults),
+                self.session, "CORE_PETAL", "WEIGHING", defaults),
             "weights", "Weights")
 
         self.delamination = self.create_test_window(
             ITkDButils.get_test_skeleton(
-                self.db_session, "CORE_PETAL", "DELAMINATION", defaults),
+                self.session, "CORE_PETAL", "DELAMINATION", defaults),
             "delamination", "Delamination")
 
         self.grounding = self.create_test_window(
             ITkDButils.get_test_skeleton(
-                self.db_session, "CORE_PETAL", "GROUNDING_CHECK", defaults),
+                self.session, "CORE_PETAL", "GROUNDING_CHECK", defaults),
             "grounding", "Grounding")
 
         self.metrology = self.create_test_window(
             ITkDButils.get_test_skeleton(
-                self.db_session, "CORE_PETAL", "METROLOGY_AVS", defaults),
+                self.session, "CORE_PETAL", "METROLOGY_AVS", defaults),
             "metrology", "Metrology")
 
         self.visual_inspection = self.create_test_window(
             ITkDButils.get_test_skeleton(
-                self.db_session, "CORE_PETAL", "VISUAL_INSPECTION", defaults),
+                self.session, "CORE_PETAL", "VISUAL_INSPECTION", defaults),
             "visual_inspection", "Visual Inspection")
 
         # List componentes
@@ -200,29 +188,48 @@ class AVSPanel(Gtk.Window):
         # The button box
         btnBox = Gtk.ButtonBox(orientation=Gtk.Orientation.HORIZONTAL)
 
-        btn = Gtk.Button(label="Reload AVS files")
-        btn.connect("clicked", self.read_avs_files)
+        # btn = Gtk.Button(label="Reload AVS files")
+        # btn.connect("clicked", self.read_avs_files)
+        # btnBox.add(btn)
+
+        btn = Gtk.Button(label="Assemble")
+        btn.set_tooltip_text("Assemble components in DB")
+        btn.connect("clicked", self.on_assembly)
         btnBox.add(btn)
 
-        btn = Gtk.Button(label="Query DB")
-        btn.connect("clicked", self.query_db)
+        btn = Gtk.Button(label="Check Components")
+        btn.set_tooltip_text("Check components in DB")
+        btn.connect("clicked", self.on_check_components)
         btnBox.add(btn)
 
-        btn = Gtk.Button(label="Assemble")
-        btn.connect("clicked", self.on_assembly)
+        btn = Gtk.Button(label="Check Tests")
+        btn.set_tooltip_text("Check test results")
+        btn.connect("clicked", self.on_check_tests)
         btnBox.add(btn)
 
         btn = Gtk.Button(label="Upload Tests")
+        btn.set_tooltip_text("Upload all tests")
+        
         btn.connect("clicked", self.on_upload)
         btnBox.add(btn)
 
-        btn = Gtk.Button(label="Quit")
-        btn.connect("clicked", Gtk.main_quit)
-        btnBox.add(btn)
-
         self.mainBox.pack_start(btnBox, False, True, 0)
         self.connect("destroy", Gtk.main_quit)
 
+
+        # The text view
+        self.mainBox.pack_start(self.message_panel.frame, True, True, 5)
+
+        self.show_all()
+
+    def on_reset(self, *args):
+        """Reset SN"""
+        self.petal_core = None
+        self.alias = None
+        self.SN.set_text("")
+        self.btnPSF.unselect_all()
+        self.btnFAT.unselect_all()
+
     def create_test_window(self, test_json, test_name, label):
         """Create the dialog for a DB test and add it to the notebook.
 
@@ -254,7 +261,7 @@ class AVSPanel(Gtk.Window):
         """Update panel for a given test."""
         scrolled, gM = create_scrolled_dictdialog(data, ("component", "testType"))
         self.test_list[self.test_index[key]] = gM
-        replace_in_container(self.test_panel[key], scrolled)
+        dbGtkUtils.replace_in_container(self.test_panel[key], scrolled)
 
     def check_register_petal(self, SN):
         """Register petal core in DB.
@@ -280,16 +287,19 @@ class AVSPanel(Gtk.Window):
                            Gtk.STOCK_OK, Gtk.ResponseType.OK)
         dialog.set_border_width(10)
         dialog.format_secondary_text("Enter Petal Core Alias")
-        alias = Gtk.Entry()
+        alias = Gtk.Entry(text=self.alias)
         box = dialog.get_content_area()
         box.add(alias)
         dialog.show_all()
         out = dialog.run()
         if out == Gtk.ResponseType.OK:
-            petal_alias = alias.get_text()
-            rc = ITkDButils.registerPetalCore(self.db_session, SN, petal_alias)
+            petal_alias = alias.get_text().strip()
+            if len(petal_alias) == 0:
+                petal_alias = self.alias
+
+            rc = ITkDButils.registerPetalCore(self.session, SN, petal_alias)
             if rc is None:
-                complain("Could not Register petal {} ({})".format(SN, petal_alias))
+                dbGtkUtils.complain("Could not Register petal {} ({})".format(SN, petal_alias))
 
         dialog.hide()
         dialog.destroy()
@@ -318,62 +328,64 @@ class AVSPanel(Gtk.Window):
         """Production Sheet file selected."""
         PSF = self.btnPSF.get_filename()
         if PSF is None or not Path(PSF).exists():
-            complain("Could not find Production File", PSF, parent=self)
+            dbGtkUtils.complain("Could not find Production File", PSF, parent=self)
             return
 
         try:
-            manuf_json, weights_json, self.DESY_comp = readAVSdata.readProductionSheet(self.db_session, PSF, "SNnnnn")
+            manuf_json, weights_json, self.DESY_comp, self.alias = readAVSdata.readProductionSheet(self.session, PSF, "SNnnnn")
             if self.petal_weight > 0:
                 weights_json["results"]["WEIGHT_CORE"] = self.petal_weight
 
         except readAVSdata.AVSDataException as E:
-            complain("Wrong Production Sheet file", str(E))
+            dbGtkUtils.complain("Wrong Production Sheet file", str(E))
             self.btnPSF.unselect_all()
             return
 
         SN = manuf_json["component"]
         if not self.check_petal_serial_number(SN):
-            complain("Inconsistent Serial number found.",
+            dbGtkUtils.complain("Inconsistent Serial number found.",
                      "Wrong Serial number extracted from the Production Sheet document.\n{}".format(PSF))
             self.btnPSF.unselect_all()
             return
 
         scrolled, gM = create_scrolled_dictdialog(manuf_json, ("component", "testType"))
         self.test_list[self.test_index["manufacture"]] = gM
-        replace_in_container(self.manufacture, scrolled)
+        dbGtkUtils.replace_in_container(self.manufacture, scrolled)
 
         scrolled, gM = create_scrolled_dictdialog(weights_json, ("component", "testType"))
         self.test_list[self.test_index["weights"]] = gM
-        replace_in_container(self.weights, scrolled)
+        dbGtkUtils.replace_in_container(self.weights, scrolled)
 
-        gD = DictDialog(self.DESY_comp)
-        replace_in_container(self.components, gD)
+        gD = dbGtkUtils.DictDialog(self.DESY_comp)
+        dbGtkUtils.replace_in_container(self.components, gD)
 
         # Check if we need to assemble the module
         self.check_assembly(self.DESY_comp)
+        
+        self.check_components()
 
     def on_fat_set(self, *args):
         """FAT file selected."""
         FAT = self.btnFAT.get_filename()
         if FAT is None or not Path(FAT).exists():
-            complain("Could not find FAT File", FAT, parent=self)
+            dbGtkUtils.complain("Could not find FAT File", FAT, parent=self)
 
         try:
             SN = self.get_app_petal_serial_number()
             if SN and not SN.startswith("20USEBC"):
                 SN = None
 
-            j_vi, j_del, j_gnd, j_mtr, batch, self.petal_weight = readAVSdata.readFATfile(self.db_session, FAT, SN)
+            j_vi, j_del, j_gnd, j_mtr, batch, self.petal_weight = readAVSdata.readFATfile(self.session, FAT, SN)
             self.test_list[self.test_index["weights"]].set_value("results.WEIGHT_CORE", self.petal_weight)
 
         except readAVSdata.AVSDataException as E:
-            complain("Wrong FAT file", str(E))
+            dbGtkUtils.complain("Wrong FAT file", str(E))
             self.btnFAT.unselect_all()
             return
 
         SN = j_vi["component"]
         if not self.check_petal_serial_number(SN):
-            complain("Inconsistent Serial number found.",
+            dbGtkUtils.complain("Inconsistent Serial number found.",
                      "Wrong Serial number extracted from the FAT document.\n{}".format(FAT))
             self.btnFAT.unselect_all()
             return
@@ -382,6 +394,8 @@ class AVSPanel(Gtk.Window):
         self.update_scroll_window("delamination", j_del)
         self.update_scroll_window("grounding", j_gnd)
         self.update_scroll_window("metrology", j_mtr)
+        
+        self.check_tests(True)
 
     def read_avs_files(self, widgets):
         """Read AVS files."""
@@ -398,50 +412,53 @@ class AVSPanel(Gtk.Window):
     def find_petal(self, SN, silent=False):
         """Finds petal with given SN."""
         try:
-            self.petal_core = ITkDButils.get_DB_component(self.db_session, SN)
+            self.petal_core = ITkDButils.get_DB_component(self.session, SN)
 
         except Exception as E:
             if not silent:
-                complain("Could not find Petal Core in DB", str(E))
+                dbGtkUtils.complain("Could not find Petal Core in DB", str(E))
 
             self.petal_core = None
             return
 
+        if self.petal_core is None:
+            return
+
         try:
             if self.petal_core["type"]["code"] != "CORE_AVS":
-                complain("Wrong component type", "This is not an AVS petal core")
+                dbGtkUtils.complain("Wrong component type", "This is not an AVS petal core")
 
             if self.petal_core["currentStage"]["code"] != "ASSEMBLY":
-                complain("Wrong component stage", "Wrong stage: {}".format(self.petal_core["currentStage"]["code"]))
+                dbGtkUtils.complain("Wrong component stage", "Wrong stage: {}".format(self.petal_core["currentStage"]["code"]))
 
-            print(json.dumps(self.petal_core, indent=3))
+            self.write_message("{}\n".format(json.dumps(self.petal_core, indent=3)))
 
         except KeyError:
             # Petal is not there
             self.petal_core = None
 
-    def query_db(self, widget=None, silent=False):
+    def query_db(self, *args):
         """Called when QueryDB button clicked."""
         SN = self.SN.get_text()
         if len(SN) == 0:
-            complain("Empty Serial number",
+            dbGtkUtils.complain("Empty Serial number",
                      "You should enter a valid Serial number for the petal core.",
                      parent=self)
             self.petal_core = None
             return
 
         # if not checkSerialNumber(SN):
-        #     complain("Wrong Serial number",
+        #     dbGtkUtils.complain("Wrong Serial number",
         #              "You should enter a valid Serial number for the petal core.",
         #              parent=self)
         #     return
-        self.find_petal(SN, silent=silent)
+        self.find_petal(SN)
 
         if self.btnFAT.get_filename() is None and self.btnPSF.get_filename() is None:
             # update tests from DB
             for test in self.petal_core["tests"]:
                 latest = None
-                latest_time = datetime.datetime(year=1, month=1, day=1, tzinfo=datetime.timezone.utc)
+                latest_time = datetime(year=1, month=1, day=1, tzinfo=timezone.utc)
                 testType = test["code"]
                 for T in test["testRuns"]:
                     test_date = dateutil.parser.parse(T["cts"])
@@ -449,10 +466,27 @@ class AVSPanel(Gtk.Window):
                         latest_time = test_date
                         latest = T["id"]
 
-                dbT = ITkDButils.get_testrun(self.db_session, latest)
+                dbT = ITkDButils.get_testrun(self.session, latest)
                 testDB = ITkDButils.from_full_test_to_test_data(dbT)
                 self.update_scroll_window(self.test_map[testType], testDB)
 
+    def on_check_components(self, *args):
+        """Button clicked."""
+        self.check_components()
+        
+    def check_components(self):
+        """Check that components are in DB."""
+        for cmp, cmp_SN in self.DESY_comp.items():
+            if not (isinstance(cmp_SN, str) and cmp_SN.startswith("20U")):
+                continue
+
+            out = ITkDButils.get_DB_component(self.session, cmp_SN)
+            if out is None:
+                self.write_message("{}: not in DB\n".format(cmp))
+            else:
+                self.write_message("{}: in {}\n".format(cmp, out["currentLocation"]["code"]))
+
+
     def check_assembly(self, components):
         """Check if we need to assemble components to core."""
         if self.petal_core is None:
@@ -487,24 +521,28 @@ class AVSPanel(Gtk.Window):
 
         error_txt = []
         txt = "Click OK to add\n\t{}".format("\n\t".join(missing))
-        if ask_for_confirmation("Missing components", txt, parent=self):
+        if dbGtkUtils.ask_for_confirmation("Missing components", txt, parent=self):
             this_petal = self.SN.get_text()
             for cmp in missing:
                 SN = components[comp_map[cmp]]
                 if SN[0:5] == "20USE":
-                    rc = ITkDButils.assemble_component(self.db_session, this_petal, SN)
+                    rc = ITkDButils.assemble_component(self.session, this_petal, SN)
                     if rc is None:
                         error_txt.append("Problem assembling {} into Petal\n".format(cmp))
 
             # Check for HonneyComb set
             for P in self.petal_core["properties"]:
                 if P["code"] == "HC_ID" and P["value"] is None:
-                    rc = ITkDButils.set_component_property(self.db_session,
+                    if dbGtkUtils.is_iterable(components["HoneyCombSet"]):
+                        val = ' '.join(components["HoneyCombSet"])
+                    else:
+                        val = str(components["HoneyCombSet"])
+                    rc = ITkDButils.set_component_property(self.session,
                                                            this_petal,
                                                            "HC_ID",
-                                                           components["HoneyCombSet"])
+                                                           val)
                     if rc is None:
-                        error_txt.append("Problems setting HoneCombSet ID.\n")
+                        error_txt.append("Problems setting HoneyCombSet ID.\n")
 
                     break
 
@@ -513,22 +551,22 @@ class AVSPanel(Gtk.Window):
                 if child["component"]:
                     cSN = child["component"]["serialNumber"]
                     ctype = get_type(child)
-                    cobj = ITkDButils.get_DB_component(session, cSN)
+                    cobj = ITkDButils.get_DB_component(self.session, cSN)
                     cstage = cobj["currentStage"]['code']
                     if cstage != final_stage[ctype]:
-                        rc = ITkDButils.set_object_stage(session, cSN, final_stage[ctype])
+                        rc = ITkDButils.set_object_stage(self.session, cSN, final_stage[ctype])
                         if rc is None:
                             print("Could not set final stage of {}".format(cSN))
 
             if len(error_txt):
-                complain("Assembly of {} could not be completeed:".format(this_petal),
+                dbGtkUtils.complain("Assembly of {} could not be completeed:".format(this_petal),
                          "\n".join(error_txt))
 
     def upload_current_test(self, *args):
         """Called with upload button clcked."""
         SN = self.SN.get_text()
         if len(SN) == 0:
-            complain("Petal SN is empty")
+            dbGtkUtils.complain("Petal SN is empty")
             return
 
         def find_children(W):
@@ -553,32 +591,32 @@ class AVSPanel(Gtk.Window):
         values = dctD.values
         values["component"] = SN
         print(json.dumps(values, indent=2))
-        rc = ITkDButils.upload_test(self.db_session, values)
+        rc = ITkDButils.upload_test(self.session, values)
         if rc is not None:
-            complain("Could not upload test", rc)
+            dbGtkUtils.complain("Could not upload test", rc)
 
         else:
-            ask_for_confirmation("Test uploaded.",
+            dbGtkUtils.ask_for_confirmation("Test uploaded.",
                                  "{} - {}".format(values["component"], values["testType"]))
 
     def upload_avs_files(self, *args):
         """Called when upload AVS files clicked."""
         SN = self.SN.get_text()
         if len(SN) == 0:
-            complain("Petal SN is empty")
+            dbGtkUtils.complain("Petal SN is empty")
             return
 
         def upload_file(file_path, title, desc):
             if file_path is not None:
                 if not Path(file_path).exists():
-                    complain("Could not find {}".format(title))
+                    dbGtkUtils.complain("Could not find {}".format(title))
 
                 else:
                     try:
-                        ITkDButils.create_component_attachment(self.db_session, SN, file_path, description=desc)
+                        ITkDButils.create_component_attachment(self.session, SN, file_path, description=desc)
 
                     except Exception as e:
-                        complain("Could not Upload {}".format(desc), str(e))
+                        dbGtkUtils.complain("Could not Upload {}".format(desc), str(e))
 
         PSF = self.btnPSF.get_filename()
         upload_file(PSF, "Production File", "AVS Production file")
@@ -586,6 +624,38 @@ class AVSPanel(Gtk.Window):
         FAT = self.btnFAT.get_filename()
         upload_file(FAT, "FAT file", "AVS FAT file")
 
+    def on_check_tests(self, *args):
+        """Button clicked."""
+        self.check_tests(True)
+
+    def check_tests(self, do_write=False):
+        """Check whether all tests are find"""
+        nbad = 0
+        bad = []
+        for test in self.test_list:
+            values = test.values
+            if not values["passed"]:
+                nbad +=1
+                bad.append(values["testType"])
+
+        if nbad:
+            dbGtkUtils.set_button_color(self.btn_state, "red", "white")
+            self.btn_state.set_label("FAILED")
+        else:
+            dbGtkUtils.set_button_color(self.btn_state, "green", "white")
+            self.btn_state.set_label("PASSED")
+
+        if do_write:
+            if nbad:
+                self.write_message("Petal Failed:\n")
+                for T in bad:
+                    self.write_message("\t{}\n".format(T))
+            else:
+                if len(self.test_list)>0:
+                    self.write_message("All tests are PASSED\n")
+
+        return nbad
+
     def on_assembly(self, widget):
         """Assembly button clicked."""
         self.check_assembly(self.DESY_comp)
@@ -599,10 +669,10 @@ class AVSPanel(Gtk.Window):
 
         for test in self.test_list:
             values = test.values
-            print(values["testType"])
-            res = ITkDButils.upload_test(self.db_session, values)
+            self.write_message("{}\n".format(values["testType"]))
+            res = ITkDButils.upload_test(self.session, values)
             if res is not None:
-                complain("Could not upload test {}".format(values["testType"]), res)
+                dbGtkUtils.complain("Could not upload test {}".format(values["testType"]), res)
 
 
 def main():

itkdb_gtk/UploadTest.py

@@ -78,7 +78,7 @@ def check_data(data):
 class UploadTest(dbGtkUtils.ITkDBWindow):
     """Collects information to upload a test and its attachments."""
 
-    def __init__(self, session, payload=None, attachment=None):
+    def __init__(self, session, payload=None, attachment=None, help=None):
         """Initialization.
 
         Args:
@@ -107,7 +107,7 @@ class UploadTest(dbGtkUtils.ITkDBWindow):
 
         global gtk_runs
         if gtk_runs:
-            super().__init__(session=session, title="Upload Test", gtk_runs=gtk_runs)
+            super().__init__(session=session, title="Upload Test", gtk_runs=gtk_runs, help=help)
             self.init_window()
 
     def init_window(self):
@@ -118,7 +118,7 @@ class UploadTest(dbGtkUtils.ITkDBWindow):
         # Prepare HeaderBar
         self.hb.props.title = "Upload Tests"
 
-        # Active buttin in header
+        # Active button in header
         button = Gtk.Button()
         icon = Gio.ThemedIcon(name="document-send-symbolic")
         image = Gtk.Image.new_from_gicon(icon, Gtk.IconSize.BUTTON)
@@ -353,7 +353,9 @@ class UploadTest(dbGtkUtils.ITkDBWindow):
 
     def find_attachments(self):
         """Find Attachments in payload."""
-        self.attachments = []
+        # We used to clean the attachmetns, but this would remove the ones given
+        # in the contructor.
+        # self.attachments = []
         if "attachments" in self.data:
             for A in self.data["attachments"]:
                 if not Path(A["path"]).exists():

itkdb_gtk/__init__.py

@@ -1,4 +1,6 @@
-__version__ = "0.9.0"
+""" itkdb-gtk python module
+"""
+__version__ = "0.10.0"
 
 
 def dash_board():
@@ -19,9 +21,9 @@ def glueWeight():
     main()
 
 
-def groundVITests():
+def petalReceptionTests():
     """GND/VI tests."""
-    from .GroundVITests import main
+    from .PetalReceptionTests import main
     main()