class Base(DB):
ID = Column('ID',
Integer,
primary_key=True,
autoincrement=True,
nullable=False)
CreateTime = Column('CreateTime',
DATETIME(fsp=6),
index=True,
nullable=False,
default=datetime.now())
ModifyTime = Column('ModifyTime',
DATETIME(fsp=6),
index=True,
nullable=False,
default=datetime.now(),
onupdate=datetime.now())
Description = Column('Description', String(2000), nullable=True)
def __init__(self,
current_id=None,
create_time=None,
modify_time=None,
description=None):
super().__init__()
self.ID = current_id
self.CreateTime = create_time
self.ModifyTime = modify_time
self.Description = description
class Classifications(db.Model):
id = db.Column(db.String(37),
primary_key=True,
default=create_guid,
unique=True,
nullable=False)
name = db.Column(db.String(100), nullable=False)
description = db.Column(db.String(2000))
image_path = db.Column(db.String(10000))
location = db.Column(db.String(1000))
healthy = db.Column(db.Boolean)
disease = db.Column(db.String(50))
tokenPush = db.Column(db.String(100))
is_processed = db.Column(db.Boolean, nullable=False, default=False)
is_sended = db.Column(db.Boolean, nullable=False, default=False)
created_at = db.Column(DATETIME(fsp=6), default=datetime.datetime.now())
updated_at = db.Column(DATETIME(fsp=6), default=datetime.datetime.now())
user_id = db.Column(db.String(37), db.ForeignKey('users.id'))
area_id = db.Column(db.String(37), db.ForeignKey('areas.id'))
user = db.relationship("Users", back_populates="classifications")
area = db.relationship("Areas", back_populates="classifications")
def __init__(self, name, description, image_path, location, tokenPush):
self.name = name
self.description = description
self.image_path = image_path
self.location = location
self.tokenPush = tokenPush
class Future(Base):
__tablename__ = 'future'
symbol = Column(String(20), primary_key=True)
pair = Column(String(10))
contract_type = Column(String(15))
delivery_timestamp = Column(BigInteger)
delivery_date = Column(DATETIME)
onboard_timestamp = Column(BigInteger)
onboard_date = Column(DATETIME)
contract_status = Column(String(20))
contract_size = Column(Integer)
base_asset = Column(String(10))
quote_asset = Column(String(10))
operations = relationship("Operation", back_populates="future_relation")
future_price = relationship("FuturePrice", uselist=False, back_populates="future")
balance = relationship("FutureBalance", uselist=False, back_populates="future")
inserted = Column(DATETIME(fsp=6), default=datetime.utcnow)
updated = Column(DATETIME(fsp=6), default=datetime.utcnow, onupdate=datetime.utcnow)
__table_args__ = (
Index('base_asset', base_asset),
)
class Ban(Base):
__tablename__ = 'banned_users'
user_id = Column(BigInteger, ForeignKey(User.id), primary_key=True)
reason = Column(UnicodeText(2500))
from_date = Column(DATETIME(fsp=6))
to_date = Column(DATETIME(fsp=6))
class Courses(Base):
__tablename__ = 'jkxc_courses'
courses_id = Column(BIGINT(11), primary_key=True, index=True)
courses_traineruid = Column(BIGINT(11))
courses_starttime = Column(DATETIME(25))
courses_endtime = Column(DATETIME(25))
courses_hour = Column(FLOAT(5))
courses_type = Column(BIGINT(9))
courses_state = Column(BIGINT(9))
courses_current_number = Column(BIGINT(9), index=True)
courses_limit_number = Column(BIGINT(9), index=True)
courses_epuid = Column(BIGINT(11))
courses_createtime = Column(DATETIME(25))
def __init__(self,
courses_traineruid=0,
courses_starttime=None,
courses_endtime=None,
courses_hour=0,
courses_type=0,
courses_state=0,
courses_current_number=0,
courses_limit_number=0,
courses_epuid=0,
courses_createtime=None):
self.courses_traineruid = courses_traineruid
self.courses_starttime = courses_starttime
self.courses_endtime = courses_endtime
self.courses_hour = courses_hour
self.courses_type = courses_type
self.courses_state = courses_state
self.courses_current_number = courses_current_number
self.courses_limit_number = courses_limit_number
self.courses_epuid = courses_epuid
self.courses_createtime = courses_createtime
class Position(Base):
__tablename__ = 'position'
id = Column(Integer, primary_key=True)
future = Column(String(20), ForeignKey('future.symbol'))
future_price = Column(Float)
spot = Column(String(20), ForeignKey('spot.symbol'))
spot_price = Column(Float)
direct_ratio = Column(Float)
hours = Column(Integer)
hour_ratio = Column(Float)
days = Column(Integer)
year_ratio = Column(Float)
contract_size = Column(Integer)
contract_qty = Column(Integer)
buy_per_contract = Column(Float)
tick_size = Column(Float)
base_asset = Column(String(20))
state = Column(String(20))
message = Column(String(200))
operations = relationship("Operation", back_populates="position")
inserted = Column(DATETIME(fsp=6), default=datetime.utcnow)
updated = Column(DATETIME(fsp=6), default=datetime.utcnow, onupdate=datetime.utcnow)
class Spot(Base):
__tablename__ = 'spot'
symbol = Column(String(20), primary_key=True)
base_asset = Column(String(20))
quote_asset = Column(String(20))
min_price = Column(Float)
max_price = Column(Float)
tick_size = Column(Float)
operations = relationship("Operation", back_populates="spot_relation")
spot_price = relationship("SpotPrice", uselist=False, back_populates="spot")
spot_orders = relationship("SpotOrder", back_populates="spot")
balance = relationship("SpotBalance", uselist=False, back_populates="spot")
inserted = Column(DATETIME(fsp=6), default=datetime.utcnow)
updated = Column(DATETIME(fsp=6), default=datetime.utcnow, onupdate=datetime.utcnow)
__table_args__ = (
Index('base_asset', base_asset),
)
class Account(Base):
__tablename__ = "accounts"
id = Column(BIGINT, primary_key=True, autoincrement=True)
created_at = Column(DATETIME(fsp=6), nullable=False, index=True)
deleted_at = Column(DATETIME(fsp=6),
nullable=True,
server_default=text("NULL"))
class Testcaseresult(Base):
__tablename__ = 'testcaseresult'
id = Column(Integer, primary_key=True)
create_worker = Column(String(30))
create_time = Column(DATETIME(fsp=6))
ending_worker = Column(String(30))
ending_time = Column(DATETIME(fsp=6))
logs = Column(LONGTEXT)
result = Column(String(30))
case_name = Column(String(255))
case_number = Column(String(100))
marker = Column(String(255))
caselevel = Column(Integer)
imgurl = Column(String(255))
taskname = Column(String(255))
request_time = Column(String(10))
def __str__(self):
return {
'id': self.id,
'create_worker': self.create_worker,
'create_time': self.create_time,
'ending_worker': self.ending_worker,
'ending_time': self.ending_time,
'logs': self.logs,
'result': self.result,
'case_name': self.case_name,
'case_number': self.case_number,
'marker': self.marker,
'caselevel': self.caselevel,
'imgurl': self.imgurl if self.imgurl else None,
'taskname': self.taskname,
'request_time': self.request_time
}
class Stage(Base):
__tablename__ = "tb_stage"
__table_args__ = {'extend_existing': True}
id = Column('id', INTEGER(11), primary_key=True)
import_table_id = Column('import_table_id', INTEGER(11), ForeignKey("tb_import_tables.id"))
import_type = Column('import_type', TINYINT(1))
stage_id = Column('stage_id', INTEGER(11))
inserted_num = Column('inserted_num', INTEGER(11))
updated_num = Column('updated_num', INTEGER(11))
deleted_num = Column('deleted_num', INTEGER(11))
record_num = Column('record_num', INTEGER(11))
status = Column('status', TINYINT(1))
fail_info = Column("fail_info" , TEXT)
create_time = Column('create_time', DATETIME())
update_time = Column('update_time', DATETIME())
begin_time = Column('begin_time', DATETIME())
end_time = Column('end_time', DATETIME())
process_status = Column('process_status', TINYINT(1))
parent = relationship("ImportTable", back_populates="children")
@hybrid_property
def triggle_cond(self):
return TriggleCond(self.import_table_id, self.import_type)
class SpotTrade(Base):
__tablename__ = 'spot_trade'
# {'symbol': 'DOTUSDT', 'id': 59934629, 'orderId': 779488260, 'orderListId': -1, 'price': '36.67460000',
# 'qty': '1.36000000', 'quoteQty': '49.87745600', 'commission': '0.00136000', 'commissionAsset': 'DOT',
# 'time': 1617197352774, 'isBuyer': True, 'isMaker': False, 'isBestMatch': True}
id = Column(Integer, primary_key=True)
spot_order_id = Column(Integer, ForeignKey('spot_order.id'))
symbol = Column(String(20), ForeignKey('spot.symbol'))
binance_id = Column(BigInteger, unique=True)
order_id = Column(BigInteger)
order_list_id = Column(BigInteger)
price = Column(Float)
qty = Column(Float)
quote_qty = Column(Float)
commission = Column(Float)
commission_asset = Column(String(10))
timestamp = Column(BigInteger)
time = Column(DATETIME)
is_buyer = Column(Boolean)
is_maker = Column(Boolean)
is_best_match = Column(Boolean)
state = Column(String(20))
message = Column(String(200))
inserted = Column(DATETIME(fsp=6), default=datetime.utcnow)
updated = Column(DATETIME(fsp=6), default=datetime.utcnow, onupdate=datetime.utcnow)
class Configuration(Base):
__tablename__ = 'configuration'
name = Column(String(20), primary_key=True)
value = Column(Float)
inserted = Column(DATETIME(fsp=6), default=datetime.utcnow)
updated = Column(DATETIME(fsp=6), default=datetime.utcnow, onupdate=datetime.utcnow)
class Experiment(db.Model, AbstractModel):
__tablename__ = 'experiments'
id = db.Column(db.Integer, primary_key=True)
dev_id = db.Column(db.String(100),
db.ForeignKey('devices.id'),
nullable=False)
start = db.Column(DATETIME(fsp=6), nullable=False)
end = db.Column(DATETIME(fsp=6), nullable=True, default=None)
description = db.Column(db.String(100), nullable=True, default=None)
class SqlRegisteredModel(Base):
__tablename__ = "registered_model"
name = Column(String(256), unique=True)
"""
Name of registered model: Part of *Primary Key* for ``registered_model`` table.
"""
creation_time = Column(DATETIME(fsp=3), default=datetime.now())
"""
Creation time of registered model: default current time in milliseconds.
"""
last_updated_time = Column(DATETIME(fsp=3), nullable=True)
"""
Last updated time of registered model.
"""
description = Column(String(5000), nullable=True, default=None)
"""
Description for registered model.
"""
tags: Mapped[List["SqlRegisteredModelTag"]] = relationship(
"SqlRegisteredModelTag", back_populates="registered_model", cascade="all"
)
"""
Registered model Tags reference to SqlRegisteredModelTag.
"""
model_versions: Mapped[List["SqlModelVersion"]] = relationship(
"SqlModelVersion", back_populates="registered_model", cascade="all"
)
"""
ModelVersions reference to SqlRegisteredModel
"""
__table_args__ = (PrimaryKeyConstraint("name", name="model_pk"),)
def __repr__(self):
return (
f"<SqlRegisteredModel ({self.name}, {self.creation_time}, {self.last_updated_time},"
f" {self.description})>"
)
def to_submarine_entity(self):
"""
Convert DB model to corresponding Submarine entity.
:return: :py:class:`submarine.entities.RegisteredModel`.
"""
return RegisteredModel(
name=self.name,
creation_time=self.creation_time,
last_updated_time=self.last_updated_time,
description=self.description,
tags=[tag.to_submarine_entity() for tag in self.tags],
)
class Source(Base):
__tablename__ = 'source'
id = Column(
INTEGER(unsigned=True),
primary_key=True, autoincrement=True, nullable=False
)
id_scp = Column(BIGINT(unsigned=True), nullable=False, unique=True)
title = Column(VARCHAR(512), nullable=False)
url = Column(VARCHAR(256), nullable=False, unique=True)
type = Column(VARCHAR(45), nullable=True)
issn = Column(VARCHAR(8), nullable=True)
e_issn = Column(VARCHAR(8), nullable=True)
isbn = Column(VARCHAR(13), nullable=True)
publisher = Column(VARCHAR(256), nullable=True)
country_id = Column(
INTEGER(unsigned=True), ForeignKey('country.id'), nullable=True)
create_time = Column(
DATETIME(), nullable=False,
server_default=text('CURRENT_TIMESTAMP')
)
update_time = Column(
DATETIME(), nullable=False,
server_default=text('CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP')
)
# Relationships
country = relationship('Country', back_populates='sources')
papers = relationship('Paper', back_populates='source')
subjects = relationship(
'Subject', secondary=Source_Subject, back_populates='sources')
metrics = relationship('Source_Metric', back_populates='source')
def __init__(
self, id_scp, title, type=None, issn=None, e_issn=None, isbn=None,
publisher=None, country_id=None, create_time=None, update_time=None
):
self.id_scp = id_scp
self.title = title
self.url = f'https://www.scopus.com/sourceid/{id_scp}'
self.type = type
self.issn = issn
self.e_issn = e_issn
self.isbn = isbn
self.publisher = publisher
self.country_id = country_id
self.create_time = create_time
self.update_time = update_time
def __repr__(self):
max_len = 50
if len(self.title) <= max_len:
return f'{self.id_scp}: {self.title}; Type: {self.type}'
return f'{self.id_scp}: {self.title[:max_len-3]}...; Type: {self.type}'
class SqlExperiment(Base):
__tablename__ = "experiment"
id = Column(String(64))
"""
ID to which this metric belongs to: Part of *Primary Key* for ``experiment`` table.
"""
experiment_spec = Column(Text)
"""
The spec to create this experiment
"""
create_by = Column(String(32))
"""
This experiment is created by whom.
"""
create_time = Column(DATETIME(fsp=3), default=datetime.now())
"""
Datetime of this experiment be created
"""
update_by = Column(String(32))
"""
This experiment is created by whom.
"""
update_time = Column(DATETIME(fsp=3))
"""
Datetime of this experiment be updated
"""
__table_args__ = (PrimaryKeyConstraint("id"),)
def __repr__(self):
return "<SqlMetric({}, {}, {}, {}, {}, {})>".format(
self.id,
self.experiment_spec,
self.create_by,
self.create_time,
self.update_by,
self.update_time,
)
def to_submarine_entity(self):
"""
Convert DB model to corresponding Submarine entity.
:return: :py:class:`submarine.entities.Experiment`.
"""
return Experiment(
id=self.id,
experiment_spec=self.experiment_spec,
create_by=self.create_by,
create_time=self.create_time,
update_by=self.update_by,
update_time=self.update_time,
)
class Profiles(db.Model):
id = db.Column(db.String(37), primary_key=True, default=create_guid, unique=True, nullable=False)
name = db.Column(db.String(20), unique=True, nullable=False)
description = db.Column(db.String(100), nullable=False)
created_at = db.Column(DATETIME(fsp=6), default=datetime.datetime.now())
updated_at = db.Column(DATETIME(fsp=6), default=datetime.datetime.now())
users = db.relationship("Users", back_populates='profile')
def __init__(self, name, description):
self.name = name
self.description = description
class SpotBalance(Base):
__tablename__ = 'spot_balance'
asset = Column(String(20), ForeignKey('spot.base_asset'), primary_key=True)
free = Column(Float)
locked = Column(Float)
outdated = Column(Boolean, default=False)
spot = relationship("Spot", back_populates="balance")
inserted = Column(DATETIME(fsp=6), default=datetime.utcnow)
updated = Column(DATETIME(fsp=6), default=datetime.utcnow, onupdate=datetime.utcnow)
class Base(db.Model):
__abstract__ = True
id = db.Column(db.Integer, primary_key=True)
date_created = db.Column(DATETIME(fsp=6), default=db.func.now(6))
date_modified = db.Column(DATETIME(fsp=6), default=db.func.now(6), onupdate=db.func.now(6))
def as_dict(self):
return {
'id': self.id,
'date_created': self.date_created.timestamp(),
'date_modified': self.date_modified.timestamp()
}
class AuthUser(Base):
__tablename__ = 'auth_user'
id = Column(INTEGER(11), primary_key=True)
password = Column(String(128, 'utf8_bin'), nullable=False)
last_login = Column(DATETIME(fsp=6))
is_superuser = Column(TINYINT(1), nullable=False)
username = Column(String(150, 'utf8_bin'), nullable=False, unique=True)
first_name = Column(String(30, 'utf8_bin'), nullable=False)
last_name = Column(String(150, 'utf8_bin'), nullable=False)
email = Column(String(254, 'utf8_bin'), nullable=False)
is_staff = Column(TINYINT(1), nullable=False)
is_active = Column(TINYINT(1), nullable=False)
date_joined = Column(DATETIME(fsp=6), nullable=False)
class FutureBalance(Base):
__tablename__ = 'future_balance'
asset = Column(String(20), ForeignKey('future.base_asset'), primary_key=True)
wallet_balance = Column(Float)
cross_wallet_balance = Column(Float)
balance_change = Column(Float)
future = relationship("Future", back_populates="balance")
outdated = Column(Boolean, default=False)
inserted = Column(DATETIME(fsp=6), default=datetime.utcnow)
updated = Column(DATETIME(fsp=6), default=datetime.utcnow, onupdate=datetime.utcnow)
class Answer(Base):
__tablename__ = 'zhihu_answers'
q_id = Column(INTEGER(), ForeignKey('zhihu_questions.id'))
question = relationship('Question', backref='answer')
answer_id = Column(INTEGER(), primary_key=True)
author_id = Column(VARCHAR(100))
author_name = Column(NVARCHAR(20))
author_is_advertiser = Column(BOOLEAN())
created_time = Column(DATETIME())
updated_time = Column(DATETIME())
voteup_num = Column(INTEGER())
comment_num = Column(INTEGER())
content = Column(MEDIUMTEXT())
class SpotPriceCalc(Base):
__tablename__ = 'spot_price_calc'
symbol = Column(String(20), ForeignKey('spot.symbol'), primary_key=True)
# price = Column(Float)
ask_risk = Column(Float)
ask_safe = Column(Float)
bid_risk = Column(Float)
bid_safe = Column(Float)
# spot = relationship("Spot", back_populates="spot_price")
inserted = Column(DATETIME(fsp=6), default=datetime.utcnow)
updated = Column(DATETIME(fsp=6), default=datetime.utcnow, onupdate=datetime.utcnow)
class FuturePosition(Base):
__tablename__ = 'future_position'
symbol = Column(String(20), primary_key=True)
position_amount = Column(Integer)
entry_price = Column(Float)
accumulated_realized = Column(Float)
unrealized_pnl = Column(Float)
margin_type = Column(String(10))
isolated_wallet = Column(Float)
position_side = Column(String(10))
margin_asset = Column(String(15))
inserted = Column(DATETIME(fsp=6), default=datetime.utcnow)
updated = Column(DATETIME(fsp=6), default=datetime.utcnow, onupdate=datetime.utcnow)
class Identity(ModelBase):
__tablename__ = 'identities'
id = Column(String(128), primary_key=True)
name = Column(String(128))
email = Column(String(128))
username = Column(String(128))
source = Column(String(32), nullable=False)
uuid = Column(String(128),
ForeignKey('uidentities.uuid', ondelete='CASCADE'))
last_modified = Column(DATETIME(fsp=6),
default=datetime.datetime.utcnow(),
onupdate=datetime.datetime.utcnow())
# Many-to-One relationship
uidentity = relationship('UniqueIdentity',
backref='uuid_identy',
lazy='joined')
__table_args__ = (UniqueConstraint('name',
'email',
'username',
'source',
name='_identity_unique'), MYSQL_CHARSET)
def to_dict(self):
return {
'id': self.id,
'name': self.name,
'email': self.email,
'username': self.username,
'source': self.source,
'uuid': self.uuid
}
class UTCDateTime(types.TypeDecorator):
"""
Datetime 转换解析类
"""
impl = DATETIME(fsp=6)
def process_bind_param(self, value, dialect):
# print(value)
if value is not None:
return value.astimezone(timezone.utc)
return None
def process_result_value(self, value, dialect):
if value is not None:
return datetime(value.year,
value.month,
value.day,
value.hour,
value.minute,
value.second,
value.microsecond,
tzinfo=timezone.utc)
return None
class Alarm(Base):
__tablename__ = 'alarm'
id = Column(Integer, primary_key=True, nullable=False)
uuid = Column(String(255), unique=True, index=True)
alarm_id = Column('alarm_id',
String(255),
ForeignKey('event_suppression.alarm_id'),
nullable=True,
index=True)
alarm_state = Column(String(255))
entity_type_id = Column(String(255), index=True)
entity_instance_id = Column(String(255), index=True)
if get_dialect_name() == 'mysql':
timestamp = Column(DATETIME(fsp=6))
else:
timestamp = Column(DateTime(timezone=False))
severity = Column(String(255), index=True)
reason_text = Column(String(255))
alarm_type = Column(String(255), index=True)
probable_cause = Column(String(255))
proposed_repair_action = Column(String(255))
service_affecting = Column(Boolean, default=False)
suppression = Column(Boolean, default=False)
inhibit_alarms = Column(Boolean, default=False)
masked = Column(Boolean, default=False)
class TestJob(Base):
__tablename__ = 'test_jobs'
id = Column(Integer, primary_key=True)
user_id = Column(Integer, ForeignKey('users.id'))
test_name = Column(String(64))
timestamp = Column(String(64))
time = Column(DATETIME(fsp=6))
test_lab = Column(String(64))
variables = Column(Text)
options = Column(Text)
arguments = Column(Text)
selection_md5 = Column(String(128))
selections = Column(MEDIUMTEXT)
selection_group = Column(MEDIUMTEXT)
schedule = Column(String(64))
status = Column(String(64))
parent_id = Column(Integer)
test_pid = Column(String(32))
output_dir = Column(String(128))
test_command = Column(Text)
total_count = Column(Integer)
pass_count = Column(Integer)
fail_count = Column(Integer)
running_node = Column(String(1024))
passed_node = Column(JSON)
failed_node = Column(JSON)
class DjangoMigration(Base):
__tablename__ = 'django_migrations'
id = Column(INTEGER(11), primary_key=True)
app = Column(String(255), nullable=False)
name = Column(String(255), nullable=False)
applied = Column(DATETIME(fsp=6), nullable=False)
class DatabaseVersions(db.Model):
id = db.Column(db.String(37),
primary_key=True,
default=create_guid,
unique=True,
nullable=False)
name = db.Column(db.String(20), nullable=False)
version = db.Column(db.String(20), nullable=False, default='1.0.0')
description = db.Column(db.String(500))
created_at = db.Column(DATETIME(fsp=6), default=datetime.datetime.now())
updated_at = db.Column(DATETIME(fsp=6), default=datetime.datetime.now())
def __init__(self, name, version, description):
self.name = name
self.version = version
self.description = description
