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

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()

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