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)