# -*- coding: utf-8 -*-
import datetime as dt
from pathlib import Path
import alchy
from sqlalchemy import Column, ForeignKey, orm, types, UniqueConstraint, Table
Model = alchy.make_declarative_base(Base=alchy.ModelBase)
file_tag_link = Table(
'file_tag_link',
Model.metadata,
Column('file_id', types.Integer, ForeignKey('file.id'), nullable=False),
Column('tag_id', types.Integer, ForeignKey('tag.id'), nullable=False),
UniqueConstraint('file_id', 'tag_id', name='_file_tag_uc'),
)
class Bundle(Model):
"""A general group of files."""
__tablename__ = 'bundle'
id = Column(types.Integer, primary_key=True)
name = Column(types.String(64), unique=True, nullable=False)
created_at = Column(types.DateTime, default=dt.datetime.now)
versions = orm.relationship('Version', backref='bundle', order_by='-Version.created_at', cascade='delete, save-update')
from alchy import make_declarative_base
from itsdangerous import (TimedJSONWebSignatureSerializer as Serializer)
from passlib.hash import sha256_crypt
from sqlalchemy import Column, types, ForeignKey, Enum, UniqueConstraint
Model = make_declarative_base()
class User(Model):
__tablename__ = 'users'
id = Column(types.Integer, primary_key=True)
username = Column(types.String(80),
unique=True) # probably should be email
password_hash = Column(
types.String(256),
nullable=False) # needs to be salted in the future, unsalted right now
def __init__(self, username, password):
Model.__init__(self)
self.username = username
self.password_hash = sha256_crypt.encrypt(password)
def set_pass(self, password):
self.password_hash = sha256_crypt.encrypt(password)
def verify_pass(self, password):
return sha256_crypt.verify(password, self.password_hash)
def gen_auth_token(self, serializer):
return serializer.dumps({'id': self.id})
# -*- coding: utf-8 -*-
import datetime as dt
from typing import List
import alchy
from sqlalchemy import Column, ForeignKey, orm, types, UniqueConstraint, Table
from cg import constants
Model = alchy.make_declarative_base(Base=alchy.ModelBase)
class PriorityMixin:
@property
def priority_human(self):
"""Humanized priority for sample."""
return constants.REV_PRIORITY_MAP[self.priority]
@priority_human.setter
def priority_human(self, priority_str: str):
self.priority = constants.PRIORITY_MAP.get(priority_str)
@property
def high_priority(self):
"""Has high priority?"""
return self.priority > 1
@property
def low_priority(self):
"""Has low priority?"""
return self.priority < 1
import json
from datetime import datetime
from alchy import ModelBase, make_declarative_base
def json_serial(obj):
"""JSON serializer for objects not serializable by default json code"""
if isinstance(obj, datetime):
return obj.isoformat()
raise TypeError("Type not serializable")
class JsonModel(ModelBase):
def to_json(self, pretty: bool = False):
"""Serialize to JSON.
Handle DateTime objects.
"""
kwargs = dict(indent=4, sort_keys=True) if pretty else dict()
return json.dumps(self.to_dict(), default=json_serial, **kwargs)
Model = make_declarative_base(Base=JsonModel)
"""JSON serializer for objects not serializable by default json code"""
if isinstance(obj, datetime.datetime):
serial = obj.isoformat()
return serial
raise TypeError('Type not serializable')
class JsonModel(alchy.ModelBase):
def to_json(self, pretty=False):
"""Serialize Model to JSON."""
kwargs = dict(indent=4, sort_keys=True) if pretty else dict()
return json.dumps(self.to_dict(), default=json_serial, **kwargs)
Model = alchy.make_declarative_base(Base=JsonModel)
class Metadata(Model):
"""Keep track of meta data."""
id = Column(types.Integer, primary_key=True)
created_at = Column(types.DateTime, default=datetime.datetime.now)
updated_at = Column(types.DateTime)
class User(Model, UserManagementMixin):
@property
def first_name(self):
from alchy import ModelBase, make_declarative_base
from sqlalchemy import orm, Column, types, ForeignKey
Model = make_declarative_base(Base=ModelBase)
class User(Model):
id = Column(types.Integer, primary_key=True)
name = Column(types.String(128))
email = Column(types.String(128))
gh_token = Column(types.String(128))
lists = orm.relationship('List')
class Todo(Model):
id = Column(types.Integer, primary_key=True)
text = Column(types.String(256))
done = Column(types.Boolean, default=False)
list_id = Column(types.Integer, ForeignKey('list.id'))
list = orm.relationship('List')
class List(Model):
id = Column(types.Integer, primary_key=True)
name = Column(types.String(128))
user_id = Column(types.Integer, ForeignKey('user.id'))
user = orm.relationship('User')
todos = orm.relationship('Todo', order_by=Todo.id.desc())
"""JSON serializer for objects not serializable by default json code"""
if isinstance(obj, datetime):
serial = obj.isoformat()
return serial
raise TypeError('Type not serializable')
class JsonModel(ModelBase):
def to_json(self, pretty=False):
"""Serialize Model to JSON."""
kwargs = dict(indent=4, sort_keys=True) if pretty else dict()
return json.dumps(self.to_dict(), default=json_serial, **kwargs)
Model = make_declarative_base(Base=JsonModel)
class Genotype(Model):
"""Represent a genotype call for a position.
Attributes:
rsnumber (str): SNP id
analysis (Analysis): related Analysis model
allele_1 (str): first allele base
allele_2 (str): second allele base
"""
__table_args__ = (UniqueConstraint('analysis_id', 'rsnumber',
name='_analysis_rsnumber'),)
def make_declarative_base(self, metadata=None):
"""Override parent function with alchy's"""
return make_declarative_base(self.session, Model=self.Model,
metadata=metadata)
def make_declarative_base(self):
"""Override parent function with alchy's"""
return make_declarative_base(self.session, Model=self.Model)
# -*- coding: utf-8 -*-
from datetime import date, datetime
from alchy import ModelBase, make_declarative_base
class ExtendedBase(ModelBase):
def to_json(self):
"""Add support for datetime objects."""
dict_model = self.to_dict()
json_ready = {key: (str(value) if isinstance(value, (date, datetime))
else value)
for key, value in dict_model.items()}
return json_ready
Model = make_declarative_base(Base=ExtendedBase)
from alchy import make_declarative_base
from itsdangerous import (TimedJSONWebSignatureSerializer as Serializer)
from passlib.hash import sha256_crypt
from sqlalchemy import Column, types, ForeignKey, Enum, UniqueConstraint
Model = make_declarative_base()
class User(Model):
__tablename__ = 'users'
id = Column(types.Integer, primary_key=True)
username = Column(types.String(80), unique=True) # probably should be email
password_hash = Column(types.String(256), nullable=False) # needs to be salted in the future, unsalted right now
def __init__(self, username, password):
Model.__init__(self)
self.username = username
self.password_hash = sha256_crypt.encrypt(password)
def set_pass(self, password):
self.password_hash = sha256_crypt.encrypt(password)
def verify_pass(self, password):
return sha256_crypt.verify(password, self.password_hash)
def gen_auth_token(self, serializer):
return serializer.dumps({'id': self.id})
class Location(Model):
