# -*- 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):