basepair 1.5__0-py3.8.egg

basepair/helpers/__init__.py

@@ -0,0 +1,3 @@
+from .eprint import eprint
+from .nice_print import NicePrint
+from .set_filter import SetFilter

basepair/helpers/eprint.py

@@ -0,0 +1,8 @@
+'''Helper for print in stderr'''
+
+# General imports
+import sys
+
+def eprint(*args, **kwargs):
+  '''print in sys.stderr'''
+  print(*args, file=sys.stderr, **kwargs)

basepair/helpers/nice_print.py

@@ -0,0 +1,170 @@
+'''Helper to print object nicely'''
+
+# General imports
+import os
+
+# Lib imports
+from tabulate import tabulate
+
+class NicePrint:
+  '''Helper class to print nice objects'''
+
+  @staticmethod
+  def analyses(data):
+    '''Print analyses'''
+    to_print = [
+      [
+        analysis['id'],
+        analysis['name'],
+        analysis['started_on'],
+        analysis['completed_on'],
+        analysis['status'],
+        analysis['meta']['num_files'],
+        analysis['tags']
+      ] for analysis in data
+    ]
+    print(tabulate(to_print, headers=[
+      'id',
+      'name',
+      'started on',
+      'completed on',
+      'status',
+      'num files',
+      'tags',
+    ]))
+
+  @staticmethod
+  def analysis(data):
+    '''Print analysis'''
+    for analysis in data:
+      to_print = [
+        ['id', analysis['id']],
+        ['name', analysis['name']],
+        ['date_created', analysis['date_created']],
+        ['completed_on', analysis['completed_on']],
+      ]
+
+      for sample in analysis['samples']:
+        to_print.append(['sample', sample.split('/')[-1]])
+
+      if analysis['controls']:
+        for control in analysis['controls']:
+          to_print.append(['control', control['id']])
+
+      print('\nAnalysis info:')
+      print(tabulate(to_print, headers=['Variable', 'Value']))
+
+      print('\nAnalysis files:')
+
+      # convert only filesizes that are not None
+      for filedata in analysis['files']:
+        filedata['filesize'] = filedata['filesize']/(1024.**3) if filedata['filesize'] else 'NA'
+
+      to_print = [
+        [
+          file['id'],
+          file['filesize'],
+          file['source'],
+          os.path.split(file['path'])[1],
+          file['tags'],
+        ] for file in analysis['files']
+      ]
+      print(tabulate(
+        to_print,
+        floatfmt='.4f',
+        headers=[
+          'id',
+          'filesize (Gigabytes)',
+          'source',
+          'name',
+          'tags',
+        ],
+        numalign='right',
+      ))
+      print('\n\n')
+
+  @staticmethod
+  def genome(data):
+    '''Print genome'''
+    to_print = [[genome['id'], genome['name'], genome['created_on']] for genome in data]
+    print(tabulate(to_print, headers=['id', 'name', 'created_on']))
+
+  @staticmethod
+  def genomes(data):
+    '''Print genomes'''
+    NicePrint.genome(data)
+
+  @staticmethod
+  def sample(data):
+    '''Print sample'''
+    for sample in data:
+      print('Sample id: {}'.format(sample['id']))
+      print('Sample name: {}'.format(sample['name']))
+      print('Sample datatype: {}'.format(sample['datatype']))
+      print('Sample genome: {}'.format(sample['genome_name'] or sample['genome']))
+      print('Sample data created: {}'.format(sample['date_created']))
+      print('Sample num reads: {}'.format(sample['meta']['num_reads']))
+      print('Analyses:')
+      to_print = [
+        [
+          analysis['id'],
+          analysis['name'],
+          analysis['started_on'],
+          analysis['completed_on'],
+          analysis['status'],
+          analysis['meta']['num_files'],
+          analysis['tags']
+        ] for analysis in sample['analyses_full']
+      ]
+      print(tabulate(to_print, headers=[
+        'id',
+        'name',
+        'started on',
+        'completed on',
+        'status',
+        'num files',
+        'tags',
+      ]))
+      print('\n\n')
+
+  @staticmethod
+  def samples(data):
+    '''Print samples'''
+    to_print = [
+      [
+        sample['id'],
+        sample['name'],
+        sample['datatype'],
+        sample['genome_name'] or sample['genome'],
+        sample['date_created'],
+        sample['meta']['num_reads']
+      ] for sample in data
+    ]
+    print(tabulate(to_print, headers=[
+      'id',
+      'name',
+      'datatype',
+      'genome',
+      'date created',
+      'num reads',
+    ]))
+
+  @staticmethod
+  def workflows(data):
+    '''Print pipelines'''
+    to_print = [
+      [
+        pipeline['id'],
+        pipeline['name'],
+        pipeline['datatype'],
+        pipeline['description'],
+        pipeline['tags']
+      ] for pipeline in data
+    ]
+    print(tabulate(to_print, headers=[
+      'id',
+      'name',
+      'datatype',
+      'description',
+      'tags',
+    ]))

basepair/helpers/set_filter.py

@@ -0,0 +1,18 @@
+'''Helper to filter sets of data'''
+
+class SetFilter:
+  '''Helper class to filter list'''
+  @staticmethod
+  def diff(a_set, b_set):
+    '''Filter by not intersection'''
+    return not set(b_set).intersection(set(a_set))
+
+  @staticmethod
+  def exact(a_set, b_set):
+    '''Filter by eq'''
+    return set(a_set) == set(b_set)
+
+  @staticmethod
+  def subset(a_set, b_set):
+    '''Filter by intersection'''
+    return set(a_set).intersection(set(b_set))

basepair/infra/configuration/__init__.py

@@ -0,0 +1 @@
+from .parser import Parser

basepair/infra/configuration/parser.py

@@ -0,0 +1,67 @@
+'''Configuration parser'''
+
+# General imports
+import json
+import os
+
+# App imports
+from basepair.helpers import eprint
+
+class Parser(): # pylint: disable=too-few-public-methods
+  '''Configuration parser class'''
+  def __init__(self, source):
+    # check if local json file
+    self.cfg = {}
+    if isinstance(source, dict):
+      self.cfg = source
+    elif os.path.isfile(source):
+      try:
+        self.cfg = json.load(open(source))
+      except OSError as error:
+        eprint(f'ERROR: Not able to open config file: {error}')
+      except ValueError as error:
+        eprint(f'ERROR: Not able to read config file: {error}')
+    # TODO: if uri implement configuration manager
+
+  @staticmethod
+  def get_cli_credentials_from(cfg):
+    '''Get cli credential from service cfg'''
+    credentials = ''
+    credentials_cfg = cfg.get('credentials', {})
+    if credentials_cfg and not credentials_cfg.get('role'):
+      credentials = 'AWS_ACCESS_KEY_ID={} AWS_SECRET_ACCESS_KEY={} '.format(
+        credentials_cfg.get('id'),
+        credentials_cfg.get('secret'),
+      )
+    return credentials
+
+  def get_reflib_storage(self, bucket=None):
+    '''Get storage setting for reflibs'''
+    storages_cfg = self.cfg.get('storage', {}).get('reflib', {})
+    all_reflib_buckets = []
+    for storage_cfg in storages_cfg:
+      storage_settings = storage_cfg.get('settings', {})
+      all_reflib_buckets.append({
+        'bucket': bucket or storage_settings.get('bucket'),
+        'credentials': storage_cfg.get('credentials'),
+        'region': storage_settings.get('region'),
+      })
+    return all_reflib_buckets
+
+  def get_user_storage(self, bucket=None):
+    '''Get storage setting'''
+    storage_cfg = self.cfg.get('storage', {}).get('user', {})
+    storage_settings = storage_cfg.get('settings', {})
+    return {
+      'bucket': bucket or storage_settings.get('bucket'),
+      'credentials': storage_cfg.get('credentials'),
+      'region': storage_settings.get('region'),
+    }
+
+  def get_webapp_api(self):
+    '''Get webapp api settings'''
+    return self.cfg.get('api', {})
+
+  def is_empty(self):
+    '''Check if cfg is empty'''
+    return not self.cfg

basepair/infra/webapp/__init__.py

@@ -0,0 +1,12 @@
+from .analysis import Analysis
+from .file import File
+from .gene import Gene
+from .genome import Genome
+from .genome_file import GenomeFile
+from .host import Host
+from .module import Module
+from .pipeline import Pipeline
+from .project import Project
+from .sample import Sample
+from .upload import Upload
+from .user import User

basepair/infra/webapp/abstract.py

@@ -0,0 +1,128 @@
+'''Webapp API'''
+
+# General imports
+import json
+import os
+
+# Lib imports
+import requests
+
+# App imports
+from basepair.helpers import eprint
+
+class Abstract:
+  '''Webapp abastract class'''
+  def __init__(self, cfg):
+    protocol = 'https' if cfg.get('ssl', True) else 'http'
+    self.endpoint = protocol + '://' + cfg.get('host') + cfg.get('prefix')
+    self.payload = {
+      'username': cfg.get('username'),
+      'api_key': cfg.get('key')
+    }
+    self.headers = {'content-type': 'application/json'}
+
+  def delete(self, obj_id, verify=True):
+    '''Delete resource'''
+    try:
+      response = requests.delete(
+        '{}{}'.format(self.endpoint, obj_id),
+        params=self.payload,
+        verify=verify
+      )
+      return self._parse_response(response)
+    except requests.exceptions.RequestException as error:
+      eprint('ERROR: {}'.format(error))
+      return { 'error': True, 'msg': error}
+
+  def get(self, obj_id, cache=False, params={}, verify=True): # pylint: disable=dangerous-default-value
+    '''Get detail of an resource'''
+    if cache:
+      filename = os.path.expanduser(cache)
+      if os.path.exists(filename) and os.path.getsize(filename):
+        return json.loads(open(filename, 'r').read().strip())
+
+    params.update(self.payload)
+    try:
+      response = requests.get(
+        '{}{}'.format(self.endpoint, obj_id),
+        params=params,
+        verify=verify,
+      )
+      parsed = self._parse_response(response)
+
+      # save in cache if required
+      if cache and parsed and not parsed.get('error'):
+        directory = os.path.dirname(filename)
+        if not os.path.exists(directory):
+          os.makedirs(directory)
+        with open(filename, 'w') as handle:
+          handle.write(json.dumps(parsed, indent=2))
+      return parsed
+    except requests.exceptions.RequestException as error:
+      eprint('ERROR: {}'.format(error))
+      return {'error': True, 'msg': error}
+
+  def list(self, params={'limit': 100}, verify=True): # pylint: disable=dangerous-default-value
+    '''Get a list of items'''
+    params.update(self.payload)
+    try:
+      response = requests.get(
+        self.endpoint.rstrip('/'),
+        params=params,
+        verify=verify,
+      )
+      return self._parse_response(response)
+    except requests.exceptions.RequestException as error:
+      eprint('ERROR: {}'.format(error))
+      return {'error': True, 'msg': error}
+
+  def list_all(self): # pylint: disable=dangerous-default-value
+    '''Get a list of all items'''
+    item_list = []
+    limit = 500
+    offset = 0
+    total_count = 1
+    while len(item_list) < total_count:
+      response = self.list({'limit': limit, 'offset': offset})
+      if response.get('error'):
+        return {'error': True, 'msg': response.get('msg')}
+      total_count = response.get('meta', {}).get('total_count')
+      item_list += response.get('objects')
+      offset += limit
+    return item_list
+
+  def save(self, obj_id=None, params={}, payload={}, verify=True): # pylint: disable=dangerous-default-value
+    '''Save or update resource'''
+    params.update(self.payload)
+    try:
+      response = getattr(requests, 'put' if obj_id else 'post')(
+        '{}{}'.format(self.endpoint, obj_id or ''),
+        data=json.dumps(payload),
+        headers=self.headers,
+        params=params,
+        verify=verify,
+      )
+      return self._parse_response(response)
+    except requests.exceptions.RequestException as error:
+      eprint('ERROR: {}'.format(error))
+      return {'error': True, 'msg': error}
+
+  @classmethod
+  def _parse_response(cls, response):
+    '''General response parser'''
+    error_msgs = {
+      401: 'You don\'t have access to this resource.',
+      404: 'Resource not found.',
+      500: 'Error retrieving data from API!'
+    }
+
+    if response.status_code in error_msgs:
+      eprint('ERROR: {}'.format(error_msgs[response.status_code]))
+      return {'error': True, 'msg': error_msgs[response.status_code]}
+
+    try:
+      return response.json()
+    except json.decoder.JSONDecodeError as error:
+      msg = 'ERROR: Not able to parse response: {}.'.format(error)
+      eprint(msg)
+      return {'error': True, 'msg': msg}

basepair/infra/webapp/analysis.py

@@ -0,0 +1,10 @@
+'''Analysis webapp api wrapper'''
+
+# App imports
+from .abstract import Abstract
+
+class Analysis(Abstract):
+  '''Webapp Analysis class'''
+  def __init__(self, cfg):
+    super().__init__(cfg)
+    self.endpoint += 'analyses/'

basepair/infra/webapp/file.py

@@ -0,0 +1,10 @@
+'''File webapp api wrapper'''
+
+# App imports
+from .abstract import Abstract
+
+class File(Abstract):
+  '''Webapp File class'''
+  def __init__(self, cfg):
+    super().__init__(cfg)
+    self.endpoint += 'files/'

basepair/infra/webapp/gene.py

@@ -0,0 +1,10 @@
+'''Gene webapp api wrapper'''
+
+# App imports
+from .abstract import Abstract
+
+class Gene(Abstract):
+  '''Webapp Gene class'''
+  def __init__(self, cfg):
+    super().__init__(cfg)
+    self.endpoint += 'genes/'

basepair/infra/webapp/genome.py

@@ -0,0 +1,10 @@
+'''Genome webapp api wrapper'''
+
+# App imports
+from .abstract import Abstract
+
+class Genome(Abstract):
+  '''Webapp Genome class'''
+  def __init__(self, cfg):
+    super().__init__(cfg)
+    self.endpoint += 'genomes/'

basepair/infra/webapp/genome_file.py

@@ -0,0 +1,10 @@
+'''Genome file webapp api wrapper'''
+
+# App imports
+from .abstract import Abstract
+
+class GenomeFile(Abstract):
+  '''Webapp GenomeFile class'''
+  def __init__(self, cfg):
+    super().__init__(cfg)
+    self.endpoint += 'genomefiles/'

basepair/infra/webapp/host.py

@@ -0,0 +1,10 @@
+'''Host webapp api wrapper'''
+
+# App imports
+from .abstract import Abstract
+
+class Host(Abstract):
+  '''Webapp Host class'''
+  def __init__(self, cfg):
+    super().__init__(cfg)
+    self.endpoint += 'hosts/'

basepair/infra/webapp/module.py

@@ -0,0 +1,10 @@
+'''Module webapp api wrapper'''
+
+# App imports
+from .abstract import Abstract
+
+class Module(Abstract):
+  '''Webapp Module class'''
+  def __init__(self, cfg):
+    super().__init__(cfg)
+    self.endpoint += 'modules/'

basepair/infra/webapp/pipeline.py

@@ -0,0 +1,10 @@
+'''Pipeline webapp api wrapper'''
+
+# App imports
+from .abstract import Abstract
+
+class Pipeline(Abstract):
+  '''Webapp Pipeline class'''
+  def __init__(self, cfg):
+    super().__init__(cfg)
+    self.endpoint += 'pipelines/'

basepair/infra/webapp/project.py

@@ -0,0 +1,10 @@
+'''Project webapp api wrapper'''
+
+# App imports
+from .abstract import Abstract
+
+class Project(Abstract):
+  '''Webapp Project class'''
+  def __init__(self, cfg):
+    super().__init__(cfg)
+    self.endpoint += 'projects/'

basepair/infra/webapp/sample.py

@@ -0,0 +1,10 @@
+'''Sample webapp api wrapper'''
+
+# App imports
+from .abstract import Abstract
+
+class Sample(Abstract):
+  '''Webapp Sample class'''
+  def __init__(self, cfg):
+    super().__init__(cfg)
+    self.endpoint += 'samples/'

basepair/infra/webapp/upload.py

@@ -0,0 +1,10 @@
+'''Upload webapp api wrapper'''
+
+# App imports
+from .abstract import Abstract
+
+class Upload(Abstract):
+  '''Webapp Upload class'''
+  def __init__(self, cfg):
+    super().__init__(cfg)
+    self.endpoint += 'uploads/'

basepair/infra/webapp/user.py

@@ -0,0 +1,48 @@
+'''User webapp api wrapper'''
+
+# General imports
+import json
+import os
+
+# Lib imports
+import requests
+
+# App imports
+from basepair.helpers import eprint
+from .abstract import Abstract
+
+class User(Abstract):
+  '''Webapp User class'''
+  def __init__(self, cfg):
+    super().__init__(cfg)
+    self.endpoint += 'users/'
+
+  def get_configuration(self, cache=False, verify=True):
+    '''Get host configuration for user'''
+    if cache:
+      filename = os.path.expanduser(cache)
+      if os.path.exists(filename) and os.path.getsize(filename):
+        return json.loads(open(filename, 'r').read().strip())
+
+    params = {'origin': 'cli'}
+    params.update(self.payload)
+    try:
+      response = requests.get(
+        '{}get_configuration'.format(self.endpoint),
+        params=params,
+        verify=verify,
+      )
+      parsed = self._parse_response(response)
+
+      # save in cache if required
+      if cache and parsed and not parsed.get('error'):
+        directory = os.path.dirname(filename)
+        if not os.path.exists(directory):
+          os.makedirs(directory)
+        eprint('Saving configuration into:', filename)
+        with open(filename, 'w') as handle:
+          handle.write(json.dumps(parsed, indent=2))
+      return parsed
+    except requests.exceptions.RequestException as error:
+      eprint('ERROR: {}'.format(error))
+      return { 'error': True, 'msg': error}