class Movie(Entity):
__tablename__ = 'movie'
title = Column(Unicode(60), nullable=False)
short_description = Column(Unicode(512))
release_date = Column(Date())
genre = Column(Unicode(15))
director_id = Column(Integer, ForeignKey('director.id'))
director = relationship('Director', backref='movies')
def __unicode__(self):
return self.title or 'Untitled movie'
class Admin(EntityAdmin):
from model import Reporte
verbose_name = 'Movie'
list_display = [
'title', 'short_description', 'release_date', 'genre', 'director'
]
form_actions = [Reporte()] #<------ Boton Reporte
class Car(Base):
"""
Class for car objects
"""
__tablename__ = 'cars'
id = Column(Integer(), primary_key=True)
make = Column(String(40), nullable=False)
model = Column(String(100), nullable=False)
description = Column(String(255), nullable=False)
price = Column(Integer())
fr_date = Column(Date())
mileage = Column(String(10))
chase_type = Column(String(30))
fuel_type = Column(String(30))
transmission = Column(String(30))
co2_emissions = Column(String(20))
def __repr__(self):
return f"{self.__class__.__name__}(id={self.id}, make={self.make}, model={self.model}," \
f" description={self.description}, price={self.price}, fr_date={self.fr_date}," \
f" mileage={self.mileage}, chase_type={self.chase_type}, fuel_type={self.fuel_type}," \
f" transmission={self.transmission}, co2_emissions={self.co2_emissions})"
class FeeEntry(Base):
__tablename__ = 'fee_entry'
id = Column(String(), primary_key=True)
member_id = Column(Integer(), ForeignKey('member.id'))
month = Column(Date(), CheckConstraint("date(month, 'start of month') == month"), primary_key=True)
tx_id = Column(String(), ForeignKey('transaction.tx_id'), nullable=False)
fee = Column(Numeric(), nullable=False)
pay_interval = Column(Enum(PayInterval), nullable=False,
default=PayInterval.MONTHLY)
detect_method = Column(Enum(DetectMethod), nullable=False,
default=DetectMethod.FALLBACK)
# --- Relationships ---
member = relationship('Member', back_populates='fee_entries')
tx = relationship(Transaction, back_populates='fee_entries')
def __str__(self):
return str(self.__dict__)
def __repr__(self):
return "FeeEntry{x}".format(x=self.__dict__)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.id = "{}|{}".format(self.member_id, self.month)
def replace(self, **kwargs):
for key in ['member_id', 'month', 'tx_id', 'fee', 'pay_interval', 'detect_method']:
if kwargs.get(key, None) is None:
if key not in self.__dict__ and key == 'tx_id':
kwargs['tx'] = self.tx
else:
kwargs[key] = self.__dict__[key]
return FeeEntry(**kwargs)
def epltosql(dd):
df = dd[0]
data = dd[1]
Base = declarative_base()
# engine = create_engine('mysql+mysqlconnector://gjn:[email protected]:3306/betradar')
engine = create_engine(
'mysql+mysqlconnector://root:password@localhost:3306/epl')
dtype = {}
for c in df.columns:
i = list(df.columns).index(c)
if i in [1, 2, 3, 4, 7, 20]:
dtype[c] = String(25)
elif i in [9, 10, 11, 12, 13, -2, -1]:
dtype[c] = Float()
elif i == 0:
dtype[c] = Date()
else:
dtype[c] = Integer()
df.to_sql('game',
engine,
schema='epl',
if_exists='append',
index=False,
dtype=dtype)
datype = {}
for c in df.columns:
i = list(df.columns).index(c)
if i in [0, 1]:
datype[c] = String(25)
else:
datype[c] = Float()
data.to_sql('team',
engine,
schema='epl',
if_exists='append',
index=False,
dtype=datype)
def upgrade():
op.create_table(
'imports', Column('import_id', Integer(), nullable=False),
PrimaryKeyConstraint('import_id', name=op.f('pk__imports')))
op.create_table(
'citizens', Column('import_id', Integer(), nullable=False),
Column('citizen_id', Integer(), nullable=False),
Column('town', String(), nullable=False),
Column('street', String(), nullable=False),
Column('building', String(), nullable=False),
Column('apartment', Integer(), nullable=False),
Column('name', String(), nullable=False),
Column('birth_date', Date(), nullable=False),
Column('gender', GenderType, nullable=False),
PrimaryKeyConstraint('import_id',
'citizen_id',
name=op.f('pk__citizens')),
ForeignKeyConstraint(('import_id', ), ['imports.import_id'],
name=op.f('fk__citizens__import_id__imports')))
op.create_index(op.f('ix__citizens__town'),
'citizens', ['town'],
unique=False)
op.create_table(
'relations', Column('import_id', Integer(), nullable=False),
Column('citizen_id', Integer(), nullable=False),
Column('relative_id', Integer(), nullable=False),
PrimaryKeyConstraint('import_id',
'citizen_id',
'relative_id',
name=op.f('pk__relations')),
ForeignKeyConstraint(
('import_id', 'citizen_id'),
['citizens.import_id', 'citizens.citizen_id'],
name=op.f('fk__relations__import_id_citizen_id__citizens')),
ForeignKeyConstraint(
('import_id', 'relative_id'),
['citizens.import_id', 'citizens.citizen_id'],
name=op.f('fk__relations__import_id_relative_id__citizens')))
def test_type_adapt(self):
dialect = cx_oracle.dialect()
for start, test in [
(Date(), cx_oracle._OracleDate),
(oracle.OracleRaw(), cx_oracle._OracleRaw),
(String(), String),
(VARCHAR(), cx_oracle._OracleString),
(DATE(), cx_oracle._OracleDate),
(oracle.DATE(), oracle.DATE),
(String(50), cx_oracle._OracleString),
(Unicode(), cx_oracle._OracleUnicodeStringCHAR),
(Text(), cx_oracle._OracleText),
(UnicodeText(), cx_oracle._OracleUnicodeTextCLOB),
(CHAR(), cx_oracle._OracleChar),
(NCHAR(), cx_oracle._OracleNChar),
(NVARCHAR(), cx_oracle._OracleUnicodeStringNCHAR),
(oracle.RAW(50), cx_oracle._OracleRaw),
]:
assert isinstance(
start.dialect_impl(dialect),
test), "wanted %r got %r" % (test, start.dialect_impl(dialect))
class Communication(DBBASE):
"""
Communication Class, logs communications between the contractor and its
CAE
"""
__tablename__ = "communication"
__table_args__ = default_table_args
id = Column(Integer, primary_key=True)
user_id = Column(Integer, ForeignKey("accounts.id"))
content = Column(Text)
date = Column(
Date(),
default=datetime.date.today,
onupdate=datetime.date.today
)
expense_sheet_id = Column(Integer, ForeignKey("expense_sheet.id"))
expense_sheet = relationship(
"ExpenseSheet",
backref=backref(
"communications",
order_by="Communication.date",
cascade="all, delete-orphan"
)
)
user = relationship(
"User",
primaryjoin="Communication.user_id==User.id",
backref=backref(
"expense_communications",
order_by="Communication.date",
cascade="all, delete-orphan",
info={
'colanderalchemy': EXCLUDED,
'export': {'exclude': True},
},
)
)
class FilerContactInfo(CustomBase):
id = Column(Integer, primary_key=True)
# Filers can change their names, but nevertheless all filings
# should be discoverable base on any of their names
filer_id = Column(UUID, ForeignKey("filer.filer_id"), nullable=False)
first_name = Column(String)
last_name = Column(String)
middle_name = Column(String)
# address data
address1 = Column(String)
address2 = Column(String)
city = Column(String)
zipcode = Column(String)
state = Column(String)
country = Column(String, nullable=False, default="US")
phone = Column(String)
# normally, the email never changes, however, we have historic netfile
# data to deal with, so we'll also store email hre
email = Column(String)
# this may be needed for particular kinds of filers
# who must report changes of address right away and if
# the addressed changed earlier than allowed they may
# get dinged by the Ethic's commission
effective_date = Column(Date(), default=today())
hide_details = Column(Boolean, nullable=False, server_default='t')
created = Column(DateTime(timezone=True),
nullable=False,
default=func.now())
updated = Column(DateTime(timezone=True),
nullable=False,
default=func.now(),
onupdate=func.now())
class Jz_autoinfo_content(Base):
__tablename__ = 'jz_autoinfo_content'
__table_args__ = {"useexisting": False}
uid = Column(Integer(), primary_key=True) # 自增序号 not null
url = Column(String(), nullable=True) # 网页的url not null
author = Column(VARCHAR(200)) # 作者 null
public_time = Column(TIMESTAMP()) # 内容发布时间 null
collection_time = Column(TIMESTAMP(),
nullable=True,
server_default=func.now()) # 首次采集时间 not null
update_time = Column(TIMESTAMP()) # 最近更新时间
page_source = Column(String(), nullable=True) # 为t_pagesource_list中的hid
content = Column(String()) # 解析后的内容 null
website_name = Column(VARCHAR(200)) # 站点名（如：微信公众号）
channel_name = Column(VARCHAR(200)) # 频道名（如：微信公众号下的汽车之家）
title = Column(VARCHAR(300)) # 标题
topic = Column(VARCHAR(300)) # 话题
tag = Column(String()) # 显示标签
meta_keywords = Column(String()) # 网页<head>头部下的<meta Keywords>
write_date = Column(Date())
flag = Column(String())
pic = Column(String())
class Question(BaseObject, AEntity):
"""
Вопрос
"""
__tablename__ = 'question'
n = Column(Integer, primary_key=True)
feature_n = Column(Integer,
ForeignKey('feature.n', ondelete='CASCADE'),
default=1)
feature = relationship('Feature',
backref=backref('questions',
cascade='all, delete-orphan'))
# Сам вопрос
txt = Column(Unicode(1024), default='')
ddate = Column(Date(), default=date.today)
# Правильный ответ (Answer не присоединяю, т.к.возникает циклическая
# зависимость)
answer_n = Column(Integer, default=1)
def __str__(self):
return "n=%s feature_n=%s txt=%s ddate=%s answer_n=%s" % (
self.n, self.feature_n, self.txt, self.ddate, self.answer_n)
class CCExtractorVersion(Base):
"""Model to manage CCExtractor version and release data."""
__tablename__ = 'ccextractor_version'
__table_args__ = {'mysql_engine': 'InnoDB'}
id = Column(Integer, primary_key=True)
version = Column(String(10), unique=True)
released = Column(Date(), unique=True)
commit = Column(String(64), unique=True)
def __init__(self, version, released, commit) -> None:
"""
Parametrized constructor for the CCExtractorVersion model.
:param version: The value of the 'version' field of
CCExtractorVersion model
:type version: str
:param released: The value of the 'released' field of
CCExtractorVersion model
:type released: datetime
:param commit: The value of the 'timestamp' field of
CCExtractorVersion model
:type commit: str
"""
self.version = version
self.released = datetime.strptime(released,
'%Y-%m-%dT%H:%M:%SZ').date()
self.commit = commit
def __repr__(self) -> str:
"""
Represent a CCExtractorVersion Model by its 'version' Field.
:return str(version): Returns the string containing
'version' field of the CCExtractorVersion model
:rtype str(version): str
"""
return '<Version {v}>'.format(v=self.version)
class Event(BaseModel):
__tablename__ = 'event'
id = Column(Integer, Sequence('event_id_seq'), primary_key=True)
name = Column(String(250), nullable=False)
description = Column(Text(), nullable=True)
community_id = Column(Integer(), nullable=False)
volunteer_count = Column(Integer(), nullable=False)
reward = Column(Integer(), nullable=True)
img = Column(String(250), nullable=True)
event_date = Column(Date(),
default=(datetime.today() + timedelta(days=5)),
nullable=False)
event_subject_id = Column(Integer(), ForeignKey('event_subject.id'))
event_subject = relationship('EventSubject', lazy='joined')
organizers = relationship("Organizer",
secondary=organizer_event_table,
back_populates="organizer_events")
volunteers = relationship("Volunteer",
secondary=volunteer_event_table,
back_populates="volunteer_events")
def marshall(self):
return dict(
id=self.id,
name=self.name,
description=self.description,
community_id=self.community_id,
volunteer_count=self.volunteer_count,
reward=self.reward,
img=self.img,
event_date=self.event_date,
organizers=[org.id for org in self.organizers],
volunteers=[vol.id for vol in self.volunteers],
)
class ScheduledStop(Base):
################################################################
# CLASS ScheduledStop
################################################################
def __init__(self, trip_id, v, run, date, stop_id, stop_name, lat, lon):
self.trip_id = trip_id
self.v = v
self.run = run
self.date = date
self.stop_id = stop_id
self.stop_name = stop_name
self.lat = lat
self.lon = lon
__tablename__ = 'scheduledstop_log'
pkey = Column(Integer(), primary_key=True)
run = Column(String(8))
v = Column(Integer())
date = Column(Date())
stop_id = Column(Integer(), index=True)
stop_name = Column(String(255))
lat = Column(Float())
lon = Column(Float())
arrival_timestamp = Column(DateTime(), index=True)
interpolated_arrival_flag = Column(Boolean())
# foreign keys
trip_id = Column(String(127), ForeignKey('trip_log.trip_id'), index=True)
__table_args__ = (Index('trip_id_stop_id', "trip_id", "stop_id"), {
'extend_existing': True
})
def __repr__(self):
return '[ScheduledStop: \ttrip_id {} \tstop_id {} \tarrival_timestamp {} \tinterpolated_arrival_flag {}]'.format(
self.trip_id, self.stop_id, self.arrival_timestamp,
self.interpolated_arrival_flag)
class Release(db.Model):
mbid = Column(String(36), primary_key=True)
title = Column(Text, nullable=False)
artist_names = Column(Text, nullable=False)
type = Column(String(36), index=True)
art = Column(Boolean(), nullable=False, default=False, server_default=expression.false())
date_release = Column(Date(), nullable=False, index=True)
date_added = Column(DateTime(True), nullable=False, default=func.now())
date_art_check = Column(DateTime(True), nullable=True, default=None)
date_updated = Column(DateTime(True), nullable=False, default=func.now())
date_checked = Column(DateTime(True), nullable=True, default=func.now())
apple_music_link = Column(String(), nullable=True, default=None)
spotify_link = Column(String(), nullable=True, default=None)
artists = db.relationship("Artist", secondary="artist_release", lazy=False)
def __repr__(self):
return '<Release {} - {} - {}>'.format(
self.artist_names,
self.title,
self.mbid)
class FundStock(Base, DBInfoMixin):
"""
基金的10大持仓股
"""
__tablename__ = 'fund_stocks' # 指定本类映射到users表
id = Column(Integer, primary_key=True, autoincrement=True) # 主键
fund_code = Column(String(20)) # 基金编码
stock_code = Column(String(20)) # 股票编码
stock_name = Column(String(20)) # 股票名称
market_cap = Column(String(20)) # 股票市值
proportion = Column(Float()) # 在基金中的资产占比
pub_date = Column(Date()) # 披露日期
__table_args__ = (UniqueConstraint('fund_code', 'stock_code'), )
def get_column_mapping(self):
return {'stock_code': '股票代码', 'stock_name': '股票名称', 'proportion': '占比'}
# __repr__方法用于输出该类的对象被print()时输出的字符串，如果不想写可以不写
def __repr__(self):
return self.get_field_values()
class System(Base):
__tablename__ = 'systems'
sys_hwuuid = Column(String(64), primary_key=True)
last_sub_date = Column(Date())
def __init__(self, sys_hwuuid, date=date.today()):
self.sys_hwuuid = sys_hwuuid
self.last_sub_date = date
def __repr__(self):
return '<System %s: Last submission at %s>' % (self.sys_hwuuid,
self.last_sub_date)
@property
def _flat_attrs(self):
return {
'sys_hwuuid': self.sys_hwuuid,
'last_sub_date': self.last_sub_date.strftime("%Y-%m-%d"),
}
@property
def serialize(self):
return dict(**self._flat_attrs)
class TbExecCmd(Base):
"""
命令运行信息表
"""
__tablename__ = 'tb_execcmd'
datatime = Column(String(8))
func_id = Column(String(40))
seq = Column(BigInteger())
memo = Column(String(100))
exec_cmd = Column(Text())
flag = Column(SMALLINT())
err_msg = Column(Text())
start_time = Column(DateTime())
end_time = Column(DateTime())
exec_elapsed = Column(BigInteger())
exec_date = Column(Date())
business_param = Column(String(40))
__table_args__ = (
PrimaryKeyConstraint('datatime', 'seq', 'func_id', 'business_param'),
{},
)
class Person(Base):
__tablename__ = 'People'
id = Column(Integer, primary_key=True)
name = Column(String(250), nullable=False)
last_name = Column(String(250), nullable=False)
birth_date = Column(Date(), nullable=True)
alerts = relationship("Alert", secondary=alerts_people, back_populates="persons")
def to_list_json(self):
sh = SerializationHelper()
sh.name = self.name
sh.last_name = self.last_name
sh.id = self.id
return sh.to_json()
def to_full_json(self):
sh = SerializationHelper()
sh.name = self.name
sh.last_name = self.last_name
sh.id = self.id
sh.birth_date = self.birth_date
return sh.to_json()
class Pessoa(Base):
__tablename__ = '__pessoa'
id = Column(Integer, primary_key=True)
nome = Column(String(250))
data_nascimento = Column(Date())
enderecos = relationship("Endereco")
telefones = relationship("Telefone")
def __init__(self, nome, data_nascimento):
self.nome = nome
self.data_nascimento = data_nascimento
def to_dict(self, includeEndereco=False):
data = {
'id': self.id,
'nome': self.nome,
'data_nascimento': self.data_nascimento,
}
if includeEndereco:
data['enderecos'] = [item.to_dict() for item in self.enderecos]
data['telefones'] = [item.to_dict() for item in self.telefones]
return data
class Author(Base):
__tablename__ = 'author'
id = Column(Integer, primary_key=True, autoincrement=True)
firstname = Column(String(30), nullable=False)
lastname = Column(String(30), nullable=False)
nickname = Column(String(30))
birthdate = Column(Date())
def __init__(self, firstname: str, lastname: str, nickname: str,
birthdate: object):
self.firstname = firstname
self.lastname = lastname
self.nickname = nickname
self.birthdate = birthdate
def update(self, firstname: str, lastname: str, nickname: str,
birthdate: object):
self.firstname = firstname
self.lastname = lastname
self.nickname = nickname
self.birthdate = birthdate
def get_table_history_data(self, table_name):
metadata = MetaData()
table_history_data = Table(
table_name,
metadata,
Column('date', Date(), primary_key=True
), #时间和日期 低频数据时为：YYYY-MM-DD 高频数为：YYYY-MM-DD HH:MM
Column('open', DECIMAL(10, 4)), #开盘价
Column('high', DECIMAL(10, 4)), #最高价
Column('close', DECIMAL(10, 4)), #收盘价
Column('low', DECIMAL(10, 4)), #最低价
Column('volume', DECIMAL(20, 4)), #成交量
Column('price_change', DECIMAL(20, 4)), #价格变动
Column('p_change', DECIMAL(20, 4)), #涨跌幅
Column('ma5', DECIMAL(20, 4)), #5日均价
Column('ma10', DECIMAL(20, 4)), #10日均价
Column('ma20', DECIMAL(20, 4)), #20日均价
Column('v_ma5', DECIMAL(20, 4)), #5日均量
Column('v_ma10', DECIMAL(20, 4)), #10日均量
Column('v_ma20', DECIMAL(20, 4)), #20日均量
Column('turnover', DECIMAL(20, 4)), #换手率
)
return table_history_data
class Member(BaseModel):
'''
Member model
'''
__tablename__ = 'members'
id = Column(Integer, primary_key=True)
name = Column(String(50), nullable=False)
phone = Column(String(11), nullable=False)
wchat = Column(String(30))
address = Column(String(100))
role = Column(Integer, ForeignKey('role.id'))
sex = Column(Enum('man', 'women'))
birthday = Column(Date())
expenses_not_quota_password = Column(String(20), nullable=False)
expenses_quota = Column(Integer)
expenses_not_quota = Column(Integer)
course_num = Column(Integer)
course_num_free = Column(Integer)
comments = Column(String(200))
body_info = Column(String(50))
coach_id = Column(Integer, ForeignKey('employees.id'))
class Data(Base):
__tablename__ = 't_articles'
id = Column('id', INTEGER, primary_key=True)
university = Column('university', String(length=255), nullable=True)
en_university = Column('en_university', String(length=255), nullable=True)
region = Column('region', String(length=255), nullable=True)
# department = Column('department', String(length=255), nullable=True)
# teacher = Column('teacher', String(length=255), nullable=True)
title = Column('title', String(length=255), nullable=True)
content = Column('content', Text())
url = Column('url', String(length=1000), nullable=True)
createtime = Column('createtime', Date())
trans_title = Column('trans_title', String(length=255), nullable=True)
trans_content = Column('trans_content', Text())
@classmethod
def universitys(cls):
with Sql() as s:
u = s.query(cls.university).group_by(cls.university).all()
if u:
u = [i[0] for i in u]
return u
@classmethod
# def departments(cls, university):
# with Sql() as s:
# d = s.query(cls.title).filter(cls.university == university).group_by(cls.department).all()#cls.department
# if d:
# d = [i[0] for i in d]
# return d
@classmethod
def count_data(cls, **kwargs):
with Sql() as s:
nums = s.query(func.count(cls.id)).filter_by(**kwargs).scalar()
return nums
class Job_Queue(Base):
__tablename__='job_queues'
job_id = Column(Integer,ForeignKey('jobs.id'), primary_key=True)
job_date = Column(Date(), primary_key=True)
def __init__(self,id,date):
self.job_id=id
self.job_date=date
@staticmethod
def del_queue(id,date):
try:
session.query(Job_Queue).filter(Job_Queue.job_id==id,Job_Queue.job_date==date).delete()
session.flush()
print('任务[%d][%s]成功Pending,删除队列'%(id,date))
except Exception as e:
print(e)
session.rollback()
return False
else:
session.commit()
return True
@staticmethod
def add_queue(id,date):
try:
queue=Job_Queue(id,date)
session.add(queue)
session.flush()
print('任务[%d][%s]加入队列'%(queue.job_id,queue.job_date))
except Exception as e:
print(e)
session.rollback()
return False
else:
session.commit()
return True
class ouraActivitySummary(Base):
__tablename__ = 'oura_activity_summary'
summary_date = Column('summary_date', Date(), index=True, primary_key=True)
average_met = Column('average_met', Float())
cal_active = Column('cal_active', Integer())
cal_total = Column('cal_total', Integer())
class_5min = Column('class_5min', String(300))
daily_movement = Column('daily_movement', Integer())
day_end_local = Column('day_end_local', DateTime())
day_start_local = Column('day_start_local', DateTime())
high = Column('high', Integer())
inactive = Column('inactive', Integer())
inactivity_alerts = Column('inactivity_alerts', Integer())
low = Column('low', Integer())
medium = Column('medium', Integer())
met_min_high = Column('met_min_high', Integer())
met_min_inactive = Column('met_min_inactive', Integer())
met_min_low = Column('met_min_low', Integer())
met_min_medium = Column('met_min_medium', Integer())
non_wear = Column('non_wear', Integer())
rest = Column('rest', Integer())
score = Column('score', Integer())
score_meet_daily_targets = Column('score_meet_daily_targets', Integer())
score_move_every_hour = Column('score_move_every_hour', Integer())
score_recovery_time = Column('score_recovery_time', Integer())
score_stay_active = Column('score_stay_active', Integer())
score_training_frequency = Column('score_training_frequency', Integer())
score_training_volume = Column('score_training_volume', Integer())
steps = Column('steps', Integer())
target_calories = Column('target_calories', Integer())
timezone = Column('timezone', Integer())
target_km = Column('target_km', Float())
target_miles = Column('target_miles', Float())
to_target_km = Column('to_target_km', Float())
to_target_miles = Column('to_target_miles', Float())
total = Column('total', Integer())
rest_mode_state = Column('rest_mode_state', Integer())
def _create_table(self):
"""
Build three main tables to save 'daily' candles, 'intraday minute level' candles, and 'splits' information.
"""
if self.tb_name in self.engine.table_names():
print(
"The table [{}] has already been created, please drop it at first."
.format(self.tb_name))
return None
else:
print("----- CREATING TABLE [{}] -----".format(self.tb_name))
# Check if the table are pre-defined table:
if self.tb_name in [
RDS_CONFIG['DAILY_TABLE'], RDS_CONFIG['INTRADAY_TABLE']
]:
self.current_table = Table(
self.tb_name, self.metadata, Column('close_price', Float(5)),
Column('high_price', Float(5)), Column('low_price', Float(5)),
Column('open_price', Float(5)), Column('status', String(255)),
Column('timestamp',
DateTime(timezone=True),
default=datetime.utcnow),
Column('volume', BigInteger()), Column('symbol', String(255)))
elif self.tb_name == RDS_CONFIG['SPLIT_TABLE']:
self.current_table = Table(
self.tb_name, self.metadata,
Column('symbol', String(255), primary_key=True),
Column('date', Date(), primary_key=True),
Column('fromFactor', Integer()), Column('toFactor', Integer()),
Column('source', String(255)))
else:
print("Sorry creating table {} is not supported for now.".format(
self.tb_name))
# Build the table:
self.metadata.create_all(self.engine)
# To check if the table is successful created:
print("----- TABLE [{}] CREATED -----".format(self.tb_name))
class Status(BaseTable):
__tablename__ = PAT_NAME.match(__name__).groups()[0]
LoanId = Column("loan_id", BigInteger(), primary_key=True)
PlatformName = Column("platform_name", String(255), primary_key=True)
RecordDate = Column("record_date", Date(), primary_key=True)
PrincipalPaid = Column("principal_paid",
Numeric(precision=15, scale=2),
nullable=False)
InterestPaid = Column("interest_paid",
Numeric(precision=15, scale=2),
nullable=False)
LoanStatus = Column("loan_status", String(255), nullable=False)
Loan = relationship("Loans", backref="status")
__table_args__ = (ForeignKeyConstraint([LoanId, PlatformName],
[Loans.LoanId, Loans.PlatformName]),
{})
def __init__(self, loan_id, platform_name, record_date, principal_paid,
interest_paid, loan_status):
self.LoanId = loan_id
self.PlatformName = platform_name
self.RecordDate = record_date
self.PrincipalPaid = principal_paid
self.InterestPaid = interest_paid
self.LoanStatus = loan_status
@property
def mode(self):
# Insert mode
return MODE_INSERT
def __repr__(self):
return "<{0} | Id: {1} | Platform: {2} | Date: {3}>".format(
self.__class__.__name__, self.LoanId, self.PlatformName,
self.RecordDate)
class User(Base):
__tablename__ = 'users'
id = Column(Integer, primary_key=True, autoincrement=True)
phone_number = Column(String(15), unique=True)
user_name = Column(String(128), nullable=False)
surname = Column(String(128))
userpic = Column(Text())
about = Column(String(1000))
birthday = Column(Date())
password_hash = Column(Text())
nickname = Column(String(128))
email = Column(String(255), nullable=False, unique=True)
last_seen = Column(DateTime())
token = Column(Text())
refresh_token = Column(Text())
user_lists = relationship("Wishlist",
cascade="all,delete",
foreign_keys="Wishlist.user_id")
friend_requests = relationship("FriendRequests",
cascade="all,delete",
foreign_keys="FriendRequests.user_id_from")
friends = relationship("FriendShip",
cascade="all,delete",
foreign_keys="FriendShip.user_id_1")
items_owner = relationship("Item",
cascade="all,delete",
foreign_keys="Item.owner_id",
doc='owner')
items_performed = relationship("Item",
cascade="all,delete",
foreign_keys="Item.owner_id")
items_giver = relationship(
"Item", cascade="all",
foreign_keys="Item.giver_id") # Performed wishes of user
groups = relationship("GroupUser",
cascade="all,delete",
foreign_keys="GroupUser.user_id")
class data(Base):
__tablename__ = 'data'
dataId = Column(Integer(), primary_key=True)
dataName = Column(String(16), nullable=False)
dataDescription = Column(Text(), nullable=True)
dataAuthor = Column(String(30), nullable=True)
dataPress = Column(String(30), nullable=True)
dataLocation = Column(String(30), nullable=True)
borrowStatus = Column(Boolean(), nullable=False, default=False)
borrowTime = Column(Date(), nullable=True)
supposedReturnTime = Column(Date, nullable=True)
borrowerId = Column(Integer(), nullable=True)
dataPrice = Column(Float(), nullable=True)
def __init__(self,
dataName=None,
dataPrice=None,
borrowStatus=False,
dataLocation=None,
borrowTime=None,
supposedReturnTime=None,
borrowerId=None,
dataDescription=None,
dataAuthor=None,
dataPress=None):
self.dataName = dataName
self.dataAuthor = dataAuthor
self.dataPress = dataPress
self.borrowStatus = borrowStatus
self.borrowTime = borrowTime
self.supposedReturnTime = supposedReturnTime
self.borrowerId = borrowerId
self.dataDescription = dataDescription
self.dataLocation = dataLocation
self.dataPrice = dataPrice
class ExecutedRecipe(Base):
"""
┌────┬─────────────┬─────────────────┬──────┬──────────┐
│ id │ recipe_name │ ingredient_name │ date │ quantity │
├────┼─────────────┼─────────────────┼──────┼──────────┤
│ 1 │ cake │ egg │ 1/1 │ 200 │
│ 2 │ cake │ sugar │ 1/1 │ 50 │
│ 3 │ cake │ milk │ 1/1 │ 200 │
│ 4 │ cake │ flour │ 1/1 │ 500 │
└────┴─────────────┴─────────────────┴──────┴──────────┘
"""
__tablename__ = "executedrecipe"
id = Column(Integer(), primary_key=True, autoincrement=True)
recipe_id = Column(Integer(), ForeignKey("recipe.id", ondelete="cascade"))
ingredient_id = Column(Integer(), ForeignKey("ingredient.id", ondelete="cascade"))
date = Column(Date(), nullable=False)
quantity = Column(Float(), nullable=False)
UniqueConstraint("recipe_id", "ingredient_id", "date")
recipe = relationship("Recipe")
ingredient = relationship("Ingredient")
