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

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

@@ -6,6 +6,10 @@ import logging
 import json
 import xml.etree.ElementTree as ET
 from collections import defaultdict, namedtuple, OrderedDict
+import re
+
+import copy
+
 
 logger = logging.getLogger(__name__)
 
@@ -22,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:
@@ -33,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():
     """
@@ -45,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 ).
@@ -81,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

@@ -15,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
 
@@ -47,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)
@@ -54,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()
@@ -82,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:///"):
@@ -92,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']
+