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

a2p2/vlti/facility.py

@@ -3,9 +3,12 @@
 __all__ = []
 
 import os
+from tkinter.constants import TRUE
 import traceback
 import logging
+import re
 
+import p2api
 
 from a2p2.facility import Facility
 from a2p2.vlti.gui import VltiUI
@@ -80,53 +83,142 @@ class VltiFacility(Facility):
         self.username = None
         self.api = None
 
+        # store ob to insert after container selection if not done previously
+        self.ob_to_confirm=[]
+        self.ob_to_submit=[]
+
+
     def getName():
         return "VLTI"
 
     def autologin(self):
+        self.ui.addToLog("\nAutologin into P2 API please wait...\n")
         self.ui.loginFrame.on_loginbutton_clicked()
         self.a2p2client.ui.showFacilityUI(self.ui)
         self.ui.showTreeFrame()
 
     def processOB(self, ob):
+        # process last accepted OB if ob is None
+        if not ob:
+            self.processLastAcceptedOB()
+            return
+
         # give focus on last updated UI
         self.a2p2client.ui.showFacilityUI(self.ui)
         # show ob dict for debug
         self.ui.addToLog(str(ob), False)
 
         # OB is checked and submitted by instrument
+        period = ob.getPeriod()
+        self.ui.addToLog(f"Request received for OB creation for P{period} - please press Submit or Abort button")
+
+        # always stores OB and pop them if everything is ok or later selecting containers in the tree
+        self.pushOB(ob)
+        self.tryLastOB()
+
+    def tryLastOB(self):
+        self.showOBConfirmationButtons()
+        # stop if no ob has to be handled
+        if not self.hasOB():
+            return
+
+        ob = self.ob_to_confirm[-1]
+        # run checkOB which may raise some error before connection request
+        # TODO we should test much more because lot of stuff still are beeing processed on live ob creations
+
+        period = ob.getPeriod()
         instrument = self.getInstrument(ob.instrumentConfiguration.name)
-        try:
-            # run checkOB which may raise some error before connection request
-            instrument.checkOB(ob)
-
-            insname = instrument.getShortName()
-
-            # performs operation
-            if not self.isConnected():
-                self.ui.showLoginFrame(ob)
-            elif not self.isReadyToSubmit():
-                # self.a2p2client.ui.addToLog("Receive OB for
-                # '"+ob.instrumentConfiguration.name+"'")
-                self.ui.addToLog(
-                    "Please select a folder (not a concatenation) in the above list. OBs are not shown")
-            elif  insname.lower() != self.containerInfo.getInstrument().lower():
-                self.ui.ShowErrorMessage("Aborting: container's instrument '%s' in not applicable for received OB's one '%s'." %(self.containerInfo.getInstrument(),insname))
-            else:
-                self.ui.addToLog(
-                    "everything ready! Request OB creation inside selected container ")
-                instrument.submitOB(ob, self.containerInfo)
-                self.refreshTree()
+        insname = instrument.getShortName()
+
+        # performs operation
+        if not self.isConnected():
+            self.ui.showLoginFrame(ob)
+        elif not self.isReadyToSubmit(ob):
+            # self.a2p2client.ui.addToLog("Receive OB for
+            # '"+ob.instrumentConfiguration.name+"'")
+            self.ui.addToLog(
+                f"Selected folder must not be a concatenation. please choose another container for '{insname}' P'{period}'.")
+        elif  insname.lower() != self.containerInfo.getInstrument().lower():
+            self.ui.addToLog(
+                f"'{self.containerInfo.getInstrument()}' selection in not applicable for received OB. Please choose another one for '{insname}' P'{period}'.")
+        elif  period != int(self.containerInfo.getIpVersion()):
+            self.ui.addToLog(
+                f"Container's IpVersion '{int(self.containerInfo.getIpVersion())}' is not applicable for received OB's one '{period}', please select another '{insname}' container or change it in Aspro2.")
+        else:
+            self.showOBConfirmationButtons(ob, insname=="GRAVITY")
+
+    def showOBConfirmationButtons(self, ob=None, showAcqButtons=False):
+        self.ui.showOBConfirmationButtons(ob, showAcqButtons)
+
+    def isReadyToSubmit(self, ob):
+        return self.api and self.containerInfo.isOk(ob)
+
+    def isConnected(self):
+        return self.connected
+
+    def setConnected(self, flag):
+        self.connected = flag
+
+    def pushOB(self,ob):
+        self.ob_to_confirm.append(ob)
+
+    def hasOB(self):
+        return len(self.ob_to_confirm)>0
+
+    def popOB(self, ignore=False):
+        """ Called as last step : ob is for the selected container and User click on submit!
+        If ignore is set to True, last ob is simply removed else it is forwarded to P2 and removed from stack. """
+
+        if not self.hasOB():
+            return
+
+        # pop last OB
+        o = self.ob_to_confirm.pop()
+        self.showOBConfirmationButtons()
+
+        if ignore:
+            self.ui.addToLog("Last received OB has been aborted")
+            return
+        else:
+            self.ob_to_submit.append(o)
+
+    def processLastAcceptedOB(self):
+        if len(self.ob_to_submit)==0:
+            return
 
-        # TODO add P2Error handling P2Error(r.status_code, method, url,
-        # r.json()['error'])
+        o=self.ob_to_submit.pop()
+        try:
+            instrument = self.getInstrument(o.instrumentConfiguration.name)
+            instrument.checkOB(o)
+            # check for warnings and abort if requested by user
+            # this implementation should be more detailled so we can have various VERSION associated to various warning
+            if len(instrument.warnings)>0:
+                linesep="\n  -  "
+                header=""
+                try:
+                    # some ditTable may have a VERSION entry some not...
+                    version=instrument.getDitTable()["VERSION"]
+                    header= f"According to the template manual {version} :\n \n  - \n"
+                except:
+                    pass
+                answer = self.ui.AskYesNoMessage(f"{header} {linesep.join(instrument.warnings)}\n\nClick \"Yes\" to proceed \"No\" to abort the submission")
+                instrument.warnings.clear()
+                if answer == False:
+                    self.ui.addToLog("Submission has been marked to be aborted - do not proceed")
+                    return
+
+            self.ui.addToLog("Everything ready! Request OB creation inside selected container")
+            instrument.submitOB(o, self.containerInfo)
+
+            # TODO add P2Error handling P2Error(r.status_code, method, url,
+            # r.json()['error'])
         except ValueError as e:
             traceback.print_exc()
             trace = traceback.format_exc(limit=1)
             # ui.ShowErrorMessage("Value error :\n %s \n%s\n\n%s" % (e, trace,
             # "Aborting submission to P2. Look at the whole traceback in the log."))
             self.ui.ShowErrorMessage("Value error :\n %s \n\n%s" %
-                                     (e, "Aborting submission to P2. Please check LOG and fix before new submission."))
+                                    (e, "Aborting submission to P2. Please check LOG and fix before new submission."))
             trace = traceback.format_exc()
             self.ui.addToLog(trace, False)
             self.ui.setProgress(0)
@@ -141,28 +233,23 @@ class VltiFacility(Facility):
             self.ui.addToLog(trace, False)
             self.ui.setProgress(0)
 
-    def isReadyToSubmit(self):
-        return self.api and self.containerInfo.isOk()
-
-    def isConnected(self):
-        return self.connected
-
-    def setConnected(self, flag):
-        self.connected = flag
-
     def getStatus(self):
+        ob_info=""
+        if self.hasOB():
+            ob_info=f" / {len(self.ob_to_confirm)} OB in stack"
         if self.isConnected():
-            return " P2API connected with " + self.username
+            return f" P2API({self.apitype}) connected with {self.username} { ob_info }"
 
     def connectAPI(self, username, password, ob):
-        if username == TUTORIAL_LOGIN or username == JMMC_LOGIN:
+        if username == TUTORIAL_LOGIN: # or username == JMMC_LOGIN:
             self.apitype = DEMO_APITYPE
         else:
             self.apitype = PRODUCTION_APITYPE
         try:
-            logger.info("Connecting to p2 api(%s).."%self.apitype)
-            self.api = P2ApiConnectionWrapper(self.apitype, username, password)
-            logger.info("Connected to p2 api")
+            logger.info("Connecting to p2 api...")
+            self.api = p2api.ApiConnection(self.apitype, username, password)
+
+            self.ui.addToLog("Connected to p2 api (%s)"%self.apitype)
             # TODO test that api is ok and handle error if any...
 
             self.refreshTree()
@@ -194,6 +281,10 @@ class VltiFacility(Facility):
         """
         return CONFDIR
 
+    def getIssVltiTypes(self):
+        return ['snapshot','imaging','time-series','astrometry']
+
+
 
 # TODO Move code out of this class
 
@@ -219,23 +310,46 @@ class P2Container:
         self.containerId = item['containerId']
         self.log()
 
+    def reset(self):
+        self.run = None  # dict returned by p2api
+        self.containerId = None
+        self.item = None
+
     def log(self):
+        logmsg = f"*** Working with {self} ***"
         if self.run != self.item and self.item['itemType'] == ITEMTYPE_CONCATENATION:
+            self.reset()
             self.facility.ui.addToLog(
-                "*** Please do not select a Concatenation and select another container. ***")
+                "*** Please do not select a Concatenation and select another container. Or just append a calibrator. ***", )
+            logger.info(logmsg)
         else:
-            self.facility.ui.addToLog("*** Working with %s ***" % self)
+            self.facility.ui.addToLog(logmsg)
 
-    def isOk(self):
+    def isOk(self, ob):
+        """ Tell if given container is ready to receive content of given OB."""
         if self.run == None:
             return False
         if self.run == self.item:
             return True
-        return self.item['itemType'] != ITEMTYPE_CONCATENATION
+
+        has_calib = False
+        has_science = False
+        for obsConf in ob.observationConfiguration:
+            if 'SCIENCE' in obsConf.type:
+                has_science = True
+            else:
+                has_calib = True
+
+        if has_science:
+            return self.item['itemType'] != ITEMTYPE_CONCATENATION
+        return has_calib
 
     def getInstrument(self):
         return self.run['instrument']
 
+    def getIpVersion(self):
+        return self.run['ipVersion']
+
     def isRoot(self):
         return self.item.keys() != None and 'pi' in self.item.keys()
 
@@ -244,79 +358,3 @@ class P2Container:
 
     def __str__(self):
         return """instrument:'%s', containerId:'%s'""" % (self.run['instrument'], self.containerId)
-
-
-# Add wrapper to wrapp p2api/requsts code and enhance
-import p2api
-from p2api import P2Error
-import json
-
-import requests
-from requests.adapters import HTTPAdapter
-from urllib3.util.retry import Retry
-#  Retry Handling for requests
-# See https://www.peterbe.com/plog/best-practice-with-retries-with-requests
-# Or https://findwork.dev/blog/advanced-usage-python-requests-timeouts-retries-hooks/
-def requests_retry_session(
-        retries=3,
-        backoff_factor=1.0,
-        status_forcelist=(500, 502, 504)):
-
-    adapter = HTTPAdapter()
-    adapter.max_retries = Retry(
-        total=retries,
-        read=retries,
-        connect=retries,
-        backoff_factor=backoff_factor,
-        status_forcelist=status_forcelist,
-        respect_retry_after_header=False
-    )
-    session = requests.Session()
-    session.mount('http://', adapter)
-    session.mount('https://', adapter)
-    return session
-
-
-requests_session = requests_retry_session()
-
-class P2ApiConnectionWrapper(p2api.ApiConnection):
-
-    def __init__(self, apitype, username, password):
-        p2api.ApiConnection.__init__(self, apitype, username, password)
-        logger.debug("init P2ApiConnectionWrapper")
-
-    def request(self, method, url, data=None, etag=None):
-        self.request_count += 1
-
-        # configure request headers
-        assert self.access_token is not None
-        headers = {
-            'Authorization': 'Bearer ' + self.access_token,
-            'Accept': 'application/json'
-        }
-        if data is not None:
-            headers['Content-Type'] = 'application/json'
-        if etag is not None:
-            headers['If-Match'] = etag
-
-        # make request
-        url = self.apiUrl + url
-        if self.debug:
-            print(method, url, data)
-        # using session makes some calls more than 2.5 X faster
-        # r = requests.request(method, url, headers=headers, data=json.dumps(data))
-        r = requests_session.request(method, url, headers=headers, data=json.dumps(data))
-        content_type = r.headers['Content-Type'].split(';')[0]
-        etag = r.headers.get('ETag', None)
-
-        # handle response
-        if 200 <= r.status_code < 300:
-            if content_type == 'application/json':
-                data = r.json()
-                return data, etag
-            return None, etag
-        elif content_type == 'application/json' and 'error' in r.json():
-            raise P2Error(r.status_code, method, url, r.json()['error'])
-        else:
-            raise P2Error(r.status_code, method, url, 'oops unknown error '+r)
-            # TODO handle 401 ? should we do something to reconnect API ...