class Courier(Base): __tablename__ = 'courier' courier_id = Column(Integer, primary_key=True) courier_type = Column(Enum(CourierType, name='courier_type'), nullable=False) regions = Column(ARRAY(Integer), nullable=False) working_hours = Column(ARRAY(String), nullable=False) def weight(self): weight_values = {'foot': 10, 'bike': 15, 'car': 50} if self.courier_type.foot: return weight_values['foot'] elif self.courier_type.bike: return weight_values['bike'] else: return weight_values['car'] def to_dict(self) -> dict: return { 'courier_id': self.courier_id, 'courier_type': self.courier_type.name, 'regions': self.regions, 'working_hours': self.working_hours }
class Product(Base): __tablename__ = 'product' STATUS_NEW = 1 STATUS_SATELLITE = 2 STATUS_REGULAR = 3 id = Column(Integer, primary_key=True) domain = Column(String) code = Column(Integer) name = Column(String) description = Column(String) params = Column(JSONB, default='{}') status = Column(Integer, default=STATUS_NEW) images = Column(ARRAY(String), default=[]) picker = Column(ARRAY(Integer), default=[]) ref_count = Column(Integer, default=0) sizes = Column(ARRAY(String), default=[]) brand_id = Column(Integer, ForeignKey('brand.id')) category_ids = Column(ARRAY(Integer), default=[]) created_at = Column(DateTime, default=datetime.datetime.now) updated_at = Column(DateTime, default=datetime.datetime.now, onupdate=datetime.datetime.now) price = relationship('ProductPrice', uselist=False, back_populates='product') price_history = relationship('ProductPriceHistory', back_populates='product') brand = relationship('Brand')
def random_update_order_parameters(): from sqlalchemy import ARRAY t = table( "foo", column("data1", ARRAY(Integer)), column("data2", ARRAY(Integer)), column("data3", ARRAY(Integer)), column("data4", ARRAY(Integer)), ) idx_to_value = [ (t.c.data1, 5, 7), (t.c.data2, 10, 18), (t.c.data3, 8, 4), (t.c.data4, 12, 14), ] def combinations(): while True: random.shuffle(idx_to_value) yield list(idx_to_value) return testing.combinations(*[ (t, combination) for i, combination in zip(range(10), combinations()) ], argnames="t, idx_to_value")
class Movie(Base): __tablename__ = 'Movies' id = Column(Integer, primary_key=True) name = Column(String(100), nullable=False) year = Column(SMALLINT, nullable=False) director = Column(String(100), nullable=False) duration = Column(SMALLINT, nullable=False) rating = Column(Float, nullable=False) users_votes = Column(Integer, nullable=False) budget = Column(String(50), nullable=False) opening_revenue = Column(String(50), nullable=False) total_revenue = Column(String(50), nullable=False) motion_picture_rating = Column(String(20), nullable=False) release_date = Column(String(20), nullable=False) genres = Column(ARRAY(String(20), dimensions=1), nullable=False) studios = Column(ARRAY(String(100), dimensions=1), nullable=False) cast = Column(ARRAY(String(100), dimensions=1), nullable=False) countries = Column(ARRAY(String(50), dimensions=1), nullable=False) you_tube_trailer_info = relationship('YouTubeMovieTrailerInfo', foreign_keys=[name,year], primaryjoin='Movie.name == YouTubeMovieTrailerInfo.name and Movie.year == YouTubeMovieTrailerInfo.year') tweets = relationship('Tweet', uselist=True, lazy='select', foreign_keys=[name,year], primaryjoin='Tweet.name == Movie.name and Movie.year == Tweet.year') def __repr__(self): return "<User(name='%s', fullname='%d', password='******')>" % ( self.name, self.year, self.genres) def __init__(self, id, name, year, director, duration, rating, users_votes, budget, opening_revenue, total_revenue, motion_picture_rating, release_date, genres, studios, cast, countries): self.id = id self.name = name self.year = year self.director = director self.duration = duration self.rating = rating self.users_votes = users_votes self.budget = budget self.opening_revenue = opening_revenue self.total_revenue = total_revenue self.motion_picture_rating = motion_picture_rating self.release_date = release_date self.genres = genres self.studios = studios self.cast = cast self.countries = countries def count_sentiment_tweets(self): positive, negative,neutral = 0, 0, 0 tweets_sentiment_count = { 'positive': 0, 'negative': 0, 'neutral': 0 } for tweet in self.tweets: tweets_sentiment_count[tweet.sentiment] += 1 return tweets_sentiment_count
class Inference(SmartBase): __tablename__ = "inference" id = Column(Integer, Sequence(f"{__tablename__}_id_seq"), primary_key=True) grd__id = Column(Integer, ForeignKey("grd.id")) ocn__id = Column(Integer, ForeignKey("ocn.id")) ml_pkls = Column(ARRAY(String)) thresholds = Column(ARRAY(Integer)) fine_pkl_idx = Column(Integer) chip_size_orig = Column(Integer) chip_size_reduced = Column(Integer) overhang = Column(Boolean) grd = relationship( "Grd", back_populates="inferences", foreign_keys=grd__id, enable_typechecks=False, cascade_backrefs=False, ) ocn = relationship( "Ocn", back_populates="inferences", foreign_keys=ocn__id, enable_typechecks=False, cascade_backrefs=False, ) posi_polys = relationship( "Posi_Poly", back_populates="inference", enable_typechecks=False, cascade_backrefs=False, )
class Livro(Base): __tablename__ = 'livros' id = Column(Integer, primary_key=True) titulo = Column(String, nullable=False) ano_publicacao_original = Column(Integer, nullable=False) edicao = Column(Integer, nullable=False) editora_id = Column(Integer, ForeignKey('editoras.id'), nullable=False) ano_publicacao_edicao = Column(Integer, nullable=False) autores = Column(ARRAY(String), nullable=False) # idioma_original = Column(String, nullable=False) idioma = Column(String, nullable=False) tipo_id = Column(Integer, nullable=False) generos_id = Column(ARRAY(Integer)) categoria_id = Column(Integer) estado_id = Column(Integer, nullable=False) exemplares = Column(Integer, default=0) preco = Column(Numeric(6, 2)) paginas = Column(Integer) classificacao = Column(Numeric, default=0.0, nullable=False) capa = Column(LargeBinary, nullable=False) capa_extra1 = Column(LargeBinary) capa_extra2 = Column(LargeBinary) sinopse = Column(TEXT)
class Characters(BaseDBModel, Base): __tablename__ = 'characters' deleted_at = Column(DateTime) name = Column(String) birthday = Column(Date) img = Column(String, nullable=True) status = Column(Enum(CharacterStatus), default=CharacterStatus.ALIVE) nickname = Column(String) occupation = Column(ARRAY(String)) appearance = Column(ARRAY(String)) portrayed = Column(String) category = Column(ARRAY(String)) __table_args__ = ( Index('uq_characters_name', text('lower(name)'), unique=True, postgresql_where=(deleted_at.is_(None))), Index('uq_characters_nickname', text('lower(nickname)'), unique=True, postgresql_where=(deleted_at.is_(None))), )
class Dataset(Base): __tablename__ = "meta_dataset" id = Column(String, primary_key=True) type = Column(String) title = Column(String) description = Column(String) date_created = Column(DateTime) auth = Column(String) date_modified = Column(DateTime) license = Column(String) homepage = Column(String) language = Column(String) status = Column(String) version = Column(String) objective = Column(String) temporal_unit = Column(String) spatial = Column(String) legal_basis = Column(String) contact_point = Column(String) # struct with name/email accrual_periodicity = Column(String) spatial_description = Column(String) spatial_coordinates = Column(String) theme = Column(ARRAY(String)) publisher = Column(String) owner = Column(String) authorization_grantor = Column(String) keywords = Column(ARRAY(String)) has_beginning = Column(DateTime) has_end = Column(DateTime) crs = Column(String)
class CatsStat(Base): __tablename__ = "cats_stat" tail_length_mean = Column("tail_length_mean", Numeric, primary_key=True) tail_length_median = Column("tail_length_median", Numeric, primary_key=True) tail_length_mode = Column("tail_length_mode", ARRAY(Integer, as_tuple=True), primary_key=True) whiskers_length_mean = Column("whiskers_length_mean", Numeric, primary_key=True) whiskers_length_median = Column("whiskers_length_median", Numeric, primary_key=True) whiskers_length_mode = Column("whiskers_length_mode", ARRAY(Integer, as_tuple=True), primary_key=True) def __init__( self, tail_length_mean, tail_length_median, tail_length_mode, whiskers_length_mean, whiskers_length_median, whiskers_length_mode, ): self.tail_length_mean = tail_length_mean self.tail_length_median = tail_length_median self.tail_length_mode = tail_length_mode self.whiskers_length_mean = whiskers_length_mean self.whiskers_length_median = whiskers_length_median self.whiskers_length_mode = whiskers_length_mode
class Unit(db.Model, BaseColumns): __tablename__ = "unit" name = Column(String(100), nullable=False, unique=True) spell = Column(String(50), server_default='') category = Column(String(50), server_default='') tags = Column(ARRAY(String), server_default='{}') city = Column(String(100), server_default='') region = Column(String(100), server_default='') domain = Column(String(200), server_default='') domains = Column(ARRAY(String), server_default='{}') keywords = Column(ARRAY(String), server_default='{}') website_count = Column(Integer, server_default='0') def as_dict(self, fields=None): detail = { 'id': self.id, 'spell': self.spell, 'keywords': self.keywords, 'name': self.name, 'category': self.category, 'domains': self.domains, 'tags': self.tags, 'city': self.city, 'region': self.region, 'website_count': self.website_count } if not fields: return detail return {attr: detail[attr] for attr in fields if attr in detail}
async def _get_osm_objects_with_issues(self, changes): node_issues_set = {Issue(**i) for i in (await (await self.conn.execute( Issue.__table__.select().where(and_( Issue.__table__.c.handle == self.handle, Issue.__table__.c.date_closed is not None, Issue.__table__.c.affected_nodes.overlap( cast(array(changes.affected_nodes), ARRAY(BigInteger))), )) )).fetchall())} way_issues_set = {Issue(**i) for i in (await (await self.conn.execute( Issue.__table__.select().where(and_( Issue.__table__.c.handle == self.handle, Issue.__table__.c.date_closed is not None, Issue.__table__.c.affected_ways.overlap( cast(array(changes.affected_ways), ARRAY(BigInteger))), )) )).fetchall())} rel_issues_set = {Issue(**i) for i in (await (await self.conn.execute( Issue.__table__.select().where(and_( Issue.__table__.c.handle == self.handle, Issue.__table__.c.date_closed is not None, Issue.__table__.c.affected_rels.overlap( cast(array(changes.affected_rels), ARRAY(BigInteger))), )) )).fetchall())} node_issues = {n: i for i in node_issues_set for n in i.affected_nodes} way_issues = {w: i for i in way_issues_set for w in i.affected_ways} rel_issues = {r: i for i in rel_issues_set for r in i.affected_rels} return node_issues, way_issues, rel_issues
class HistoricDUNS(Base): """ Legacy DUNS Records with their latest updates """ __tablename__ = "historic_duns" duns_id = Column(Integer, primary_key=True) awardee_or_recipient_uniqu = Column(Text, index=True) legal_business_name = Column(Text) dba_name = Column(Text) activation_date = Column(Date) registration_date = Column(Date) expiration_date = Column(Date) last_sam_mod_date = Column(Date) address_line_1 = Column(Text) address_line_2 = Column(Text) city = Column(Text) state = Column(Text) zip = Column(Text) zip4 = Column(Text) country_code = Column(Text) congressional_district = Column(Text) business_types_codes = Column(ARRAY(Text)) business_types = Column(ARRAY(Text)) ultimate_parent_unique_ide = Column(Text) ultimate_parent_legal_enti = Column(Text) high_comp_officer1_full_na = Column(Text) high_comp_officer1_amount = Column(Text) high_comp_officer2_full_na = Column(Text) high_comp_officer2_amount = Column(Text) high_comp_officer3_full_na = Column(Text) high_comp_officer3_amount = Column(Text) high_comp_officer4_full_na = Column(Text) high_comp_officer4_amount = Column(Text) high_comp_officer5_full_na = Column(Text) high_comp_officer5_amount = Column(Text)
def _select_from_database(self, main_db_cols, imdb_cols, input_json): query = self.session.query(MovieDatabase).join(ExtensionIMDB) arguments = [(main_db_cols, MovieDatabase), (imdb_cols, ExtensionIMDB)] try: for argument in arguments: for key in argument[0]: value = input_json.get(key) if isinstance(value, dict): query = query.filter( getattr(argument[1], key).between(value.get('lower'), value.get('higher'))) elif isinstance(value, list): if any(isinstance(i, list) for i in value): for inner_value in value: query = query.filter( getattr(argument[1], key).overlap( cast(inner_value, ARRAY(String)))) else: query = query.filter( getattr(argument[1], key).overlap( cast(value, ARRAY(String)))) else: query = query.filter( getattr(argument[1], key) == value) result_list = dict() for item in query: result_list[item.movie_title] = item.as_dict() return json.dumps(result_list) except Exception: raise Exception
def test_update_to_expression_two(self): """test update from an expression. this logic is triggered currently by a left side that doesn't have a key. The current supported use case is updating the index of a PostgreSQL ARRAY type. """ from sqlalchemy import ARRAY t = table( "foo", column("data1", ARRAY(Integer)), column("data2", ARRAY(Integer)), ) stmt = t.update().ordered_values( (t.c.data1[5], 7), (t.c.data2[10], 18) ) dialect = default.StrCompileDialect() dialect.paramstyle = "qmark" dialect.positional = True self.assert_compile( stmt, "UPDATE foo SET data1[?]=?, data2[?]=?", dialect=dialect, checkpositional=(5, 7, 10, 18), )
class FactApiLocations(Base): __tablename__ = 'idetect_fact_api_locations' fact = Column(Integer, primary_key=True) location_ids = Column(ARRAY(Integer)) location_names = Column(ARRAY(String)) location_ids_num = Column(Integer)
class Submission(Base): __tablename__ = 'submissions' id = Column(Integer, primary_key=True) value = Column(String, nullable=False) category: SubmissionCategory = Column(Enum(SubmissionCategory)) language: Language = Column(Enum(Language)) lemmas: List[str] = Column(ARRAY(String)) words: List[str] = Column(ARRAY(String)) points = Column(Float, default=0, nullable=False) score = Column(Float, default=0, nullable=False) mwe_words: List[str] = Column(ARRAY(String)) mwe_indices: List[int] = Column(ARRAY(Integer)) conllu = Column(Text) hash = Column(String, default="", nullable=False) created = Column(DateTime, default=datetime.datetime.now, nullable=False) flagged = Column(Boolean, default=False, nullable=False) user_id = Column(Integer, ForeignKey('users.id')) user = relationship("User", back_populates="submissions") mwe_id = Column(Integer, ForeignKey("mwes.id")) mwe = relationship("Mwe", back_populates="submissions") reviews: List[Review] = relationship("Review", back_populates="submission") review_count: int = column_property( select([func.count(Review.id)]).where(Review.submission_id == id)) def __repr__(self): return "<Value(id='%s', value='%s')>" % (self.id, self.value)
class Movie(DeclarativeBase): """ Movie Model """ __tablename__ = 'movies' #unique fields id = Column(Integer, primary_key=True) movie_title = Column('movie_title', String) movie_cover = Column('movie_cover', ARRAY(String)) length = Column('length', Time) movie_trailer = Column('movie_trailer', String, nullable=True) description = Column('description', Text(), nullable=True) gallary_urls = Column("gallary_urls", ARRAY(String), nullable=True) #repetitive fields studio_id = Column(Integer, ForeignKey('studios.id')) director_id = Column(Integer, ForeignKey('directors.id')) performers = relationship("Performer", secondary=movie_cast_table, backref='movies') release_date_id = Column(Integer, ForeignKey('releasedates.id')) rating_id = Column(Integer, ForeignKey('ratings.id')) scenes = relationship("Scene", backref='movie', cascade_backrefs=False) genres = relationship("Genre", secondary=movie_genres_table, backref='movies', cascade_backrefs=False) tags = relationship("Tag", secondary=movie_tags_table, backref='movies', cascade_backrefs=False)
class Notifications(Base): __tablename__ = 'notifications' id_notifications = Column(Integer, Sequence('notifications_id_notifications_seq'), primary_key=True) address = Column(String, nullable=False) # matchingrule = Column(String, nullable=False) id_matchingrule = Column(Integer) modifytime = Column(TIMESTAMP(True)) currcontent = Column(String) coloredcurrcontent = Column(String) currdocslinks = Column(String) detectedreplacedorinserted = Column(String) oldcontenttime = Column(TIMESTAMP(True)) oldcontent = Column(String) coloredoldcontent = Column(String) olddocslinks = Column(String) detecteddeleted = Column(String) changes = Column(String, nullable=False) recipients = Column(ARRAY(String)) ackers = Column( ARRAY(String) ) # It's an array in case of future use. Normally should have maximum 1 element def __repr__(self): return "<Notification(id_notifications='%s', address='%s', matchingrule='%s', id_matchingrule='%s'," \ " modifytime='%s', oldcontent='%s', changes='%s' recipients='%s', ackers='%s')>" % \ (self.id_notifications, self.address, self.matchingrule, self.id_matchingrule, self.modifytime, self.oldcontent, self.changes, self.recipients, self.ackers)
def create_schema(cls, db_engine, db_meta): cls.classroom_t = Table( cls.TABLE_NAME, db_meta, Column("id", Integer, primary_key=True, autoincrement=True), Column("name", String, nullable=False, autoincrement=False), Column("teacher", ForeignKey("tb_user.id"), nullable=False, autoincrement=False), Column("students_name", ARRAY(String), nullable=False, autoincrement=False), Column("students_cid", ARRAY(Integer), nullable=False, autoincrement=False), Column("students_sid", ARRAY(String), nullable=False, autoincrement=False), Column("folder", String, nullable=True, autoincrement=True, default=""), Column("comment", JSON, nullable=True, default={}, autoincrement=True), Column("progress", Integer, nullable=False, default=10, autoincrement=True), Column("links", ARRAY(String), nullable=True, default=[], autoincrement=True), Column("create_at", DateTime, default=datetime.utcnow, autoincrement=True), Column("type", String, nullable=True, autoincrement=False)) cls.classroom_t.create(db_engine, checkfirst=True) return cls.classroom_t
class Sights(Base): __tablename__ = 'sights' id_sight = Column(Integer, primary_key=True) name = Column(String(100), nullable=False) tag = Column(ARRAY(Text)) cost = Column(REAL) id_town = Column(Integer, ForeignKey(Town.id_town)) cord_lat = Column(Integer) cord_long = Column(Integer) rating = Column(REAL) type_sight = Column(Text) urls = Column(ARRAY(Text)) web_site = Column(Text) description = Column(Text) history = Column(Text) phone_number = Column(String(20)) def serialize(self): return { 'id_town': self.id_town, 'id_sight': self.id_sight, 'name': self.name, 'tags': self.tag, 'cost': self.cost, 'coordinate': [self.cord_lat, self.cord_long], 'rating': self.rating, 'type': self.type_sight, 'photo_urls': self.urls, 'web_site': self.web_site, 'description': self.description, 'history': self.history, 'phone_number': self.phone_number, }
class PubChemData(EntityBase): __tablename__ = 'pubchem_data' pubchem_id = Column(String(20), primary_key=True) names = Column(ARRAY(TEXT)) mass = Column(Float) #weight = Column(Float) monoisotopic_mass = Column(Float) logp = Column(Float) # structure info - smiles = Column(ARRAY(TEXT)) inchi = Column(TEXT) inchikey = Column(String(27)) formula = Column(String(256)) chebi_id = Column(String(20), ForeignKey('chebi_data.chebi_id')) kegg_id = Column(String(20), ForeignKey('kegg_data.kegg_id')) hmdb_id = Column(String(20), ForeignKey('hmdb_data.hmdb_id')) chemspider_id = Column(String(20)) ref_etc = Column(JSON_GEN()) def __init__(self, **kwargs): pass
class Integers(Base): __tablename__ = 'Integers' id = Column(Integer, primary_key=True, autoincrement=True) surce_array = Column(ARRAY(Integer)) result_array = Column(ARRAY(Integer)) date_of_creation = Column(DateTime, default=datetime.datetime.utcnow)
class ServerSetting(Base): server_id = Column(Integer, ForeignKey("server.id")) server = relationship(Server, backref=backref("serversetting", uselist=True)) bot_prefix = Column(ARRAY(String)) modmail_server_id = Column(BigInteger) modmail_unanswered_cat_id = Column(BigInteger) modmail_in_progress_cat_id = Column(BigInteger) muted_role = Column(BigInteger) bot_bypass_role = Column(BigInteger) mod_channel = Column(BigInteger) wordfilter_data = Column(JSON) appeals_invite_code = Column(String) welcome_msg = Column(String) footer_msg = Column(String) antispam_quickmsg = Column(Boolean, default=False) antispam_mass_mentions = Column(Boolean, default=False) antispam_twitch = Column(Boolean, default=False) antispam_discord_invites = Column(Boolean, default=False) antispam_mixer = Column(Boolean, default=False) antispam_patreon = Column(Boolean, default=False) antispam_paypal = Column(Boolean, default=False) antispam_wordfilter = Column(Boolean, default=False) bot_id = Column(BigInteger) admin_role = Column(BigInteger) mod_role = Column(BigInteger) request_channel = Column(BigInteger) request_channel_allowed = Column(ARRAY(BigInteger)) request_alert_channel = Column(BigInteger) activity_status = Column(ARRAY(String)) activity_status_enabled = Column(Boolean, default=False) enabled = Column( Boolean, default=True, comment="Whether the bot is in the server, thus loading the settings", ) antispam_quickmsg_modmail = Column(Boolean, default=True) welcome_msg_enabled = Column(Boolean, default=False) on_join_role_id = Column(BigInteger) on_join_role_enabled = Column(Boolean, default=False) cd_on_message_rate = Column( DECIMAL, comment= "on_message event number of messages per cd_on_message_time before on cooldown", ) cd_on_message_time = Column( DECIMAL, comment="on_message event cooldown time, in seconds") antispam_mute_time = Column( String, comment= "Time to mute someone if antispam is tripped. Format is same as mute, e.g. '1h', '1d', '30m', etc", ) upvote_emoji = Column(BigInteger) downvote_emoji = Column(BigInteger) question_emoji = Column(BigInteger) allow_downvotes = Column(Boolean, default=True) allow_questions = Column(Boolean, default=False) request_type = Column(sqlalchemy.Enum(RequestType), default=RequestType.request)
class ZoneRiskResults(Base): __tablename__ = 'zone_risk_results' # Columns risk_analysis_name = Column(String, primary_key=True) risk_criteria_list = Column(ARRAY(String)) risk_scores_list = Column(ARRAY(String))
class OsmDeuWay(Base): __tablename__ = 'osm_deu_ways' __table_args__ = {'schema': 'openstreetmap'} id = Column(BigInteger, primary_key=True, index=True) nodes = Column(ARRAY(BigInteger()), nullable=False, index=True) tags = Column(ARRAY(Text())) pending = Column(Boolean, nullable=False)
class Courier(Base): __tablename__ = "Courier" id = Column(Integer, primary_key=True) type = Column(String, nullable=False) regions = Column(ARRAY(Integer), nullable=False) working_hours = Column(ARRAY(String), nullable=False) current_taken_weight = Column(Float, nullable=False, default=0)
class AffaireType(Base): __tablename__ = 'affaire_type' __table_args__ = {'schema': 'infolica'} id = Column(BigInteger, primary_key=True, autoincrement=True) nom = Column(Text, nullable=False) ordre = Column(BigInteger) reservation_numeros_types_id = Column(ARRAY(BigInteger)) modif_affaire_type_id_vers = Column(ARRAY(BigInteger)) logique_processus = Column(ARRAY(BigInteger))
class Device(Base): __tablename__ = "device" id = Column(Integer, primary_key=True) type = Column(Enum(DeviceType)) traits = Column(ARRAY(Enum(TraitType))) name = Column(String(255)) nicknames = Column(ARRAY(String(255))) attributes = Column(MutableDict.as_mutable(JSONB)) states = Column(MutableDict.as_mutable(JSONB)) user_id = Column(Integer, ForeignKey('user.id')) user = relationship("User", foreign_keys=[user_id]) def serialize_info(self): serialized = { "id": self.id, "type": self.type.value, "traits": [t.value for t in self.traits], "name": { "name": self.name, "nicknames": self.nicknames, }, "willReportState": False, "attributes": {} } for attribute in self.attributes.values(): serialized["attributes"].update(attribute) return serialized def serialize_status(self): serialized = { "on": True, "online": True, "status": "SUCCESS", } for state in self.states.values(): serialized.update(state) return serialized def serialize(self): serialized = self.serialize_info() serialized["status"] = self.serialize_status() return serialized def execute_command(self, command, params): trait_enum = get_trait_by_command(command) if trait_enum not in self.traits: raise trait_class = get_class_by_trait(trait_enum) attributes = self.attributes.get(trait_enum.value, {}) states = self.states.get(trait_enum.value, {}) trait = trait_class(attributes, states) self.states[trait_enum.value] = trait.process_command(command, params)
def createTable( self, n, tablename): #Table creation and mapping with QueenSolution class. table_q = Table(tablename, self.metadata, Column('id_solution', Integer, primary_key=True), Column('queen_rows', ARRAY(Integer)), Column('queen_cols', ARRAY(Integer))) self.metadata.create_all(self.engine) orm.mapper(QueenSolution, table_q)
class ModificationAffaireType(Base): __tablename__ = 'modification_affaire_type' __table_args__ = {'schema': 'infolica'} id = Column(BigInteger, primary_key=True, autoincrement=True) nom = Column(Text, nullable=False) ordre = Column(BigInteger) reservation_numeros_types_id = Column(ARRAY(BigInteger)) affaire_source_type_id = Column(ARRAY(BigInteger)) affaire_destination_type_id = Column(BigInteger, ForeignKey(AffaireType.id))