class KubernetesClusterMigrationTask(db.Model):
ID_KEY = "id"
STARTED_AT = "started_at"
COMPLETED_AT = "completed_at"
MESSAGE_KEY = "message"
SOURCE_CLUSTER = "source_cluster"
TARGET_CLUSTER = "target_cluster"
COS = "cos"
__tablename__ = 'kubernetes_cluster_migration_tasks'
id = Column(String(100), primary_key=True)
base_task_id = Column(String(32), nullable=False)
source_cluster = Column(JSON())
target_cluster = Column(JSON())
cos = Column(JSON())
started_at = Column(DateTime)
message = Column(String(1024))
completed_at = Column(DateTime)
def __init__(self,
base_task_id,
cos=None,
source_cluster=None,
target_cluster=None):
self.id = str(uuid.uuid4().hex)
self.base_task_id = base_task_id
self.target_cluster = target_cluster
self.source_cluster = source_cluster
self.cos = cos
self.started_at = datetime.utcnow()
class ModelKisiler(TanimlarBase, _Base):
__tablename__ = 't_kisiler'
profiller_data = Column(JSON())
birimler_data = Column(JSON())
kimlikno = Column(String(11))
tel = Column(String(100))
eposta = Column(String(100))
def __GetMovieInfoTable(meta):
"""
获取电影信息表，如果数据库中存在，使用autoload的方式加载
:return: 电影信息表
"""
try:
return Table("MovieInfo", meta, autoload=True)
except sqlalchemy.exc.NoSuchTableError:
MovieInfoTableTmp = Table(
"MovieInfo", meta,
Column("id", String(64), primary_key=True, comment="电影ID，唯一标识"),
Column("name", String(256), nullable=False, comment="电影名称"),
Column("url", String(256), nullable=False, comment="电影在豆瓣的链接"),
Column("image", String(512), comment="电影海报"),
Column("director", JSON(), comment="导演列表，人物ID"),
Column("author", JSON(), comment="编剧列表，人物ID"),
Column("actor", JSON(), comment="演员列表， 人物ID"),
Column("country", String(512), comment="制片国家"),
Column("datePublished", String(10), comment="发布日期"),
Column("duration", String(10), comment="电影时长"),
Column("genre", JSON(), comment="电影类型"),
Column("description", String(1024), comment="电影描述"),
Column("rateDetails", JSON(), comment="电影评分详情"),
Column("rateNumber", Integer(), comment="电影评分数量"),
Column("imdb", String(256), comment="imdb链接"))
MovieInfoTableTmp.create()
return MovieInfoTableTmp
class PDV(Model):
__tablename__ = 'partner'
id = Column(Integer, primary_key=True, autoincrement=True)
tradingName = Column(String(244), nullable=False, index=True, unique=True)
ownerName = Column(String(244))
document = Column(String(244))
coverageArea = Column(JSON())
address = Column(JSON())
def upgrade():
op.create_table('regions',
Column('id', Integer(), primary_key=True, nullable=False),
Column('name', String(length=50)))
op.create_table(
'cities', Column('id', Integer(), primary_key=True, nullable=False),
Column('name', String(length=50), default=ColumnDefault('')),
Column('region_id', Integer(), ForeignKey('regions.id')),
Column('image', String(length=300)))
op.create_table('users',
Column('id', Integer(), primary_key=True, nullable=False),
Column('email', String(length=50)))
op.create_table('venues',
Column('id', Integer(), primary_key=True, nullable=False),
Column('name', String(length=100)))
op.create_table('spaces',
Column('id', Integer(), primary_key=True, nullable=False),
Column('venue_id', Integer(), ForeignKey('venues.id')),
Column('owner_id', Integer(), ForeignKey('users.id')),
Column('name', String(length=100)))
op.create_table('space_images',
Column('id', Integer(), primary_key=True, nullable=False),
Column('space_id', Integer(), ForeignKey('spaces.id')),
Column('file', String(length=300)),
Column('order', SmallInteger(), default=ColumnDefault(0)))
op.create_table('features',
Column('id', Integer(), primary_key=True, nullable=False),
Column('name', String(length=40)),
Column('description', Text()))
op.create_table('space_features',
Column('id', Integer(), primary_key=True, nullable=False),
Column('space_id', Integer(), ForeignKey('spaces.id')),
Column('feature_id', Integer(), ForeignKey('features.id')),
Column('price', Numeric(), default=ColumnDefault(0)))
op.create_table(
'orders', Column('id', Integer(), primary_key=True, nullable=False),
Column('space_id', Integer(), ForeignKey('spaces.id')),
Column('user_id', Integer(), ForeignKey('users.id')),
Column('date_created',
DateTime(),
default=ColumnDefault(datetime.datetime.utcnow)),
Column('status', String(length=8), default=ColumnDefault('NEW')),
Column('activity_type', JSON()), Column('configuration', JSON()),
Column('booking_date_start', JSON()), Column('booking_date_end',
JSON()))
op.create_table(
'order_items', Column('id',
Integer(),
primary_key=True,
nullable=False),
Column('order_id', Integer(), ForeignKey('orders.id')),
Column('feature_id', Integer(), ForeignKey('space_features.id')),
Column('price', Numeric(), default=ColumnDefault(0)),
Column('date_created',
DateTime(),
default=ColumnDefault(datetime.datetime.utcnow)),
Column('status', String(length=8), default=ColumnDefault('PAID')),
Column('name', String(length=100), default=ColumnDefault('')))
class KVPaylasimModel(KVBaseModel, _Base):
__tablename__ = 'kv_paylasim'
#paylasim
birim_pidm = Column(Integer())
kv_pidm = Column(Integer())
kurum_pidm = Column(Integer())
islemeamaclari_data = Column(JSON())
paylasimamaclari_data = Column(JSON())
paylasimsekilleri_data = Column(JSON())
class AttributeSave(Base):
__tablename__ = "attribute_save"
id = Column(Integer(), primary_key=True, autoincrement=True)
attr = Column(Attribute())
value = Column(JSON()) # primary저장할 때 int랑 str이랑 구분하려고
before_submit_attr = Column(JSON())
before_submit_value = Column(JSON())
diff_type = Column(Integer())
class LogCityTemp(Model):
__tablename__ = 'log_city_temp'
id = Column(Integer, nullable=False, unique=True, primary_key=True, autoincrement=True)
city = Column(String(244))
uf = Column(String(244))
temp = Column(String(244))
music_gender = Column(String(244))
provider = Column(String(244))
status = Column(String(244))
created = Column(DateTime(timezone=True), server_default=func.now(tz=pytz.timezone('America/Sao_Paulo')))
weather_response = Column(JSON())
provider_response = Column(JSON())
class HttpAccessLog(Base):
__tablename__ = 'http_access_log'
log_id: int = Column(Integer(), primary_key=True, autoincrement=True)
path: str = Column(String(255), index=True)
client_ip: str = Column(VARCHAR(42), index=True)
method: str = Column(VARCHAR(255), index=True)
arg: dict = Column(JSON())
body: str = Column(Text())
file: dict = Column(JSON())
header: dict = Column(JSON())
body_type: int = Column(SmallInteger())
log_time: str = Column(DateTime(), default=datetime.datetime.utcnow)
region: str = ''
class AttributeSaveHistory(Base):
__tablename__ = "attribute_save_history"
id = Column(Integer(), primary_key=True, autoincrement=True)
parent_id = Column(Integer(), ForeignKey('attribute_save.id'))
history = relationship('AttributeSave', backref="history")
prev_attr = Column(JSON())
prev_value = Column(JSON())
next_attr = Column(JSON())
next_value = Column(JSON())
diff_type = Column(Integer())
version = Column(Integer())
class Pages(Base):
__tablename__ = 'pages'
url = Column(String(1000), primary_key=True)
domain_id = Column(Integer,
ForeignKey(Domaines.id,
onupdate="CASCADE",
ondelete="CASCADE"),
nullable=False)
language = Column(String(50))
title_vector = Column(JSON(), nullable=False)
content_vector = Column(JSON(), nullable=False)
title = Column(String(100), nullable=False)
update_datetime = Column(DateTime(timezone=True),
default=datetime.now(tz=pytz.utc))
class SearchRecord(Base, db.Model, QueryMixin):
__tablename__ = 'search_record'
id = db.Column(db.Integer, primary_key=True)
openid = db.Column(db.String(80))
unionid = db.Column(db.String(80))
address = db.Column(db.String(80))
locations = db.Column(JSON())
def test_table_valued(
self,
joins_implicitly,
additional_transformation,
):
"""test #7845"""
my_table = table(
"tbl",
column("id", Integer),
column("data", JSON()),
)
sub_dict = my_table.c.data["d"]
tv = func.json_each(sub_dict)
tv = tv.table_valued("key", joins_implicitly=joins_implicitly)
if additional_transformation == "render_derived":
tv = tv.render_derived(name="tv", with_types=True)
elif additional_transformation == "alias":
tv = tv.alias()
has_key = tv.c.key == "f"
stmt = select(my_table.c.id).where(has_key)
froms, start = find_unmatching_froms(stmt, my_table)
if joins_implicitly:
is_(start, None)
is_(froms, None)
else:
assert start == my_table
assert froms == {tv}
class Event(Base):
"""A single event"""
__tablename__ = "events"
id = Column(Integer, primary_key=True, nullable=False)
event_type = Column(String(50), nullable=False)
event_ts = Column(TIMESTAMP(True), nullable=False)
event_id = Column(String(36), nullable=False)
aggregate_id = Column(String(36), nullable=False)
kafka_ts = Column(TIMESTAMP(timezone=True), nullable=False)
json_data = Column(JSON(none_as_null=False), nullable=True)
def __init__(self,
event_type: str,
event_ts: dt.datetime,
event_id: str,
aggregate_id: str,
kafka_ts: dt.datetime,
json_data: Optional[Dict] = None):
self.event_type = event_type
self.event_ts = event_ts
self.event_id = event_id
self.aggregate_id = aggregate_id
self.kafka_ts = kafka_ts
self.json_data = json_data
def __repr__(self) -> str:
return f'<Event {self.event_type}, {self.event_id}>'
class Address(Base):
"""
Store raw addresses as entered, and google geocoding api responses
"""
raw = Column(String(), index=True, unique=True)
formatted = Column(String(), index=True)
formatted_tsv = Column(TSVECTOR)
geocoding_api_response = Column(JSON())
directory_id = Column(Integer(), index=True)
point = Column(Geometry)
zip_code = Column(Integer(), index=True)
providers = relationship("Provider",
secondary=provider_address_table,
back_populates="addresses")
phone_numbers = relationship("Phone",
secondary=phone_address_table,
back_populates="addresses")
class ObjectLoadCache(Base):
__tablename__ = 'object_cache'
uid = Column(Integer(), primary_key=True)
name = Column(String(length=64))
resource = Column(JSON())
last_load = Column(DateTime())
class AxAction(Base):
"""Stores actions for each workflow"""
__tablename__ = '_ax_actions'
guid = Column(GUID(),
primary_key=True,
default=uuid.uuid4,
unique=True,
nullable=False)
name = Column(String(255))
db_name = Column(String(255))
form_guid = Column(GUID(), ForeignKey('_ax_forms.guid'))
form = relationship("AxForm")
roles = relationship("AxRole", secondary='_ax_action2role')
from_state_guid = Column(GUID(), ForeignKey('_ax_states.guid'))
to_state_guid = Column(GUID(), ForeignKey('_ax_states.guid'))
from_state = relationship('AxState', foreign_keys=[from_state_guid])
to_state = relationship('AxState', foreign_keys=[to_state_guid])
# Python code that is executed on this action. Sea action_schema.py
code = Column(Text(convert_unicode=True))
# If not None, the user will be see prompt before action is executed
confirm_text = Column(String(255))
# If True, the form will be closed after this action
close_modal = Column(Boolean, unique=False, default=True)
icon = Column(String(255)) # font-awesome key
radius = Column(Float) # used in d3 worklfow constructor
messages = None # Used to store messages and exceptions got from code
# Execution
private_options_json = Column(JSON())
job_running = False
class DbNotification(DbBase, EntityBase):
__tablename__ = 'notification'
id = Column(String(), primary_key=True)
file_id = Column(String(), ForeignKey('file.id'), nullable=False)
status = Column(String(), nullable=False)
payload = Column(JSON(), nullable=False)
created_at = Column(DateTime, default=datetime.utcnow, nullable=False)
updated_at = Column(DateTime,
default=datetime.utcnow,
nullable=False,
onupdate=datetime.utcnow)
file = relationship("DbFile", back_populates='notifications')
def __str__(self, prefix="", verbose=False):
output = colored(f"{prefix}Notification {self.id}\n", 'magenta') + \
f"{prefix} File ID: {self.file_id}\n" \
f"{prefix} Status: {self.status}\n" \
f"{prefix} created_at: {self.created_at}\n" \
f"{prefix} updated_at: {self.updated_at}\n"
if verbose:
output = output + f"{prefix} payload: {self.payload}\n"
return output
def print(self,
prefix="",
verbose=False,
associated_entities_to_show=None):
print(self.__str__(prefix=prefix, verbose=verbose))
class Repo(Base):
"""
env_vars:
schema: [{<key>: <value>}, ...]
"""
__tablename__ = 'repo'
name = Column(String(50), primary_key=True, nullable=False)
scm = Column(String(50), nullable=False)
env_vars = Column(JSON(5000), default=[])
username = Column(String(50), ForeignKey('user.username'))
user = relationship('User', backref=backref('repositories'))
def __repr__(self):
return '%s(name: %s)' % (self.__class__.__name__, self.name)
def shell_ready_envvars(self):
if self.env_vars:
return [
'{}={}'.format(k, v) for var in self.env_vars
for k, v in var.items()
]
return []
def add_envvar(self, var):
if not self.env_vars:
self.env_vars = []
self.env_vars.append(var)
flag_modified(self, 'env_vars')
class Vaccancies(DeclarativeBase):
"""Sqlalchemy deals model"""
__tablename__ = "vaccancy"
id = Column(Integer, primary_key=True)
vaccancy = Column(JSON())
timestamp = Column(DateTime(timezone=True), server_default=func.now())
class TemplateRule(declarative_base(), Unified):
__tablename__ = "t_coder_template_rule"
sort = Column(Integer(), default=0, nullable=False)
template_code = Column(String(), default="", nullable=False)
path = Column(String(), default="", nullable=False)
engine = Column(Integer(), default=0, nullable=False)
data = Column(JSON(), nullable=False)
comment = Column(String(), default="", nullable=False)
def override_by(self, template_rule):
if template_rule.name is not None and template_rule.name.strip() != "":
self.name = template_rule.name
if template_rule.type is not None:
self.type = template_rule.type
if template_rule.sort is not None:
self.sort = template_rule.sort
if template_rule.template_code is not None and template_rule.template_code.strip(
) != "":
self.template_code = template_rule.template_code
if template_rule.engine is not None and template_rule.engine.strip(
) != "":
self.engine = template_rule.engine
if template_rule.data is not None and template_rule.data.strip() != "":
self.data = template_rule.data
if template_rule.comment is not None and template_rule.comment.strip(
) != "":
self.comment = template_rule.comment
class TransactionLog(BaseModel):
__tablename__ = 'transaction_log'
TYPE = {1: 'paypal', 2: 'stripe'}
STATUS = {1: 'success', -1: 'fail'}
transaction_log_uuid = Column(String(36),
primary_key=True,
default=generate_uuid_str(),
server_default=func.uuid_generate_v4())
transaction_time = Column(DateTime(True),
nullable=False,
server_default=func.now())
license_lrn_uuid = Column(String(36))
license_switch_uuid = Column(String(36))
user_uuid = Column(ForeignKey('user.user_uuid', ondelete='CASCADE'),
nullable=True,
index=True)
type = Column(ChoiceType(TYPE), default=1)
amount_total = Column(Numeric, nullable=False, server_default='0')
amount_lrn = Column(Numeric, nullable=False, server_default='0')
amount_switch = Column(Numeric, nullable=False, server_default='0')
transaction_fee = Column(Numeric, nullable=False, server_default='0')
transaction_id = Column(String(255))
transaction_type = Column(String(255))
from_ip = Column(String(36))
transaction_src = Column(JSON())
status = Column(ChoiceType(STATUS), default=-1)
result = Column(Text())
payment_uuid = Column(ForeignKey('payment.payment_uuid',
ondelete='CASCADE'),
index=True)
user_name = column_property(
select([User.name
]).where(user_uuid == User.user_uuid).correlate_except(User))
class Agent(Base):
__tablename__ = 'agents'
id = Column(String(50), primary_key=True)
delegated_id = Column(String(50), unique=True, nullable=False)
did_handshake = Column(Boolean(), nullable=False, default=False)
history = Column(JSON(), nullable=False, default=dict())
last_time_accessed = Column(DateTime(), nullable=False)
time_created = Column(DateTime(), nullable=False)
def __init__(self, peer_id=None, last_time_accessed=None, json=None):
self.id = uuid.uuid5(uuid.NAMESPACE_URL,
time.time().__str__()[:10]).__str__()
self.time_created = datetime.datetime.now()
self.last_time_accessed = datetime.datetime.now(
) if last_time_accessed is None else last_time_accessed
self.delegated_id = peer_id
if self.delegated_id:
self.did_handshake = True
self.history = dict() if json is None else json
def __repr__(self):
return '<Agent %r>' % self.id
def to_json(self):
return {
'id': self.id,
'peerId': self.delegated_id,
'didHandshake': self.did_handshake,
'timeCreated': self.time_created.__str__(),
'lastTimeAccessed': self.last_time_accessed.__str__(),
'history': self.history
}
class SlamOutput(Base):
__tablename__ = 'slam_outputs'
id = Column(Integer, primary_key=True)
is_running = Column(Boolean(), default=False)
metrics = Column(JSON(), default=None)
latency = Column(Float(), default=None)
computation_time = Column(Float(), default=None)
duration = Column(Float(), default=None)
cpu_utilization = Column(Float())
time_offset_to_groundtruth = Column(Float(), default=None)
translation_rmse = Column(Float(), default=None)
translation_aape = Column(Float(), default=None)
translation_drift = Column(Float(), default=None)
translation_rmse_pc = Column(Float(), default=None)
translation_aape_pc = Column(Float(), default=None)
translation_drift_pc = Column(Float(), default=None)
rotation_rmse = Column(Float(), default=None)
rotation_mean = Column(Float(), default=None)
rotation_drift = Column(Float(), default=None)
translation_aape_during_tracking = Column(Float(), default=None)
frac_tracking_state_good = Column(Float(), default=None)
frac_tracking_state_lost = Column(Float(), default=None)
frac_tracking_state_imu3 = Column(Float(), default=None)
frac_tracking_state_imu6 = Column(Float(), default=None)
total_time_lost_pc = Column(Float(), default=None)
total_time_lost = Column(Float(), default=None)
nb_lost = Column(Integer(), default=None)
median_lost_duration = Column(Float(), default=None)
translation_aape_when_good = Column(Float(), default=None)
rotation_mean_when_good = Column(Float(), default=None)
time_before_first_lost = Column(Float(), default=None)
time_pc_before_first_lost = Column(Float(), default=None)
class NotifyModel(MB):
__tablename__ = 'notify'
id = Column(String(), primary_key=True)
ts_updt = Column(String())
ts_recv = Column(String())
ts_send = Column(String())
status = Column(String())
remittee = Column(String())
payload = Column(JSON())
def __repr__(self):
'''
Objective............: Return Object Representation
Return...............: Return Object Representation
'''
return f"<NotifyModel(id='{self.id}', ts_updt='{self.ts_updt}', ts_recv='{self.ts_recv}', ts_send='{self.ts_send}', status='{self.status}', remittee='{self.remittee}', payload='{self.payload}')>"
def to_dict(self):
'''
Objective............: Return Object Dict Representation
Return...............: Return Object Dict Representation
'''
return {
'id': self.id,
'ts_updt': self.ts_updt,
'ts_recv': self.ts_recv,
'ts_send': self.ts_send,
'status': self.status,
'remittee': self.remittee,
'payload': self.payload,
}
class EmailTrigger(Base):
__tablename__ = "email_trigger"
__url__ = "/api/event/<int:event>/email_trigger"
id = Column(Integer, primary_key=True)
event = Column(Integer, ForeignKey('event.id', ondelete="CASCADE"))
trigger = Column(String())
timestamp = Column(DateTime())
context = Column(JSON())
class APIQueryCache(Base):
__tablename__ = 'uri_cache'
pk = Column(Integer(), primary_key=True)
uri = Column(String(length=512))
owner = Column(String(length=16))
response = Column(JSON())
last_load = Column(DateTime())
class Area(db.Model, QueryMixin):
"""
Area 包括：City 城市, City Code (考虑用城市的邮编）, 坐标（ 4个角，经纬度），区域中心点坐标（经纬度），区域代码，区域名称，区域说明，区域价格表（多个区域可以对应 一个价格表）
"""
__tablename__ = 'areas'
id = db.Column(db.Integer, primary_key=True)
city_name = db.Column(db.String(80))
city_code = db.Column(db.String(10))
locations = db.Column(JSON())
# center_axis = db.Column(db.String(80))
area_description = db.Column(db.String(80))
rate_id = db.Column(db.Integer, db.ForeignKey('area_rates.id'))
surrounds = db.Column(JSON())
business = db.Column(db.String(80))
sur_count = db.Column(db.Integer)
address = db.Column(db.String(80))
active = db.Column(db.Integer, default=0)
class DatasetEntity(Base):
__tablename__ = 'cd_dataset'
name = Column(String(128), primary_key=True)
is_temporary = Column(Boolean())
label_col = Column(String(128), nullable=True)
status = Column(String(128))
file_size = Column(Integer())
n_rows = Column(Integer(), nullable=True)
n_cols = Column(Integer(), nullable=True)
has_header = Column(Boolean(), nullable=True)
features = Column(JSON(), nullable=True)
hints = Column(JSON(), nullable=True)
feature_summary = Column(JSON(), nullable=True)
source_type = Column(String(128))
file_path = Column(String(4096))
extension = Column(JSON(), nullable=True) # update result
create_datetime = Column(DateTime())
last_update_datetime = Column(DateTime())
class Status:
Created = 'created' # init
# Uploaded = 'uploaded' # has a file uploaded
Analyzed = 'analyzed'
Failed = 'failed'
class SourceType:
Upload = 'upload'
Import = 'import'
def get_abs_file_path(self):
if self.source_type == DatasetEntity.SourceType.Upload:
return P.join(consts.DATA_DIR, self.file_path)
else:
return self.file_path
def to_dataset_stats(self):
return \
DatasetStats(label_col=self.label_col,
file_path=self.file_path,
has_header=self.has_header,
n_rows=self.n_rows,
n_cols=self.n_cols,
features=Feature.load_dict_list(self.features),
feature_summary=self.feature_summary,
create_datetime=self.create_datetime)
class Blog(Base):
__tablename__ = "weibo"
blog_id = Column(String(256), primary_key=True) # blog id 唯一标识
scheme_url = Column(String(4096)) # blog对应的url
created_time = Column(String(256)) # blog创建时间
crawl_time = Column(DateTime, default=datetime.datetime.now) # blog捕获时间
contents = Column(String(65535)) # blog文字内容
pictures = Column(JSON()) # blog图片内容