pyxetabase 3.1.0.dev0__py3-none-any.whl

pyopencga/opencga_config.py

@@ -0,0 +1,160 @@
+import os
+import json
+import requests
+import yaml
+
+
+class ClientConfiguration(object):
+    """PyOpenCGA configuration"""
+    
+    def __init__(self, config_input):
+        """
+        :param dict or str config_input: a dict, or a yaml/json file containing an OpenCGA valid client configuration.
+        """
+
+        if isinstance(config_input, dict):
+            self._config = config_input
+        else:
+            self._config = self._get_dictionary_from_file(config_input)
+
+        self.get_sso_login_info()
+
+        self._validate_configuration()
+
+    @staticmethod
+    def _get_dictionary_from_file(config_fpath):
+        config_fhand = open(config_fpath, 'r')
+
+        if config_fpath.endswith('.yml') or config_fpath.endswith('.yaml'):
+            config_dict = yaml.safe_load(config_fhand)
+        elif config_fpath.endswith('.json'):
+            config_dict = json.loads(config_fhand.read())
+        else:
+            raise NotImplementedError('Input must be a dictionary, a yaml file (.yml or .yaml) or a json file (.json)')
+
+        config_fhand.close()
+
+        return config_dict
+
+    def get_sso_login_info(self):
+        if (('sso_login' in self._config and self._config['sso_login']) or
+                ('cookies' in self._config and self._config['cookies'])):
+            python_session_fhand = open(os.path.expanduser("~/.opencga/session.json"), 'r')
+            session_info = json.loads(python_session_fhand.read())
+            self._config['sso_login'] = True
+            self._config['cookies'] = session_info['cookies']
+            self._config['token'] = session_info['token']
+
+    def _validate_configuration(self):
+        if self._config is None:
+            raise ValueError('Missing configuration dictionary.')
+
+        if 'rest' not in self._config:
+            raise ValueError('Missing configuration field "rest".')
+
+        if 'host' not in self._config['rest'] or not self._config['rest']['host']:
+            raise ValueError('Missing configuration field "host".')
+
+        self._validate_host(self._config['rest']['host'])
+
+    @staticmethod
+    def _validate_host(host):
+        try:
+            r = requests.head(host, timeout=2)
+            if r.status_code == 302:
+                return
+        except requests.ConnectionError:
+            raise Exception('Unreachable host "{}"'.format(host))
+
+    @property
+    def configuration(self):
+        return self._config
+
+    @property
+    def host(self):
+        return self._config['rest']['host']
+
+    @host.setter
+    def host(self, host):
+        self._config['rest']['host'] = host
+        self._validate_host(host)
+
+    @property
+    def version(self):
+        return self._config['version'] if 'version' in self._config else 'v2'
+
+    @version.setter
+    def version(self, version):
+        self._config['version'] = version
+
+    @property
+    def sso_login(self):
+        if 'sso_login' in self._config and self._config['sso_login']:
+            return self._config['sso_login']
+        else:
+            return False
+
+    @sso_login.setter
+    def sso_login(self, sso_login):
+        if isinstance(str, sso_login):
+            self._config['sso_login'] = sso_login.lower() == 'true'
+        if isinstance(bool, sso_login):
+            self._config['sso_login'] = sso_login
+
+    @property
+    def cookies(self):
+        if 'cookies' in self._config and self._config['cookies']:
+            return self._config['cookies']
+        else:
+            return None
+
+    @cookies.setter
+    def cookies(self, cookies):
+        self._config['cookies'] = cookies
+
+    @property
+    def token(self):
+        if 'token' in self._config and self._config['token']:
+            return self._config['token']
+        else:
+            return None
+
+    @token.setter
+    def token(self, token):
+        self._config['token'] = token
+
+    @property
+    def max_attempts(self):
+        """Returns configured max_attempts or 1 if not configured"""
+        if 'max_attempts' in self._config and self._config['max_attempts']:
+            return self._config['max_attempts']
+        else:
+            return 1
+
+    @max_attempts.setter
+    def max_attempts(self, max_attempts):
+        self._config['max_attempts'] = max_attempts
+
+    @property
+    def min_retry_secs(self):
+        """Returns configured min_retry_seconds or 0 if not configured"""
+        if 'min_retry_secs' in self._config and self._config['min_retry_secs']:
+            return self._config['min_retry_secs']
+        else:
+            return 0
+
+    @min_retry_secs.setter
+    def min_retry_secs(self, min_retry_secs):
+        self._config['min_retry_secs'] = min_retry_secs
+
+    @property
+    def max_retry_secs(self):
+        """Returns configured max_retry_seconds or 0 if not configured"""
+        if 'max_retry_secs' in self._config and self._config['max_retry_secs']:
+            return self._config['max_retry_secs']
+        else:
+            return 0
+
+    @max_retry_secs.setter
+    def max_retry_secs(self, max_retry_secs):
+        self._config['max_retry_secs'] = max_retry_secs

pyopencga/rest_clients/_parent_rest_clients.py

@@ -0,0 +1,110 @@
+import json
+
+from pyopencga.commons import execute
+from pyopencga.rest_response import RestResponse
+from pyopencga.retry import retry
+
+
+class _ParentRestClient(object):
+    """Queries the REST service given the different query params"""
+
+    def __init__(self, configuration, token=None, login_handler=None,
+                 auto_refresh=True):
+        self.auto_refresh = auto_refresh
+        self._cfg = configuration
+        self.token = token
+        self.refresh_token = None
+        self.login_handler = login_handler
+        self.on_retry = None
+
+    def _client_login_handler(self):
+        if self.login_handler:
+            self.token, self.refresh_token = self.login_handler()
+
+    def _refresh_token_client(self):
+        if self.login_handler:
+            self.token, self.refresh_token = self.login_handler(refresh=True)
+
+    @staticmethod
+    def _get_query_id_str(query_ids):
+        if query_ids is None:
+            return None
+        elif isinstance(query_ids, list):
+            return ','.join(map(str, query_ids))
+        else:
+            return str(query_ids)
+
+    def _rest_retry(self, method, category, resource, query_id=None, subcategory=None,
+                    second_query_id=None, data=None, dont_retry=None,
+                    **options):
+
+        query_ids_str = self._get_query_id_str(query_id)
+
+        def exec_retry():
+            return execute(config=self._cfg,
+                           sid=self.token,
+                           category=category,
+                           subcategory=subcategory,
+                           method=method,
+                           query_id=query_ids_str,
+                           second_query_id=second_query_id,
+                           resource=resource,
+                           data=data,
+                           options=options)
+
+        def notify_retry(exc_type, exc_val, exc_tb):
+            if self.on_retry is not None:
+                self.on_retry(self, exc_type, exc_val, exc_tb, dict(
+                    method=method, resource=resource, query_id=query_id,
+                    category=category, subcategory=subcategory,
+                    second_query_id=second_query_id, data=data,
+                    options=options
+                ))
+
+        response = retry(
+            exec_retry, self._cfg.max_attempts, self._cfg.min_retry_secs,
+            self._cfg.max_retry_secs, login_handler=self.login_handler,
+            on_retry=notify_retry, dont_retry=dont_retry
+        )
+
+        if self.auto_refresh:
+            self._refresh_token_client()
+
+        if isinstance(response, dict):
+            return RestResponse(response)
+        else:  # Not a JSON (e.g. /{apiVersion}/files/{file}/download)
+            return response
+
+    def _get(self, category, resource, query_id=None, subcategory=None,
+             second_query_id=None, **options):
+        """Queries the REST service and returns the result"""
+        return self._rest_retry(
+            method='get', category=category, resource=resource, query_id=query_id,
+            subcategory=subcategory, second_query_id=second_query_id,
+            **options
+        )
+
+    def _post(self, category, resource, data=None, query_id=None, subcategory=None,
+              second_query_id=None, **options):
+        """Queries the REST service and returns the result"""
+        if data is not None:
+            return self._rest_retry(
+                method='post', category=category, resource=resource, query_id=query_id,
+                subcategory=subcategory, second_query_id=second_query_id,
+                data=data, **options
+            )
+        else:
+            return self._rest_retry(
+                method='post', category=category, resource=resource, query_id=query_id,
+                subcategory=subcategory, second_query_id=second_query_id,
+                **options
+            )
+
+    def _delete(self, category, resource, query_id=None, subcategory=None,
+                second_query_id=None, **options):
+        """Queries the REST service and returns the result"""
+        return self._rest_retry(
+            method='delete', category=category, resource=resource, query_id=query_id,
+            subcategory=subcategory, second_query_id=second_query_id,
+            **options
+        )

pyopencga/rest_clients/admin_client.py

@@ -0,0 +1,173 @@
+"""
+WARNING: AUTOGENERATED CODE
+
+    This code was generated by a tool.
+    
+    Manual changes to this file may cause unexpected behavior in your application.
+    Manual changes to this file will be overwritten if the code is regenerated.
+"""
+
+from pyopencga.rest_clients._parent_rest_clients import _ParentRestClient
+
+
+class Admin(_ParentRestClient):
+    """
+    This class contains methods for the 'Admin' webservices
+    PATH: /{apiVersion}/admin
+    """
+
+    def __init__(self, configuration, token=None, login_handler=None, *args, **kwargs):
+        super(Admin, self).__init__(configuration, token, login_handler, *args, **kwargs)
+
+    def group_by_audit(self, fields, entity, **options):
+        """
+        Group by operation.
+        PATH: /{apiVersion}/admin/audit/groupBy
+
+        :param str entity: Entity to be grouped by. Allowed values: ['AUDIT
+            NOTE ORGANIZATION USER PROJECT STUDY FILE SAMPLE JOB INDIVIDUAL
+            COHORT DISEASE_PANEL FAMILY CLINICAL_ANALYSIS INTERPRETATION
+            VARIANT ALIGNMENT CLINICAL EXPRESSION RGA FUNCTIONAL WORKFLOW
+            RESOURCE'] (REQUIRED)
+        :param str fields: Comma separated list of fields by which to group
+            by. (REQUIRED)
+        :param bool count: Count the number of elements matching the group.
+        :param int limit: Maximum number of documents (groups) to be returned.
+        :param str action: Action performed.
+        :param str before: Object before update.
+        :param str after: Object after update.
+        :param str date: Date <,<=,>,>=(Format: yyyyMMddHHmmss) and
+            yyyyMMddHHmmss-yyyyMMddHHmmss.
+        """
+
+        options['fields'] = fields
+        options['entity'] = entity
+        return self._get(category='admin', resource='groupBy', subcategory='audit', **options)
+
+    def install_catalog(self, data=None, **options):
+        """
+        Install OpenCGA database.
+        PATH: /{apiVersion}/admin/catalog/install
+
+        :param dict data: JSON containing the mandatory parameters. (REQUIRED)
+        """
+
+        return self._post(category='admin', resource='install', subcategory='catalog', data=data, **options)
+
+    def jwt_catalog(self, data=None, **options):
+        """
+        Change JWT secret key.
+        PATH: /{apiVersion}/admin/catalog/jwt
+
+        :param dict data: JSON containing the parameters. (REQUIRED)
+        :param str organization: Organization id.
+        """
+
+        return self._post(category='admin', resource='jwt', subcategory='catalog', data=data, **options)
+
+    def fetch_resource(self, data=None, **options):
+        """
+        Fetch resources from the public server and save them into the OpenCGA
+            local installation.
+        PATH: /{apiVersion}/admin/resource/fetch
+
+        :param dict data: Download-resources tool parameters. (REQUIRED)
+        :param str job_id: Job ID. It must be a unique string within the
+            study. An ID will be autogenerated automatically if not provided.
+        :param str job_description: Job description.
+        :param str job_depends_on: Comma separated list of existing job IDs
+            the job will depend on.
+        :param str job_tags: Job tags.
+        :param str job_scheduled_start_time: Time when the job is scheduled to
+            start.
+        :param str job_priority: Priority of the job.
+        :param bool job_dry_run: Flag indicating that the job will be executed
+            in dry-run mode. In this mode, OpenCGA will validate that all
+            parameters and prerequisites are correctly set for successful
+            execution, but the job will not actually run.
+        """
+
+        return self._post(category='admin', resource='fetch', subcategory='resource', data=data, **options)
+
+    def create_users(self, data=None, **options):
+        """
+        Create a new user.
+        PATH: /{apiVersion}/admin/users/create
+
+        :param dict data: JSON containing the parameters. (REQUIRED)
+        """
+
+        return self._post(category='admin', resource='create', subcategory='users', data=data, **options)
+
+    def import_users(self, data=None, **options):
+        """
+        Import users or a group of users from LDAP or AAD.
+        PATH: /{apiVersion}/admin/users/import
+
+        :param dict data: JSON containing the parameters. (REQUIRED)
+        :param str organization: Organization id.
+        """
+
+        return self._post(category='admin', resource='import', subcategory='users', data=data, **options)
+
+    def permissions_users(self, **options):
+        """
+        User permissions.
+        PATH: /{apiVersion}/admin/users/permissions
+
+        :param str study: Study [[organization@]project:]study where study and
+            project can be either the ID or UUID.
+        :param str entry_ids: Comma separated list of entry ids.
+        :param str permissions: Comma separated list of permissions to be
+            retrieved.
+        :param str category: Category corresponding to the id's provided.
+        """
+
+        return self._get(category='admin', resource='permissions', subcategory='users', **options)
+
+    def search_users(self, **options):
+        """
+        User search method.
+        PATH: /{apiVersion}/admin/users/search
+
+        :param str include: Fields included in the response, whole JSON path
+            must be provided.
+        :param str exclude: Fields excluded in the response, whole JSON path
+            must be provided.
+        :param int limit: Number of results to be returned.
+        :param int skip: Number of results to skip.
+        :param bool count: Get the total number of results matching the query.
+            Deactivated by default.
+        :param str organization: Organization id.
+        :param str user: User ID.
+        :param str authentication_id: Authentication origin ID.
+        """
+
+        return self._get(category='admin', resource='search', subcategory='users', **options)
+
+    def sync_users(self, data=None, **options):
+        """
+        Synchronise a group of users from an authentication origin with a
+            group in a study from catalog.
+        PATH: /{apiVersion}/admin/users/sync
+
+        :param dict data: JSON containing the parameters. (REQUIRED)
+        :param str organization: Organization id.
+        """
+
+        return self._post(category='admin', resource='sync', subcategory='users', data=data, **options)
+
+    def users_update_groups(self, user, data=None, **options):
+        """
+        Add or remove users from existing groups.
+        PATH: /{apiVersion}/admin/users/{user}/groups/update
+
+        :param dict data: JSON containing the parameters. (REQUIRED)
+        :param str user: User ID. (REQUIRED)
+        :param str organization: Organization id.
+        :param str action: Action to be performed: ADD or REMOVE user to/from
+            groups. Allowed values: ['ADD REMOVE']
+        """
+
+        return self._post(category='admin/users', resource='update', query_id=user, subcategory='groups', data=data, **options)
+