class PlayerNotes(Base):
__tablename__ = 'player_notes'
game_id = Column(Integer, ForeignKey('games.game_id'), primary_key=True)
player = Column(String, primary_key=True)
notes = Column(ARRAY(String))
def __init__(self, game_id, player, notes):
self.game_id = game_id
self.player = player
self.notes = notes
class User(Base):
__tablename__ = "users"
id = Column(UUID(as_uuid=True),
primary_key=True,
index=True,
default=uuid.uuid4)
name = Column(String)
email = Column(String, unique=True, index=True)
hashed_password = Column(String)
api_key = Column(String)
is_active = Column(Boolean, default=True)
teams = Column(ARRAY(String, as_tuple=False, dimensions=1))
organizations = Column(ARRAY(String, as_tuple=False, dimensions=1))
def __repr__(self):
return (f'<User(id="{self.id}", '
f'name="{self.name}", '
f'is_active="{self.is_active}", '
f'email="{self.email}")>')
class ModelGroup(Base):
__tablename__ = 'model_groups'
__table_args__ = {"schema": "model_metadata"}
model_group_id = Column(Integer, primary_key=True)
model_type = Column(Text)
model_parameters = Column(JSONB)
feature_list = Column(ARRAY(Text))
model_config = Column(JSONB)
class Operation(db.Model):
__tablename__ = 'operation'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
operation_id = db.Column(db.String(255), nullable=False)
permissions_list = db.Column(ARRAY(db.String(255)))
resource_id = db.Column(db.Integer, db.ForeignKey('resource.id'))
def __init__(self, operation_id, permissions_list):
self.operation_id = operation_id
self.permissions_list = permissions_list
class Record(Base):
__tablename__ = "records"
id = Column(Integer, primary_key=True, autoincrement=True)
patient = Column(String, ForeignKey("patients.name"), nullable=False)
date_from = Column(String, nullable=False)
date_to = Column(String, nullable=False)
stool = Column(String, nullable=False)
vomit = Column(String, nullable=False)
appetite = Column(String, nullable=False)
mucositis = Column(String, nullable=False)
nausea = Column(String, nullable=False)
ration = Column(String, nullable=False)
sipping = Column(ARRAY(String), nullable=False)
EN = Column(ARRAY(String), nullable=False)
components = Column(String, nullable=False)
interval = Column(String, nullable=False)
needs = Column(String, nullable=False)
doctor = Column(String, nullable=False)
class Recommendation(Base):
__tablename__ = 'recommendations'
id = Column(Integer, primary_key=True)
served_at = Column(DateTime(timezone=True), server_default=func.now())
user_id = Column(String)
model = Column(String)
model_num = Column(Integer)
movie_ids = Column(ARRAY(String))
def __repr__(self):
return "<Recommendation(id='{}', served_at='{}', user_id={}, model={}, model_num={}, movie_ids={})>" \
.format(self.id, self.served_at, self.user_id, self.model, self.model_num, self.movie_ids)
class Operation(Base):
__tablename__ = 'operation'
id = Column(Integer, primary_key=True, autoincrement=True)
operation_id = Column(db.String(255), nullable=False)
permissions_list = Column(ARRAY(db.String(255)))
creator = Column(Integer)
resource_id = Column(Integer, ForeignKey('resource.id'))
def __init__(self, operation_id, permissions_list, creator):
self.operation_id = operation_id
self.permissions_list = permissions_list
self.creator = creator
class News(Base):
"""Модель новости"""
__tablename__ = "news"
id = Column(Integer, primary_key=True, index=True, autoincrement=True)
link = Column(String, unique=True, index=True, nullable=False)
title = Column(String, nullable=False)
image = Column(String)
content = Column(ARRAY(Text))
pub_date = Column(DateTime)
class VUserImportsErrors(DB.Model):
__tablename__ = "v_imports_errors"
__table_args__ = {"schema": "gn_imports"}
id_user_error = DB.Column(DB.Integer, primary_key=True)
id_import = DB.Column(DB.Integer, ForeignKey("gn_imports.t_imports.id_import"))
error_type = DB.Column(DB.Unicode)
error_name = DB.Column(DB.Unicode)
error_level = DB.Column(DB.Unicode)
error_description = DB.Column(DB.Unicode)
column_error = DB.Column(DB.Unicode)
id_rows = DB.Column(ARRAY(DB.Integer))
comment = DB.Column(DB.Unicode)
class Binarytree(BaseModel, Base):
"""
Class to define a Binarytree
tree_list: represents the serialization of a binarytree
"""
__tablename__ = 'Binarytrees'
tree_list = Column(ARRAY(Integer(), dimensions=1), default=[])
def __init__(self, *args, **kwargs):
"""initializes Binarytree Class"""
super().__init__(*args, **kwargs)
class GroupNames(Base):
__tablename__ = 'group_names'
id = Column(
Integer,
primary_key=True,
unique=True,
autoincrement=True,
nullable=False,
)
name = Column(String(50), nullable=False)
synonyms = Column(ARRAY(String(50)))
class Property(Base):
__tablename__ = 'properties'
id = Column(String, primary_key=True)
geocode_geo = Column(Geography)
parcel_geo = Column(Geography)
building_geo = Column(Geography)
image_bounds = Column(ARRAY(Float))
image_url = Column(String)
geocode_geojson = column_property(ST_AsGeoJSON(geocode_geo))
def __repr__(self):
return "<Property(id='{}', image_url='{}')>"\
.format(self.id, self.image_url)
class Location(Base): __tablename__ = "locations" id = Column(Integer, primary_key=True, autoincrement=True) uuid = Column(UUID(as_uuid=True), default=uuid4) name = Column(String) category = Column(ARRAY(String)) # categories: ['business', 'test_centre'] creator_id = Column(UUID) coordinates = Column(ARRAY(Float)) address = Column(String) description = Column(String) contact = Column(String) update_ids = Column(ARRAY(UUID)) date_created = Column(DateTime) date_modified = Column(DateTime) def create_location(self, name, address=None, description=None, creator_id=None): self.name = name self.address = address self.description = description self.contact = contact self.date_created = datetime.datetime.now() self.date_modified = datetime.datetime.now()
class Monitor(base):
"""ORM for the ``monitor`` table"""
# Name the table
__tablename__ = 'monitor'
id = Column(Integer, primary_key=True)
monitor_name = Column(String(), nullable=False)
start_time = Column(DateTime, nullable=False)
end_time = Column(DateTime, nullable=True)
status = Column(Enum('SUCCESS', 'FAILURE', name='monitor_status'),
nullable=True)
affected_tables = Column(ARRAY(String, dimensions=1), nullable=True)
log_file = Column(String(), nullable=False)
class Artist(db.Model):
__tablename__ = 'Artist'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String, nullable=False)
city = db.Column(db.String(120))
state = db.Column(db.String(120))
phone = db.Column(db.String(120))
image_link = db.Column(db.String(350))
genres = db.Column(ARRAY(db.String(120)))
facebook_link = db.Column(db.String(200))
website = db.Column(db.String(200))
seeking_venue = db.Column(db.Boolean, default=False)
seeking_description = db.Column(db.String(120), default='no details provided')
shows = db.relationship('Shows', backref='artist', lazy=True)
class Intent(db.Model):
__tablename__ = 'intents'
id = db.Column(db.Integer, primary_key=True)
bot_guid = db.Column(db.String(),
ForeignKey("bots.bot_guid", ondelete="CASCADE"))
name = db.Column(db.String())
utterances = db.Column(ARRAY(db.String()))
patterns = db.Column(ARRAY(db.String()))
has_entities = db.Column(Boolean, unique=False, default=False)
responses = db.Column(ARRAY(db.String()))
calls = db.Column(db.Integer, default=0)
is_folder = db.Column(Boolean, unique=False, default=False)
modified = db.Column(db.DateTime(timezone=False))
created = db.Column(db.DateTime(timezone=False))
def __init__(self,
bot_guid,
name,
has_entities,
is_folder=False,
utterances=[],
responses=[],
patterns=[]):
self.name = name
self.bot_guid = bot_guid
self.utterances = utterances
self.patterns = patterns
self.has_entities = has_entities
self.responses = responses
self.calls = 0
self.is_folder = is_folder
self.modified = datetime.datetime.utcnow()
self.created = datetime.datetime.utcnow()
def __repr__(self):
return '<name {}>'.format(self.name)
def get_type(self, col_type, params=None, unsigned=False):
"""Map the type to valid Column Types.
Notes:
http://docs.sqlalchemy.org/en/latest/core/type_basics.html
Args:
col_type (str): Type of column
params (dict, optional): Defaults to None. Additional Column Options.
unsigned (bool, optional): Defaults to False. If it is an unsigned integer or not.
Returns:
sqlalchemy.types.TypeEngine: Type for new column
"""
# TODO: Check if vendor specific types like json, mediumint, etc work
params = {} if params is None else params
# Get number types
if (
'integer' in col_type or 'increments' in col_type or col_type == 'decimal' or
col_type == 'double' or col_type == 'float'
):
return get_number_type(col_type, params, unsigned)
# Get String types
elif (
'text' in col_type or col_type == 'char' or col_type == 'json' or col_type == 'string'
):
return get_string_type(col_type, params)
# Get Date/Time Types
elif 'date' in col_type or 'time' in col_type:
return get_time_type(col_type)
# Get BINARY type
elif col_type == 'binary':
return LargeBinary()
# Get Boolean type
elif col_type == 'boolean':
return Boolean()
# Get Enum Type
elif col_type == 'enum':
return Enum(*params.get('fields', []))
# Get Array type
elif col_type == 'array':
arr_type = self.get_type(params.get('arr_type', 'text'))
return arr_type.with_variant(
ARRAY(arr_type, dimensions=params.get('dimensions')),
'postgresql'
)
return Text()
class cart(db.Model):
id = db.Column('cart_id', db.Integer, primary_key=True)
cart_id = db.Column('cart_userID', db.String(64),
db.ForeignKey('nata_user.user_id'))
cart_name = db.Column('cart_name', db.String(64))
cart_email = db.Column('cart_email', db.String(120))
cart_date = db.Column('cart_date', db.String(10))
cart_events = db.Column('cart_orders',
ARRAY(db.String(10), dimensions=2),
nullable=False,
default=[])
cart_image_link = db.Column('cart_image_link', db.String(120))
def __repr__(self):
return f"cart('{self.cart_name}', '{self.cart_email}', '{self.cart_date}')"
class Tweet(Base):
__tablename__ = 'filteredStreams2' # 'academicTweets'
id = Column(Integer, primary_key=True) # Auto-generated ID
twitter_id = Column(String) # (data.id)
text = Column(String) # (data.text)
lang = Column(String) # (data.lang)
created_at = Column(DateTime) # (data.created_at)
places_geo_place_id = Column(String) # (includes.places.id)
places_geo_bbox = Column(ARRAY(Float)) # (includes.places.geo.bbox)
places_full_name = Column(String) # (includes.places.full_name)
places_place_type = Column(String) # (includes.places.place_type)
places_country_code = Column(String) # (includes.places.country_code)
stream_rule_tag = Column(String) # (matching_rules.tag)
# Constructor
def __repr__(self):
return "<Tweet(twitter_id='{}', text='{}', lang={}, created_at={}, places_geo_place_id={}, places_geo_bbox={}, places_full_name={}, places_place_type={}, places_country_code={}, stream_rule_tag={})>"\
.format(self.twitter_id, self.text, self.lang, self.created_at, self.places_geo_place_id, self.places_geo_bbox, self.places_full_name, self.places_place_type, self.places_country_code, self.stream_rule_tag)
class nata_user(db.Model):
id = db.Column('user_id', db.String(64), primary_key=True)
user_line = db.Column('user_line', db.String(20))
user_events = db.Column('user_events',
ARRAY(db.String(10), dimensions=2),
nullable=False,
default=[])
# confirmation input
user_toggle = db.Column('user_toggle',
db.Boolean,
nullable=False,
default=False)
user_name = db.Column('user_name', db.String(64))
user_email = db.Column('user_email', db.String(120))
user_date = db.Column('user_date', db.String(10))
user_image_link = db.Column('user_image_link', db.String(120))
def __repr__(self):
return f"nata_user('{self.user_line}')"
class Venue(db.Model):
__tablename__ = 'Venue'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
city = db.Column(db.String(120))
state = db.Column(db.String(120))
address = db.Column(db.String(120))
phone = db.Column(db.String(120))
image_link = db.Column(db.String(500))
facebook_link = db.Column(db.String(120))
website = db.Column(db.String(500))
seeking_talent = db.Column(db.Boolean)
seeking_description = db.Column(db.String(500))
image_link = db.Column(db.String(500))
past_shows_count = db.Column(db.Integer)
upcoming_shows_count = db.Column(db.Integer)
genres = db.Column(ARRAY(db.String))
def create_site_tables(metadata):
# MW incompatibility: dropped the iw_wikiid column
interwiki = Table(
"interwiki", metadata,
Column("iw_prefix", UnicodeText, primary_key=True, nullable=False),
Column("iw_url", UnicodeText, nullable=False),
Column("iw_api", UnicodeText),
Column("iw_local", Boolean, nullable=False),
Column("iw_trans", Boolean, nullable=False, server_default="0"))
tag = Table(
"tag", metadata,
Column("tag_id", Integer, primary_key=True, nullable=False),
Column("tag_name", UnicodeText, nullable=False),
Column("tag_displayname", UnicodeText, nullable=False),
Column("tag_description", UnicodeText),
Column("tag_defined", Boolean, nullable=False, server_default="1"),
Column("tag_active", Boolean, nullable=False, server_default="1"),
Column("tag_source", ARRAY(UnicodeText)))
Index("tag_name", tag.c.tag_name, unique=True)
class Ship(Base):
__tablename__ = 'ships'
ship_name = Column(String(100))
hull_id = Column(String(100), primary_key=True)
sprite_name = Column(String(150))
width = Column(Float)
height = Column(Float)
hull_size = Column(String(50))
style = Column(String(50))
center = Column(ARRAY(Float))
armor_rating = Column(Float)
acceleration = Column(Float)
cargo = Column(Float)
deceleration = Column(Float)
flux_dissipation = Column(Float)
fuel = Column(Float)
fuel_ly = Column(Float)
fighter_bays = Column(Integer)
hitpoints = Column(Float)
mass = Column(Float)
max_crew = Column(Integer)
max_flux = Column(Float)
max_speed = Column(Float)
max_burn = Column(Integer)
max_turn_rate = Column(Float)
min_crew = Column(Integer)
ordnance_points = Column(Integer)
shield_arc = Column(Float)
shield_efficiency = Column(Float)
shield_type = Column(String(20))
shield_upkeep = Column(Float)
supplies_month = Column(Float)
mod_name = Column(String(50))
weapon_slots = Column(JSON)
description = Column(Text)
def __repr__(self):
return "<Ship(hull_id={})>".format(self.hull_id)
class UserRule(db.Model):
__tablename__ = "users_rules"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
rule_id = db.Column(db.Integer, db.ForeignKey('rules.id'), nullable=False)
enabled = db.Column(db.Boolean, nullable=False)
levels = db.Column(ARRAY(db.Integer))
created_at = db.Column(db.DateTime, nullable=False)
last_modified = db.Column(db.DateTime, nullable=False)
rule = db.relationship("Rule", back_populates="user_associations")
user = db.relationship("User", back_populates="rule_associations")
db.UniqueConstraint('user_id', 'rule_id')
def __init__(self, user_id, rule_id, enabled=False, levels=None):
self.user_id = user_id
self.rule_id = rule_id
self.levels = levels
self.enabled = enabled
self.created_at = datetime.datetime.now()
self.last_modified = datetime.datetime.now()
class RedditMeme(db.Model):
__tablename__ = 'reddit_memes'
__bind_key__ = 'memedata'
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(20),
db.ForeignKey('redditors.username'),
nullable=False)
reddit_id = db.Column(db.String(20), nullable=False)
subreddit = db.Column(db.String(50), nullable=False)
title = db.Column(db.String(500), nullable=False)
url = db.Column(db.String(200), nullable=False)
meme_text = db.Column(db.String(10000))
template = db.Column(db.String(100))
timestamp = db.Column(db.Integer, nullable=False)
datetime = db.Column(db.DateTime, nullable=False)
upvote_ratio = db.Column(db.Float, nullable=False)
upvotes = db.Column(db.Integer, nullable=False)
downvotes = db.Column(db.Integer, nullable=False)
num_comments = db.Column(db.Integer, nullable=False)
features = db.Column(ARRAY(db.Float), nullable=False)
@property
def serialize(self):
return {
"reddit_id": self.reddit_id,
"subreddit": self.subreddit,
"title": self.title,
"username": self.username,
"url": self.url,
"meme_text": self.meme_text,
"template": self.template,
"timestamp": self.timestamp,
"datetime": dump_datetime(self.datetime),
"upvote_ratio": self.upvote_ratio,
"upvotes": self.upvotes,
"downvotes": self.downvotes,
'num_comments': self.num_comments
}
class TransitLine(Base): __tablename__ = "transit_lines" id = Column(Integer, primary_key=True, autoincrement=True) uuid = Column(UUID(as_uuid=True), default=uuid4) name = Column(String) alert = Column(Boolean) coordinates = Column(ARRAY(Float)) description = Column(String) date_created = Column(DateTime) date_modified = Column(DateTime) def create_entry(self, name, alert, coordinates, description): self.name = name self.alert = alert self.coordinates = coordinates self.description = description self.date_created = datetime.datetime.now() self.date_modified = datetime.datetime.now() def __repr__(self): return "<TransitLine(uuid='%s', name='%s')>" %(self.uuid, self.name)
class Game(db.Model):
__tablename__ = 'games'
id = Column(Integer, primary_key=True)
player_name = Column(String)
round = Column(Integer, default=1)
board = Column(ARRAY(Integer, dimensions=3))
def is_over(self):
revealed = filter(
lambda field: field[FIELD_STATE] == InternalFieldState.TREASURE_REVEALED.value,
flatten(self.board))
return len(list(revealed)) == TREASURES_COUNT
def get_field_state(self, x, y):
return self.board[y][x][FIELD_STATE]
def is_field_revealed(self, x, y):
return self.get_field_state(x, y) in [InternalFieldState.TREASURE_REVEALED.value, InternalFieldState.EMPTY_REVEALED.value]
def reveal_field(self, x, y):
board = copy.deepcopy(self.board)
if board[y][x][FIELD_STATE] == InternalFieldState.TREASURE_UNREVEALED.value:
board[y][x][FIELD_STATE] = InternalFieldState.TREASURE_REVEALED.value
if board[y][x][FIELD_STATE] == InternalFieldState.EMPTY_UNREVEALED.value:
board[y][x][FIELD_STATE] = InternalFieldState.EMPTY_REVEALED.value
self.board = board
def serialize_fields(self, fields):
return [map_field(field["x"], field["y"], self.board) for field in fields]
def serialize(self):
return {
"player_name": self.player_name,
"board": internal_to_external_board(self.board),
"round": self.round,
"is_over": self.is_over()
}
class Podcast(Audio):
__tablenames__ = 'podcasts'
id = db.Column(db.Integer, unique=True, primary_key=True)
host = db.Column(db.String(100), nullable=False)
participants = db.Column(ARRAY(String(100)), nullable=True)
upload_time = db.Column(db.DateTime, default=datetime.utcnow)
def __init__(self, title, duration, host, participants):
super().__init__(title, duration)
self.title = title
self.duration = duration
self.host = host
self.participants = participants
def save(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Encounter(Base):
__tablename__ = 'encounter'
id = Column(Integer, primary_key=True)
name = Column(String(), unique=True)
description = Column(String(), default='')
tags = Column(ARRAY(String()), default=[])
def __init__(self, name, description, tags):
self.name = name
self.description = description
self.tags = tags
def __repr__(self):
return '<Encounter id:{}>'.format(self.id)
def json(self):
return {
'id': self.id,
'name': self.name,
'description': self.description,
'tags': self.tags
}
class BaseSeries():
__table_args__ = (ForeignKeyConstraint(
['datasource_id', 'dataset_id'],
['datasets.datasource_id', 'datasets.id']), )
id = Column(String, primary_key=True)
dataset_id = Column(String)
datasource_id = Column(String)
name = Column(String)
theme = Column(Enum(Theme))
subtheme = Column(Enum(SubTheme))
tags = Column(ARRAY(String))
frequency = Column(Enum(Frequency))
seasonal_adjustment = Column(Enum(SeasonalAdjustment))
series_type = Column(Enum(SeriesType))
series_subtype = Column(Enum(SeriesSubType))
categorical = Column(Boolean, default=False)
def __repr__(self):
return "<Series(id='%s', dataset='%s', datasource='%s')>" % (
self.id, self.dataset_id, self.datasource_id)
