itkdb-gtk 0.0.12__py3-none-any.whl → 0.0.16__py3-none-any.whl

itkdb_gtk/__init__.py

@@ -1,16 +1,15 @@
-from . import dashBoard
-
-__version__ = "0.0.12"
+__version__ = "0.0.16"
 
 
 def dash_board():
     """Launches the dash board."""
+    from .dashBoard import main
     dashBoard.main()
 
 
 def getShipments():
     """getShipments."""
-    from .getShipments import main
+    from .GetShipments import main
     main()
 
 
@@ -20,25 +19,34 @@ def glueWeight():
     main()
 
 
-def gndVITests():
+def groundVITests():
     """GND/VI tests."""
-    from .gndVITests import main
+    from .GroundVITests import main
     main()
 
 
 def sendShipments():
     """Send items."""
-    from .sendShipments import main
+    from .SendShipments import main
     main()
 
-
 def uploadTest():
-    """Upload tests."""
-    from .uploadTest import main
+    """Upload a single tests."""
+    from .UploadTest import main
     main()
 
 
 def uploadMultipleTests():
     """Upload multiple tests."""
-    from .uploadMultipleTests import main
+    from .UploadMultipleTests import main
+    main()
+
+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

@@ -3,16 +3,23 @@
 import sys
 
 try:
-    import dbGtkUtils
-    import getShipments
-    import groundingTest
-    import ITkDBlogin
-    import sendShipments
-    import uploadMultipleTests
-    import GlueWeight
-
-except Exception:
-    from itkdb_gtk import dbGtkUtils, getShipments, groundingTest, ITkDBlogin, sendShipments, uploadMultipleTests, GlueWeight
+    import itkdb_gtk
+    
+except ImportError:
+    from pathlib import Path
+    cwd = Path(sys.argv[0]).parent.parent
+    sys.path.append(cwd.as_posix())
+    
+    
+from itkdb_gtk import dbGtkUtils
+from itkdb_gtk import GetShipments
+from itkdb_gtk import GroundVITests
+from itkdb_gtk import ITkDBlogin
+from itkdb_gtk import SendShipments
+from itkdb_gtk import UploadMultipleTests
+from itkdb_gtk import GlueWeight
+from itkdb_gtk import UploadModuleIV
+from itkdb_gtk import WireBondGui
 
 import gi
 
@@ -22,7 +29,14 @@ 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
+    WIRE_BOND = 7
+    
     def __init__(self, session):
         """Initialization."""
         super().__init__(title="ITkDB Dashboard", session=session)
@@ -59,6 +73,17 @@ 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
+        btnWireBond = Gtk.Button(label="Wire Bond")
+        btnWireBond.connect("clicked", self.wire_bond)
+        grid.attach(btnWireBond, 0, irow, 1, 1)
+
+
+
         irow += 1
         grid.attach(Gtk.Label(), 0, irow, 1, 1)
 
@@ -83,51 +108,51 @@ 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
 
         self.mask |= bt
-        W = uploadMultipleTests.UploadMultipleTests(self.session)
+        W = UploadMultipleTests.UploadMultipleTests(self.session)
         W.connect("destroy", self.app_closed, bitn)
 
     def create_shipment(self, *args):
         """Launch sendShipment."""
-        bitn = 2
+        bitn = DashWindow.CREATE_SHIPMNT
         bt = 1 << bitn
         if self.mask & bt:
             return
 
         self.mask |= bt
-        W = sendShipments.SendShipments(self.session)
+        W = SendShipments.SendShipments(self.session)
         W.connect("destroy", self.app_closed, bitn)
 
     def receive_shipment(self, *args):
         """Launch getShipments."""
-        bitn = 3
+        bitn = DashWindow.RECV_SHIPMNT
         bt = 1 << bitn
         if self.mask & bt:
             return
 
         self.mask |= bt
-        W = getShipments.ReceiveShipments(self.session)
+        W = GetShipments.ReceiveShipments(self.session)
         W.connect("destroy", self.app_closed, bitn)
 
     def petal_gnd(self, *args):
         """Petal GND/VI test."""
-        bitn = 4
+        bitn = DashWindow.PETAL_GND
         bt = 1 << bitn
         if self.mask & bt:
             return
 
         self.mask |= bt
-        W = groundingTest.GroundingTest(self.session)
+        W = GroundVITests.GroundingTest(self.session)
         W.connect("destroy", self.app_closed, bitn)
 
     def glue_weight(self, *args):
         """Glue Weight test."""
-        bitn = 5
+        bitn = DashWindow.GLUE_WEIGHT
         bt = 1 << bitn
         if self.mask & bt:
             return
@@ -136,11 +161,33 @@ 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 = UploadModuleIV.IVwindow(self.session)
+        W.connect("destroy", self.app_closed, bitn)
+
+    def wire_bond(self, *args):
+        """Module IV tests."""
+        bitn = DashWindow.WIRE_BOND
+        bt = 1 << bitn
+        if self.mask & bt:
+            return
+
+        self.mask |= bt
+        W = WireBondGui.WireBond(session=self.session, title="Wirebond")
+        W.connect("destroy", self.app_closed, bitn)
+
     def app_closed(self, *args):
         """Application window closed. Clear mask."""
         bt = 1 << args[1]
         self.mask &= ~bt
-        print(bt, self.mask)
+        # print(bt, self.mask)
 
 
 def main():

itkdb_gtk/dbGtkUtils.py

@@ -7,33 +7,72 @@ 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
+from gi.repository import Gtk, GObject, Gio, GLib
 
+def parse_date(txt):
+    """Parse a date."""
+    try:
+        return dateutil.parser.parse(txt, fuzzy=False)
 
-def set_combo_iter(combo, txt, col=0):
-    """Set scombo active iter to that containing txt in column col."""
-    model = combo.get_model()
-    iter = model.get_iter_first()
-    while iter:
-        val = model.get_value(iter, col)
-        if val == txt:
-            combo.set_active_iter(iter)
-            break
+    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
 
-        iter = model.iter_next(iter)
+    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."""
+    try:
+        dateutil.parser.parse(txt, fuzzy=False)
+        return True
 
+    except Exception:
+        return False
+
+def new_small_text_entry():
+    """Returs a new, smaller Gtk.Entry."""
+    entry = Gtk.Entry()
+    provider = Gtk.CssProvider()
+    style_context = entry.get_style_context()
+    font_size = 2.25*style_context.get_property("font-size", 0)
+    css = "entry {{ min-height: {}px; }}".format(font_size)
+    provider.load_from_data(css.encode())
+    style_context.add_provider(provider, Gtk.STYLE_PROVIDER_PRIORITY_SETTINGS)
+    return entry
 
 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)
+    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()
+    iter = model.get_iter_first()
+    while iter:
+        val = model.get_value(iter, col)
+        if val == txt:
+            combo.set_active_iter(iter)
+            break
+
+        iter = model.iter_next(iter)
 
 
 def is_iterable(obj):
@@ -55,6 +94,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)
 
@@ -138,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()
@@ -156,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:
@@ -170,6 +242,13 @@ class TextEntry(object):
         else:
             return self.entry.get_text()
 
+    def set_text(self, text):
+        """Sets text."""
+        if self.nlines > 1:
+            self.entry.get_buffer().set_text(text)
+        else:
+            self.entry.set_text(text)
+
 
 def get_a_value(main_title, second_text=None, is_tv=False, parent=None):
     """Open a dialog to get a value.
@@ -216,7 +295,7 @@ def get_a_value(main_title, second_text=None, is_tv=False, parent=None):
     return out
 
 
-def get_a_list_of_values(main_title, labels, second_text=None, parent=None):
+def get_a_list_of_values(main_title, labels, defaults=None, second_text=None, parent=None):
     """Get a list of values.
 
     Args:
@@ -224,6 +303,7 @@ def get_a_list_of_values(main_title, labels, second_text=None, parent=None):
         main_title: Main title for window
         labels: List of labes to get the values. If the label ends with /v
                 then a TextView will be shown instead of a TextEntry.
+        defaults (optional): default values-
         second_text (optional): Second title for window-. Defaults to None.
 
     Returns
@@ -252,7 +332,7 @@ def get_a_list_of_values(main_title, labels, second_text=None, parent=None):
     is_text_view = []
     vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
     area.pack_start(vbox, False, True, 0)
-    for txt in labels:
+    for i, txt in enumerate(labels):
         use_tv = False
         if txt.endswith("/v"):
             is_text_view.append(True)
@@ -266,6 +346,11 @@ def get_a_list_of_values(main_title, labels, second_text=None, parent=None):
         vbox.pack_start(lbl, False, False, 0)
 
         entry = TextEntry(3 if use_tv else -1)
+        try:
+            entry.set_text(defaults[i])
+        except Exception:
+            pass
+
         vbox.pack_start(entry.widget, False, False, 0)
         entries.append(entry)
 
@@ -301,11 +386,70 @@ def add_button_to_container(box, label, tooltip=None, callback=None):
 
     box.pack_start(btn, True, False, 0)
 
+    return btn
+
+
+class MessagePanel(object):
+    """Encapsulates a TExtView object to show messages."""
+
+    def __init__(self, size=100):
+        """Initializarion."""
+        self.frame = None
+        self.text_view = Gtk.TextView()
+        self.textbuffer = self.text_view.get_buffer()
+
+        self.__create_message_panel(size)
+
+
+    def __create_message_panel(self, size):
+        """Creates a message panel within a frame.
+
+        Args:
+            size: size of the panel
+
+        Returns
+            Gtk.TextBuffer, Gtk.Frame
+        """
+        frame = Gtk.Frame()
+        frame.set_shadow_type(Gtk.ShadowType.IN)
+
+        box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
+        box.set_size_request(-1, size)
+        frame.add(box)
+
+        # The title for the tet view
+        box.pack_start(Gtk.Label(label="Messages"), False, True, 0)
+
+        # A scroll window with the text view
+        scrolled = Gtk.ScrolledWindow()
+        scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
+        scrolled.add(self.text_view)
+        box.pack_start(scrolled, True, True, 0)
+        self.frame = frame
+
+    def scroll_to_end(self):
+        """Scrolls text view to end."""
+        end = self.textbuffer.get_end_iter()
+        self.text_view.scroll_to_iter(end, 0, False, 0, 0)
+
+    def write_message(self, text):
+        """Writes text to Text Viewer."""
+        nlines = self.textbuffer.get_line_count()
+        if nlines > 100:
+            start = self.textbuffer.get_iter_at_line(0)
+            end = self.textbuffer.get_iter_at_line(75)
+            self.textbuffer.delete(start, end)
+
+        end = self.textbuffer.get_end_iter()
+        msg = "[{}]  {}".format(time.strftime("%d/%m/%y %T"), text)
+        self.textbuffer.insert(end, msg)
+        GLib.idle_add(self.scroll_to_end)
+
 
 class ITkDBWindow(Gtk.Window):
     """Base class for GUI main windows."""
 
-    def __init__(self, title="", session=None, show_search=None, gtk_runs=True):
+    def __init__(self, title="", session=None, show_search=None, gtk_runs=True, panel_size=100):
         """Initialization.
 
         Args:
@@ -321,12 +465,13 @@ class ITkDBWindow(Gtk.Window):
         self.session = session
         self.inst2code = {}
         self.code2inst = {}
+        self.message_panel = None
 
         if gtk_runs:
             super().__init__(title=title)
-            self.prepare_window(show_search)
+            self.prepare_window(show_search, panel_size)
 
-    def prepare_window(self, show_search):
+    def prepare_window(self, show_search, panel_size):
         """Inititalizes GUI."""
         # Prepare HeaderBar
         self.hb = Gtk.HeaderBar()
@@ -351,11 +496,13 @@ 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
-        self.text_view = Gtk.TextView()
-        self.textbuffer = self.text_view.get_buffer()
+        self.message_panel = MessagePanel(size=panel_size)
 
         # The button box
         btnBox = Gtk.ButtonBox(orientation=Gtk.Orientation.HORIZONTAL)
@@ -378,7 +525,8 @@ class ITkDBWindow(Gtk.Window):
     def new_login(self, obj, msg):
         """A new user logged in."""
         if msg == "<OK>":
-            self.session = self.session.user_gui.get_client()
+            if hasattr(self.session, "user_gui"):
+                self.session = self.session.user_gui.get_client()
             self.userLabel.get_child().set_text(self.session.user.name)
 
         else:
@@ -450,29 +598,15 @@ class ITkDBWindow(Gtk.Window):
 
         return frame
 
-    def scroll_to_end(self):
-        """Scrolls text view to end."""
-        end = self.textbuffer.get_end_iter()
-        self.text_view.scroll_to_iter(end, 0, False, 0, 0)
-
     def write_message(self, text):
         """Writes text to Text Viewer."""
-        nlines = self.textbuffer.get_line_count()
-        if nlines > 100:
-            start = self.textbuffer.get_iter_at_line(0)
-            end = self.textbuffer.get_iter_at_line(75)
-            self.textbuffer.delete(start, end)
-
-        end = self.textbuffer.get_end_iter()
-        msg = "[{}]  {}".format(time.strftime("%d/%m/%y %T"), text)
-        self.textbuffer.insert(end, msg)
-        GLib.idle_add(self.scroll_to_end)
+        self.message_panel.write_message(text)
 
 
 class DictDialog(Gtk.Grid):
     """Creates a dialog to show and edit variables in a JSon dict."""
 
-    def __init__(self, values, hidden_keys={}):
+    def __init__(self, values, hidden_keys=None):
         """Create the Gtk.Grid.
 
         Args:
@@ -484,12 +618,18 @@ class DictDialog(Gtk.Grid):
         super().__init__(column_spacing=5, row_spacing=1)
 
         self.set_border_width(10)
+        self.factory = deepcopy(values)
         self.values = deepcopy(values)
         self.keys = {}
         self.containers = {}
-        self.hidden_keys = hidden_keys
+        self.hidden_keys = hidden_keys if hidden_keys else {}
         self.show_values()
 
+    def factory_reset(self):
+        """Set values to original values."""
+        self.values = deepcopy(self.factory)
+        self.refresh()
+
     def on_enter(self, entry, *args):
         """Get the value when we first enter into the Entry."""
         self.keys[args[2]] = entry.get_text()
@@ -519,6 +659,15 @@ class DictDialog(Gtk.Grid):
             elif isinstance(itm[last_key], datetime):
                 itm[last_key] = dateutil.parser.parse(txt)
 
+            elif is_a_date(itm[last_key]):
+                D = dateutil.parser.parse(txt)
+                out = D.isoformat(timespec='milliseconds')
+                if out[-1] not in ['zZ']:
+                    out += 'Z'
+
+                itm[last_key] = out
+                self.containers[name].set_text(out)
+
             else:
                 tp = type(itm[last_key])
                 itm[last_key] = tp(txt)

itkdb_gtk/readAVSdata.py

@@ -5,10 +5,14 @@ from argparse import ArgumentParser
 from pathlib import Path
 
 try:
-    import ITkDBlogin
-    import ITkDButils
-except ModuleNotFoundError:
-    from itkdb_gtk import ITkDBlogin, ITkDButils
+    import itkdb_gtk
+    
+except ImportError:
+    from pathlib import Path
+    cwd = Path(sys.argv[0]).parent.parent
+    sys.path.append(cwd.as_posix())
+
+from itkdb_gtk import ITkDBlogin, ITkDButils
 
 import dateutil.parser
 import openpyxl as XL

itkdb_gtk/readGoogleSheet.py

@@ -13,7 +13,7 @@ SCOPES = ['https://www.googleapis.com/auth/spreadsheets.readonly']
 
 
 # Get spreadsheet ID from share link
-re_sheet_id = re.compile(r"https://docs.google.com/spreadsheets/d/(?P<ID>\w+)", re.DOTALL)
+re_sheet_id = re.compile(r"https://docs.google.com/spreadsheets/d/(?P<ID>[\w-]+)", re.DOTALL)
 
 
 def get_spreadsheet_service():

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))