itkdb-gtk 0.0.3__py3-none-any.whl → 0.20.1__py3-none-any.whl

itkdb_gtk/ITkDBlogin.py

@@ -92,6 +92,7 @@ class ITkDBlogin(Gtk.Dialog):
 
         if gtk_runs:
             self.create_window()
+            self.present()
             self.run()
 
         else:
@@ -216,7 +217,7 @@ class ITkDBlogin(Gtk.Dialog):
         #
         self.has_window = True
         self.add_buttons(
-            Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OK, Gtk.ResponseType.OK
+            Gtk.STOCK_OK, Gtk.ResponseType.OK, Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL
         )
         # self.set_position(Gtk.WindowPosition.CENTER_ALWAYS)
 
@@ -238,10 +239,10 @@ class ITkDBlogin(Gtk.Dialog):
         self.ac1.set_visibility(False)
         self.ac2.set_visibility(False)
 
-        grid.attach(Gtk.Label(label="Acces Code 1"), 0, irow, 1, 1)
+        grid.attach(Gtk.Label(label="Access Code 1"), 0, irow, 1, 1)
         grid.attach(self.ac1, 1, irow, 1, 1)
         irow = irow + 1
-        grid.attach(Gtk.Label(label="Acces Code 1"), 0, irow, 1, 1)
+        grid.attach(Gtk.Label(label="Access Code 2"), 0, irow, 1, 1)
         grid.attach(self.ac2, 1, irow, 1, 1)
 
         btn = self.get_widget_for_response(Gtk.ResponseType.OK)
@@ -253,7 +254,6 @@ class ITkDBlogin(Gtk.Dialog):
         """Opens an error dialog.
 
         Args:
-        ----
             main_title: Main text in window
             second_text: Second text
 
@@ -306,12 +306,12 @@ class ITkDBlogin(Gtk.Dialog):
             #     token_file.write(json.dumps(self.token))
             self.hide()
 
-    def get_client(self):
+    def get_client(self, use_eos=True):
         """Return the client."""
         if not self.is_connected():
             return None
 
-        return itkdb.Client(user=self.user)
+        return itkdb.Client(user=self.user, use_eos=use_eos)
 
     def __del__(self):
         """Delete."""
@@ -336,6 +336,10 @@ if __name__ == "__main__":
     #     print(l)
 
     print("Hello {}".format(dlg.name))
+
+    rc = client.get("getUser", json={"userIdentity": dlg.user.identity})
+    print(rc)
+
     if gtk_runs:
         try:
             while True:

itkdb_gtk/ITkDButils.py

@@ -1,22 +1,39 @@
 """Utilities for the inteaction with the ITkDB."""
-import mimetypes
 from collections.abc import Iterable
 from datetime import datetime
 from pathlib import Path
+import getpass
 
 import dateutil.parser
+import itkdb
 
 # The response of the DB
 db_response = ""
+attachment_urls = {}
+uploaded_test_runs = []
 
 
 # define an Attachment object.
 class Attachment(object):
     """Encapsulates Attachment information."""
 
-    def __init__(self, path=None, title=None, desc=None):
+    def __init__(self, path=None, url=None, title=None, desc=None):
         """Initialization."""
-        self.path = path
+        if path is not None:
+            self.path = Path(path).expanduser().resolve()
+            self.type = "file"
+        else:
+            self.path = None
+
+        if url is not None:
+            self.url = url
+            self.type = "link"
+        else:
+            self.url = None
+
+        if self.path and self.url:
+            raise ValueError("Invalid Attachment. Has both file and link.")
+
         self.title = title
         self.desc = desc
 
@@ -38,7 +55,6 @@ def get_db_response():
     It is stores in a global variable. Trust the function if call
     right after your interaction with the DB.
     """
-    global db_response
     return db_response
 
 
@@ -46,7 +62,6 @@ def get_db_date(timestamp=None):
     """Convert a date string into the expected DB format.
 
     Args:
-    ----
         timestamp: A date in string format
 
     """
@@ -67,23 +82,61 @@ def get_db_date(timestamp=None):
         try:
             this_date = dateutil.parser.parse(timestamp)
             out = date2string(this_date)
-        except Exception:
+
+        except (OverflowError, dateutil.parser.ParserError):
             out = ""
 
     return out
 
 
-def registerPetalCore(client, SN, alias, HC_id=None):
+
+def get_petal_core_batches(session):
+    """Get list of Petal core batches"""
+    payload = {
+        "filterMap": {
+            "project": "S",
+            "batchType": ["PETAL_CORE_BATCH_TYPE"],
+        }
+    }
+    batch_list = session.get("listBatches", json=payload)
+    rc = {}
+    for B in batch_list:
+        rc[B["number"] ]= B["id"]
+
+    return rc
+
+def set_petal_core_batch(session, petal_core):
+    """Set the batch of the petal core."""
+    if isinstance(petal_core["type"], str):
+        tp = petal_core["type"]
+    else:
+        tp = petal_core["type"]["code"]
+
+    if tp != "CORE_AVS":
+        return
+
+    batch_list = get_petal_core_batches(session)
+    aliasID = petal_core["alternativeIdentifier"]
+    if "PPB" in aliasID:
+        batch_code = "PETAL_CORE_PREPROD"
+    elif "PPC" in aliasID:
+        batch_code = "PETAL_CORE_PROD"
+    else:
+        batch_code = "PETAL_CORE_PROTO"
+
+    rc = session.post("addBatchComponent", json={"id":batch_list[batch_code], "component": petal_core["id"]})
+    return rc
+
+
+def registerPetalCore(client, SN, alias, HC_id=None, petal_core=None):
     """Register a Petal Core in the DB.
 
     Args:
-    ----
         SN: Serial Number
         alias: The alias of the Petal
         HC_id: Comma separated list of HC identifiers.
 
-    Returns
-    -------
+    Returns:
         _type_: _description_
 
     """
@@ -95,14 +148,39 @@ def registerPetalCore(client, SN, alias, HC_id=None):
         "componentType": "CORE_PETAL",
         "type": "CORE_AVS",
         "serialNumber": SN,
-        "properties": {'DESY_ID': alias}
+        "properties": {'PRODUCTION_ID': alias}
     }
     if HC_id is not None:
         dto["properties"]["HC_ID"] = HC_id
 
-    db_response = client.post('registerComponent', json=dto)
+    the_component = None
+
     try:
-        return db_response['component']
+        if petal_core is None:
+            db_response = client.post('registerComponent', json=dto)
+            petal_core = db_response['component']
+
+        else:
+            # WE set the alternative ID and the HC_ID
+            the_component = SN
+            if petal_core["alternativeIdentifier"] is None:
+                dto = {
+                    "component": SN,
+                    "code": "PRODUCTION_ID",
+                    "value": alias
+                }
+                db_response = client.post("setComponentProperty", json=dto)
+
+            if HC_id is not None:
+                dto = {
+                    "component": SN,
+                    "code": "HC_ID",
+                    "value": HC_id
+                }
+                db_response = client.post("setComponentProperty", json=dto)
+
+        set_petal_core_batch(client, petal_core)
+        return petal_core
 
     except KeyError:
         return None
@@ -112,7 +190,6 @@ def create_component_attachment(client, SN, file_path, title=None, description="
     """Create an attachment to the given component.
 
     Args:
-    ----
         client: The DB client
         SN: The SN of the component.
         file_path: The pat to th efile to be attached.
@@ -124,7 +201,7 @@ def create_component_attachment(client, SN, file_path, title=None, description="
     global db_response
     db_response = None
     path = Path(file_path).expanduser().resolve()
-    filetype = mimetypes.guess_type(path)
+    filetype =   itkdb.utils.get_mimetype(path, None)
     if title is None:
         title = path.name
 
@@ -159,14 +236,13 @@ def create_component_attachment(client, SN, file_path, title=None, description="
     return db_response
 
 
-def set_component_property(client, SN, property, value):
+def set_component_property(client, SN, the_property, value):
     """Set the value of an object property.
 
     Args:
-    ----
         client: The DB client
         SN: The object SN
-        property: The property name
+        the_property: The property name
         value: The property value
 
     """
@@ -174,7 +250,7 @@ def set_component_property(client, SN, property, value):
     try:
         db_response = client.post('setComponentProperty',
                                   json={'component': SN,
-                                        'code': property,
+                                        'code': the_property,
                                         'value': value})
         return db_response
 
@@ -188,7 +264,6 @@ def assemble_component(client, parent, child):
     """Assemble child into parent.
 
     Args:
-    ----
         client: The DB client
         parent: The parent object or container.
         child: The child to be assembled.
@@ -206,63 +281,192 @@ def assemble_component(client, parent, child):
         return None
 
 
+def set_object_stage(client, SN, stage):
+    """Set stage of object
+
+    Args:
+        client: DB session
+        SN: Serial number
+        stage: Stage
+
+    """
+    global db_response
+    try:
+        db_response = client.post("setComponentStage",
+                                  json={"component": SN, "stage": stage})
+        return db_response
+
+    except Exception as e:
+        print("Problems changing stage of {} into {}:\n\t{}".format(
+            SN, stage, str(e)))
+        return None
+
+
 def get_DB_component(client, SN):
     """Get ta component by its serial number."""
     global db_response
-    db_response = client.get('getComponent', json={'component': SN})
-    return db_response
 
+    try:
+        db_response = client.get("getComponent", json={"component": SN})
+        return db_response
+
+    except Exception as e:
+        db_response = str(e)
+
+    try:
+        out = client.get('getComponent', json={'component': SN, "alternativeIdentifier":True})
+        db_response = out
+        return out
+
+    except Exception as e:
+        db_response = str(e)
+        return None
 
-def upload_test(client, data, attachments=None):
+def upload_test(client, data, attachments=None, check_runNumber=False):
     """Upload a test to the DB.
 
     Args:
-    ----
         client: The DB client
-        data (dict): A distionary with all the elements of thee test.
-        attachments (Attachments): one or more (in a list) Attachments to the test
+        data (dict): A dictionary with all the elements of thee test.
+        attachments ([Attachment]): one or more (in a list) Attachment to the test
 
     Return:
-    ------
         resp: The response of the DB session.
 
     """
     global db_response
+    global attachment_urls
+    global uploaded_test_runs
+
+    uploaded_test_runs = []
+    attachment_urls = {}
+    db_response = None
+
+    # Check the given run_number. If already existing, give another one which
+    # will try to be consecutive.
+    if check_runNumber:
+        # Get all the runNumbers in this test
+        test_list = client.get("listTestRunsByComponent",
+                               json={
+                                    "filterMap":{
+                                    "serialNumber": data["component"],
+                                    "state": "ready",
+                                    "testType":[data["testType"]]
+                                    }
+                                }
+                               )
+        runN= {}
+        for T in test_list:
+            runN[T["runNumber"]] = 1
+
+        if data["runNumber"] in runN:
+            # if the given runNumber is there, try to create a new one.
+            #print("runNumber {} already in {} of {}".format(data["runNumber"], data["testType"], data["component"]))
+            try:
+                irun = int(data["runNumber"])
+                for i in range(irun+1, 100):
+                    newRn = "{}".format(i)
+                    if newRn not in runN:
+                        data["runNumber"] = newRn
+                        break
+
+            except ValueError:
+                for i in range(100):
+                    newRn = "{}_{}".format(data["runNumber"], i+1)
+                    if newRn not in runN:
+                        data["runNumber"] = newRn
+                        break
+
+    # Try to upload the test
     try:
         db_response = client.post("uploadTestRunResults", json=data)
+        testRun = db_response["testRun"]["id"]
+        uploaded_test_runs.append(testRun)
+
+    except Exception as e:
+        msg = "Could not upload the test:\n{}".format(str(e))
+        return msg
+
+    try:
+        # Handle attachments.
+        attachment_urls = {}
         if attachments is not None:
             if not isinstance(attachments, Iterable):
                 attachments = (attachments)
 
             for att in attachments:
-                path = Path(att.path).expanduser().resolve()
-                if not path.exists():
-                    print("File {} does not exist".format(path))
-                    continue
-
-                data = {"testRun": db_response["testRun"]["id"],
+                data = {"testRun": testRun,
                         "title": att.title if att.title is not None else path.name,
                         "description": att.desc if att.desc is not None else path.name,
-                        "type": "file",
+                        "type": att.type,
                         }
-                filetype = mimetypes.guess_type(path.name)
-                attachment = {'data': (path.name, open(path.as_posix(), 'rb'), filetype[0])}
+                if att.type == "file":
+                    path = Path(att.path).expanduser().resolve()
+                    if not path.exists():
+                        print("File {} does not exist".format(path))
+                        continue
+
+                    data["url"] = path.as_uri()
+                    filetype = itkdb.utils.get_mimetype(path.as_posix(), None)
+                    attachment = {'data': (path.as_posix(), open(path.as_posix(), 'rb'), filetype)}
+                else:
+                    data["url"] = att.url
+                    filetype = itkdb.utils.get_mimetype(att.url, None)
+                    attachment = {'data':(att.url, None, "text/x-uri") }
+
                 db_response = client.post('createTestRunAttachment',
                                           data=data,
                                           files=attachment)
+                try:
+                    url = db_response['url'].replace("https://eosatlas.cern.ch","https://cernbox.cern.ch/files/spaces")
+                    attachment_urls[path.name] = url
+
+                except KeyError:
+                    pass
+
 
         return None
 
     except Exception as e:
-        return(str(e))
+        return "Could not upload attachment:\n{}".format(str(e))
+
 
+def set_test_run_parameter(session, test_run, parameter, value):
+    """Modify testRun Parameter
 
-def create_shipment(session, sender, recipient, items, name=None, send=False, type="domestic",
-                    attachment=None, comments=None):
+    Args:
+        session: The ITkDB session
+        test_run: ID of test run
+        parameter: parameter code
+        value: The new value
+    """
+    global db_response
+    try:
+        db_response = session.post("setTestRunParameter",
+                                   json={"testRun": test_run, "code": parameter, "value": value})
+        return None
+
+    except Exception as E:
+        return (str(E))
+
+def create_test_run_comment(session, test_run, comments):
+    """Adds a new comment in testRun."""
+    global db_response
+    if not isinstance(comments, Iterable):
+        comments = (comments)
+
+    try:
+        db_response = session.post("createTestRunComment", json={"testRun": test_run, "comments": comments})
+        return None
+
+    except Exception as E:
+        return (str(E))
+
+def create_shipment(session, sender, recipient, items, name=None, send=False,
+                    shipment_type="domestic", attachment=None, comments=None):
     """Create a chipment.
 
     Args:
-    ----
         session : The itkdb session
         sender : The sender ID
         recipient : The recipient ID
@@ -270,7 +474,7 @@ def create_shipment(session, sender, recipient, items, name=None, send=False, ty
         name: the name of the shipment.
         send: If true, the status of the shipment is updated to inTransit
         type (optional): Type of shipment. Defaults to "domestic".
-        attachment (optional): Attachment object.
+        attachment (optional, :class:`Attachment`): :class:`Attachment` object.
         comments (optional): comments for the shipment
 
     """
@@ -278,7 +482,7 @@ def create_shipment(session, sender, recipient, items, name=None, send=False, ty
     if name is None:
         name = "From {} to {}".format(sender, recipient)
 
-    if type not in ["domestic", "intraContinental", "continental"]:
+    if shipment_type not in ["domestic", "intraContinental", "continental"]:
         db_response = "Wrong shipment type."
         return None
 
@@ -297,7 +501,7 @@ def create_shipment(session, sender, recipient, items, name=None, send=False, ty
         "name": name,
         "sender": sender,
         "recipient": recipient,
-        "type": type,
+        "type": shipment_type,
         "shipmentItems": items,
     }
 
@@ -388,16 +592,19 @@ def from_full_test_to_test_data(full_test):
     for P in full_test["properties"]:
         test["properties"][P["code"]] = P['value']
 
-    for P in full_test["results"]:
-        test["results"][P["code"]] = P['value']
+    if full_test["results"]:
+        for P in full_test["results"]:
+            test["results"][P["code"]] = P['value']
 
-    for C in full_test["comments"]:
-        test["comments"].append(C["comment"])
+    if full_test["comments"]:
+        for C in full_test["comments"]:
+            test["comments"].append(C["comment"])
 
-    for D in full_test["defects"]:
-        test["defects"].append({"name": D["name"],
-                                "description": D["description"],
-                                "properties": D["properties"]})
+    if full_test["defects"]:
+        for D in full_test["defects"]:
+            test["defects"].append({"name": D["name"],
+                                    "description": D["description"],
+                                    "properties": D["properties"]})
 
     return test
 
@@ -406,7 +613,6 @@ def get_testrun(session, test_id, out_type="object"):
     """Retrieve information about a given test.
 
     Args:
-    ----
         session : The itkdb session
         test_id : The ID of the test.
         out_type (optional): Type of output (full or object). Defaults to "object".
@@ -421,11 +627,10 @@ def get_testrun(session, test_id, out_type="object"):
         return None
 
 
-def get_test_skeleton(session, component, test_code, userdef={}, uservalues={}):
+def get_test_skeleton(session, component, test_code, userdef=None, uservalues=None):
     """Get the skeleton of the given test.
 
     Args:
-    ----
         session: The DB session
         component: The component which is tested
         test_code: The test code
@@ -434,6 +639,13 @@ def get_test_skeleton(session, component, test_code, userdef={}, uservalues={}):
 
     """
     global db_response
+
+    if userdef is None:
+        userdef = {}
+
+    if uservalues is None:
+        uservalues = {}
+
     defvalues = {
         "string": "",
         "integer": -9999,
@@ -479,9 +691,9 @@ def get_test_skeleton(session, component, test_code, userdef={}, uservalues={}):
     }
 
     # Set default values
-    for key in skltn.keys():
+    for key, val in skltn.items():
         if key in userdef:
-            if isinstance(skltn[key], dict):
+            if isinstance(val, dict):
                 continue
 
             skltn[key] = userdef[key]
@@ -494,7 +706,7 @@ def get_test_skeleton(session, component, test_code, userdef={}, uservalues={}):
             if vtype in uservalues:
                 val = uservalues[vtype]
             else:
-                print("default for data type ", vtype, " not found")
+                # print("default for data type ", vtype, " not found")
                 val = None
 
         else:
@@ -519,3 +731,29 @@ def get_test_skeleton(session, component, test_code, userdef={}, uservalues={}):
             skltn['results'][key] = get_default(par)
 
     return skltn
+
+def create_client():
+    """Create a Client."""
+    client = itkdb.Client()
+    client.user._access_code1 = getpass.getpass("Access 1: ")
+    client.user._access_code2 = getpass.getpass("Access 2: ")
+    client.user.authenticate()
+    print("Hello {} !".format(client.user.name))
+    return client
+
+def get_db_user(client):
+    """REturn PDB information of current user.
+
+    Args:
+        client (itkdb.Client): The DB client.
+
+    """
+    global db_response
+    if client is None:
+        return None
+
+    try:
+        db_response = client.get("getUser", json={"userIdentity": client.user.identity})
+        return db_response
+    except Exception:
+        return None