* new methods and adaptations to model change

Author: lukasheinrich

recastapi/analysis/read.py

@@ -15,3 +15,31 @@ def analysis(analysis_id = None):
         return responses['_items']
     else:
         return responses
+
+def analysis_by_pub_identifier(pubtype, pubid):
+    """List analysis given uuid or all analyses.
+
+    :param uuid: analysis_id.
+
+    :return: JSON object containing all analyses retrieved.
+    """
+
+    query = None
+    if pubtype == 'cds':
+        query = 'cds_id=="{}"'.format(pubid)
+    elif pubtype == 'arxiv':
+        query = 'arxiv_id=="{}"'.format(pubid)
+    elif pubtype == 'inspire':
+        query = 'inspire_id=="{}"'.format(pubid)
+    elif pubtype == 'recast':
+        query = 'id=="{}"'.format(pubid)
+    else:
+        raise NotImplementedError()
+
+    url = '{}{}'.format(recastapi.ENDPOINTS['ANALYSIS'], '?where={}'.format(query))
+    responses = recastapi.get(url)
+
+    if not responses['_items']:
+        return None
+
+    return responses['_items'][0]

recastapi/analysis/write.py

@@ -3,21 +3,20 @@
 
 def analysis(title,
              collaboration,
-             e_print,
-             journal,
              doi,
-             inspire_url,
+             arxiv_id,
+             inspire_id,
+             cds_id,
              description,
              run_condition_name,
              run_condition_description):
     """Create a new analysis and Run Condition.
 
     :param title: Title of the analysis.
     :param collaboration: Choice among: ALICE, ATLAS, CMS, .
-    :param e_print: link.
-    :param journal: Name of journal.
-    :param doi: Arxiv doi?
-    :param inspire_url: URL on inspire website.
+    :param doi:  Digital Object Identifier
+    :param inspire_id: INSPIRE Record identifier
+    :param arxiv_id: link.
     :param description: A detailed description of the analysis.
     :param run_condition_name: Name of the run condition.
     :param run_condition_descprition: Detailed description of the run condition.
@@ -40,10 +39,10 @@ def analysis(title,
         'owner_id':owner_id,
         'title':title,
         'collaboration':collaboration,
-        'e_print':e_print,
-        'journal':journal,
         'doi':doi,
-        'inspire_URL':inspire_url,
+        'arxiv_id':arxiv_id,
+        'inspire_id':inspire_id,
+        'cds_id':cds_id,
         'description':description,
         'run_condition_id':run_condition_id,
         }

recastapi/apicli.py

@@ -1,29 +1,17 @@
 import yaml
 import json
+import recastapi.analysis.read
 import recastapi.request.write
 import click
 import zipfile
 import tempfile
 import os
 
-@click.command()
-@click.argument('specfile')
-def createscan(specfile):
-    spec = yaml.load(open(specfile))
-    scanrequest = recastapi.request.write.scan_request(
-        spec['analysis_id'],
-        spec['title'],
-        spec['description'],
-        spec['reason'],
-        spec['additional_information']
-    )
-
-    parnames = spec['parameters']
-    points = spec['points']
-
+def addpoints_to_scan(scanid,req_format,parnames,points):
     point_requests = []
     basic_requests = []
-    for p in points:
+
+    for i,p in enumerate(points):
         coordinates = p['coordinates']
         data = p['data']
 
@@ -42,18 +30,53 @@ def createscan(specfile):
             raise click.ClickException('point data needs to be zipfiles or directory')
 
         pointdict = dict(zip(parnames,coordinates))
-        pr = recastapi.request.write.point_request_with_coords(scanrequest['id'],pointdict)
+        pr = recastapi.request.write.point_request_with_coords(scanid,pointdict)
         point_requests += [{'point':pointdict,'id':pr['id']}]
-        br = recastapi.request.write.basic_request_with_archive(pr['id'],archive)
-        basic_requests += [{'point':pointdict,'id':br['id']}]
+        br = recastapi.request.write.basic_request_with_archive(pr['id'],archive,req_format)
+        basic_requests += [{'point':pointdict,'id':br['id'], 'point_request': pr['id']}]
+        click.secho('uploaded {}/{} requests'.format(i+1,len(points)))
+    return point_requests, basic_requests
+
+
+@click.command()
+@click.argument('specfile')
+@click.argument('outputfile')
+def createscan(specfile,outputfile):
+    spec = yaml.load(open(specfile))
+
+    analysis_info = recastapi.analysis.read.analysis_by_pub_identifier(*spec['pubkey'].split('/'))
+    if not analysis_info:
+        raise click.ClickException('Analysis {} not known, import it first.'.format(spec['pubkey']))
+
+    scanrequest = recastapi.request.write.scan_request(
+        analysis_info['id'],
+        spec['title'],
+        spec['description'],
+        spec['reason'],
+        spec['additional_information']
+    )
 
-    click.echo(yaml.safe_dump({
+
+    parnames = spec['parameters']
+    points = spec['points']
+
+    prlist, brlist = addpoints_to_scan(scanrequest['id'],spec['request_format'],parnames,points)
+
+    yaml.safe_dump({
             'scan_id': scanrequest['id'],
-            'point_requests': point_requests,
-            'basic_requests': basic_requests
+            'point_requests': prlist,
+            'basic_requests': brlist
         },
+        open(outputfile,'w'),
         default_flow_style = False
-    ))
+    )
+
+@click.command()
+@click.argument('specfile')
+@click.argument('outputfile')
+def addtoscan(specfile,outputfile):
+    #existing_points = {tuple(x['value'] for x in p['point_coordinates']):p['id'] for p in  recastapi.request.read.point_request_of_scan(2) }
+    pass
 
 if __name__ == '__main__':
     createscan()

recastapi/request/read.py

@@ -33,13 +33,13 @@ def scan_request(scan_request_id = None, analysis_id = None, query='?max_results
 
 def point_request(point_request_id):
     """" Returns basic JSON. """
-    url = '{}/{}'.format(recastapi.ENDPOINTS['POINT_REQUESTS'], point_request_id)
+    url = '{}/{}/?embedded={{"point_coordinates":1,"requests":1}}'.format(recastapi.ENDPOINTS['POINT_REQUESTS'], point_request_id)
     response = recastapi.get(url)
     return response
 
 def basic_request(basic_request_id):
     """" Returns basic JSON. """
-    url = '{}/{}'.format(recastapi.ENDPOINTS['BASIC_REQUESTS'], basic_request_id)
+    url = '{}/{}/?embedded={{"point_request": 1}}'.format(recastapi.ENDPOINTS['BASIC_REQUESTS'], basic_request_id)
     response = recastapi.get(url)
     return response
 
@@ -48,7 +48,7 @@ def point_request_of_scan(scan_request_id, point_request_index=None):
     :param scan_request_id: the request ID to query
     :param point_request_index: starting from 0
     """
-    point_req_url = '{}?where=scan_request_id=="{}"'.format(
+    point_req_url = '{}?embedded={{"point_coordinates":1,"requests": 1}}&where=scan_request_id=="{}"'.format(
         recastapi.ENDPOINTS['POINT_REQUESTS'],
         scan_request_id
     )
@@ -93,7 +93,7 @@ def coordinate(point_request_id, coordinate_index=None):
 
 
 def basic_request_of_point(point_request_id):
-    basic_url = '{}?where=point_request_id=="{}"'.format(
+    basic_url = '{}?embedded={{"point_request": 1}}&where=point_request_id=="{}"'.format(
                         recastapi.ENDPOINTS['BASIC_REQUESTS'],
                         point_request_id)
     return recastapi.get(basic_url)['_items']

recastapi/request/write.py

@@ -64,21 +64,22 @@ def point_request_with_coords(scan_request_id,coordinate_map):
         coordinate(k,float(v),pr['id'])
     return pr
 
-def basic_request(point_request_id):
+def basic_request(point_request_id,request_format):
     """Adds basic request
     :param point_request_id: ID of the point request
     :return: JSON object
     """
     user = recastapi.user.read.this_user()
     payload = {
+        'request_format': request_format,
         'requester_id': user['id'],
         'point_request_id': point_request_id,
     }
     url = '{}/'.format(recastapi.ENDPOINTS['BASIC_REQUESTS'])
     return recastapi.post(url, data=payload)
 
-def basic_request_with_archive(point_request_id,filename):
-    br = basic_request(point_request_id)
+def basic_request_with_archive(point_request_id,filename,request_format):
+    br = basic_request(point_request_id,request_format)
     request_archive(br['id'],filename)
     return br
 
@@ -90,9 +91,9 @@ def request_archive(basic_request_id, filename = None):
 
     files = {'file': open(filename, 'rb')} if filename else {}
     url = '{}/'.format(recastapi.ENDPOINTS['REQUEST_ARCHIVES'])
-    basic_request_response = recastapi.post(
+    basic_request_archive = recastapi.post(
         url,
         data=payload,
         files=files,
     )
-    return basic_request_response
+    return basic_request_archive

recastapi/response/read.py

@@ -3,6 +3,7 @@
 from termcolor import colored
 import urllib
 import yaml
+import json
 
 def scan_response(scan_response_id =  None, scan_request_id = None):
     """List request depending on criteria
@@ -56,29 +57,28 @@ def point_response(point_response_id =  None, point_request_id = None):
             return None
         return response['_items'][0]
 
-def basic_response(basic_response_id =  None, basic_request_id = None):
+def basic_response(basic_response_id =  None, basic_request_id_filter = None, description_filter = None):
     """" Returns basic JSON. """
 
-    if (basic_response_id is None) and (basic_request_id is None):
-        response = recastapi.get(recastapi.ENDPOINTS['BASIC_RESPONSES'])
-        return response['_items']
+    query = {}
+    if description_filter:
+        query.update(description = description_filter)
+    if basic_request_id_filter:
+        query.update(basic_request_id = basic_request_id_filter)
+    if basic_response_id:
+        query.update(id = basic_response_id)
 
-    if (basic_response_id is not None) and (basic_request_id is not None):
-        raise RuntimeError('Cannot fetch basic_response_id and basic_request_id simultaneously')
+    query = 'where={}'.format(json.dumps(query))
 
-    elif basic_response_id is not None:
-        url = '{}/{}'.format(recastapi.ENDPOINTS['BASIC_RESPONSES'], basic_response_id)
-        response = recastapi.get(url)
-        return response
+    print query
 
-    elif basic_request_id is not None:
-        selection_str = '?where=basic_request_id=="{}"'.format(basic_request_id)
-        url = '{}{}'.format(recastapi.ENDPOINTS['BASIC_RESPONSES'], selection_str)
-        response = recastapi.get(url)
-        assert(len(response['_items']) < 2)
-        if not response['_items']:
-            return None
+    url = '{}/?{}'.format(recastapi.ENDPOINTS['BASIC_RESPONSES'],query)
+    response = recastapi.get(url)
+
+    if basic_response_id:
         return response['_items'][0]
+    else:
+        return response['_items']
 
 def response_archive(basic_response_id = None, basic_request_id = None, filename = None):
     if basic_response_id is None:

recastapi/response/write.py

@@ -55,7 +55,7 @@ def point_response(scan_response_id,point_request_id,result_data):
     url = '{}/'.format(recastapi.ENDPOINTS['POINT_RESPONSES'])
     return recastapi.post(url, json=payload)
 
-def basic_response(point_response_id,basic_request_id,result_data):
+def basic_response(point_response_id,basic_request_id,result_data, description, replace_existing = True):
     """Adds basic request
     :param point_response_id: ID of the point response
     :param basic_request_id: ID of the basic request
@@ -66,11 +66,13 @@ def basic_response(point_response_id,basic_request_id,result_data):
         'model_id': None,
         'basic_request_id': basic_request_id,
         'point_response_id': point_response_id,
+        'description': description
     }
     payload.update(**result_data)
 
-    existing = recastapi.response.read.basic_response(basic_request_id = basic_request_id)
-    if existing:
+    existing = recastapi.response.read.basic_response(basic_request_id_filter = basic_request_id, description_filter = description)
+    if existing and replace_existing:
+        existing = existing[0]
         url = '{}/{}'.format(recastapi.ENDPOINTS['BASIC_RESPONSES'],existing['id'])
         existing.update(**payload)
         existing = {k:v for k,v in existing.iteritems() if not (k.startswith('_') or k=='id')}
@@ -79,9 +81,8 @@ def basic_response(point_response_id,basic_request_id,result_data):
     url = '{}/'.format(recastapi.ENDPOINTS['BASIC_RESPONSES'])
     return recastapi.post(url, json=payload)
 
-
-def basic_response_with_archive(point_response_id,basic_request_id,filename, result_data):
-    br = basic_response(point_response_id,basic_request_id,result_data)
+def basic_response_with_archive(point_response_id,basic_request_id,result_data,description,filename):
+    br = basic_response(point_response_id,basic_request_id,result_data,description)
     response_archive(br['id'],filename)
     return br
 

tests/test_files.py

@@ -25,10 +25,10 @@
 print colored('Add Analaysis POST METHOD', 'green')
 print recastapi.analysis.create(title='test adding analysis from SDK',
                                 collaboration='CMS',
-                                e_print='http://example.com',
-                                journal='example journal',
                                 doi='1211.121121',
-                                inspire_url='http://example.com',
+                                inspire_id='1234',
+                                arxiv_id='56780',
+                                cds_id='938472',
                                 description='this is a test',
                                 run_condition_name='Name of this run condition',
                                 run_condition_description='and finally the description')