コード例 #1
0
ファイル: models.py プロジェクト: UlyssesD/bioInfo
class Info(StructuredNode):

	# ---- attributi
	info_id = StringProperty(UniqueIndex=True, Required=True)
	END = IntegerProperty()
	ID = StringProperty()
	QUAL = FloatProperty()
	FILTER = StringProperty()
	FORMAT = StringProperty()
	HETEROZIGOSITY = FloatProperty()
	dbSNP = StringProperty()

	DP = FloatProperty()
	Gene_refGene = ArrayProperty()
	Func_refGene = ArrayProperty()
	QD = FloatProperty()
	SIFT_score = FloatProperty()
	otg_all = FloatProperty()
	NM = IntegerProperty()
	LM = ArrayProperty()
	FS = FloatProperty()
	MQ0 = FloatProperty()
	attributes = JSONProperty()

	# ---- relazioni
	contains = RelationshipFrom('File', 'Contains')
	supportedBy = RelationshipTo('Genotype', 'Supported_By', model=SupportedByRel)
	forVariant = RelationshipTo('Variant', 'For_Variant')
コード例 #2
0
ファイル: models.py プロジェクト: UlyssesD/bioInfo
class Gene(StructuredNode):

	# ---- attributi
	gene_id = StringProperty(UniqueIndex=True, Required=True)

	# ---- relazioni
	inVariant = RelationshipTo('Variant', 'In_Variant')
	inChromosomome = RelationshipTo('Chromosome', 'In_Chromosome')
コード例 #3
0
ファイル: models.py プロジェクト: UlyssesD/bioInfo
class Experiment(StructuredNode):

	# ---- attributi
	name = StringProperty(Required=True)

	# ---- relazioni
	created = RelationshipFrom('User', 'Created')
	forSpecies = RelationshipTo('Species', 'For_Species')
	composedBy = RelationshipTo('File', 'Composed_By')
コード例 #4
0
class Fusion(StructuredNode):
    fusion_id = IntegerProperty()
    #
    with_fc_script = RelationshipTo('FusionCatcher', "WITH_FC_SCRIPT")
    with_eric_script = RelationshipTo('EricScript', "WITH_ERIC_SCRIPT")
    with_tophat_script = RelationshipTo('Tophat', "WITH_TOPHAT_SCRIPT")
    with_gene = RelationshipTo('Gene', "WITH")
    at_chromosome = RelationshipTo('Chromosome', "AT_CHROMOSOME")
    #
    fromCellLineToFusion = RelationshipFrom('CellLine', "HAPPEN")
    fromGeneToFusion = RelationshipFrom('Gene', "HAD")
コード例 #5
0
class Couple(StructuredNode):
    couple = IntegerProperty()
    #
    with_other_transcript = RelationshipTo('Transcript',
                                           "WITH_OTHER_TRANSCRIPT",
                                           model=WITH_OTHER_TRANSCRIPT)
    with_protein = RelationshipTo('Protein', "WITH_PROTEIN")
    #
    fromTranscriptToCouple = RelationshipFrom('Transcript',
                                              "IN_COUPLE",
                                              model=IN_COUPLE)
    fromFusionToCouple = RelationshipFrom('FusionCatcher', "WITH_TRANS_COUPLE")
コード例 #6
0
ファイル: models.py プロジェクト: UlyssesD/bioInfo
class User(StructuredNode):

	# ---- attributi
	username = StringProperty(UniqueIndex=True, Required=True)

	# ---- relazioni
	created = RelationshipTo('Experiment', 'Created')
コード例 #7
0
class Chromosome(StructuredNode):
    chromosome = StringProperty()
    #
    of_gene = RelationshipTo('Gene', "OF_GENE")
    #
    fromFusiontoChromosome = RelationshipFrom('Fusion',
                                              "AT_CHROMOSOME",
                                              model=AT_CHROMOSOME)
コード例 #8
0
class Transcript(StructuredNode):
    transcript = StringProperty()
    #
    in_couple = RelationshipTo('Couple', "IN_COUPLE", model=IN_COUPLE)
    #
    fromCoupleToTranscript = RelationshipFrom('Couple',
                                              "WITH_OTHER_TRANSCRIPT",
                                              model=WITH_OTHER_TRANSCRIPT)
コード例 #9
0
ファイル: models.py プロジェクト: UlyssesD/bioInfo
class Chromosome(StructuredNode):

	# ---- attributi
	chromosome = StringProperty(UniqueIndex=True, Required=True)

	# ---- relazioni 
	inChromosomome = RelationshipFrom('Gene', 'In_Chromosome')
	hasVariant = RelationshipTo('Variant', 'Has_Variant')
コード例 #10
0
class PersonaNode(DjangoNode):
    uid = UniqueIdProperty()
    nombre = StringProperty()
    creada = DateTimeProperty(default=datetime.utcnow)
    beacons = RelationshipTo('BeaconNode', 'INTERACCION', model=InteraccionRel)

    class Meta:
        app_label = 'logs'
コード例 #11
0
ファイル: models.py プロジェクト: UlyssesD/bioInfo
class Genotype(StructuredNode):

	# ---- attributi
	sample = StringProperty(UniqueIndex=True, Required=True)

	# ---- relazioni
	supportedBy = RelationshipFrom('Info', 'Supported_By', model=SupportedByRel)
	ofSpecies = RelationshipTo('Species', 'Of_Species')
コード例 #12
0
ファイル: models.py プロジェクト: UlyssesD/bioInfo
class File(StructuredNode):
	
	# ---- attributi
	name = StringProperty(UniqueIndex=True, Required=True)
	extension = StringProperty()
	statistics = JSONProperty()

	# ---- relazioni
	composedBy = RelationshipFrom('Experiment', 'Composed_By')
	contains = RelationshipTo('Info', 'Contains')
コード例 #13
0
class Gene(StructuredNode):
    ensid = StringProperty()
    symbol = StringProperty()
    description = StringProperty()
    #
    had = RelationshipTo('Fusion', "HAD")
    #
    #fromFusion = RelationshipFrom('Fusion',"WITH", model=WITH)
    fromExonToGene = RelationshipFrom('Exon', "IN_GENE")
    fromChromosomeToGene = RelationshipFrom('Chromosome', "OF_GENE")
    fromFusionToGene = RelationshipFrom('Fusion', 'WITH')
コード例 #14
0
class FusionCatcher(StructuredNode):
    fusion_id = IntegerProperty()
    description = ArrayProperty()
    common_mapping_reads = IntegerProperty()
    spanning_pairs = IntegerProperty()
    spanning_unique_reads = IntegerProperty()
    longest_anchor_found = IntegerProperty()
    fusion_finding_method = StringProperty()
    fusion_sequence = StringProperty()
    fusion_point_1 = IntegerProperty()
    fusion_point_2 = IntegerProperty()
    strand_1 = StringProperty()
    strand_2 = StringProperty()
    predicted_effect_1 = StringProperty()
    predicted_effect_2 = StringProperty()
    #
    at_exon = RelationshipTo('Exon', "AT_EXON")
    with_trans_couple = RelationshipTo('Couple', "WITH_TRANS_COUPLE")
    with_gene = RelationshipTo('Gene', "WITH")
    #
    #fromCellLineToFusion = RelationshipFrom('CellLine',"HAPPEN")
    fromFusionToFusionCatcher = RelationshipFrom('Fusion', "WITH_FC_SCRIPT")
コード例 #15
0
class Payment(BaseModel):
    """
    Payment object represents a payment for a card
    contained in a wallet
    """
    value = FloatProperty()
    date_time = DateTimeProperty(default_now=True)
    card = RelationshipTo('.card.Card', 'FOR', cardinality=One)
    wallet = RelationshipFrom('.wallet.Wallet', 'FOR', cardinality=One)

    def to_dict(self):
        return dict(value=self.value,
                    cid=self.card.single().uid,
                    date_time=self.date_time,
                    wid=self.wallet.single().uid)
コード例 #16
0
class Purchase(BaseModel):
    """
    Purchase objects represents a purchase made with wallet,
    it is, with one or more cards
    """
    total = FloatProperty(required=True)

    cards_ = RelationshipTo('.card.Card', 'WITH', model=BillingAction)
    wallet_ = RelationshipFrom('.wallet.Wallet', 'DONE_WITH', cardinality=One)

    @property
    def wallet(self):
        return self.wallet_

    @wallet.setter
    def wallet(self, wallet):
        raise PurchaseUnchangeableProperty()

    @property
    def cards(self):
        return self.cards_

    @cards.setter
    def cards(self, card):
        raise PurchaseUnchangeableProperty()

    def use_card(self, card, value):
        self.cards_.connect(card, {'value': value})
        self.save()
        card.purchases.connect(self, {'value': value})

        card.decrease_free_limit(value)
        card.save()

        return self

    def to_dict(self):
        card_relations = []

        for card in self.cards:
            relation = dict()
            relation['cid'] = card.uid

            rel = self.cards.relationship(card)
            relation['value'] = rel.value
            relation['date_time'] = rel.date_time

            card_relations.append(relation)

        return dict(wid=self.wallet.single().uid,
                    total=self.total,
                    relations=relation)

    def set_wallet(self, wallet):
        self.save()
        self.wallet_.connect(wallet)
        wallet.purchases.connect(self)
        self.save()
        wallet.save()

        return self
コード例 #17
0
class User(BaseModel):
    """
    This class models an user in database
    """

    # Basic field names
    name = StringProperty(required=True)
    username = StringProperty(required=True, unique_index=True)
    address = StringProperty(default=None)
    mail_address = EmailProperty(default=None)

    # Sensible data
    # TODO: Would be good hide password_ on collecting object
    password_ = StringProperty(db_property='password', required=True)

    # Relationships
    wallets = RelationshipTo('.wallet.Wallet', 'OWN')

    def wallet_uid(self):
        if self.wallets.single():
            return self.wallets.single().uid
        return None

    def to_dict(self):
        return dict(name=self.name,
                    username=self.username,
                    uid=self.uid,
                    mail_address=self.mail_address,
                    active=self.active,
                    wid=self.wallet_uid())

    @property
    def password(self):
        """
        Return hashed password
        :return: hashed password
        """
        return self.password_ if self.password_ else None

    @password.setter
    def password(self, value):
        """
        Once password need to be hashed, this method/property is
        used to hash entered password and save the hash instead
        of clean one
        """
        self.password_ = mixture_pwd(self.uid, value)

    @property
    def active(self):
        return self.active_

    @active.setter
    def active(self, state):
        self.active_ = state

    def save(self):
        """
        validates if an username is in use before save it
        :return:
            * Saved user object if it's ok
            * 'username_in_use' if username already in use
            * 'no_password_given' if password is not set
            * 'no_username_given' if username is not set
        """
        if not hasattr(self, 'username') or self.username is None:
            raise UsernameNotGiven()

        if not hasattr(self, 'password_') or self.password_ is None:
            raise UserPasswordNotGiven()

        # validate username
        if len(User.nodes.filter(username=self.username,
                                 uid__ne=self.uid)) == 0:
            return super(User, self).save()
        else:
            # Found user with same username and different uid, so, username is in use
            raise UsernameInUse()

    def create_wallet(self, label):
        """
        Create Wallet associated with user
        :param label: name to identify this wallet
        :return: generated wallet
        """
        wallet = Wallet(label=label)
        wallet.save()

        wallet.owner.connect(self)

        self.wallets.connect(wallet)
        self.save()
        wallet.save()

        return wallet

    @staticmethod
    def login(username, passwd):
        """
        Try to login an user
        :param username: username to login
        :param passwd: user password before hash
        :return:
            * True if login is ok,
            * False if wrong password
            * 'inexistent' if username not found
            * 'inactive' if user.active is False
        """
        # find user by username
        user = User.nodes.get_or_none(username=username)
        if user is None:
            raise UsernameNotFound()

        # Test if user is active
        if user.active:
            # If user is active, compare password
            hash_passwd = mixture_pwd(user.uid, passwd)
            if user.password_ == hash_passwd:
                return user
            else:
                # If password is wrong, raise an exception
                raise UserPasswordIncorrect()
        else:
            # If user is inactive, raise an exception
            raise UserInactive()
コード例 #18
0
class CellLine(StructuredNode):
    cell_line = StringProperty()
    #
    happen = RelationshipTo('Fusion', "HAPPEN")
    with_viruses = RelationshipTo('Virus', "WITH_VIRUSES", model=WITH_VIRUSES)
コード例 #19
0
class Exon(StructuredNode):
    exon = StringProperty()
    #
    in_gene = RelationshipTo('Gene', "IN_GENE")
    #
    fromFusionToExon = RelationshipFrom('FusionCatcher', "AT_EXON")
コード例 #20
0
class Wallet(BaseModel):
    """
    Model a wallet in database
    """

    label = StringProperty(required=True)
    max_limit_ = FloatProperty(db_property='max_limit', default=0)
    real_limit_ = FloatProperty(db_property='real_limit', default=0)
    free_limit_ = FloatProperty(db_property='free_limit', default=0)

    owner = RelationshipFrom('.user.User', 'OWNED', cardinality=One)
    cards = RelationshipTo('.card.Card', 'CONTAINS')

    purchases = RelationshipTo('.billing.Purchase', 'DID')
    payments = RelationshipFrom('.billing.Payment', 'RECEIVED')

    # === real_limit ===
    @property
    def real_limit(self):
        """
        real_limit is set to max_limit by default
        """
        return self.real_limit_ if self.real_limit_ else self.max_limit

    @real_limit.setter
    def real_limit(self, value):
        """
        Wallet limit set by user. Should be
        less than max_limit and non-negative
        :param value: new real limit
        :return:
        """
        if value > self.max_limit:
            raise WalletLimitExceed()
        elif value < 0:
            raise WalletLimitNotAllowed()
        else:
            self.real_limit_ = value
        self.save()

    # === max_limit ===
    @property
    def max_limit(self):
        return self.max_limit_

    @max_limit.setter
    def max_limit(self, value):
        raise UnchangeableWalletValue()

    # === free_limit ===
    @property
    def free_limit(self):
        """
        usable remaining limit related to max_limit
        """
        return self.free_limit_

    @free_limit.setter
    def free_limit(self, value):
        raise UnchangeableWalletValue()

    # === real_free_limit ===
    @property
    def real_free_limit(self):
        """
        Analogous to free limit, but related to
        real_limit instead of max_limit
        :return:
        """
        return self.real_limit - self.total_used

    # === total_used ===
    @property
    def total_used(self):
        return self.max_limit - self.free_limit

    # === Limits Manipulators ===
    def increase_free_limit(self, value=1.0):
        """
        Increase free_limit of wallet, usually
        in card bill payments.
        :param value: amount to be increased
        :return: new free limit
        """
        self.free_limit_ += value
        self.save()
        return self.free_limit

    def decrease_free_limit(self, value=1.0):
        """
        Decrease free_limit of wallet, usually
        in purchases
        Raises an exception if limit become negative
        :param value: amount to reduce
        :return: new limit
        """
        if self.free_limit < value:
            raise WalletLimitNotAllowed()
        else:
            return self.increase_free_limit(-value)

    def increase_max_limit(self, amount=1.0):
        self.max_limit_ += amount
        self.save()
        return self.max_limit

    def decrease_max_limit(self, amount=1.0):

        # Raise exception if limit become negative
        if amount > self.max_limit:
            raise WalletLimitNotAllowed()

        self.max_limit_ -= amount
        self.save()

        if self.real_limit > self.max_limit:
            self.real_limit = self.max_limit

        return self.max_limit

    # === Card manipulators ===
    def create_card(self, **kwargs):
        card = Card(**kwargs)
        card.save()
        card.wallet.connect(self)

        self.cards.connect(card)

        self.increase_max_limit(card.max_limit)
        self.increase_free_limit(card.free_limit)

        self.save()
        card.save()

        return card

    def sorted_cards(self, fake_today=None, date_format='%m/%d/%Y'):
        """
        Sort cards by distance to due date, than to lower limit
        considering today as fake_today
        :param fake_today: a pseudo date (or None for today)
        :param date_format: (format of used date)
        :return: active cards sorted according to rules in
        (enuntiate)[https://slack-files.com/T06M9ENDT-F5XK4J0P2-532510c5c0]
        """
        cards = []

        for card in self.cards:
            if card.active:
                card.set_fake_today(fake_today, date_format)
                cards.append(card)

        cards.sort()
        return cards

    # === object dictionarization ===
    def to_dict(self):
        return dict(real_limit=self.real_limit,
                    max_limit=self.max_limit,
                    free_limit=self.free_limit,
                    real_free_limit=self.real_free_limit,
                    total_used=self.total_used,
                    total_cards=len(self.cards))

    # === purchase ===
    def purchase(self, value):
        """
        Purchase following rules in
        (enuntiate)[https://slack-files.com/T06M9ENDT-F5XK4J0P2-532510c5c0]
        :param value:
        :return: Purchase object generated on purchase
        """
        # Raise RealLimitExceeded if purchase exceeds real_free_limit
        if self.real_free_limit < value:
            raise RealLimitExceeded()

        purchase = Purchase()
        purchase.total = value
        purchase = purchase.set_wallet(self)

        # If possible, purchase with only one card
        for card in self.sorted_cards():
            if card.free_limit >= value:
                purchase = purchase.use_card(card, value)
                return purchase

        # Else, purchase with multiple cards
        for card in self.sorted_cards():

            value_in_card = value if card.free_limit > value else card.free_limit

            purchase = purchase.use_card(card, value_in_card)
            value -= value_in_card

            if value <= 0:
                break

        return purchase