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

a2p2/gui.py

@@ -3,6 +3,7 @@
 __all__ = []
 
 import sys
+import logging
 
 from a2p2 import __release_notes__
 from a2p2 import __version__
@@ -18,10 +19,13 @@ else:
 
 from distutils.version import LooseVersion
 
+import signal
+
 HELPTEXT = """This application provides the link between ASPRO (that you should have started) and interferometers facilities.
 
 """
 
+logger = logging.getLogger(__name__)
 
 class MainWindow():
 
@@ -42,6 +46,8 @@ class MainWindow():
             print("Can not set tk scaling !")
 
         self.window.protocol("WM_DELETE_WINDOW", self._requestAbort)
+        # throws an exception self.window.bind_all('<Control-c>', self._requestAbort) # maybe already bound with WM_DELETE_WINDOW ?
+        signal.signal(signal.SIGINT, self._requestAbortSignal)
 
         self.notebook = ttk.Notebook(self.window)
 
@@ -94,6 +100,10 @@ class MainWindow():
     def _requestAbort(self):
         self.requestAbort = True
 
+    def _requestAbortSignal(self, arg1,arg2):
+        self.requestAbort = True
+
+
     def addHelp(self, tabname, txt):
         frame = Frame(self.helptabs)
         widget = Text(frame, width=120)
@@ -168,12 +178,17 @@ class MainWindow():
     def get_api(self):
         return self.api
 
-    def addToLog(self, text, displayString=True):
+    def addToLog(self, text, displayString=True, level=logging.INFO):
         if displayString:
             self.log_string.set(str(text))
         self.logtext.insert(END, "\n" + str(text))
         self.logtext.see(END)
         self.showFrameToFront()
+        self.refresh()
+        logger.log(level,text)
+
+    def refresh(self):
+        self.window.update()
 
     def ShowErrorMessage(self, text):
         if self.a2p2client.fakeAPI:
@@ -181,7 +196,7 @@ class MainWindow():
         else:
             showerror("Error", text)
         self.addToLog("Error message")
-        self.addToLog(text, False)
+        self.addToLog(text, False, logging.ERROR)
 
         # do also append to simple error stack (for testing purpose first)
         self.a2p2client.addError(text)
@@ -192,7 +207,7 @@ class MainWindow():
         else:
             showwarning("Warning", text)
         self.addToLog("Warning message")
-        self.addToLog(text, False)
+        self.addToLog(text, False, logging.WARNING)
 
     def ShowInfoMessage(self, text):
         if self.a2p2client.fakeAPI:
@@ -200,7 +215,20 @@ class MainWindow():
         else:
             showinfo("Info", text)
         self.addToLog("Info message")
-        self.addToLog(text, False)
+        self.addToLog(text, False, logging.INFO)
+
+    def AskYesNoMessage(self, text):
+        if self.a2p2client.fakeAPI:
+            pass
+        else:
+            self.addToLog(f"Question: {text}", displayString=False)
+            ret = askyesno("", text)
+            self.addToLog(f"Reply: yes={ret}", displayString=False)
+            return ret
+
+    def addProgress(self, offset=0.1):
+        self.setProgress(self.progress_value.get()+offset)
+
 
     def setProgress(self, perc):
         if perc > 1:
@@ -252,18 +280,24 @@ class FacilityUI(Frame):
         self.facility = facility
         self.a2p2client = facility.a2p2client
 
-    def addToLog(self, text, displayString=True):
+    def addToLog(self, *args, **kwargs):
         """ Wrapper to log message in the common textfield """
-        self.a2p2client.ui.addToLog(text, displayString)
+        self.a2p2client.ui.addToLog(*args, **kwargs)
 
-    def ShowErrorMessage(self, text):
-        self.a2p2client.ui.ShowErrorMessage(text)
+    def ShowErrorMessage(self, *args, **kwargs):
+        self.a2p2client.ui.ShowErrorMessage(*args, **kwargs)
 
-    def ShowWarningMessage(self, text):
-        self.a2p2client.ui.ShowWarningMessage(text)
+    def ShowWarningMessage(self, *args, **kwargs):
+        self.a2p2client.ui.ShowWarningMessage(*args, **kwargs)
 
-    def ShowInfoMessage(self, text):
-        self.a2p2client.ui.ShowInfoMessage(text)
+    def ShowInfoMessage(self, *args, **kwargs):
+        self.a2p2client.ui.ShowInfoMessage(*args, **kwargs)
+
+    def AskYesNoMessage(self,*args, **kwargs):
+        return self.a2p2client.ui.AskYesNoMessage(*args, **kwargs)
+
+    def addProgress(self, offset=0.1):
+        self.a2p2client.ui.addProgress(offset)
 
     def setProgress(self, perc):
         """ Wrapper to update progress bar """

a2p2/instrument.py

@@ -2,6 +2,9 @@
 
 __all__ = []
 
+import logging
+
+logger = logging.getLogger(__name__)
 
 class Instrument():
 

a2p2/jmmc/__init__.py

@@ -0,0 +1,7 @@
+__all__ = ['Catalog', 'Models','CallIper']
+
+PRODLABEL = {True: "production", False: "pre-prod"}
+
+from .catalogs import Catalog
+from .models import Models
+from .webservices import CallIper

a2p2/jmmc/catalogs.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python
+
+__all__ = []
+
+import logging
+
+from ..client import A2P2ClientPreferences
+
+from .utils import JmmcAPI
+from . import PRODLABEL
+
+logger = logging.getLogger(__name__)
+
+
+class Catalog():
+    """ Get remote access to read and update catalogs exposed through JMMC's API.
+        Credential can be explicitly given for method that require an authentication, else:
+        - a2p2 preferences login will be used if present (see a2p2 -c)
+        - or uses .netrc file
+    """
+
+    def __init__(self, catalogName, username=None, password=None, prod=False, apiUrl=None):
+        self.catalogName = catalogName
+        self.prod = prod
+
+        # Manage prod & preprod or user provided access points
+        if apiUrl:
+            self.apiUrl = apiUrl  # trust given url as catalogAPI if value is provided
+        elif self.prod:
+            self.apiUrl = "https://oidb.jmmc.fr/restxq/catalogs"
+        else:
+            self.apiUrl = "https://oidb-beta.jmmc.fr/restxq/catalogs"
+
+        self.api = JmmcAPI(self.apiUrl, username, password)
+
+        logger.info(f"Create catalog wrapper to access '{catalogName}' ({PRODLABEL[self.prod]} API at {self.api.rootURL})")
+
+    def list(self):
+        """ Get list of exposed catalogs on API associated to this catalog. """
+        return self.api._get("")
+
+    def metadata(self):
+        """ Get catalog metadata """
+        return self.api._get(f"/meta/{self.catalogName}")
+
+    def pis(self):
+        """ Get PIs from catalog and check for associated JMMC login in OiDB datapi table."""
+        return self.api._get(f"/accounts/{self.catalogName}")["pi"]
+
+    def piname(self, jmmcLogin=None):
+        """ Get the piname associated to the given jmmcLogin.
+            If jmmcLogin parameter is not provided, try to get jmmc.login preferences.
+            Only pi names returned by pis() can be retrieved.
+
+            usage: piname()
+        """
+        if not jmmcLogin:
+            prefs = A2P2ClientPreferences()
+            jmmcLogin = prefs.getJmmcLogin()
+        if not jmmcLogin:
+            raise Exception(
+                "missing login parameter or jmmc.login preference.")
+        pis = self.pis()
+        for pi in pis:
+            if "login" in pi and pi["login"] == jmmcLogin:
+                return pi["name"]
+
+    def getRow(self, id):
+        """ Get a single catalog record for the given id.
+
+            usage: cat.getRow(42)
+        """
+        return self.api._get(f"/{self.catalogName}/{id}")
+
+    def updateRow(self, id, values):
+        """ Update record identified by given id and associated values.
+
+            usage: cat.updateRows(42, {"col_a":"a", "col_b":"b" })
+        """
+        return self.api._put(f"/{self.catalogName}/{id}", values)
+
+    def updateRows(self, values):
+        """ Update multiple rows.
+            Values must contain a list of dictionnary and each entry must contains id key among other columns.
+
+            usage: updateRows([ { "id":42, "col_a":"a" }, { "id":24, "col_b":"b" } ])
+        """
+
+        # We may check befere sending payload that we always provide an id for every record
+        return self.api._put(f"/{self.catalogName}", values)
+
+    def addRows(self, values):
+        """ Add multiple rows.
+            Values is an array of row to add. id column values will be ignored.
+
+            usage: addCatalogRows([ { "id":42, "col_a":"a" }, { "id":24, "col_b":"b" } ])
+        """
+        return self.api._post(f"/{self.catalogName}", json=values)
+
+    def getDelegations(self, pi=None):
+        """ Get -all- delegations.
+            A specific pi parameter may be given but requires admin priviledges. Else use current piname will be used by remote service.
+
+            usage: getDelegations()
+        """
+        res = self.api._get(f"/delegations?pi={pi}")
+        if "delegations" in res:
+            return res["delegations"] # login and pi values not returned
+
+        return []
+
+    def updateDelegations(self, delegations):
+        """ Update delegations according given array of delegations.
+            A specific "pi" key may be given in delegations dict but requires admin privileges. Else current piname will be used by remote service.
+            "action" may be provided with "add" or "remove" value to set proper delegations (default add given delegation).
+
+            usage: addDelegations([{"pi":"mypiname", "catalogs":"mycats", "coi":["alice","bob"]}])
+
+        """
+        return self.api._put("/delegations", json=delegations)
+
+    def removeDelegations(self, delegations):
+        """ Remove delegations according given array of delegations.
+            A specific pi key may be given but requires admin privileges. Else current piname will be used by remote service.
+            usage: removeDelegations([{}, {}])
+        """
+        return "TODO"
+
+

a2p2/jmmc/generated_models.py

@@ -0,0 +1,191 @@
+from .models import _model
+
+def punct( name, flux_weight=1.0, x=0.0, y=0.0,  output_mode=None):
+    """ Returns the Fourier transform of a punctual object (Dirac function) at coordinates (X,Y)
+(milliarcsecond).
+
+FLUX_WEIGHT is the intensity coefficient. FLUX_WEIGHT=1 means total energy is 1. """
+
+    return _model({"flux_weight" : flux_weight, "x" : x, "y" : y, "name":name, "type":"punct"}, output_mode)
+
+def disk( name, flux_weight=1.0, x=0.0, y=0.0, diameter=0.0,  output_mode=None):
+    """ Returns the Fourier transform of a normalized uniform disk of diameter DIAMETER
+(milliarcsecond) and centered at coordinates (X,Y) (milliarcsecond).
+
+FLUX_WEIGHT is the intensity coefficient. FLUX_WEIGHT=1 means total energy is 1.
+
+The function returns an error if DIAMETER is negative. """
+
+    return _model({"flux_weight" : flux_weight, "x" : x, "y" : y, "diameter" : diameter, "name":name, "type":"disk"}, output_mode)
+
+def elong_disk( name, flux_weight=1.0, x=0.0, y=0.0, minor_axis_diameter=0.0, elong_ratio=1.0, major_axis_pos_angle=0.0,  output_mode=None):
+    """ Returns the Fourier transform of a normalized ellipse centered at coordinates (X,Y)
+(milliarcsecond) with a ratio ELONG_RATIO between the major diameter and the minor one
+MINOR_AXIS_DIAMETER, turned from the positive vertical semi-axis (i.e. North direction)
+with angle MAJOR_AXIS_POS_ANGLE, in degrees, towards to the positive horizontal semi-axis
+(i.e. East direction). (the elongation is along the major_axis)
+
+For avoiding degenerescence, the domain of variation of MAJOR_AXIS_POS_ANGLE is 180
+degrees, for ex. from 0 to 180 degrees.
+
+ELONG_RATIO = major_axis / minor_axis
+FLUX_WEIGHT is the intensity coefficient. FLUX_WEIGHT=1 means total energy is 1.
+
+The function returns an error if MINOR_AXIS_DIAMETER is negative or if ELONG_RATIO is
+smaller than 1. """
+
+    return _model({"flux_weight" : flux_weight, "x" : x, "y" : y, "minor_axis_diameter" : minor_axis_diameter, "elong_ratio" : elong_ratio, "major_axis_pos_angle" : major_axis_pos_angle, "name":name, "type":"elong_disk"}, output_mode)
+
+def flatten_disk( name, flux_weight=1.0, x=0.0, y=0.0, major_axis_diameter=0.0, flatten_ratio=1.0, minor_axis_pos_angle=0.0,  output_mode=None):
+    """ Returns the Fourier transform of a normalized ellipse centered at coordinates (X,Y)
+(milliarcsecond) with a ratio FLATTEN_RATIO between the major diameter
+MAJOR_AXIS_DIAMETER and the minor one, turned from the positive vertical semi-axis
+(i.e. North direction) with angle MINOR_AXIS_POS_ANGLE, in degrees, towards to the
+positive horizontal semi-axis (i.e. East direction). (the flattening is along the minor_axis)
+
+For avoiding degenerescence, the domain of variation of MINOR_AXIS_POS_ANGLE is 180
+degrees, for ex. from 0 to 180 degrees.
+
+FLATTEN_RATIO = major_axis / minor_axis
+FLUX_WEIGHT is the intensity coefficient. FLUX_WEIGHT=1 means total energy is 1.
+
+The function returns an error if MAJOR_AXIS_DIAMETER is negative or if FLATTEN_RATIO
+is smaller than 1. """
+
+    return _model({"flux_weight" : flux_weight, "x" : x, "y" : y, "major_axis_diameter" : major_axis_diameter, "flatten_ratio" : flatten_ratio, "minor_axis_pos_angle" : minor_axis_pos_angle, "name":name, "type":"flatten_disk"}, output_mode)
+
+def circle( name, flux_weight=1.0, x=0.0, y=0.0, diameter=0.0,  output_mode=None):
+    """ Returns the Fourier transform of a normalized uniform circle of diameter DIAMETER
+(milliarcsecond) and centered at coordinates (X,Y) (milliarcsecond).
+
+FLUX_WEIGHT is the intensity coefficient. FLUX_WEIGHT=1 means total energy is 1.
+
+The function returns an error if DIAMETER is negative. """
+
+    return _model({"flux_weight" : flux_weight, "x" : x, "y" : y, "diameter" : diameter, "name":name, "type":"circle"}, output_mode)
+
+def ring( name, flux_weight=1.0, x=0.0, y=0.0, diameter=0.0, width=0.0,  output_mode=None):
+    """ Returns the Fourier transform of a normalized uniform ring with internal diameter
+DIAMETER (milliarcsecond) and external diameter DIAMETER + WIDTH centered at coordinates
+(X,Y) (milliarcsecond).
+
+FLUX_WEIGHT is the intensity coefficient. FLUX_WEIGHT=1 means total energy is 1.
+
+The function returns an error if DIAMETER or WIDTH are negative. """
+
+    return _model({"flux_weight" : flux_weight, "x" : x, "y" : y, "diameter" : diameter, "width" : width, "name":name, "type":"ring"}, output_mode)
+
+def elong_ring( name, flux_weight=1.0, x=0.0, y=0.0, minor_internal_diameter=0.0, elong_ratio=1.0, width=0.0, major_axis_pos_angle=0.0,  output_mode=None):
+    """ Returns the Fourier transform of a normalized uniform elongated ring centered at
+coordinates (X,Y) (milliarcsecond). The sizes of the function in two orthogonal directions
+are given by the narrowest internal diameter (MINOR_INTERNAL_DIAMETER) and by the ratio
+ELONG_RATIO between the widest internal diameter and MINOR_INTERNAL_DIAMETER,
+in the same way as for an ellipse (the elongation is along the major_axis) :
+
+ELONG_RATIO = MAJOR_INTERNAL_DIAMETER / MINOR_INTERNAL_DIAMETER.
+In the direction of MINOR_INTERNAL_DIAMETER, the external diameter is
+MINOR_INTERNAL_DIAMETER + WIDTH. In the direction of the widest internal diameter,
+the width is magnified by the ratio ELONG_RATIO, so that the external diameter is
+the elongated MAJOR_INTERNAL_DIAMETER + WIDTH * ELONG_RATIO.
+MAJOR_AXIS_POS_ANGLE is measured in degrees, from the positive vertical semi-axis
+(i.e. North direction) towards to the positive horizontal semi-axis (i.e. East direction).
+For avoiding degenerescence, the domain of variation of MAJOR_AXIS_POS_ANGLE is 180
+degrees, for ex. from 0 to 180 degrees.
+
+FLUX_WEIGHT is the intensity coefficient. FLUX_WEIGHT=1 means total energy is 1.
+
+The function returns an error if MINOR_INTERNAL_DIAMETER is negative or if ELONG_RATIO
+is smaller than 1. """
+
+    return _model({"flux_weight" : flux_weight, "x" : x, "y" : y, "minor_internal_diameter" : minor_internal_diameter, "elong_ratio" : elong_ratio, "width" : width, "major_axis_pos_angle" : major_axis_pos_angle, "name":name, "type":"elong_ring"}, output_mode)
+
+def flatten_ring( name, flux_weight=1.0, x=0.0, y=0.0, major_internal_diameter=0.0, flatten_ratio=1.0, width=0.0, minor_axis_pos_angle=0.0,  output_mode=None):
+    """ Returns the Fourier transform of a normalized uniform flattened ring centered at
+coordinates (X,Y) (milliarcsecond). The sizes of the function in two orthogonal directions
+are given by the widest internal diameter (MAJOR_INTERNAL_DIAMETER) and by the ratio
+FLATTEN_RATIO between MAJOR_INTERNAL_DIAMETER and the narrowest internal diameter,
+in the same way as for an ellipse (the flattening is along the minor axis) :
+
+FLATTEN_RATIO = MAJOR_INTERNAL_DIAMETER / MINOR_INTERNAL_DIAMETER.
+In the direction of MAJOR_INTERNAL_DIAMETER, the external diameter is
+MAJOR_INTERNAL_DIAMETER + WIDTH. In the direction of the narrowest internal diameter,
+the width is decreased by the ratio FLATTEN_RATIO, so that the external diameter is
+the flattened MINOR_INTERNAL_DIAMETER + WIDTH / FLATTEN_RATIO.
+MINOR_AXIS_POS_ANGLE is measured in degrees, from the positive vertical semi-axis
+(i.e. North direction) towards to the positive horizontal semi-axis (i.e. East direction).
+For avoiding degenerescence, the domain of variation of MINOR_AXIS_POS_ANGLE is 180
+degrees, for ex. from 0 to 180 degrees.
+
+FLUX_WEIGHT is the intensity coefficient. FLUX_WEIGHT=1 means total energy is 1.
+
+The function returns an error if MAJOR_INTERNAL_DIAMETER is negative or if FLATTEN_RATIO
+is smaller than 1. """
+
+    return _model({"flux_weight" : flux_weight, "x" : x, "y" : y, "major_internal_diameter" : major_internal_diameter, "flatten_ratio" : flatten_ratio, "width" : width, "minor_axis_pos_angle" : minor_axis_pos_angle, "name":name, "type":"flatten_ring"}, output_mode)
+
+def gaussian( name, flux_weight=1.0, x=0.0, y=0.0, fwhm=0.0,  output_mode=None):
+    """ Returns the Fourier transform of a normalized gaussian with given FWHM (milliarcsecond)
+centered at coordinates (X,Y) (milliarcsecond).
+
+FLUX_WEIGHT is the intensity coefficient. FLUX_WEIGHT=1 means total energy is 1.
+
+The function returns an error if FWHM is negative. """
+
+    return _model({"flux_weight" : flux_weight, "x" : x, "y" : y, "fwhm" : fwhm, "name":name, "type":"gaussian"}, output_mode)
+
+def elong_gaussian( name, flux_weight=1.0, x=0.0, y=0.0, minor_axis_fwhm=0.0, elong_ratio=1.0, major_axis_pos_angle=0.0,  output_mode=None):
+    """ Returns the Fourier transform of a normalized elongated gaussian centered at coordinates
+(X,Y) (milliarcsecond). The sizes of the function in two orthogonal directions are given by
+the narrowest FWHM (MINOR_AXIS_FWHM) and by the ratio ELONG_RATIO between the largest
+FWHM (MAJOR_AXIS_FWHM) and the MINOR_AXIS_FWHM, in the same way as for an ellipse
+(the elongation is along the major_axis) :
+
+ELONG_RATIO = MAJOR_AXIS_FWHM / MINOR_AXIS_FWHM.
+MAJOR_AXIS_POS_ANGLE is measured in degrees, from the positive vertical semi-axis
+(i.e. North direction) towards to the positive horizontal semi-axis (i.e. East direction).
+For avoiding degenerescence, the domain of variation of MAJOR_AXIS_POS_ANGLE is 180
+degrees, for ex. from 0 to 180 degrees.
+
+FLUX_WEIGHT is the intensity coefficient. FLUX_WEIGHT=1 means total energy is 1.
+
+The function returns an error if MINOR_AXIS_FWHM is negative or if ELONG_RATIO
+is smaller than 1. """
+
+    return _model({"flux_weight" : flux_weight, "x" : x, "y" : y, "minor_axis_fwhm" : minor_axis_fwhm, "elong_ratio" : elong_ratio, "major_axis_pos_angle" : major_axis_pos_angle, "name":name, "type":"elong_gaussian"}, output_mode)
+
+def flatten_gaussian( name, flux_weight=1.0, x=0.0, y=0.0, major_axis_fwhm=0.0, flatten_ratio=1.0, minor_axis_pos_angle=0.0,  output_mode=None):
+    """ Returns the Fourier transform of a normalized flattened gaussian centered at coordinates
+(X,Y) (milliarcsecond). The sizes of the function in two orthogonal directions are given by
+the largest FWHM (MAJOR_AXIS_FWHM) and by the ratio FLATTEN_RATIO between the largest
+FWHM (MAJOR_AXIS_FWHM) and the MINOR_AXIS_FWHM, in the same way as for an ellipse
+(the flattening is along the minor_axis) :
+
+FLATTEN_RATIO = MAJOR_AXIS_FWHM / MINOR_AXIS_FWHM.
+MINOR_AXIS_POS_ANGLE is measured in degrees, from the positive vertical semi-axis
+(i.e. North direction) towards to the positive horizontal semi-axis (i.e. East direction).
+For avoiding degenerescence, the domain of variation of MINOR_AXIS_POS_ANGLE is 180
+degrees, for ex. from 0 to 180 degrees.
+
+FLUX_WEIGHT is the intensity coefficient. FLUX_WEIGHT=1 means total energy is 1.
+
+The function returns an error if MAJOR_AXIS_FWHM is negative or if FLATTEN_RATIO
+is smaller than 1. """
+
+    return _model({"flux_weight" : flux_weight, "x" : x, "y" : y, "major_axis_fwhm" : major_axis_fwhm, "flatten_ratio" : flatten_ratio, "minor_axis_pos_angle" : minor_axis_pos_angle, "name":name, "type":"flatten_gaussian"}, output_mode)
+
+def limb_quadratic( name, flux_weight=1.0, x=0.0, y=0.0, diameter=0.0, a1_coeff=0.0, a2_coeff=0.0,  output_mode=None):
+    """ Returns the Fourier transform of a center-to-limb darkened disk of diameter DIAMETER
+(milliarcsecond) centered at coordinates (X,Y) (milliarcsecond).
+
+The brightness distribution o, if expressed versus mu, the cosine of the azimuth of
+a surface element of the star, follows a quadratic law of coefficients
+A1_COEFF, A2_COEFF ([-1,1]), and is normalized for mu = 1 (center of the star).
+o(mu) = 1 -A1_COEFF(1-mu) - A2_COEFF(1-mu)^2.
+
+FLUX_WEIGHT is the intensity coefficient. FLUX_WEIGHT=1 means total energy is 1.
+
+The function returns an error if DIAMETER is negative or if A1_COEFF or A2_coeff is
+outside bounds [-1,1] """
+
+    return _model({"flux_weight" : flux_weight, "x" : x, "y" : y, "diameter" : diameter, "a1_coeff" : a1_coeff, "a2_coeff" : a2_coeff, "name":name, "type":"limb_quadratic"}, output_mode)
+

a2p2/jmmc/models.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python
+
+__all__ = []
+
+import json
+import logging
+import xml.etree.ElementTree as ET
+import json
+
+from .utils import JmmcAPI
+from a2p2.ob import etree_to_dict
+
+logger = logging.getLogger(__name__)
+
+
+#
+# first release done for SAMP interoperability with Aspro2
+#
+
+def modelsFromXml(xmlmodel):
+    """ Returns a python object representing JSON LIKE model(s) from given XML."""
+    # read xml models from Aspro2 and convert them to a JSON Model
+    e = ET.fromstring(xmlmodel)
+    _remove_namespace(e, "http://www.jmmc.fr/jmcs/models/0.1")
+    container = etree_to_dict(e)
+    modellist=container['model']['model']
+    if not isinstance(modellist, list):
+        modellist=[modellist]
+
+    models=[]
+    for m in modellist:
+        model={}
+        for p in m['parameter']:
+            model[p['type']]=p['value']
+        model['name']=m['name']
+        model['type']=m['type']
+        models.append(model)
+
+    return json.dumps(models)
+
+
+def _remove_namespace(doc, namespace):
+    """Remove namespace in the passed document in place.
+    from https://homework.nwsnet.de/releases/45be/"""
+    ns = u'{%s}' % namespace
+    nsl = len(ns)
+    for elem in doc.getiterator():
+        if elem.tag.startswith(ns):
+            elem.tag = elem.tag[nsl:]
+
+
+def _model(models, output_mode=None):
+    """ Returns a serialisation of given model(s) to XML by default or another format given to output_mode value (only jsonlike at present time)."""
+
+    # deserialize if models is a string
+    if isinstance(models, str):
+        models=json.loads(models)
+
+    if output_mode:
+        return models
+    else :
+        return _xml_model(models)
+
+def _xml_model(models, position=1):
+    """ Rough conversion of dict(s) to xml (Aspro2 namespaces)
+    if name key is not provided, position value will be used to compute suffix(es)"""
+
+    if isinstance(models, list):
+        modellist=[]
+        pos=1
+        for m in models:
+            modellist.append(_xml_model(m, pos))
+            pos+=1 # do not use models.index(m) since same str components would get the same index
+        return "".join(modellist)
+
+    model = models # models is now a single element
+    modeltype=model["type"]
+    if "name" in model.keys():
+        modelname=model["name"]
+    else:
+        modelname=modeltype+str(position)
+
+
+    params=""
+    paramNames=[ k for k in model.keys() if not k in ("type", "name")]
+    # at present time we must use Aspro2's approach with the same xml namespaces
+    # see
+    for p in paramNames:
+        params+=f"""    <tm:parameter name="{modelname}_{p}" type="{p}"><value>{model[p]}</value></tm:parameter>\n"""
+
+    return f"""<tm:model name="{modelname}" type="{modeltype}">\n{params}</tm:model>\n"""
+
+
+class Models():
+    """ Get analytical model's representations (in sync with Aspro2's ones).
+    """
+    SAMP_UCD_MODEL="meta.code.class;meta.modelled" # use it for colums that would be filled by models below
+
+# generated code below from an Asprox file that contains a single star with list of all supported models
+# cd a2p2/jmmc
+# xml sel -o "from .models import _model" -n -n -b -t -m "//tm:model" -o "def " -v "@type" -o "( name, " -m "tm:parameter" -v "@type" -o "=" -v "value" -o ", " -b -o " output_mode=None):" -n -o '    """ ' -v "desc" -o ' """ ' -n -n -o '    return _model({' -m "tm:parameter" -o '"' -v "@type" -o '" : ' -v "@type" -o ", " -b -o '"name":name, "type":"' -v "@type" -o '"}, output_mode)' -n -n models_template.asprox > generated_models.py
+# xml sel -t -o "    from .generated_models import " -m "//tm:model" -v "@type" -o ", "  -b -n models_template.asprox
+# cd -
+    from .generated_models import punct, disk, elong_disk, flatten_disk, circle, ring, elong_ring, flatten_ring, gaussian, elong_gaussian, flatten_gaussian, limb_quadratic

a2p2/jmmc/services.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python
+
+__all__ = []
+
+import logging
+
+from .catalogs import Catalog
+from .webservices import CallIper
+
+logger = logging.getLogger(__name__)
+
+#  TODO list and give access to whole services and their beta/alpha / pre-prod instances if existing
+
+oidb_catalog = Catalog("oidb")
+
+calliper = CallIper()