def __init__(self, properties): """ Create a new Sequence object. Parameters: - **properties**: properties of this sequence, as a dictionary. Must contain at least a 'name' and 'sequence' property, or a :class:`MetagenomeDB.errors.InvalidObjectError` exception is thrown. A 'length' property is automatically calculated and would overwrite any such property if provided. .. note:: The 'name' property is unique within a collection, but not across the whole database. It means that two sequences with the same name can coexist in the database as long as they belong to two different collections (or if they are not related to any collection). """ if (not "name" in properties): raise errors.InvalidObjectError("Property 'name' is missing") if (not "sequence" in properties): raise errors.InvalidObjectError("Property 'sequence' is missing") sequence, length = Sequence._process_sequence(properties["sequence"]) properties["sequence"] = sequence properties["length"] = length indices = { "name": False, "length": False, "class": False, } orm.PersistentObject.__init__(self, indices, properties)
def _getitem_precallback(self, key, value): if (key == ("sequence", )): if (type(value) in (str, unicode)): return value if ("data" in value): sequence = zlib.decompress(value["data"]) if (zlib.crc32(sequence) != value["crc"]): raise errors.InvalidObjectError( "Sequence information has been corrupted.") return sequence if ("handle" in value): pass raise errors.InvalidObjectError( "Invalid value for 'sequence' property.")
def adapt(obj): """ Adapt an object to a uniform interface that can be used to easily pass to the C/C++ layers of skylark. """ if ELEM_INSTALLED and sys.modules.has_key('El'): global El import El haselem = True else: haselem = False if KDT_INSTALLED and sys.modules.has_key('kdt'): global kdt import kdt haskdt = True else: haskdt = False if isinstance(obj, numpy.ndarray): return NumpyAdapter(obj) elif isinstance(obj, scipy.sparse.csr_matrix) or isinstance( obj, scipy.sparse.csc_matrix): return ScipyAdapter(obj) elif haselem and isinstance(obj, El.Matrix): return ElMatrixAdapter(obj) elif haselem and isinstance(obj, El.DistMatrix): return DistMatrixAdapter(obj) elif haskdt and isinstance(obj, kdt.Mat): return KDTAdapter(obj) else: raise errors.InvalidObjectError( "Invalid/unsupported object passed as parameter")
def __init__(self, properties): """ Create a new Collection object. Parameters: - **properties**: properties of this sequence, as a dictionary. Must contain at least a 'name' property, or a :class:`MetagenomeDB.errors.InvalidObjectError` exception is thrown. .. note:: Collection names are unique in the database; if attempting to commit a collection while another collection already exists with the same name a :class:`MetagenomeDB.errors.DuplicateObjectError` exception is thrown. """ if (not "name" in properties): raise errors.InvalidObjectError("Property 'name' is missing") indices = { "name": True, "class": False, } orm.PersistentObject.__init__(self, indices, properties)
def apply(self, A, SA, dim=0): """ Apply the transform on **A** along dimension **dim** and write result in **SA**. Note: for rowwise (aka right) sketching **A** is mapped to **A S^T**. :param A: Input matrix. :param SA: Ouptut matrix. If "None" then the output will be allocated. :param dim: Dimension to apply along. 0 - columnwise, 1 - rowwise. or can use "columnwise"/"rowwise", "left"/"right" default is columnwise :returns: SA """ if dim == 0 or dim == "columnwise" or dim == "left": dim = 0 if dim == "rowwise" or dim == "right": dim = 1 if dim != 0 and dim != 1: raise ValueError( "Dimension must be either columnwise/rowwise or left/right or 0/1" ) A = lib.adapt(A) # Allocate in case SA is not given, and then adapt it. if SA is None: if self._defouttype is None: ctor = A.getctor() else: ctor = lib.map_to_ctor[self._defouttype] if dim == 0: SA = ctor(self._s, A.getdim(1), A) if dim == 1: SA = ctor(A.getdim(0), self._s, A) SA = lib.adapt(SA) reqcomb = (self._ttype, A.ctype(), SA.ctype()) if reqcomb not in SUPPORTED_SKETCH_TRANSFORMS: raise errors.UnsupportedError("Unsupported transform-input-output combination: " \ + str(reqcomb)) incomp, cinvert = A.iscompatible(SA) if incomp is not None: raise errors.UnsupportedError( "Input and output are incompatible: " + incomp) if A.getdim(dim) != self._n: raise errors.DimensionMistmatchError( "Sketched dimension is incorrect (input)") if SA.getdim(dim) != self._s: raise errors.DimensionMistmatchError( "Sketched dimension is incorrect (output)") if A.getdim(1 - dim) != SA.getdim(1 - dim): raise errors.DimensionMistmatchError( "Sketched dimension is incorrect (input != output)") if self._ppy: self._ppyapply(A.getobj(), SA.getobj(), dim) else: Aobj = A.ptr() SAobj = SA.ptr() if (Aobj == -1 or SAobj == -1): raise errors.InvalidObjectError( "Invalid/unsupported object passed as A or SA") if cinvert: cdim = 1 - dim else: cdim = dim lib.callsl("sl_apply_sketch_transform", self._obj, \ A.ctype(), Aobj, SA.ctype(), SAobj, cdim+1) A.ptrcleaner() SA.ptrcleaner() return SA.getobj()