#!/usr/bin/env python

import sqlite3

import collections

from itertools import tee, ifilterfalse

from gemini_subjects import Subject

def map_samples_to_indices(c):

"""Return a dict mapping samples names (key)

to sample indices in the numpy genotype arrays (value).

"""

sample_to_idx = {}

c.execute("select sample_id, name from samples")

for row in c:

name = str(row['name'])

idx = row['sample_id'] - 1

sample_to_idx[name] = idx

return sample_to_idx

def map_indices_to_samples(c):

"""Return a dict mapping samples indices in the

numpy arrays (key) to sample names.

"""

return {k: v.name for (k, v) in map_indices_to_sample_objects(c).items()}

# c.execute("select sample_id, name from samples")

# for row in c:

# name = str(row['name'])

# idx = row['sample_id'] - 1

# idx_to_sample[idx] = name

# return idx_to_sample

def map_indices_to_sample_objects(c):

idx_to_sample_object = {}

c.execute("select * from samples")

for row in c:

idx = row['sample_id'] - 1

idx_to_sample_object[idx] = Subject(row)

return idx_to_sample_object

def get_col_names_and_indices(sqlite_description, ignore_gt_cols=False):

"""Return a list of column namanes and a list of the row indices.

Optionally exclude gt_* columns.

"""

col_indices = []

col_names = []

for idx, col_tup in enumerate(sqlite_description):

# e.g., each col in sqlite desc is a tuple like:

# ('variant_id', None, None, None, None, None, None)

col_name = col_tup[0]

if ((not ignore_gt_cols) or

(ignore_gt_cols and not col_name.startswith('gt'))):

col_indices.append(idx)

col_names.append(col_name)

return col_names, col_indices

# http://code.activestate.com/recipes/576694/

class OrderedSet(collections.MutableSet):

def __init__(self, iterable=None):

self.end = end = []

end += [None, end, end] # sentinel node for doubly linked list

self.map = {} # key --> [key, prev, next]

if iterable is not None:

self |= iterable

def __len__(self):

return len(self.map)

def __contains__(self, key):

return key in self.map

def add(self, key):

if key not in self.map:

end = self.end

curr = end[1]

curr[2] = end[1] = self.map[key] = [key, curr, end]

def discard(self, key):

if key in self.map:

key, prev, next = self.map.pop(key)

prev[2] = next

next[1] = prev

def __iter__(self):

end = self.end

curr = end[2]

while curr is not end:

yield curr[0]

curr = curr[2]

def __reversed__(self):

end = self.end

curr = end[1]

while curr is not end:

yield curr[0]

curr = curr[1]

def pop(self, last=True):

if not self:

raise KeyError('set is empty')

key = self.end[1][0] if last else self.end[2][0]

self.discard(key)

return key

def __repr__(self):

if not self:

return '%s()' % (self.__class__.__name__,)

return '%s(%r)' % (self.__class__.__name__, list(self))

def __eq__(self, other):

if isinstance(other, OrderedSet):

return len(self) == len(other) and list(self) == list(other)

return set(self) == set(other)

# Backport of OrderedDict() class that runs on Python 2.4, 2.5, 2.6, 2.7 and pypy.

# Passes Python2.7's test suite and incorporates all the latest updates.

try:

from thread import get_ident as _get_ident

except ImportError:

from dummy_thread import get_ident as _get_ident

try:

from _abcoll import KeysView, ValuesView, ItemsView

except ImportError:

pass

# from: http://code.activestate.com/recipes/576693/

class OrderedDict(dict):

'Dictionary that remembers insertion order'

# An inherited dict maps keys to values.

# The inherited dict provides __getitem__, __len__, __contains__, and get.

# The remaining methods are order-aware.

# Big-O running times for all methods are the same as for regular dictionaries.

# The internal self.__map dictionary maps keys to links in a doubly linked list.

# The circular doubly linked list starts and ends with a sentinel element.

# The sentinel element never gets deleted (this simplifies the algorithm).

# Each link is stored as a list of length three: [PREV, NEXT, KEY].

def __init__(self, *args, **kwds):

'''Initialize an ordered dictionary. Signature is the same as for

regular dictionaries, but keyword arguments are not recommended

because their insertion order is arbitrary.

'''

if len(args) > 1:

raise TypeError('expected at most 1 arguments, got %d' % len(args))

try:

self.__root

except AttributeError:

self.__root = root = [] # sentinel node

root[:] = [root, root, None]

self.__map = {}

self.__update(*args, **kwds)

def __setitem__(self, key, value, dict_setitem=dict.__setitem__):

'od.__setitem__(i, y) <==> od[i]=y'

# Setting a new item creates a new link which goes at the end of the linked

# list, and the inherited dictionary is updated with the new key/value pair.

if key not in self:

root = self.__root

last = root[0]

last[1] = root[0] = self.__map[key] = [last, root, key]

dict_setitem(self, key, value)

def __delitem__(self, key, dict_delitem=dict.__delitem__):

'od.__delitem__(y) <==> del od[y]'

# Deleting an existing item uses self.__map to find the link which is

# then removed by updating the links in the predecessor and successor nodes.

dict_delitem(self, key)

link_prev, link_next, key = self.__map.pop(key)

link_prev[1] = link_next

link_next[0] = link_prev

def __iter__(self):

'od.__iter__() <==> iter(od)'

root = self.__root

curr = root[1]

while curr is not root:

yield curr[2]

curr = curr[1]

def __reversed__(self):

'od.__reversed__() <==> reversed(od)'

root = self.__root

curr = root[0]

while curr is not root:

yield curr[2]

curr = curr[0]

def clear(self):

'od.clear() -> None. Remove all items from od.'

try:

for node in self.__map.itervalues():

del node[:]

root = self.__root

root[:] = [root, root, None]

self.__map.clear()

except AttributeError:

pass

dict.clear(self)

def popitem(self, last=True):

'''od.popitem() -> (k, v), return and remove a (key, value) pair.

Pairs are returned in LIFO order if last is true or FIFO order if false.

'''

if not self:

raise KeyError('dictionary is empty')

root = self.__root

if last:

link = root[0]

link_prev = link[0]

link_prev[1] = root

root[0] = link_prev

else:

link = root[1]

link_next = link[1]

root[1] = link_next

link_next[0] = root

key = link[2]

del self.__map[key]

value = dict.pop(self, key)

return key, value

# -- the following methods do not depend on the internal structure --

def keys(self):

'od.keys() -> list of keys in od'

return list(self)

def values(self):

'od.values() -> list of values in od'

return [self[key] for key in self]

def items(self):

'od.items() -> list of (key, value) pairs in od'

return [(key, self[key]) for key in self]

def iterkeys(self):

'od.iterkeys() -> an iterator over the keys in od'

return iter(self)

def itervalues(self):

'od.itervalues -> an iterator over the values in od'

for k in self:

yield self[k]

def iteritems(self):

'od.iteritems -> an iterator over the (key, value) items in od'

for k in self:

yield (k, self[k])

def update(*args, **kwds):

'''od.update(E, **F) -> None. Update od from dict/iterable E and F.

If E is a dict instance, does: for k in E: od[k] = E[k]

If E has a .keys() method, does: for k in E.keys(): od[k] = E[k]

Or if E is an iterable of items, does: for k, v in E: od[k] = v

In either case, this is followed by: for k, v in F.items(): od[k] = v

'''

if len(args) > 2:

raise TypeError('update() takes at most 2 positional '

'arguments (%d given)' % (len(args),))

elif not args:

raise TypeError('update() takes at least 1 argument (0 given)')

self = args[0]

# Make progressively weaker assumptions about "other"

other = ()

if len(args) == 2:

other = args[1]

if isinstance(other, dict):

for key in other:

self[key] = other[key]

elif hasattr(other, 'keys'):

for key in other.keys():

self[key] = other[key]

else:

for key, value in other:

self[key] = value

for key, value in kwds.items():

self[key] = value

__update = update # let subclasses override update without breaking __init__

__marker = object()

def pop(self, key, default=__marker):

'''od.pop(k[,d]) -> v, remove specified key and return the corresponding value.

If key is not found, d is returned if given, otherwise KeyError is raised.

'''

if key in self:

result = self[key]

del self[key]

return result

if default is self.__marker:

raise KeyError(key)

return default

def setdefault(self, key, default=None):

'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od'

if key in self:

return self[key]

self[key] = default

return default

def __repr__(self, _repr_running={}):

'od.__repr__() <==> repr(od)'

call_key = id(self), _get_ident()

if call_key in _repr_running:

return '...'

_repr_running[call_key] = 1

try:

if not self:

return '%s()' % (self.__class__.__name__,)

return '%s(%r)' % (self.__class__.__name__, self.items())

finally:

del _repr_running[call_key]

def __reduce__(self):

'Return state information for pickling'

items = [[k, self[k]] for k in self]

inst_dict = vars(self).copy()

for k in vars(OrderedDict()):

inst_dict.pop(k, None)

if inst_dict:

return (self.__class__, (items,), inst_dict)

return self.__class__, (items,)

def copy(self):

'od.copy() -> a shallow copy of od'

return self.__class__(self)

@classmethod

def fromkeys(cls, iterable, value=None):

'''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S

and values equal to v (which defaults to None).

'''

d = cls()

for key in iterable:

d[key] = value

return d

def __eq__(self, other):

'''od.__eq__(y) <==> od==y. Comparison to another OD is order-sensitive

while comparison to a regular mapping is order-insensitive.

'''

if isinstance(other, OrderedDict):

return len(self)==len(other) and self.items() == other.items()

return dict.__eq__(self, other)

def __ne__(self, other):

return not self == other

# -- the following methods are only used in Python 2.7 --

def viewkeys(self):

"od.viewkeys() -> a set-like object providing a view on od's keys"

return KeysView(self)

def viewvalues(self):

"od.viewvalues() -> an object providing a view on od's values"

return ValuesView(self)

def viewitems(self):

"od.viewitems() -> a set-like object providing a view on od's items"

return ItemsView(self)

def itersubclasses(cls, _seen=None):

"""

snagged from: http://code.activestate.com/recipes/576949/

itersubclasses(cls)

Generator over all subclasses of a given class, in depth first order.

>>> list(itersubclasses(int)) == [bool]

True

>>> class A(object): pass

>>> class B(A): pass

>>> class C(A): pass

>>> class D(B,C): pass

>>> class E(D): pass

>>>

>>> for cls in itersubclasses(A):

... print(cls.__name__)

B

D

E

C

>>> # get ALL (new-style) classes currently defined

>>> [cls.__name__ for cls in itersubclasses(object)] #doctest: +ELLIPSIS

['type', ...'tuple', ...]

"""

if not isinstance(cls, type):

raise TypeError('itersubclasses must be called with '

'new-style classes, not %.100r' % cls)

if _seen is None:

_seen = set()

try:

subs = cls.__subclasses__()

except TypeError: # fails only when cls is type

subs = cls.__subclasses__(cls)

for sub in subs:

if sub not in _seen:

_seen.add(sub)

yield sub

for sub in itersubclasses(sub, _seen):

yield sub

def partition(pred, iterable):

'Use a predicate to partition entries into false entries and true entries'

# partition(is_odd, range(10)) --> 0 2 4 6 8 and 1 3 5 7 9

t1, t2 = tee(iterable)

return list(ifilterfalse(pred, t1)), list(filter(pred, t2))

def quote_string(item):

""" if the item is a string, put quotes around it else leave it """

if isinstance(item, basestring):

item = "\"" + item + "\""

return item