a2p2 0.2.15__py3-none-any.whl → 0.7.4__py3-none-any.whl

a2p2/vlti/gui.py

@@ -4,27 +4,25 @@ __all__ = []
 
 import sys
 import logging
+from turtle import bgcolor
 
 from a2p2.gui import FacilityUI
 
-if sys.version_info[0] == 2:
-    from Tkinter import *
-    from tkMessageBox import *
-    import ttk
-else:
-    from tkinter import *
-    from tkinter.messagebox import *
-    import tkinter.ttk as ttk
+from tkinter import ttk
+from tkinter import *
+from tkinter.ttk import *
 
 logger = logging.getLogger(__name__)
 
+
 class VltiUI(FacilityUI):
 
     def __init__(self, a2p2client):
         logger.info("init VltiUI")
         FacilityUI.__init__(self, a2p2client)
 
-        self.container = Frame(self, bd=3, relief=SUNKEN)
+        #self.container = Frame(self, bd=3, relief=SUNKEN)
+        self.container = Frame(self, relief=SUNKEN)
         self.container.grid_rowconfigure(0, weight=1)
         self.container.grid_columnconfigure(0, weight=1)
 
@@ -39,25 +37,32 @@ class VltiUI(FacilityUI):
         self.treeItemToRuns = {}
         self.treeItemToP2Items = {}
 
-        self.ob=None
+        self.ob = None
 
     def showLoginFrame(self, ob):
         self.ob = ob
         self.addToLog(
-            "Sorry, your %s OB can't be submitted, please log in first, select container and send OB again from Aspro2." %
+            "Sorry, your %s OB can't be submitted, please log in first, select container and press submit button." %
             (ob.instrumentConfiguration.name))
         self.loginFrame.tkraise()
 
+    def isBusy(self):
+        self.tree.configure(selectmode='none')
+
+    def isIdle(self):
+        self.tree.configure(selectmode='browse')
+
     def showTreeFrame(self, ob=None):
         if ob:
             instrum = ob.instrumentConfiguration.name
         else:
             instrum = "incoming"
-        self.addToLog("Please select a runId in ESO P2 database to process %s OB" % instrum )
+        self.addToLog(
+            "Please select a runId in ESO P2 database to process %s OB" % instrum)
         self.treeFrame.tkraise()
 
     def fillTree(self, runs):
-        logger.debug("Start filling tree")
+        logger.debug(f"Start filling tree with {len(runs)} runs")
         if len(runs) == 0:
             self.ShowErrorMessage(
                 "No Runs defined, impossible to program ESO's P2 interface.")
@@ -74,24 +79,31 @@ class VltiUI(FacilityUI):
             if self.facility.hasSupportedInsname(run['instrument']):
                 cid = run['containerId']
                 self._insertInTree('', run['progId'], cid, run, run)
-                # if folders, add them recursively
-                folders = getFolders(self.facility.api, cid)
-                if len(folders) > 0:
-                    try:
-                        self.folder_explore(folders, cid, run)
-                    except:
-                        pass
-
-    def folder_explore(self, folders, contid, run):
-        for folder in folders:
-            self._insertInTree(
-                contid, folder['name'], folder['containerId'], run, folder)
-            folders2 = getFolders(self.facility.api, folder['containerId'])
-            if len(folders2) > 0:
-                try:
-                    self.folder_explore(folders2, folder['containerId'], run)
-                except:
-                    pass
+
+    def updateTree(self, run, containerId):
+        logger.debug(
+            f"updateTree with run : {run}\n and containerId: {containerId}")
+        items, _ = self.facility.api.getItems(containerId)
+        logger.debug(f"sub items are {items}")
+        logger.debug(f"item keys in tree: {self.treeItemToP2Items.keys()}")
+        for item in items:
+            if item['itemType'] in ['Folder', 'Concatenation', 'Group']:
+                if str(item['containerId']) in self.treeItemToP2Items.keys():
+                    logger.debug(f"Item {item['containerId']} already in tree")
+                else:
+                    logger.debug(f"adding in tree : {item}")
+                    self._insertInTree(
+                        containerId, item['name'], item['containerId'], run, item)
+            else:
+                logger.debug(f"not inserted in tree : {item}")
+        # TODO get children of our tree and remove part non present in items
+
+    def selectTreeItem(self, containerId):
+        item = str(containerId)
+        self.tree.selection_set(item)
+        self.tree.see(item)
+        self.facility.containerInfo.store(
+            self.treeItemToRuns[item], self.treeItemToP2Items[item])
 
     def _insertInTree(self, parentContainerID, name, containerID, run, item):
         instrument = run['instrument']
@@ -110,18 +122,47 @@ class VltiUI(FacilityUI):
         self.treeItemToRuns[e] = run
         self.treeItemToP2Items[e] = item
 
+        # add a dummy child so we can show to the user he has to walk into the tree
+        if run['itemCount'] > 0:
+            self.tree.insert(containerID, 'end',
+                             f"{containerID}_fillme", values=[])
+        # return new tree item
+        return e
+
     def on_tree_selection_changed(self, selection):
+        logger.debug(f"tree selection change: {selection}")
         curItem = self.tree.focus()
         ret = self.tree.item(curItem)
         if len(ret['values']) > 0:
             self.facility.containerInfo.store(
                 self.treeItemToRuns[curItem], self.treeItemToP2Items[curItem])
+            self.facility.tryLastOB()
 
-    def isBusy(self):
-        self.tree.configure(selectmode='none')
+    def on_tree_open(self, selection):
+        logger.debug(f"tree open: {selection}")
+        curItem = self.tree.focus()
+        curChildren = self.tree.get_children(curItem)
+        firstChild = curChildren[0]
+        if not firstChild in self.treeItemToRuns.keys():
+            self.tree.delete(firstChild)
+
+            parentRun = self.treeItemToRuns[curItem]
+            parentContainer = self.treeItemToP2Items[curItem]
+            parentContainerID = parentContainer['containerId']
+            self.updateTree(parentRun, parentContainerID)
+
+    def showOBConfirmationButtons(self, ob=None, showAcqButtons=False):
+        if not (ob):
+            self.treeFrame.enable_buttons(False, showAcqButtons)
+            return
+        else:
+            self.treeFrame.enable_buttons(True, showAcqButtons)
 
-    def isIdle(self):
-        self.tree.configure(selectmode='browse')
+    def getIssVltitypeVars(self):
+        return self.treeFrame.issVltiTypeCheckboxesVars
+
+    def getAcquisitionType(self):
+        return self.treeFrame.acquisitionType.get()
 
 
 class TreeFrame(Frame):
@@ -129,22 +170,24 @@ class TreeFrame(Frame):
     def __init__(self, vltiUI):
         Frame.__init__(self, vltiUI.container)
         self.vltiUI = vltiUI
-
         subframe = Frame(self)
 
+        treeframe = Frame(subframe)
         self.tree = ttk.Treeview(
-            subframe, columns=('Project ID'))  # , 'instrument'))#, 'folder ID'))
+            treeframe, columns=('Project ID'), selectmode='browse')  # , 'instrument'))#, 'folder ID'))
         ysb = ttk.Scrollbar(
-            subframe, orient='vertical', command=self.tree.yview)
+            treeframe, orient='vertical', command=self.tree.yview)
         xsb = ttk.Scrollbar(
-            subframe, orient='horizontal', command=self.tree.xview)
+            treeframe, orient='horizontal', command=self.tree.xview)
 
         self.tree.configure(yscroll=ysb.set, xscroll=xsb.set)
         self.tree.heading('#0', text='Project ID', anchor='w')
         self.tree.heading('#1', text='Instrument', anchor='w')
         self.tree.heading('#2', text='Container type', anchor='w')
         self.tree.bind(
-            '<ButtonRelease-1>', self.vltiUI.on_tree_selection_changed)
+            '<<TreeviewOpen>>', self.vltiUI.on_tree_open)
+        self.tree.bind(
+            '<<TreeviewSelect>>', self.vltiUI.on_tree_selection_changed)
 
         # grid layout does not expand and fill all area then move to pack
         #       self.tree.grid(row=0, column=0, sticky='nsew')
@@ -154,9 +197,88 @@ class TreeFrame(Frame):
         ysb.pack(side=RIGHT, fill="y")
         # xsb.pack(side=BOTTOM, fill="y") # will probably require to add
         # another 2 frames
+        treeframe.pack(side=TOP, fill=BOTH, expand=True)
+
+        # Control button Panel to abort /submit or provide more information to the current OB
+        buttonframe = Frame(subframe)
+
+        cindex = 0
+
+
+        acquisitionFrame = Frame(buttonframe)
+
+        self.acquisitionType = StringVar()
+        self.acquisitionType.set("onaxis") # initialiser
+        self.r1 = Radiobutton(acquisitionFrame, text="onaxis", variable=self.acquisitionType, value="onaxis")
+        self.r2 = Radiobutton(acquisitionFrame, text="offaxis", variable=self.acquisitionType, value="offaxis")
+        self.r3 = Radiobutton(acquisitionFrame, text="wide", variable=self.acquisitionType, value="wide")
+
+        acquisitionFrame.grid(row=0, column=cindex)
+        cindex += 1
+
+
+        label = Label(buttonframe, text="|")
+        label.grid(row=0, column=cindex)
+        cindex += 1
+
+        psection = "p2.iss.vltitype"
+        pvltitypes = self.vltiUI.facility.a2p2client.preferences.getConfigKeys(
+            psection)
+
+        self.issVltiTypeCheckboxesVars = {}
+        for isvt in self.vltiUI.facility.getIssVltiTypes():
+            boolv = BooleanVar()
+            self.issVltiTypeCheckboxesVars[isvt]=boolv
+            boolv.set( not pvltitypes or len(pvltitypes)==0 or isvt in pvltitypes )
+            logger.debug(f"Set preference value for {isvt} : {boolv.get()}")
+            cb = Checkbutton(buttonframe, text=isvt, variable=boolv, onvalue=True, offvalue=False)
+            cb.grid(row=0, column=cindex)
+            cindex += 1
+
+        self.abortButton = Button(buttonframe, text="Abort this OB",
+                                  command=self.on_abortbutton_clicked, state=DISABLED)
+        style = ttk.Style()
+        sButtonStyle="Custom.TButton"
+        ttk.Style().configure(sButtonStyle, background="green")
+        self.submitButton = Button(
+            buttonframe, text="Submit", command=self.on_submitbutton_clicked, state=DISABLED,
+            style=sButtonStyle)
+        self.abortButton.grid(row=0, column=cindex)
+        cindex += 1
+        self.submitButton.grid(row=0, column=cindex)
+        buttonframe.pack(side=RIGHT)
 
         subframe.pack(side=TOP, fill=BOTH, expand=True)
 
+    def enable_buttons(self, enableActions, showAcqButtons=False):
+        if showAcqButtons and enableActions:
+            self.r1.pack(side=LEFT)
+            self.r2.pack(side=LEFT)
+            self.r3.pack(side=LEFT)
+        else:
+            self.r1.pack_forget()
+            self.r2.pack_forget()
+            self.r3.pack_forget()
+
+        if enableActions:
+            flag = NORMAL
+        else:
+            flag = DISABLED
+        self.submitButton["state"] = flag
+        self.abortButton["state"] = flag
+
+        # leave abort button always active to let user remove in case of error
+        if self.vltiUI.facility.hasOB():
+            self.abortButton["state"] = NORMAL
+
+    def on_submitbutton_clicked(self):
+        self.vltiUI.facility.popOB()
+        self.enable_buttons(False)
+
+    def on_abortbutton_clicked(self):
+        self.vltiUI.facility.popOB(ignore=True)
+        self.enable_buttons(False)
+
 
 class LoginFrame(Frame):