pyxetabase 3.1.0.dev0__py3-none-any.whl

pyopencga/commons.py

@@ -0,0 +1,347 @@
+import sys
+import threading
+from time import sleep
+import warnings
+
+import requests
+
+from pyopencga.exceptions import OpencgaInvalidToken, OpencgaAuthorisationError
+
+try:
+    from Queue import Queue
+except ImportError:
+    from queue import Queue
+
+_CALL_BATCH_SIZE = 2000
+_NUM_THREADS_DEFAULT = 4
+
+
+def deprecated(func):
+    """Prints a warning for functions marked as deprecated"""
+    def new_func(*args, **kwargs):
+        warnings.simplefilter('always', DeprecationWarning)  # turn off filter
+        warnings.warn('Call to deprecated function "{}".'.format(func.__name__),
+                      category=DeprecationWarning, stacklevel=2)
+        warnings.simplefilter('default', DeprecationWarning)  # reset filter
+        return func(*args, **kwargs)
+    return new_func
+
+
+def snake_to_camel_case(text):
+    """Converts snake_case to camelCase"""
+    components = text.split('_')
+    return components[0] + ''.join(x.title() for x in components[1:])
+
+
+def _create_rest_url(host, version, sid, category, resource, subcategory=None, query_id=None,
+                     second_query_id=None, options=None):
+    """Creates the URL for querying the REST service"""
+
+    # Creating the basic URL
+    url = ('/'.join([host,
+                     'webservices/rest',
+                     version,
+                     category
+                     ]))
+
+    # If subcategory is queried, query_id can be absent
+    if query_id is not None:
+        url += '/' + query_id
+
+    if subcategory is not None:
+        url += '/' + subcategory
+
+    if second_query_id is not None:
+        url += '/' + second_query_id
+
+    url += '/' + resource
+
+    header = {"Accept-Encoding": "gzip"}
+    if sid is not None:
+        header['Authorization'] = 'Bearer {}'.format(sid)
+
+    # Checking optional params
+    if options is not None:
+        opts = []
+        for k, v in options.items():
+            k = snake_to_camel_case(k)
+            if k == 'debug':
+                continue
+            if isinstance(v, list):
+                opts.append(k + '=' + ','.join(map(str, v)))
+            else:
+                opts.append(k + '=' + str(v))
+        if opts:
+            url += '?' + '&'.join(opts)
+    return url, header
+
+
+def _fetch(config, sid, category, resource, method, subcategory=None, query_id=None,
+           second_query_id=None, data=None, options=None):
+    """Queries the REST service retrieving results until exhaustion or limit"""
+    # HERE BE DRAGONS
+    final_response = None
+
+    # Setting up skip and limit default parameters
+    call_skip = 0
+    call_limit = 1000
+    max_limit = None
+    if options is None:
+        opts = {'skip': call_skip, 'limit': call_limit}
+    else:
+        opts = options.copy()  # Do not modify original data!
+        if 'skip' not in opts:
+            opts['skip'] = call_skip
+        # If 'limit' is specified, a maximum of 'limit' results will be returned
+        if 'limit' in opts:
+            max_limit = int(opts['limit'])
+        # Server must be always queried for results in groups of 1000
+        opts['limit'] = call_limit
+
+    # If there is a query_id, the next variables will be used
+    total_id_list = []  # All initial ids
+    next_id_list = []  # Ids which should be queried again for more results
+    next_id_indexes = []  # Ids position in the final response
+    if query_id is not None:
+        total_id_list = query_id.split(',')
+
+    # If some query has more than 'call_limit' results, the server will be
+    # queried again to retrieve the next 'call_limit results'
+    call = True
+    current_query_id = None  # Current REST query
+    current_id_list = None  # Current list of ids
+    time_out_counter = 0  # Number of times a query is repeated due to time-out
+    while call:
+        # Check 'limit' parameter if there is a maximum limit of results
+        if max_limit is not None and max_limit <= call_limit:
+            opts['limit'] = max_limit
+
+        # Updating query_id and list of ids to query
+        if query_id is not None:
+            if current_query_id is None:
+                current_query_id = query_id
+                current_id_list = total_id_list
+                current_id_indexes = range(len(total_id_list))
+            else:
+                current_query_id = ','.join(next_id_list)
+                current_id_list = next_id_list
+                current_id_indexes = next_id_indexes
+
+        # Retrieving url
+        url, header = _create_rest_url(host=config.host,
+                                       version=config.version,
+                                       category=category,
+                                       sid=sid,
+                                       subcategory=subcategory,
+                                       query_id=current_query_id,
+                                       second_query_id=second_query_id,
+                                       resource=resource,
+                                       options=opts)
+
+        # DEBUG param
+        if opts is not None and 'debug' in opts and opts['debug']:
+            sys.stderr.write(url + '\n')
+
+        # Getting REST response
+        if method == 'get':
+            try:
+                r = requests.get(url, headers=header, cookies=config.cookies)
+            except requests.exceptions.ConnectionError:
+                sleep(1)
+                r = requests.get(url, headers=header, cookies=config.cookies)
+        elif method == 'post':
+            try:
+                r = requests.post(url, json=data, headers=header, cookies=config.cookies)
+            except requests.exceptions.ConnectionError:
+                sleep(1)
+                r = requests.post(url, json=data, headers=header, cookies=config.cookies)
+        elif method == 'delete':
+            try:
+                r = requests.delete(url, headers=header, cookies=config.cookies)
+            except requests.exceptions.ConnectionError:
+                sleep(1)
+                r = requests.delete(url, headers=header, cookies=config.cookies)
+        else:
+            raise NotImplementedError('method: ' + method + ' not implemented.')
+
+        if r.status_code == 504:  # Gateway Time-out
+            if time_out_counter == 99:
+                msg = 'Server not responding in time'
+                raise requests.ConnectionError(msg)
+            time_out_counter += 1
+            continue
+        time_out_counter = 0
+
+        if r.status_code == 401:
+            raise OpencgaInvalidToken(r.content)
+        elif r.status_code == 403:
+            raise OpencgaAuthorisationError(r.content)
+        elif r.status_code != 200:
+            raise Exception(r.content)
+
+        if r.headers['Content-Type'] == 'application/json':
+            try:
+                response = r.json()
+
+                # TODO Remove deprecated response and result in future release. Added for backwards compatibility
+                if 'response' in response:
+                    response['responses'] = response['response']
+                for query_result in response['responses']:
+                    if 'result' in query_result:
+                        query_result['results'] = query_result['result']
+
+            except ValueError:
+                raise ValueError('Bad JSON format retrieved from server')
+        elif r.headers['Content-Type'] == 'application/octet-stream':
+            return r.content
+        else:
+            raise ValueError('Unexpected content type retrieved from server ("{}"): "{}"'.format(
+                r.headers['Content-Type'], r.content)
+            )
+
+        # Setting up final_response
+        if final_response is None:
+            final_response = response
+        # Concatenating results
+        else:
+            if query_id is not None:
+                for index, res in enumerate(response['responses']):
+                    id_index = current_id_indexes[index]
+                    final_response[id_index]['results'] += res['results']
+            else:
+                final_response['responses'][0]['results'] += response['responses'][0]['results']
+
+        if query_id is not None:
+            # Checking which ids are completely retrieved
+            next_id_list = []
+            next_id_indexes = []
+            for index, res in enumerate(response['responses']):
+                if res['numResults'] == call_limit:
+                    next_id_list.append(current_id_list[index])
+                    next_id_indexes.append(current_id_indexes[index])
+            # Ending REST calling when there are no more ids to retrieve
+            if not next_id_list:
+                call = False
+        else:
+            # Ending REST calling when there are no more results to retrieve
+            if response['responses'][0]['numResults'] != call_limit:
+                call = False
+
+        # Skipping the first 'limit' results to retrieve the next ones
+        opts['skip'] += call_limit
+
+        # Subtracting the number of returned results from the maximum goal
+        if max_limit is not None:
+            max_limit -= call_limit
+            # When 'limit' is 0 returns all the results. So, break the loop if 0
+            if max_limit == 0:
+                break
+
+    return final_response
+
+
+def _worker(queue, results, config, sid, category, resource, method, subcategory=None,
+            second_query_id=None, data=None, options=None):
+
+    """Manages the queue system for the threads"""
+    while True:
+        # Fetching new element from the queue
+        index, query_id = queue.get()
+        response = _fetch(config=config, sid=sid, category=category, subcategory=subcategory,
+                          resource=resource, method=method, data=data, query_id=query_id,
+                          second_query_id=second_query_id, options=options)
+        # Store data in results at correct index
+        results[index] = response
+        # Signaling to the queue that task has been processed
+        queue.task_done()
+
+
+def merge_query_responses(query_response_list):
+    final_response = query_response_list[0]
+    for i, query_response in enumerate(query_response_list):
+        if i != 0:
+            final_response['events'] += query_response['events']
+            final_response['time'] += query_response['time']
+            # final_response['responses'] += response['responses']
+
+            for key in query_response['params']:
+                if final_response['params'][key] != query_response['params'][key]:
+                    final_response['params'][key] += ',' + query_response['params'][key]
+
+            for j, query_result in enumerate(query_response['responses']):
+                if len(final_response['responses'])-1 < j:
+                    final_response['responses'] += []
+                for key in query_result:
+                    if key not in final_response['responses'][j]:
+                        final_response['responses'][j][key] = query_result[key]
+                    else:
+                        if isinstance(query_result[key], (int, list)):
+                            final_response['responses'][j][key] += query_result[key]
+    return final_response
+
+
+def execute(config, sid, category, resource, method, subcategory=None, query_id=None,
+            second_query_id=None, data=None, options=None):
+    """Queries the REST service using multiple threads if needed"""
+
+    # If query_id is an array, convert to comma-separated string
+    if query_id is not None:
+        if isinstance(query_id, list):
+            query_id = ','.join([str(item) for item in query_id])
+        else:
+            query_id = str(query_id)  # convert to string so we can call this method with int ids
+
+    # Multithread if the number of queries is greater than _CALL_BATCH_SIZE
+    if query_id is None or len(query_id.split(',')) <= _CALL_BATCH_SIZE:
+        response = _fetch(config=config, sid=sid, category=category, subcategory=subcategory,
+                          resource=resource, method=method, data=data, query_id=query_id,
+                          second_query_id=second_query_id, options=options)
+        return response
+    else:
+        if options is not None and 'num_threads' in options:
+            num_threads = options['num_threads']
+        else:
+            num_threads = _NUM_THREADS_DEFAULT
+
+        # Splitting query_id into batches depending on the call batch size
+        id_list = query_id.split(',')
+        id_batches = [','.join(id_list[x:x + _CALL_BATCH_SIZE])
+                      for x in range(0, len(id_list), _CALL_BATCH_SIZE)]
+
+        # Setting up the queue to hold all the id batches
+        q = Queue(maxsize=0)
+        # Creating a size defined list to store thread results
+        res = [''] * len(id_batches)
+
+        # Setting up the threads
+        for thread in range(num_threads):
+            t = threading.Thread(target=_worker,
+                                 kwargs={'queue': q,
+                                         'results': res,
+                                         'config': config,
+                                         'sid': sid,
+                                         'category': category,
+                                         'subcategory': subcategory,
+                                         'second_query_id': second_query_id,
+                                         'resource': resource,
+                                         'method': method,
+                                         'data': data,
+                                         'options': options})
+            # Setting threads as "daemon" allows main program to exit eventually
+            # even if these do not finish correctly
+            t.daemon = True
+            t.start()
+
+        # Loading up the queue with index and id batches for each job
+        for index, batch in enumerate(id_batches):
+            q.put((index, batch))  # Notice this is a tuple
+
+        # Waiting until the queue has been processed
+        q.join()
+
+    # Joining all the responses into a one final response
+    final_query_response = merge_query_responses(res)
+
+    return final_query_response
+
+

pyopencga/exceptions.py

@@ -0,0 +1,8 @@
+class OpencgaAuthorisationError(Exception):
+    def __init__(self, message):
+        super(OpencgaAuthorisationError, self).__init__(message)
+
+
+class OpencgaInvalidToken(Exception):
+    def __init__(self, message):
+        super(OpencgaInvalidToken, self).__init__(message)

pyopencga/opencga_client.py

@@ -0,0 +1,334 @@
+import getpass
+import time
+import sys
+import re
+if sys.version_info >= (3, 8):
+    from importlib.metadata import version
+else:
+    from importlib_metadata import version
+
+from pyopencga.opencga_config import ClientConfiguration
+from pyopencga.rest_clients.admin_client import Admin
+from pyopencga.rest_clients.alignment_client import Alignment
+from pyopencga.rest_clients.clinical_analysis_client import ClinicalAnalysis
+from pyopencga.rest_clients.cohort_client import Cohort
+from pyopencga.rest_clients.family_client import Family
+from pyopencga.rest_clients.file_client import File
+from pyopencga.rest_clients.ga4gh_client import GA4GH
+from pyopencga.rest_clients.individual_client import Individual
+from pyopencga.rest_clients.job_client import Job
+from pyopencga.rest_clients.meta_client import Meta
+from pyopencga.rest_clients.disease_panel_client import DiseasePanel
+from pyopencga.rest_clients.project_client import Project
+from pyopencga.rest_clients.sample_client import Sample
+from pyopencga.rest_clients.study_client import Study
+from pyopencga.rest_clients.variant_operation_client import VariantOperation
+from pyopencga.rest_clients.user_client import User
+from pyopencga.rest_clients.variant_client import Variant
+from pyopencga.rest_clients.organization_client import Organization
+from pyopencga.rest_clients.workflow_client import Workflow
+
+
+class OpencgaClient(object):
+    def __init__(self, configuration, token=None, refresh_token=None, on_retry=None, auto_refresh=True):
+        """
+        :param on_retry: callback to be called with client retries an operation.
+            It must accept parameters: client, exc_type, exc_val, exc_tb, call
+        """
+
+        if not isinstance(configuration, ClientConfiguration):
+            raise ValueError('Expected ClientConfiguration instance')
+
+        self.configuration = configuration
+        self.auto_refresh = auto_refresh
+        self.on_retry = on_retry
+        self.clients = []
+        self._login_handler = None
+        self.token = token
+        self.refresh_token = refresh_token
+        self._create_clients()
+        self._check_versions()
+        if self.configuration.sso_login:
+            self._sso_login()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.logout()
+
+    def _check_versions(self):
+        # Getting client and server versions
+        client_version = version("pyopencga")
+        server_version = self.meta.about().get_result(0)['Version'].split('-')[0]
+
+        ansi_reset = "\033[0m"
+        ansi_red = "\033[31m"
+        ansi_yellow = "\033[33m"
+        if tuple(server_version.split('.')[:2]) < tuple(client_version.split('.')[:2]):
+            msg = '[WARNING]: Client version ({}) is higher than server version ({}).' \
+                  ' Some client features may not be implemented in the server.\n'.format(client_version, server_version)
+            sys.stdout.write('{}{}{}'.format(ansi_red, msg, ansi_reset))
+        elif tuple(server_version.split('.')[:2]) > tuple(client_version.split('.')[:2]):
+            msg = '[INFO]: Client version ({}) is lower than server version ({}).' \
+                   ' Some client features may not work as intended.\n'.format(client_version, server_version)
+            sys.stdout.write('{}{}{}'.format(ansi_yellow, msg, ansi_reset))
+
+    def _create_clients(self):
+        self.organizations = Organization(self.configuration, self.token, self._login_handler, auto_refresh=self.auto_refresh)
+        self.users = User(self.configuration, self.token, self._login_handler, auto_refresh=self.auto_refresh)
+        self.projects = Project(self.configuration, self.token, self._login_handler, auto_refresh=self.auto_refresh)
+        self.studies = Study(self.configuration, self.token, self._login_handler, auto_refresh=self.auto_refresh)
+        self.files = File(self.configuration, self.token, self._login_handler, auto_refresh=self.auto_refresh)
+        self.jobs = Job(self.configuration, self.token, self._login_handler, auto_refresh=self.auto_refresh)
+        self.samples = Sample(self.configuration, self.token, self._login_handler, auto_refresh=self.auto_refresh)
+        self.individuals = Individual(self.configuration, self.token, self._login_handler, auto_refresh=self.auto_refresh)
+        self.families = Family(self.configuration, self.token, self._login_handler, auto_refresh=self.auto_refresh)
+        self.cohorts = Cohort(self.configuration, self.token, self._login_handler, auto_refresh=self.auto_refresh)
+        self.disease_panels = DiseasePanel(self.configuration, self.token, self._login_handler, auto_refresh=self.auto_refresh)
+        self.alignments = Alignment(self.configuration, self.token, self._login_handler, auto_refresh=self.auto_refresh)
+        self.variants = Variant(self.configuration, self.token, self._login_handler, auto_refresh=self.auto_refresh)
+        self.clinical = ClinicalAnalysis(self.configuration, self.token, self._login_handler, auto_refresh=self.auto_refresh)
+        self.operations = VariantOperation(self.configuration, self.token, self._login_handler, auto_refresh=self.auto_refresh)
+        self.variant_operations = self.operations  # DEPRECATED: use 'self.operations'
+        self.meta = Meta(self.configuration, self.token, self._login_handler, auto_refresh=self.auto_refresh)
+        self.ga4gh = GA4GH(self.configuration, self.token, self._login_handler, auto_refresh=self.auto_refresh)
+        self.admin = Admin(self.configuration, self.token, self._login_handler, auto_refresh=self.auto_refresh)
+        self.workflows = Workflow(self.configuration, self.token, self._login_handler, auto_refresh=self.auto_refresh)
+
+        self.clients = [
+            self.organizations, self.users, self.projects, self.studies, self.files, self.jobs,
+            self.samples, self.individuals, self.families, self.cohorts,
+            self.disease_panels, self.alignments, self.variants, self.clinical, self.operations,
+            self.variant_operations, self.meta, self.ga4gh, self.admin, self.workflows
+        ]
+
+        for client in self.clients:
+            client.on_retry = self.on_retry
+
+    def _make_login_handler(self, user=None, password=None, organization=None):
+        """
+        Returns a closure that performs the log-in. This will be called on retries
+        if the current session ever expires.
+        The reason for using a closure and not a normal function is that a normal
+        function would require storing the password in a field. It is more secure
+        not to do so. This way, the password stored in the closure is inaccessible
+        to other code
+        """
+        def login_handler(refresh=False):
+            if refresh:
+                data = {'refreshToken': self.refresh_token}
+            else:
+                data = {'user': user, 'password': password}
+            if organization:
+                data.update({'organization': organization})
+            tokens = User(self.configuration).login(data=data).get_result(0)
+            self.token = tokens['token']
+            self.refresh_token = tokens['refreshToken']
+            return self.token, self.refresh_token
+        return login_handler
+
+    def login(self, user=None, password=None, organization=None):
+        if user is not None and password is None:
+            password = getpass.getpass()
+        if not (user and password):
+            raise ValueError('User and password required')
+
+        self._login_handler = self._make_login_handler(user=user, password=password, organization=organization)
+        self._login_handler()
+        for client in self.clients:
+            client.token = self.token
+            client.refresh_token = self.refresh_token
+            client.login_handler = self._login_handler
+
+    def _sso_login(self):
+        # Getting token and refresh token from configuration
+        self.token = self.configuration.token
+        self.refresh_token = self.configuration.token
+
+        self._login_handler = self._make_login_handler()
+        for client in self.clients:
+            client.token = self.token
+            client.refresh_token = self.refresh_token
+            client.login_handler = self._login_handler
+
+    def logout(self):
+        self.token = None
+        self.refresh_token = None
+        for client in self.clients:
+            client.token = self.token
+            client.refresh_token = self.refresh_token
+
+    def wait_for_job(self, response=None, study_id=None, job_id=None, retry_seconds=10):
+        if response is not None:
+            study_id = response['results'][0]['study']['id']
+            job_id = response['results'][0]['id']
+
+        if response is None and (study_id is None or job_id is None):
+            raise ValueError('Argument "response" or arguments "study" and "job_id" must be provided')
+
+        if len(job_id.split(',')) > 1:
+            raise ValueError('Only one job ID is allowed')
+
+        retry_seconds = retry_seconds if retry_seconds >= 10 else 10
+        while True:
+            job_info = self.jobs.info(study=study_id, jobs=job_id).get_result(0)
+            if job_info['internal']['status']['id'] in ['ERROR', 'ABORTED']:
+                raise ValueError('{} ({}): {}'.format(
+                    job_info['internal']['status']['id'],
+                    job_info['internal']['status']['date'],
+                    job_info['internal']['status']['description']
+                ))
+            elif job_info['internal']['status']['id'] in ['DONE']:
+                break
+            time.sleep(retry_seconds)
+
+    def _get_help_info(self, client_name=None, parameters=False):
+        info = []
+        for client in self.clients:
+            # Name
+            cls_name = type(client).__name__
+            client_method = re.sub(r'(?<!^)(?=[A-Z])', '_', cls_name).lower() \
+                if cls_name != 'GA4GH' else cls_name.lower()
+            client_method = 'get_' + client_method + '_client'
+
+            if client_name is not None and client_name != cls_name:
+                continue
+
+            # Description and path
+            class_docstring = client.__doc__
+            cls_desc = re.findall('(This class contains methods .+)\n', class_docstring)[0]
+            cls_path = re.findall('PATH: (.+)\n', class_docstring)[0]
+
+            # Methods
+            methods = []
+            method_names = [method_name for method_name in dir(client)
+                            if callable(getattr(client, method_name))
+                            and not method_name.startswith('_') and method_name != 'login_handler']
+            for method_name in method_names:
+                if client_name is None:
+                    continue
+                method_docstring = getattr(client, method_name).__doc__
+                desc = re.findall('(.+)\n +PATH', method_docstring, re.DOTALL)
+                desc = re.sub(' +', ' ', desc[0].replace('\n', ' ').strip())
+                path = re.findall('PATH: (.+)\n', method_docstring)[0]
+
+                args = []
+                arguments = re.findall(
+                    ' +:param (.+)', method_docstring, re.DOTALL
+                )
+                if arguments and parameters:
+                    arguments = arguments[0].replace('\n', ' ').strip()
+                    arguments = re.sub(' +', ' ', arguments)
+                    arguments = arguments.split(' :param ')
+                    for parameter in arguments:
+                        param_info = parameter.split(' ', 2)
+                        args.append({
+                            'name': param_info[1].rstrip(':'),
+                            'type': param_info[0],
+                            'desc': param_info[2]
+                        })
+                methods.append({
+                    'name': method_name,
+                    'desc': desc,
+                    'path': path,
+                    'params': args
+                })
+
+            info.append(
+                {'class_name': cls_name, 'client_method': client_method,
+                 'desc': cls_desc, 'path': cls_path, 'methods': methods}
+            )
+        return info
+
+    def help(self, client_name=None, show_parameters=False):
+        help_txt = []
+
+        info = self._get_help_info(client_name, show_parameters)
+        if client_name is None:
+            help_txt += ['Available clients:']
+            for client in info:
+                txt = '{}- {}: {} ({}). USAGE: opencga_client.{}()'
+                help_txt += [txt.format(
+                    ' '*4, client['class_name'], client['desc'],
+                    client['path'], client['client_method']
+                )]
+        else:
+            for client in info:
+                help_txt += ['{}: {} ({}). USAGE: opencga_client.{}()'.format(
+                    client['class_name'], client['desc'], client['path'],
+                    client['client_method']
+                )]
+                help_txt += ['{}Available methods:'.format(' '*4)]
+                for method in client['methods']:
+                    help_txt += ['{}- {}: {} ({})'.format(
+                        ' '*8, method['name'], method['desc'], method['path']
+                    )]
+                    if not show_parameters:
+                        continue
+                    for param in method['params']:
+                        help_txt += ['{}* {} ({}): {}'.format(
+                            ' ' * 12, param['name'], param['type'],
+                            param['desc']
+                        )]
+        sys.stdout.write('\n'.join(help_txt) + '\n')
+
+    def get_organization_client(self):
+        return self.organizations
+
+    def get_user_client(self):
+        return self.users
+
+    def get_project_client(self):
+        return self.projects
+
+    def get_study_client(self):
+        return self.studies
+
+    def get_file_client(self):
+        return self.files
+
+    def get_job_client(self):
+        return self.jobs
+
+    def get_sample_client(self):
+        return self.samples
+
+    def get_individual_client(self):
+        return self.individuals
+
+    def get_family_client(self):
+        return self.families
+
+    def get_cohort_client(self):
+        return self.cohorts
+
+    def get_disease_panel_client(self):
+        return self.disease_panels
+
+    def get_alignment_client(self):
+        return self.alignments
+
+    def get_variant_client(self):
+        return self.variants
+
+    def get_clinical_client(self):
+        return self.clinical
+
+    def get_operations_client(self):
+        return self.operations
+
+    def get_variant_operation_client(self):
+        return self.variant_operations
+
+    def get_meta_client(self):
+        return self.meta
+
+    def get_ga4gh_client(self):
+        return self.ga4gh
+
+    def get_admin_client(self):
+        return self.admin
+
+    def get_workflows_client(self):
+        return self.workflows