__tablename__ = 'vp_text'
__table_args__ = {'schema': 'public'}
object_id = db.Column(db.Integer, primary_key=True, nullable=False, server_default=db.FetchedValue())
object_type = db.Column(db.String(32), primary_key=True, nullable=False)
name = db.Column(db.String(50), primary_key=True, nullable=False)
value = db.Column(db.Text)
class VpTranslatedText(db.Model):
__tablename__ = 'vp_translated_text'
__table_args__ = {'schema': 'public'}
object_id = db.Column(db.Integer, primary_key=True, nullable=False, server_default=db.FetchedValue())
object_type = db.Column(db.String(32), primary_key=True, nullable=False)
name = db.Column(db.String(50), primary_key=True, nullable=False)
value = db.Column(db.Text)
language = db.Column(db.String(5), nullable=False)
t_zope_principal_role_map = db.Table(
'zope_principal_role_map',
db.Column('principal_id', db.String(50), nullable=False, index=True),
db.Column('role_id', db.String(50), nullable=False),
db.Column('setting', db.Boolean, nullable=False),
db.Column('object_type', db.String(100)),
db.Column('object_id', db.Integer),
db.Index('prm_oid_idx', 'object_id', 'object_type'),
schema='public'
)
qty = db.Column(db.Integer, nullable=False)
symbol = db.Column(db.String,
db.ForeignKey("symbols.symbol"),
nullable=False)
timestamp = db.Column(db.DateTime, nullable=False)
def __repr__(self):
return "<Orders(ID='%i', username='******', symbol='%s', price='%.2f', timestamp='%s')>" % (
self.id, self.user, self.symbol, self.price, self.timestamp)
class Holdings(db.Model):
__tablename__ = "holdings"
user = db.Column(db.Integer,
db.ForeignKey("users.id"),
primary_key=True,
nullable=False)
symbol = db.Column(db.String,
db.ForeignKey("symbols.symbol"),
primary_key=True,
nullable=False)
qty = db.Column(db.Integer, nullable=False)
def __repr__(self):
return "<Holdings(username='******', symbol='%s', qty='%i')>" % (
self.user, self.symbol, self.qty)
db.Index('username', User.username, unique=True)
db.Index('symbol', Symbols.symbol, unique=True)
import uuid
import datetime
db = SQLAlchemy()
migrate = Migrate()
class SandboxToken(db.Model):
__tablename__ = 'sandbox_tokens'
token = db.Column(db.String, primary_key=True)
user_id = db.Column(db.Integer)
app_uuid = db.Column(UUID(as_uuid=True))
db.Index('sandbox_token_uid_appuuid_index', SandboxToken.user_id, SandboxToken.app_uuid, unique=True)
class TimelinePin(db.Model):
__tablename__ = 'timeline_pins'
guid = db.Column(UUID(as_uuid=True), primary_key=True)
app_uuid = db.Column(UUID(as_uuid=True), nullable=False)
user_id = db.Column(db.Integer, nullable=False)
id = db.Column(db.String(64), nullable=False)
time = db.Column(db.DateTime, nullable=False)
duration = db.Column(db.Integer)
create_notification = db.Column(JSONB, nullable=True)
update_notification = db.Column(JSONB, nullable=True)
layout = db.Column(JSONB, nullable=False)
db.session.add_all(new_zones)
db.session.commit()
class RestaurantScore(db.Model):
__tablename__ = 'restaurant_score'
id = db.Column(db.Integer, primary_key=True)
res_id = db.Column(db.Integer, db.ForeignKey('restaurants.id'))
score = db.Column(db.ARRAY(db.String, dimensions=1))
restaurant = relationship("Restaurants",
uselist=False,
back_populates="score")
@classmethod
def add_restaurant_score_bulk(cls, res_score):
"""Put a new restaurants in the database."""
new_res_score = []
for rs in res_score:
res_sc = RestaurantScore(res_id=rs['res_id'], score=rs['score'])
new_res_score.append(res_sc)
db.session.add_all(new_res_score)
db.session.commit()
db.Index('zone_name', Zones.zone_name)
db.Index('locality', Restaurants.location_locality)
class Collection(db.Model):
__tablename__ = "collections"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
slug = db.Column(db.String, unique=True)
app_type = db.Column(db.String, index=True)
platforms = db.Column(ARRAY(db.String))
apps = db.relationship('App',
back_populates='collections',
secondary=collection_apps,
passive_deletes=True,
lazy='dynamic')
db.Index('collection_platforms_index',
Collection.platforms,
postgresql_using="gin")
class App(db.Model):
__tablename__ = "apps"
id = db.Column(db.String(24), primary_key=True)
app_uuid = db.Column(
UUID(),
index=True) # There *are* multiple apps with the same UUID. Good luck!
asset_collections = db.relationship(
'AssetCollection',
back_populates='app',
collection_class=attribute_mapped_collection('platform'),
lazy='selectin')
category_id = db.Column(db.String(24),
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join(
basedir, 'n1.db')
app.config['SQLALCHEMY_RECORD_QUERIES'] = True
# app.config['SQLALCHEMY_ECHO'] = True
db = SQLAlchemy(app)
relations = db.Table(
'relations',
db.Column('tid', db.Integer, db.ForeignKey('hashtag_table.id'),
index=True),
db.Column('pid', db.Integer, db.ForeignKey('post_table.id'), index=True),
db.Index("ix_tid_pid", "tid", "pid", unique=True))
class Hashtag(db.Model):
__tablename__ = 'hashtag_table'
id = db.Column(db.Integer, primary_key=True)
tag = db.Column(db.String(20), nullable=False)
class Post(db.Model):
__tablename__ = 'post_table'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(80), nullable=False)
post_tag_rel = db.relationship("Hashtag",
secondary=relations,
lazy='joined',
return self.status == statuses.INTERRUPTED
@property
def failed(self):
return self.status == statuses.FAILURE
@property
def errored(self):
return self.status == statuses.ERROR
session_subject = db.Table(
'session_subject',
db.Column('session_id', db.Integer,
db.ForeignKey('session.id', ondelete='CASCADE')),
db.Index('ix_session_subject_session_id', 'session_id'),
db.Column('subject_id', db.Integer,
db.ForeignKey('subject_instance.id', ondelete='CASCADE')))
class Session(db.Model, TypenameMixin, StatusPredicatesMixin, HasRelatedMixin,
HasSubjectsMixin, UserDetailsMixin):
id = db.Column(db.Integer, primary_key=True)
logical_id = db.Column(db.String(256), index=True)
start_time = db.Column(db.Float, default=get_current_time)
end_time = db.Column(db.Float, default=None, index=True)
hostname = db.Column(db.String(100))
in_pdb = db.Column(db.Boolean, server_default='FALSE')
class Annotation(db.Model):
__tablename__ = 'annotation'
_aid = db.Column('id', db.Integer, primary_key=True)
_annotation = db.Column('annotation', db.String)
_sid = db.Column('sentence_id', db.Integer, db.ForeignKey('sentence.id'))
_uid = db.Column('user_id', db.Integer, db.ForeignKey('user.id'))
_intensity = db.Column('intensity', db.Float)
def __init__(self, annotation, sentence_id, user_id, intensity):
self._annotation = annotation
self._sid = sentence_id
self._uid = user_id
self._intensity = intensity
db.Index('ix_annotation_lookup', Annotation._sid, Annotation._uid)
class User(db.Model, UserMixin):
__tablename__ = 'user'
_uid = db.Column('id', db.Integer, primary_key=True)
_user = db.Column('user', db.String)
_pass = db.Column('pass', db.String)
@property
def user(self):
return self._user
@user.setter
def user(self, username):
self._user = username
@property
def timeline_ttl(self):
return 30 if self.has_active_sub else (3 * 60)
class UserIdentity(db.Model):
__tablename__ = "user_identities"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
user = db.relationship('User')
idp = db.Column(db.String)
idp_user_id = db.Column(db.String, nullable=False)
db.Index('user_identity_idp_id_index', UserIdentity.idp,
UserIdentity.idp_user_id)
class AuthClient(db.Model):
__tablename__ = "oauth_clients"
name = db.Column(db.String)
client_id = db.Column(db.String(40), primary_key=True)
client_secret = db.Column(db.String(55),
unique=True,
index=True,
nullable=False)
redirect_uris = db.Column(ARRAY(db.String))
is_confidential = db.Column(db.Boolean)
default_scopes = db.Column(ARRAY(db.String))
is_rws = db.Column(
db.Boolean, server_default='false'
client_id = db.Column(db.Integer,
db.ForeignKey('users.user_id'),
nullable=False)
active = db.Column(db.Boolean, default=False)
start_date = db.Column(db.Date, nullable=True)
professional = db.relationship('Professional',
backref=db.backref('contracts'))
client = db.relationship('User', backref=db.backref('contracts'))
def __repr__(self):
return "<Contract pro=%s client=%s active=%s>" % (
self.pro_id, self.client_id, self.active)
db.Index('contract', Contract.pro_id, Contract.client_id, unique=True)
class Prescription(db.Model):
"""Prescription of a drug by a professional to a client"""
__tablename__ = "prescriptions"
prescription_id = db.Column(db.Integer,
autoincrement=True,
primary_key=True)
client_id = db.Column(db.Integer,
db.ForeignKey('users.user_id'),
nullable=False)
pro_id = db.Column(db.Integer,
db.ForeignKey('professionals.user_id'),
backref='tbl_instructor_users')
class TblIsUseraccount(db.Model):
__tablename__ = 'tbl_is_useraccount'
acc_id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(30))
password = db.Column(db.String(30))
staff_id = db.Column(db.String(30))
instructor_id = db.Column(db.Integer)
t_tbl_nstp = db.Table('tbl_nstp', db.Column('SerialNumber', db.String(25)),
db.Column('Name', db.String(50)),
db.Index('SerialNumber', 'SerialNumber', 'Name'))
class TblSchoolYear(db.Model):
__tablename__ = 'tbl_school_year'
school_year_id = db.Column(db.Integer, primary_key=True)
school_year = db.Column(db.String(25), nullable=False)
class TblStudentModality(db.Model):
__tablename__ = 'tbl_student_modality'
Id = db.Column(db.Integer, primary_key=True)
student_id = db.Column(db.String(255))
modality_id = db.Column(db.ForeignKey('tbl_student_modality_type.Id'),
def next(self):
prev = None
for run in self.experiment.runs.order_by(Run.id):
if prev == self:
return run
else:
prev = run
block_values = db.Table(
"block_values",
db.Column("block_db_id", db.Integer, db.ForeignKey("block._db_id")),
db.Column("factor_value_db_id", db.Integer,
db.ForeignKey("factor_value._db_id")),
db.Index("index_block_factor_values", "block_db_id"),
)
class Block(db.Model):
class BlockQuery(BaseQuery):
def get_by_number(self, block_number, run_id, experiment_id):
return (Block.query.join(Run, Experiment).filter(
Block.number == block_number,
Experiment.id == experiment_id,
Run.id == run_id,
).one())
query_class = BlockQuery
_db_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
# `updated_at`
last_updated = db.Column(db.DateTime)
owner_id = db.Column(db.Integer, db.ForeignKey("gh_users.id"))
owner = db.relationship(User, backref=db.backref("repos", lazy="dynamic"))
def short_dict(self):
return dict(
id=self.id,
name=self.fullname,
username=self.fullname.split("/")[0],
reponame="/".join(self.fullname.split("/")[1:]),
)
def basic_dict(self):
return dict(
self.short_dict(),
description=self.description,
language=self.language,
stars=self.star_count,
watchers=self.watcher_count,
forks=self.fork_count,
issues=self.issues_count,
)
db.Index("ix_gh_users_login_lower",
db.func.lower(db.metadata.tables["gh_users"].c.login))
db.Index("ix_gh_repos_fullaname_lower",
db.func.lower(db.metadata.tables["gh_repos"].c.fullname))
username = db.Column(db.String(30), nullable=False, unique=True)
password = db.Column(db.String(255), nullable=False)
is_admin = db.Column(db.Boolean, nullable=False)
groups = db.relationship('Group',
secondary=group_membership_table,
backref=db.backref('users'))
def valid_password(self, password):
return check_password_hash(self.password, password)
class Group(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False, unique=True)
description = db.Column(db.Text, nullable=False, default='')
class SiteSettingType(enum.Enum):
string = "String"
boolean = "Boolean"
integer = "Integer"
class SiteSettings(db.Model):
setting = db.Column(db.String(25), nullable=False, primary_key=True)
type = db.Column(db.Enum(SiteSettingType), nullable=False)
value = db.Column(db.String(100), nullable=False)
db.Index('user_username_password_idx', User.username, User.password)
db.ForeignKey(Project.id),
primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey(User.id), primary_key=True)
# автозаполняемые справочники
external_project_id = db.Column(db.Integer)
external_project_title = db.Column(db.String(255))
tracker = db.relationship(Tracker)
project = db.relationship(Project)
user = db.relationship(User)
########################################### fulltext index: ############################################################
db.Index('project_name', Project.title, mysql_prefix='FULLTEXT')
db.Index('activity_comment', Activity.comment, mysql_prefix='FULLTEXT')
db.Index('activity_name', Activity.name, mysql_prefix='FULLTEXT')
db.Index('hashtag_name', HashTag.name, mysql_prefix='FULLTEXT')
################################################# schema: ##############################################################
# Schema - модуль дампа оъектов моделей, позволяет преобразовать объект модели в словарь, его можно отправить как json
#
# Пример использования:
# from .model.mysql import ActivitySchema
# schema = ActivitySchema()
# fact = db.session.query(Activity).filter(Activity.user_id == self.user.id).first()
# result = schema.dump(fact).data
# return jsonify(result)
#
return "<User id={id}, username: {username}, email: {email}>".format(
id=self.id, username=self.username, email=self.email)
class Role(db.Model, RoleMixin):
__tablename__ = 'roles'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(100), unique=True)
description = db.Column(db.String(200))
def __repr__(self):
return "<Role id={id}, name: {name}>, description: {description}>"\
.format(id=self.id, name=self.name,
description=self.description
if self.description
else '')
# full-text search indices
db.Index('idx_authors_name_full_text_search',
func.to_tsvector('simple', Author.name),
func.to_tsvector('simple', Author.surname),
postgresql_using='gin')
db.Index('idx_fullname_text_search',
func.to_tsvector('simple', Author.fullname),
postgresql_using='gin')
db.Index('idx_books_title_full_text_search',
func.to_tsvector('simple', Book.title),
postgresql_using='gin')
to_allele = db.Column(db.String)
mutation_r = db.Column(db.String(4))
t_mutation_trinucleotide = db.Table(
'mutation_trinucleotide', db.Column('donor_id', db.Integer,
nullable=False),
db.Column('tumor_type_id', db.SmallInteger, nullable=False, index=True),
db.Column('chrom', db.SmallInteger, nullable=False, index=True),
db.Column('position', db.Integer, nullable=False),
db.Column('mutation_code_id',
db.ForeignKey(u'mutation_code.mutation_code_id'),
db.ForeignKey(u'trinucleotide_encoded.id'),
nullable=False),
db.Column('trinucleotide_id_r', db.SmallInteger, nullable=False),
db.Index('mutation_trinucleotide_chrom_position_index', 'chrom',
'position'),
db.Index('mutation_trinucleotide_tumor_type_id_chrom_position_index',
'tumor_type_id', 'chrom', 'position'))
t_mutation_trinucleotide_test = db.Table(
'mutation_trinucleotide_test', db.Column('donor_id', db.Integer),
db.Column('tumor_type_id', db.SmallInteger),
db.Column('chrom', db.SmallInteger), db.Column('position', db.Integer),
db.Column('mutation_code_id', db.SmallInteger),
db.Column('trinucleotide_id_r', db.SmallInteger))
class TrinucleotideEncoded(db.Model):
__tablename__ = 'trinucleotide_encoded'
id = db.Column(db.SmallInteger,
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate
from sqlalchemy.dialects.postgresql import DOUBLE_PRECISION
from os import environ
db = SQLAlchemy()
migrate = Migrate(db)
class Note(db.Model):
id = db.Column(db.Integer, primary_key=True)
kind = db.Column(db.String, nullable=False)
content = db.Column(db.Text)
# We could use PostGIS for this, but I think it's overkill when we just need to find points.
lat = db.Column(DOUBLE_PRECISION, nullable=False)
long = db.Column(DOUBLE_PRECISION, nullable=False)
altitude = db.Column(db.Float)
expires = db.Column(db.DateTime, index=True)
colour = db.Column(db.Integer)
db.Index('note_lat_long_index', Note.lat, Note.long)
def init_app(app):
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['SQLALCHEMY_DATABASE_URI'] = environ['DATABASE_URL']
db.init_app(app)
migrate.init_app(app, db)
"""
def __init__(self, dog_id, hippie_id):
self.dog_id = dog_id
self.hippie_id = hippie_id
# "helper" table
dogs = db.Table(
"dogs",
db.metadata,
db.Column("id", db.Integer, primary_key=True),
db.Column("dog_id", db.Integer, db.ForeignKey("dog.id")),
db.Column("hippie_id", db.Integer, db.ForeignKey("hippie.id")),
)
# unique index of hippie_id and dog_id
db.Index("love", dogs.c.hippie_id, dogs.c.dog_id, unique=True)
class Hippie(db.Model):
"""
Hippie model contains relationship to "Dog"
secondary table "dogs" is "helper" table which contains
unique index of Hippie.id and Dog.id
the backref "hippies" provides a query object for Dog
"""
__tablename__ = "hippie"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True, nullable=False)
dogs = db.relationship(
"Dog",
secondary=dogs,
stream_title = stream_data["stream_title"]
viewer_count = stream_data["viewer_count"]
new_data = cls(timestamp=timestamp,
stream_id=stream_id,
game_id=game_id,
game_name=game_name,
stream_title=stream_title,
viewer_count=viewer_count)
db.session.add(new_data)
db.session.commit()
# Adds index to stream_sessions table; will be filtering by started_at for
# API calls
db.Index('ix_user_started', StreamSession.user_id, StreamSession.started_at)
class TwitchClip(db.Model):
"""Clips auto-generated for Tweets."""
__tablename__ = "twitch_clips"
clip_id = db.Column(db.Integer, primary_key=True)
slug = db.Column(db.Text, nullable=False)
stream_id = db.Column(db.Integer,
db.ForeignKey("stream_sessions.stream_id"),
nullable=False)
session = db.relationship("StreamSession", backref="clips")
tweet = db.relationship("SentTweet", back_populates="clip", uselist=False)
db.metadata,
db.Column("id", db.Integer, primary_key=True),
db.Column("genre_id", db.Integer, db.ForeignKey("genre.id")),
db.Column("venue_id", db.Integer, db.ForeignKey("venue.id")),
)
genres_artist = db.Table(
"genres_artist",
db.metadata,
db.Column("id", db.Integer, primary_key=True),
db.Column("genre_id", db.Integer, db.ForeignKey("genre.id")),
db.Column("artist_id", db.Integer, db.ForeignKey("artist.id")),
)
# unique index of venue_id and genre_id
db.Index("genre_venue_link",
genres_venue.c.venue_id,
genres_venue.c.genre_id,
unique=True)
# unique artist_id and genre_id
db.Index("genre_artist_link",
genres_artist.c.artist_id,
genres_artist.c.genre_id,
unique=True)
class Show(db.Model):
__tablename__ = "show"
id = db.Column(db.Integer, primary_key=True)
venue_id = db.Column(db.Integer,
db.ForeignKey("venue.id", ondelete='CASCADE'))
artist_id = db.Column(db.Integer,
db.ForeignKey("artist.id", ondelete='CASCADE'))
t_attorney_case = db.Table(
'attorney_case',
db.Column('attorney', db.ForeignKey(u'person.id'), primary_key=True, nullable=False),
db.Column('case', db.ForeignKey(u'case.id'), primary_key=True, nullable=False, index=True)
)
t_attorney_case_hearing = db.Table(
'attorney_case_hearing',
db.Column('attorney', db.ForeignKey(u'person.id'), primary_key=True, nullable=False),
db.Column('case_hearing_case', db.Integer, primary_key=True, nullable=False),
db.Column('case_hearing_hearingtype', db.Integer, primary_key=True, nullable=False),
db.Column('case_hearing_hearing_date', db.DateTime, primary_key=True, nullable=False),
db.ForeignKeyConstraint(['case_hearing_case', 'case_hearing_hearingtype', 'case_hearing_hearing_date'], [u'case_hearing.case', u'case_hearing.hearingtype', u'case_hearing.hearing_date']),
db.Index('idx_attorney_case_hearing', 'case_hearing_case', 'case_hearing_hearingtype', 'case_hearing_hearing_date')
)
class Bail(db.Model):
__tablename__ = 'bail'
case = db.Column(db.ForeignKey(u'case.id'), primary_key=True, nullable=False)
defendant = db.Column(db.ForeignKey(u'person.id'), primary_key=True, nullable=False, index=True)
amount = db.Column(db.Float(53), nullable=False)
surety_count = db.Column(db.Integer, nullable=False)
paid = db.Column(db.Boolean, nullable=False)
paid_date = db.Column(db.Date, nullable=False)
receipt_number = db.Column(db.Text, nullable=False)
case1 = db.relationship(u'Case', primaryjoin='Bail.case == Case.id', backref=u'bails')
