Create intermine2os.py

intermine2os.py

@@ -0,0 +1,236 @@
+# intermine2os.py
+
+NAMESPACE = 'wormmine' 
+NAMESPACE = 'mousemine' 
+NAMESPACE = 'flymine' 
+
+from opensearchpy import OpenSearch
+from opensearch_dsl import Search
+
+import opensearch_py_ml as oml
+import pandas as pd
+
+from os_credential import credentials
+
+import json
+from datetime import datetime
+
+from intermine.webservice import Service
+
+import time
+
+def  get_os_client():   
+
+    (OS_HOST, OS_PORT, OS_USER, OS_PASSWORD) = credentials()
+    
+    # Create the client with SSL/TLS enabled, but hostname verification disabled.
+    client = OpenSearch(
+        hosts = [{'host': OS_HOST, 'port': OS_PORT}],
+        http_compress = True, # enables gzip compression for request bodies
+        http_auth = (OS_USER, OS_PASSWORD),
+        use_ssl = True,
+        verify_certs = False,
+        ssl_assert_hostname = False,
+        ssl_show_warn = False
+    )
+    
+    #print(client)
+
+    return client
+
+os_client = get_os_client()
+os_client
+
+oml_classes = oml.DataFrame(os_client, 'intermine-classe')
+oml_classes.shape
+
+pd_classes = oml.opensearch_to_pandas(oml_classes)
+pd_classes.shape
+pd_classes
+
+pd_classes_name = pd_classes.get(['classe', 'namespace', 'count']).query('namespace == "'+NAMESPACE+'"').sort_values('classe')
+print('max', pd_classes_name['count'].max())
+print('sum', pd_classes_name['count'].sum())
+#pd_classes_name
+
+list_classes_name = pd_classes_name.values.tolist()
+list_classes_name
+
+def list2doc(data_views):
+    data_obj = {} 
+    for i in range(0, len(data_views['data'])):
+        key = data_views['views'][i]
+        key = key.split('.')[1]
+        value = data_views['data'][i]
+        #print(key, value)
+
+        if not value is None:
+            data_obj[key] = value
+        
+    return data_obj
+
+test = {'data': [1, '(3R)-3-hydroxyacyl-CoA dehydrogenase', None, 13396260, True], 'views': ['UniProtFeature.begin', 'UniProtFeature.description', 'UniProtFeature.end', 'UniProtFeature.id', 'UniProtFeature.type'], 'index_map': None}
+list2doc(test)
+
+def clase2obj(intermine_service, intermine_class_name, end_pos=10, start_pos=0):
+    
+    query = intermine_service.new_query(intermine_class_name)
+
+    ctr = 0
+    for row in query.rows():
+        ctr += 1
+        if ctr < start_pos:
+            continue
+        if ctr > end_pos:
+            break
+    
+        #print(row["diseaseId"], row["diseaseType"], row["name"], row["primaryIdentifier"], row["alleles.primaryIdentifier"], row["genes.primaryIdentifier"])
+        row_dict = list2doc(row.__dict__)
+        #print(row_dict)
+
+        yield row_dict, ctr
+
+#for (row_dict, ctr) in clase2obj(intermine_service, 'CrossReference', end_pos=100*1000*1000, start_pos=0):
+#    pass
+#print(ctr)
+
+class OSBulkBuffer:
+  """
+  A fixed-size buffer class that overwrites the oldest element when full.
+  """
+  def __init__(self, size, length, index_name, os_connection, debug_mode=False):
+    """
+    Initializes the buffer with a specified size.
+
+    Args:
+        size (int): The maximum number of elements the buffer can hold.
+    """
+    self.buffer = []
+    self.str_length = 0
+    self.head = 0  # Index of the element to be overwritten on next insertion
+
+    self.max_size = size
+    self.max_length = length
+    self.index = index_name
+    self.connection = os_connection
+    self.debug_mode = debug_mode
+
+  def is_full(self):
+    """
+    Checks if the buffer is at its maximum capacity.
+
+    Returns:
+        bool: True if the buffer is full, False otherwise.
+    """
+    return len(self.buffer) == self.max_size
+
+  def transmit(self):
+        """
+        Checks if the buffer is at its maximum capacity.
+        
+        Returns:
+        bool: True if the buffer is full, False otherwise.
+        """
+        #print('plein', self.head)
+        
+        os_buffer = ''
+        
+        for doc in self.buffer:
+            #print(doc)
+            #response = self.connection.index(index=self.index, body=doc, id=doc['doc_id'])
+            #print(response)
+            
+            operation = { "index" : { "_index" : self.index, "_id" : doc['doc_id'] } }
+            os_buffer = os_buffer + '\n' + json.dumps(operation) + '\n' + json.dumps(doc)
+        
+        try:
+            response = self.connection.bulk(os_buffer)
+            if self.debug_mode:
+                print(response)
+        except:
+            print("OS retry 3 minutes")
+            time.sleep(180)
+            response = self.connection.bulk(os_buffer)
+            if self.debug_mode:
+                print(response)
+        
+        
+        self.buffer = []
+        #print(self.buffer)
+        self.str_length = 0
+        self.head = 0
+
+  def put(self, data):
+    """
+    Adds an element to the buffer. If full, overwrites the oldest element.
+
+    Args:
+        data: The data to be added to the buffer.
+    """
+    if self.is_full():
+        self.transmit()
+
+    self.head += 1
+      
+    self.buffer.append(data)
+    #print(len(self.buffer))
+
+  def close(self):
+    """
+    Retrieves the most recently added element from the buffer.
+
+    Returns:
+        any: The data from the buffer, or None if empty.
+    """
+      
+    if self.head == 0:
+        return None
+    else:
+        self.transmit()
+        self.connection.close()
+
+    print('close')
+        
+    return self.connection
+
+
+service_taxon = NAMESPACE
+class_name = 'Sequence'
+
+services = {}
+services['humanmine'] = "https://www.humanmine.org/humanmine/service"
+services['flymine'] = "https://www.flymine.org/flymine/service"
+
+services['mousemine'] = "https://www.mousemine.org/mousemine/service"
+
+services['wormmine'] = "http://intermine.wormbase.org/tools/wormmine/service"
+
+intermine_service = Service(services[NAMESPACE])
+#service = Service("https://www.wormmine.org/wormmine/service")
+
+# Get a new query on the class (table) you will be querying:
+query = intermine_service.new_query(class_name)
+
+log_freq = 100*1000
+namespace = NAMESPACE
+
+my_buffer = OSBulkBuffer(1000, 10000000, 'intermine-' + namespace + '-object', os_client, False)
+
+for class1 in list_classes_name:
+    print(NAMESPACE, class1[0], class1[2])
+    class_name = class1[0]
+    namespace = class1[1]
+
+    if class_name < 'ZZZ':
+        continue
+
+    for (row_dict, ctr) in clase2obj(intermine_service, class_name, end_pos=100*1000*1000, start_pos=0):
+
+        row_dict['doc_id'] = namespace + '-' + class_name + '-' + str(row_dict['id'])
+        row_dict['timestamp'] = datetime.utcnow().isoformat()
+        
+        my_buffer.put(row_dict)
+        if ctr % log_freq == 0 or ctr == 1:
+            print('clase2obj', NAMESPACE, ctr, datetime.utcnow().isoformat())
+
+my_buffer.close()