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

a2p2/jmmc/utils.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python
+
+from urllib3.util.retry import Retry
+from requests.adapters import HTTPAdapter
+from requests.auth import HTTPBasicAuth
+import requests
+
+from a2p2.client import A2P2ClientPreferences
+__all__ = []
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Do not use next code directly - this is dev related code.
+# Please have a look on the other jmmc modules for client code.
+
+
+#  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/
+
+
+# TODO check that we return more infiormation for 500 error case because some server side code part do return 500
+# and here we may
+
+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
+
+#            r = requests.request(method, url, headers=headers, data=json.dumps(data))
+# -> r = requests_session.request(method, url, headers=headers, data=json.dumps(data))
+
+
+class JmmcAPI():
+    def __init__(self, rootURL, username=None, password=None):
+        self.rootURL = rootURL
+
+        # credentials can be given :
+        # by parameters
+        # if username or password is None, try to get it from the a2p2 preferences ( run: a2p2 -c )
+        # if username or password still is None keep auth to None.
+        # a None auth will search for ~/.netrc files trying to fix 401 accesses
+
+        prefs = A2P2ClientPreferences()
+        if not username :
+            username = prefs.getJmmcLogin()
+        if not password :
+            password = prefs.getJmmcPassword()
+
+        # if we got complete credential
+        if username and password:
+            self.auth = HTTPBasicAuth(username, password)
+        else:
+            self.auth = None
+
+        self.requests_session = requests_retry_session()
+
+        logger.debug("Instanciating JmmcAPI on '%s'" % self.rootURL)
+
+    def _get(self, url):
+        return self._request('GET', url)
+
+    def _put(self, url, json):
+        return self._request('PUT', url, json)
+
+    def _post(self, url, json):
+        return self._request('POST', url, json)
+
+    def _post(self, url, **kwargs):
+        return self._request2('POST', url, **kwargs)
+
+    def _request2(self, method, url, **kwargs):
+        logger.info("performing %s request on %s" % (method, self.rootURL+url))
+        r = self.requests_session.request(
+            method, self.rootURL+url, **kwargs)
+        # handle response if any or throw an exception
+        if (r.status_code == 204):  # No Content : everything is fine
+            return
+        elif 200 <= r.status_code < 300:
+            if 'Content-Type' in r.headers.keys() and 'application/json' in r.headers['Content-Type']:
+                return r.json()
+            else:
+                return r.content
+        # TODO enhance error handling ? Throw an exception ....
+        error = []
+        error.append("status_code is %s"%r.status_code)
+        if r.reason :
+            error.append(r.reason)
+        if "X-Http-Error-Description" in r.headers.keys():
+            error.append(r.headers["X-Http-Error-Description"])
+
+        raise Exception(error)
+
+    def _request(self, method, url, json=None, data=None, files=None):
+        logger.info("performing %s request on %s" % (method, self.rootURL+url))
+        r = self.requests_session.request(
+            method, self.rootURL+url, auth=self.auth, json=json, data=data, files=files)
+        # handle response if any or throw an exception
+        if (r.status_code == 204):  # No Content : everything is fine
+            return
+        elif 200 <= r.status_code < 300:
+            if 'Content-Type' in r.headers.keys() and 'application/json' in r.headers['Content-Type']:
+                return r.json()
+            else:
+                return r.content
+        # TODO enhance error handling ? Throw an exception ....
+        error = []
+        error.append("status_code is %s"%r.status_code)
+        if r.reason :
+            error.append(r.reason)
+        if "X-Http-Error-Description" in r.headers.keys():
+            error.append(r.headers["X-Http-Error-Description"])
+
+        raise Exception(error)

a2p2/jmmc/webservices.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+
+__all__ = []
+
+import logging
+import json
+
+from .utils import JmmcAPI
+from . import PRODLABEL
+
+logger = logging.getLogger(__name__)
+
+class CallIper():
+    """ Call IPER using its 'API' through simple methods.
+
+    from a2p2.jmmc import CallIper
+    calliper = CallIper()
+    diskresult   = caliper.runDiskFit(pathname)
+    ud = diskresult["diameter"]
+
+    """
+    def __init__(self, prod=False, apiUrl=None):
+        self.prod = prod
+        self.serviceName = "callIper"
+
+        # Manage prod & preprod or user provided access points
+        if apiUrl:
+            self.apiUrl = apiUrl  # trust given url as callIperAPI if value is provided
+        elif self.prod:
+            self.apiUrl = ""  # no api in production yet
+            raise Warning("sorry, no api for production yet")
+        else:
+            self.apiUrl = "http://apps.jmmc.fr/~mellag/LITproWebService/run.php"
+
+        self.api = JmmcAPI(self.apiUrl)
+
+        logger.info("Create calliper client to access '%s' (%s API at %s)" %
+                    (self.serviceName, PRODLABEL[self.prod], self.api.rootURL))
+
+    # API will evolve in the future with parameter to select fitter, model and data to fit...
+    def runDiskFit(self, oifitsFilename, jsonOutput=True):
+        """ Ask CallIper to fit given data for a simple disk """
+        files = {'userfile': (oifitsFilename, open(oifitsFilename, 'rb'))}
+        data = {'method': 'runJsonFit'}
+        res=self.api._post("", data=data, files=files)
+        if jsonOutput:
+            return json.loads(res)
+        return res

a2p2/ob.py

@@ -2,9 +2,16 @@
 
 __all__ = []
 
+import logging
 import json
 import xml.etree.ElementTree as ET
 from collections import defaultdict, namedtuple, OrderedDict
+import re
+
+import copy
+
+
+logger = logging.getLogger(__name__)
 
 # https://stackoverflow.com/questions/2148119/how-to-convert-an-xml-string-to-a-dictionary-in-python
 # see comment below for our custom mods on attributes naming
@@ -19,8 +26,11 @@ def etree_to_dict(t):
         d = {t.tag: {k: v[0] if len(v) == 1 else v for k, v in dd.items()}}
         # print("add d=%s"%str(d))
     if t.attrib:
-        d[t.tag].update(('' + k, v)
-                        for k, v in t.attrib.items())  # was '@' but can't be serialized by namedtuple
+        attrs = {}
+        for k, v in t.attrib.items():
+            if not "{" in k[0]: # ignore elementName with prefix
+                attrs[k]=v
+        d[t.tag].update(attrs)
     if t.text:
         text = t.text.strip()
         if children or t.attrib:
@@ -30,6 +40,66 @@ def etree_to_dict(t):
             d[t.tag] = text
     return d
 
+def normalizeObj(obj):
+    """
+    Modify in place the structure if required.
+    Note:
+        dict key must be valid identifier (only tested for EXTRA_INFORMATIONS created fields)
+    """
+    otype=type(obj)
+    if otype is dict:
+        for k,v in obj.items():
+
+            if k in ['observationConfiguration', 'HAinterval', 'LSTinterval'] and not isinstance(v, list):
+                # always defines observationConfiguration as a list
+                normalizeObj(v)
+                obj[k]=[v]
+            elif k=='EXTRA_INFORMATIONS':
+                #print(f"Updating dict {k} was : {obj[k]}")
+                # normalize input that may have various form on list of dict
+                try:
+                    fields=[]
+                    funits={}
+                    for fk in ["parameter","field"]:
+                        if fk in obj[k]:
+                            l=obj[k][fk].copy()
+                            #print(f"'{fk}' => {l}\n({type(l)})\n")
+                            if type(l) is dict:
+                                fields.append(l)
+                            else:
+                                fields+=l
+
+                    #print(f"Fields to update: {fields}")
+                    #store new fields
+                    for vn in fields:
+                        fname=vn["name"]
+                        # test if we have to normalize field name that will become a python field
+                        if not fname.isidentifier():
+                            # replace unvalid chars by _ and append F to avoid starting by _
+                            fname=re.sub('^_','F_', re.sub('\W|^(?=\d)','_', fname))
+                        obj[k][fname]=vn["value"]
+                        if "unit" in vn:
+                            funits[fname]=vn["unit"]
+                    #store units
+                    obj[k]["field_units"]=funits
+                    # remove old arrays or dicts
+                    for fk in ["parameter","field"]:
+                        if fk in obj[k]:
+                            del obj[k][fk]
+                            pass
+                except:
+                    import traceback
+                    print (traceback.format_exc())
+                    print(f"\nCan't read {v}")
+                    pass
+            else:
+                normalizeObj(v)
+        return obj
+    elif otype is list:
+        for e in obj:
+            normalizeObj(e)
+    else:
+        pass
 
 class OB():
     """
@@ -42,29 +112,40 @@ class OB():
 
     every values are string (must be converted for numeric values).
 
+    Following fields are converted to list even if the list get a single element. The OB code can then handle such multiples values.
+    ['observationConfiguration', 'HAinterval', 'LSTinterval']
+
     """
 
     def __init__(self, url):
         # extract XML in elementTree
-
         e = ET.parse(url)
+        # convert data to dict structure
         d = etree_to_dict(e.getroot())
         # keep only content of subelement to avoid schema version change
         # '{http://www.jmmc.fr/aspro-ob/0.1}observingBlockDefinition'
         ds = d[list(d)[0]]  # -> version and name are lost
-        # store attributes
+
+        #self.srcDict  = copy.deepcopy(ds)
+        normalizeObj(ds)
+        #self.normDict = ds
+        #self.srcObj  = toObject(self.srcDict,inputName="OB")
+        #self.normObj  = toObject(self.normDict,inputName="OB")
+
+        # store subelements as attributes
         for e in ds.keys():
             # parse JSON into an object with attributes corresponding to dict keys.
             # We should probably avoid json use...
             o = json.loads(
                 json.dumps(ds[e]), object_hook=lambda d: namedtuple(e, d.keys())(*d.values()))
-            # observationConfiguration may be uniq but force it to be a list
-            if "observationConfiguration" in e and not isinstance(o, list):
-                setattr(self, e, [o])
-            else:
-                setattr(self, e, o)
+            setattr(self, e, o)
+
+        # store normalized source for str repr
         self.ds = ds
 
+    def as_dict(self):
+        return self.ds
+
     def getFluxes(self, target):
         """
         Return a flux mesurements as dict (ordered dict by BVRIJHK ).
@@ -78,6 +159,14 @@ class OB():
 
         return OrderedDict(sorted(fluxes.items(), key=lambda t: order.find(t[0])))
 
+    def getPeriod(self):
+        """
+        Return period given by Aspro2 as integer.
+        """
+        # use re to remove alpha characters from "Period 109" and make.
+        return int(re.sub(r"\D", "", self.interferometerConfiguration.version))
+
+
     def get(self, obj, fieldname, defaultvalue=None):
         if fieldname in obj._fields:
             return getattr(obj, fieldname)

a2p2/samp.py

@@ -4,6 +4,9 @@ __all__ = []
 
 from astropy.samp import SAMPIntegratedClient
 from os import sep
+import logging
+
+logger = logging.getLogger(__name__)
 
 class Receiver(object):
 
@@ -12,12 +15,14 @@ class Receiver(object):
         self.received = False
 
     def receive_call(self, private_key, sender_id, msg_id, mtype, params, extra):
+        self.mtype=mtype
         self.params = params
         self.received = True
         self.client.reply(
             msg_id, {"samp.status": "samp.ok", "samp.result": {}})
 
     def receive_notification(self, private_key, sender_id, mtype, params, extra):
+        self.mtype=mtype
         self.params = params
         self.received = True
 
@@ -44,6 +49,7 @@ class A2p2SampClient():
         # an error is thrown here if no hub is present
 
         # TODO get samp client name and display it in the UI
+        # TODO !! declare mtypes as enum
 
         # Instantiate the receiver
         self.r = Receiver(self.sampClient)
@@ -51,6 +57,10 @@ class A2p2SampClient():
         self.sampClient.bind_receive_call("ob.load.data", self.r.receive_call)
         self.sampClient.bind_receive_notification(
             "ob.load.data", self.r.receive_notification)
+        # Listen for Model related instructions
+        self.sampClient.bind_receive_call("fr.jmmc.litpro.start.setting",self.r.receive_call)
+        self.sampClient.bind_receive_notification(
+            "fr.jmmc.litpro.start.setting",self.r.receive_notification)
 
     def disconnect(self):
         self.sampClient.disconnect()
@@ -79,6 +89,9 @@ class A2p2SampClient():
     def clear_message(self):
         return self.r.clear()
 
+    def has_ob_message(self):
+        return "ob.load.data" in self.r.mtype
+
     def get_ob_url(self):
         url = self.r.params['url']
         if url.startswith("file:///"):
@@ -89,3 +102,10 @@ class A2p2SampClient():
         elif url.startswith("file:/"):  # work arround bugged file urls on *nix
             return url[5:]
         return url
+
+    def has_model_message(self):
+        return "fr.jmmc.litpro.start.setting" in self.r.mtype
+
+    def get_model(self):
+        return self.r.params['model']
+