class DeclEnumType(SchemaType, TypeDecorator): def __init__(self, enum): self.enum = enum # convert CamelCase to underscore_separated name = re.sub('.([A-Z])', lambda m: '_' + m.group(1).lower(), enum.__name__).lower() self.impl = Enum(*enum.values(), name=name) def _set_table(self, table, column): self.impl._set_table(table, column) def copy(self): return DeclEnumType(self.enum) def process_bind_param(self, value, dialect): if value is None: return None if isinstance(value, basestring): return value if value.cls_ != self.enum: raise TypeError('Cannot use %r as bind parameter for column ' 'of type %r' % (value, self.enum)) return value.value def process_result_value(self, value, dialect): if value is None: return None return self.enum.from_string(value.strip())
class LayerExternalWMS(Layer): __label__ = _(u"External WMS layer") __plural__ = _(u"External WMS layers") __tablename__ = "layer_external_wms" __table_args__ = {"schema": _schema} __acl__ = [ (Allow, AUTHORIZED_ROLE, ALL_PERMISSIONS), ] __mapper_args__ = {"polymorphic_identity": "l_ext_wms"} id = Column(Integer, ForeignKey(_schema + ".layer.id"), primary_key=True) url = Column(Unicode, label=_(u"Base URL")) layer = Column(Unicode, label=_(u"Layers")) image_type = Column(Enum("image/jpeg", "image/png", native_enum=False), label=_(u"Image type")) style = Column(Unicode, label=_(u"Style")) is_single_tile = Column(Boolean, label=_(u"Single tile")) time_mode = Column(Enum("disabled", "single", "range", native_enum=False), default="disabled", nullable=False, label=_(u"Time mode")) time_widget = Column(Enum("slider", "datepicker", native_enum=False), default="slider", nullable=True, label=_(u"Time widget")) def __init__(self, name=u"", public=True): Layer.__init__(self, name=name, public=public)
class DeclEnumType(SchemaType, TypeDecorator): """DeclEnum augmented so that it can persist to the database.""" def __init__(self, enum): self.enum = enum self.impl = Enum(*enum.names(), name="ck%s" % re.sub('([A-Z])', lambda m: '_' + m.group(1).lower(), enum.__name__)) def drop(self, bind=None, checkfirst=False): return "DROP {} IF EXISTSZZ".format("ck%s" % re.sub( '([A-Z])', lambda m: '_' + m.group(1).lower(), self.enum.__name__)) def _set_table(self, table, column): self.impl._set_table(table, column) def copy(self): return DeclEnumType(self.enum) def process_bind_param(self, value, dialect): if isinstance(value, EnumSymbol): value = value.name return value def process_result_value(self, value, dialect): if value is not None: return getattr(self.enum, value.strip())
def __init__(self, enum, name=None, default=None): self.enum = enum if name is None: self.impl = Enum(*enum.values(), name='RUCIO_ENUM_' + str(uuid.uuid4())[:6]) else: self.impl = Enum(*enum.values(), name=name)
class IntegrityMetrics(Base): """.""" __tablename__ = "integrity" integrity_id = Column("integrity_id", KeyInteger, primary_key=True) wf_id = Column( "wf_id", KeyInteger, ForeignKey(Workflow.wf_id, ondelete="CASCADE"), nullable=False, ) job_instance_id = Column( "job_instance_id", KeyInteger, ForeignKey(JobInstance.job_instance_id, ondelete="CASCADE"), nullable=False, ) type = Column("type", Enum("check", "compute", name="integrity_type_desc"), nullable=False) file_type = Column( "file_type", Enum("input", "output", name="integrity_file_type_desc")) count = Column("count", Integer, nullable=False) duration = Column("duration", DurationType, nullable=False)
def __init__(self, enum, **kwargs): super(DeclEnumType, self).__init__(**kwargs) self.enum = enum self.impl = Enum(*list(enum.values()), name="ck%s" % re.sub('([A-Z])', lambda m: "_" + m.group(1).lower(), enum.__name__))
class Enum(SchemaType, TypeDecorator): def __init__(self, enum): name = re.sub('([A-Z])', lambda m:"_" + m.group(1).lower(), enum.__name__) self.enum = enum self.impl = SaEnum(*enum.values(), name="ck%s" % name) def _set_table(self, table, column): self.impl._set_table(table, column) def copy(self): return Enum(self.enum) def process_bind_param(self, value, dialect): if value is None: return None return value.value def process_result_value(self, value, dialect): if value is None: return None return self.enum.from_string(value.strip()) def create(self, bind=None, checkfirst=False): super(Enum, self).create(bind, checkfirst) t = self.dialect_impl(bind.dialect) if t.impl.__class__ is not self.__class__ and isinstance(t, SchemaType): t.impl.create(bind=bind, checkfirst=checkfirst)
class DeclEnumType(SchemaType, TypeDecorator): def __init__(self, enum): self.enum = enum self.impl = Enum(*enum.values(), name="ck%s" % re.sub('([A-Z])', lambda m: "_" + m.group(1).lower(), enum.__name__)) def _set_table(self, table, column): self.impl._set_table(table, column) def copy(self): return DeclEnumType(self.enum) def process_bind_param(self, value, dialect): if value is None: return None return value.value def process_result_value(self, value, dialect): if value is None: return None return self.enum.from_string(value.strip()) def create(self, bind=None, checkfirst=False): """Issue CREATE ddl for this type, if applicable.""" super(DeclEnumType, self).create(bind, checkfirst) t = self.dialect_impl(bind.dialect) if t.impl.__class__ is not self.__class__ and isinstance( t, SchemaType): t.impl.create(bind=bind, checkfirst=checkfirst)
class EnumType(SchemaType, TypeDecorator): def __init__(self, enum): self.enum = enum self.impl = SAEnum( *[sym.value for sym in enum], name="enum%s" % re.sub( '([A-Z])', lambda m: "_" + m.group(1).lower(), enum.__name__)) def _set_table(self, table, column): self.impl._set_table(table, column) def copy(self): return EnumType(self.enum) def process_bind_param(self, value, dialect): if value is None: return None if isinstance(value, str): return value return value.value def process_result_value(self, value, dialect): if value is None: return None return self.enum(value.strip())
class DeclEnumType(SchemaType, TypeDecorator): def __init__(self, enum): self.enum = enum self.impl = Enum(*enum.values(), name=to_underscore(enum.__name__)) def _set_table(self, table, column): self.impl._set_table(table, column) def copy(self): return DeclEnumType(self.enum) def process_bind_param(self, value, dialect): if value is None: return value if isinstance(value, str): return value return value.value def process_result_value(self, value, dialect): if value is None: return None return self.enum.from_string(value.strip()) python_type = str
class Rune(Base): __tablename__ = "runes" runeType = Column(Enum(RuneID)) replayID = Column(BigInteger, ForeignKey("Replays.replayID"), primary_key=True) id = Column(Integer, primary_key=True) time = Column(Integer) team = Column(Enum(Team), primary_key=True) steamID = Column(BigInteger, ForeignKey(Player.steamID)) # Relationships player = relationship( Player, lazy="select", primaryjoin= "and_(Rune.steamID == Player.steamID, Rune.replayID == Player.replayID)" ) replay = relationship("Replay", back_populates="runes") def __init__(self, replay_in): self.replay = replay_in self.replayID = replay_in.replayID @hybrid_property def game_time(self): return self.time - self.replay.creepSpawn @game_time.expression def game_time(self): from .Replay import Replay creepSpawn = select([Replay.creepSpawn]).\ where(self.replayID == Replay.replayID).as_scalar() return self.time - creepSpawn
class DeclarativeEnumType(SchemaType, TypeDecorator): """Column type usable in table column definitions.""" def __init__(self, enum): self.enum = enum constraint = 'ck{0}'.format(re.sub('([A-Z])', lambda m: '_' + m.group(1).lower(), enum.__name__)) self.impl = Enum(*enum.values(), name=constraint) def _set_table(self, table, column): self.impl._set_table(table, column) def copy(self): return DeclarativeEnumType(self.enum) def process_bind_param(self, value, dialect): if value is None: # pragma: no cover return None return value.value def process_result_value(self, value, dialect): if value is None: # pragma: no cover return None return self.enum.from_string(value.strip())
class DeclEnumType(SchemaType, TypeDecorator): def __init__(self, enum): self.enum = enum self.impl = Enum( *enum.values(), name="ck%s" % re.sub( '([A-Z])', lambda m:"_" + m.group(1).lower(), enum.__name__) ) def _set_table(self, table, column): self.impl._set_table(table, column) def copy(self): return DeclEnumType(self.enum) def process_bind_param(self, value, dialect): if value is None: return None return value.value def process_result_value(self, value, dialect): if value is None: return None return self.enum.from_string(value.strip())
def __init__(self, enum): import re self.enum = enum self.impl = Enum(*enum.names(), name="ck%s" % re.sub('([A-Z])', lambda m: '_' + m.group(1).lower(), enum.__name__))
class PhoneFunckey(Base): __tablename__ = 'phonefunckey' __table_args__ = ( PrimaryKeyConstraint('iduserfeatures', 'fknum'), Index('phonefunckey__idx__exten', 'exten'), Index('phonefunckey__idx__progfunckey', 'progfunckey'), Index('phonefunckey__idx__typeextenumbers_typevalextenumbers', 'typeextenumbers', 'typevalextenumbers'), Index('phonefunckey__idx__typeextenumbersright_typevalextenumbersright', 'typeextenumbersright', 'typevalextenumbersright'), ) iduserfeatures = Column(Integer, nullable=False, autoincrement=False) fknum = Column(Integer, nullable=False, autoincrement=False) exten = Column(String(40)) typeextenumbers = Column(Enum('extenfeatures', 'featuremap', 'generalfeatures', name='phonefunckey_typeextenumbers', metadata=Base.metadata)) typevalextenumbers = Column(String(255)) typeextenumbersright = Column(Enum('agent', 'group', 'meetme', 'queue', 'user', 'paging', name='phonefunckey_typeextenumbersright', metadata=Base.metadata)) typevalextenumbersright = Column(String(255)) label = Column(String(32)) supervision = Column(Integer, nullable=False, server_default='0') progfunckey = Column(Integer, nullable=False, server_default='0')
class DeclEnumType(SchemaType, TypeDecorator): def __init__(self, enum, **kwargs): super(DeclEnumType, self).__init__(**kwargs) self.enum = enum self.impl = Enum( *enum.values(), name="ck%s" % re.sub( '([A-Z])', lambda m:"_" + m.group(1).lower(), enum.__name__) ) def _set_table(self, column, table): self.impl.name = "ck_%s_%s_%s" % ( '_'.join(table.schema.split('.')), table.name, self.impl.name[3:]) self.impl._set_table(column, table) def copy(self, **kw): return DeclEnumType(self.enum, **kw) def process_bind_param(self, value, dialect): if value is None: return None if isinstance(value, EnumSymbol): return value.value elif isinstance(value, (str, unicode)): # Should not happen, but mask the error for now. return value def process_result_value(self, value, dialect): if value is None: return None return self.enum.from_string(value.strip())
class Callerid(Base): __tablename__ = 'callerid' __table_args__ = (PrimaryKeyConstraint('type', 'typeval'), ) mode = Column( Enum('prepend', 'overwrite', 'append', name='callerid_mode', metadata=Base.metadata)) callerdisplay = Column(String(80), nullable=False, server_default='') type = Column( Enum('callfilter', 'incall', 'group', 'queue', name='callerid_type', metadata=Base.metadata)) typeval = Column(Integer, nullable=False, autoincrement=False) @hybrid_property def name(self): if self.callerdisplay == '': return None return self.callerdisplay @name.setter def name(self, value): if value is None: self.callerdisplay = '' else: self.callerdisplay = value
class DeclEnumType(SchemaType, TypeDecorator): def __init__(self, enum, **kwargs): super(DeclEnumType, self).__init__(**kwargs) self.enum = enum self.impl = Enum(*list(enum.values()), name="ck%s" % re.sub('([A-Z])', lambda m: "_" + m.group(1).lower(), enum.__name__)) def _set_table(self, column, table): self.impl.name = "ck_%s_%s_%s" % ('_'.join( table.schema.split('.')), table.name, self.impl.name[3:]) self.impl._set_table(column, table) def copy(self, **kw): return DeclEnumType(self.enum, **kw) def process_bind_param(self, value, dialect): if value is None: return None if isinstance(value, EnumSymbol): return value.value elif isinstance(value, string_types): # Should not happen, but mask the error for now. return value def process_result_value(self, value, dialect): if value is None: return None return self.enum.from_string(value.strip())
class DeclEnumType(SchemaType, TypeDecorator): def __init__(self, enum, **kwargs): self.enum = enum self.impl = Enum(*enum.values(), name="ck%s" % re.sub('([A-Z])', lambda m: "_" + m.group(1).lower(), enum.__name__), **kwargs) super(DeclEnumType, self).__init__(**kwargs) def _set_table(self, table, column): self.impl._set_table(table, column) def copy(self): return DeclEnumType(self.enum) def process_bind_param(self, value, dialect): if value is None: return None return value.value def process_result_value(self, value, dialect): if value is None: return None return self.enum.from_string(value.strip()) def register_with_psycopg(self, conn): import psycopg2.extensions my_enum_array_oid = conn.execute(text( "SELECT typarray FROM pg_catalog.pg_type " "WHERE typname = :tn"), tn=self.impl.name).scalar() psycopg2.extensions.register_type( psycopg2.extensions.new_array_type( (my_enum_array_oid, ), self.impl.name + '[]', psycopg2.STRING))
class QueueMember(Base): __tablename__ = 'queuemember' __table_args__ = ( PrimaryKeyConstraint('queue_name', 'interface'), UniqueConstraint('queue_name', 'channel', 'usertype', 'userid', 'category'), Index('queuemember__idx__category', 'category'), Index('queuemember__idx__channel', 'channel'), Index('queuemember__idx__userid', 'userid'), Index('queuemember__idx__usertype', 'usertype'), ) queue_name = Column(String(128)) interface = Column(String(128)) penalty = Column(Integer, nullable=False, server_default='0') commented = Column(Integer, nullable=False, server_default='0') usertype = Column(Enum('agent', 'user', name='queuemember_usertype', metadata=Base.metadata), nullable=False) userid = Column(Integer, nullable=False) channel = Column(String(25), nullable=False) category = Column(Enum('queue', 'group', name='queue_category', metadata=Base.metadata), nullable=False) position = Column(Integer, nullable=False, server_default='0')
class t_ipsec(BaseModel): __tablename__ = 't_ipsec' id = Column(Integer, primary_key=True) server_id = Column(Integer, index=True) chain = Column(Enum('INPUT', 'OUTPUT', 'FORWARD')) source_addr = Column(VARCHAR(50)) dest_addr = Column(VARCHAR(50)) protocal = Column(Enum('tcp', 'udp', 'icmp', 'all')) dport = Column(VARCHAR(50)) # status = Column(Integer) description = Column(VARCHAR(100)) create_time = Column(DATETIME) modify_time = Column(DATETIME) def __init__(self, server_id, protocal, source_addr, dport, description, status=0, chain='INPUT'): self.chain = chain self.server_id = server_id self.chain = chain self.source_addr = source_addr self.protocal = protocal self.dport = dport self.status = status self.description = description self.create_time = datetime.datetime.now() self.modify_time = datetime.datetime.now()
class Status(Base): """Representation of a logged status change.""" __tablename__ = 'Status' __table_args__ = {'mysql_engine': 'InnoDB'} OPEN = 'open' CLOSED = 'closed' AWAY = 'away' timestamp = Column(DateTime, primary_key=True, default=datetime.now) value = Column( Enum(OPEN, CLOSED, AWAY), nullable=False ) modified_by = Column(Enum('BITS', 'web'), nullable=False) def __init__(self, value, modified_by): self.value = value self.modified_by = modified_by def __str__(self): return 'Status {.value}'.format(self) def jsondict(self, wrap=True): """Return a JSON-serializable dictionary representing the object""" data = { "timestamp": int(float(self.timestamp.strftime('%s.%f')) * 1000), "modifiedby": self.modified_by, "value": self.value } if wrap: return {'status': data} else: return data
class EnumType(SchemaType, TypeDecorator): def __init__(self, enum, name): self.enum = enum self.name = name members = (member.value for member in enum) kwargs = {'name': name} self.impl = SAEnum(*members, **kwargs) def _set_table(self, table, column): self.impl._set_table(table, column) def copy(self): return EnumType(self.enum, self.name) def process_bind_param(self, enum_instance, dialect): if enum_instance is None: return None return enum_instance.value def process_result_value(self, value, dialect): if value is None: return None return self.enum(value)
class Job(Base): __tablename__ = 'jobs' job_id = Column(Integer(), primary_key=True) title = Column(String(255), nullable=False) company = Column(String(255)) region = Column(String(255), nullable=False) city = Column(String(255), nullable=False) country = Column(String(255), nullable=False) job_type = Column(Enum(JobType), nullable=False) description = Column(String(), nullable=False) requirements = Column(String(), nullable=False) posted_by = Column(String(100), nullable=False) poster_family_name = Column(String(100), nullable=False) poster_given_name = Column(String(100), nullable=False) can_contact = Column(Boolean(), nullable=False) people_contacted = Column(Integer(), default=0) job_status = Column(Enum(JobStatus), nullable=False) job_tags = Column(ARRAY(Enum(JobTags)), nullable=False) salary = Column(Integer()) times_viewed = Column(Integer(), default=0) deadline = Column(DateTime(), nullable=False) created_on = Column(DateTime(), default=datetime.now) updated_on = Column(DateTime(), default=datetime.now, onupdate=datetime.now) job_applications = relationship("JobApplication")
class Certificate(Base): __tablename__ = 'certificate' id = Column(Integer # The key identifier , primary_key=True) Type = Column(Enum( 'CA' # sub-CA certificate , 'Server' # Server certificate , 'User' # User certificate ) ) CommonName = Column(String) # Subject CN OrganizationalUnit = Column(String) # Subject OU Organization = Column(String) # Subject O Location = Column(String) # Subject L State = Column(String) # Subject S Country = Column(String) # Subject CO CSR = Column(String) # The certificate signing request PEM string Certificate = Column(String) # The signed certificate PEM string Status = Column(Enum( 'Waiting-For-Approval' # Certificate needs administrator approval , 'Waiting-For-Signature' # Certificate is ready to be signed , 'Waiting-For-Transmission' # Certificate is signed and is ready for transmission to the web interface , 'Valid' # Certificate is valid , 'Expired' # Certificate has expired , 'Revoked-Unspecified' # From here on, only revocation reasons follow , 'Revoked-KeyCompromise' , 'Revoked-CACompromise' , 'Revoked-AffiliationChanged' , 'Revoked-Superseded' , 'Revoked-CessationOfOperation' , 'Revoked-CertificateHold' ) )
class AccessRequest(Base): __tablename__ = u'access_requests' id = Column(UnicodeText, primary_key=True, default=make_uuid) timestamp = Column(DateTime, default=datetime.datetime.utcnow, nullable=False) user_id = Column(UnicodeText, nullable=False) message = Column(UnicodeText, nullable=False) role = Column( Enum('member', 'editor', 'admin', name='access_request_role_enum'), nullable=False, ) status = Column( Enum('requested', 'approved', 'rejected', name='access_request_status_enum'), default='requested', nullable=False, ) object_type = Column( Enum('package', 'organization', 'user', name='access_request_object_type_enum'), nullable=False, ) object_id = Column(UnicodeText, nullable=False) data = Column(MutableDict.as_mutable(JSONB), nullable=True) actioned_by = Column( UnicodeText, nullable=True) # user who approved or rejected the request
class Ranking(Base): __tablename__ = "ranking" id: int = Column(Integer, primary_key=True, autoincrement=True) institution_id: int = Column(Integer, ForeignKey("institution.id")) ranking_system: RankingSystemEnum = Column( Enum(RankingSystemEnum), nullable=False, index=True ) ranking_type: RankingTypeEnum = Column( Enum(RankingTypeEnum), nullable=False, index=True ) year: int = Column(Integer) field: str = Column(String(255), nullable=False) subject: str = Column(String(255), nullable=False) metric: MetricEnum = Column(Enum(MetricEnum), nullable=False, index=True) value: Decimal = Column(DECIMAL(13, 3)) value_type: ValueTypeEnum = Column(Enum(ValueTypeEnum), nullable=False) # Relationships institution: Institution = relationship( "Institution", back_populates="rankings" ) def __init__(self, **kwargs): kwargs = {k: v for k, v in kwargs.items() if k in self.__table__.c} super().__init__(**kwargs) def __repr__(self): return ( f"{self.ranking_system.name} ({self.year}) | " + f"{self.field} ({self.subject}) -> " + f"{self.metric.name}: {self.value}" )
class DeclarativeEnumType(SchemaType, TypeDecorator): """Column type usable in table column definitions.""" def __init__(self, enum, name=None): self.enum = enum enum_args = enum.__enum_args__.copy() if name is not None: enum_args['name'] = name elif 'name' not in enum_args: enum_args['name'] = 'ck_' + camelcase_to_underscore(enum.__name__) self.impl = Enum(*enum.values(), **enum_args) def _set_table(self, table, column): self.impl._set_table(table, column) def copy(self): return DeclarativeEnumType(self.enum) def process_bind_param(self, value, dialect): if value is None: # pragma: no cover return None return value.value def process_result_value(self, value, dialect): if value is None: # pragma: no cover return None return self.enum.from_string(value.strip())
class EnumType(SchemaType, TypeDecorator): def __init__(self, enum): self.enum = enum self.impl = SAEnum( *[sym.value for sym in enum], name="enum%s" % re.sub( '([A-Z])', lambda m: "_" + m.group(1).lower(), enum.__name__) ) def _set_table(self, table, column): self.impl._set_table(table, column) def copy(self): return EnumType(self.enum) def process_bind_param(self, value, dialect): if value is None: return None if isinstance(value, str): return value return value.value def process_result_value(self, value, dialect): if value is None: return None return self.enum(value.strip())
class EnumType(SchemaType, TypeDecorator): # pylint: disable=W0223 def __init__(self, enum, *args, **kwargs): self.enum = enum self.impl = SQLAEnum( *enum.values(), name="ck%s" % re.sub( "([A-Z])", lambda m: "_" + m.group(1).lower(), enum.__name__)) super(EnumType, self).__init__(*args, **kwargs) def _set_table(self, table, column): # pylint: disable=W0212 self.impl._set_table(table, column) def copy(self): return EnumType(self.enum) def process_bind_param(self, value, dialect): if value is None: return None return value.value def process_result_value(self, value, dialect): if value is None: return None return self.enum.from_string(value.strip())
class DeclEnumType(SchemaType, TypeDecorator): """ DeclEnumType supports object instantiation in two different ways: Passing in an enum: This is to be used in the application code. It will pull enum values straight from the DeclEnum object. A helper for this is available in DeclEnum.db_type() Passing in a tuple with enum values: In migrations the enum value list needs to be fix. It should not be pulled in from the application code, otherwise later modifications of enum values could result in those values being added in an earlier migration when re-running migrations from the beginning. Therefore DeclEnum(enum_values=('one', 'two'), enum_name='MyEnum') should be used. """ def __init__(self, enum=None, enum_values=None, enum_name=None): self.enum = enum self.enum_values = enum_values self.enum_name = enum_name if enum: self.enum_values=enum.values() self.enum_name=enum.__name__ self.impl = Enum( *self.enum_values, name="ck%s" % re.sub( '([A-Z])', lambda m: "_" + m.group(1).lower(), self.enum_name) ) def create(self, bind=None, checkfirst=False): """Issue CREATE ddl for this type, if applicable.""" super(DeclEnumType, self).create(bind, checkfirst) t = self.dialect_impl(bind.dialect) if t.impl.__class__ is not self.__class__ and isinstance(t, SchemaType): t.impl.create(bind=bind, checkfirst=checkfirst) def _set_table(self, table, column): self.impl._set_table(table, column) def copy(self): if self.enum: return DeclEnumType(self.enum) else: return DeclEnumType(enum_name=self.enum_name, enum_values=self.enum_values) def process_bind_param(self, value, dialect): if value is None: return None return value.value def process_result_value(self, value, dialect): if value is None: return None return self.enum.from_string(value.strip())
class Item(Base): __tablename__ = 'item' id = Column(Integer, primary_key=True) name = Column(String(64)) serial = Column(String(64), nullable=False, unique=True) model_id = Column(Integer, ForeignKey('model.id'), nullable=False) vendor_id = Column(Integer, ForeignKey('vendor.id'), nullable=False) installed_id = Column(Integer, ForeignKey('item.id')) installed_description = Column(String(32)) support = Column(Enum('None', 'on site', 'send back'), nullable=False) support_end = Column(Date, default=datetime.datetime.now) status = Column(Enum('in stock', 'in use', 'disposed'), nullable=False) location_id = Column(Integer, ForeignKey('location.id'), nullable=False) asset_number = Column(String(10)) settlement_number = Column(String(10)) delivery_date = Column(Date, default=datetime.datetime.now) description = Column(String(256)) updated_at = Column(Date, onupdate=datetime.datetime.now) #last_updated_by_id = Column(Integer, ForeignKey('user.id')) model = relationship('Model', back_populates='items') vendor = relationship('Vendor', back_populates='items') location = relationship('Location', back_populates='items') attachments = relationship('Item', backref=backref('parent', remote_side=[id]))
class DeclEnumType(SchemaType, TypeDecorator): def __init__(self, enum): self.enum = enum self.impl = Enum( *enum.values(), name="ck%s" % re.sub( '([A-Z])', lambda m: "_" + m.group(1).lower(), enum.__name__) ) def _set_table(self, table, column): self.impl._set_table(table, column) def copy(self): return DeclEnumType(self.enum) def process_bind_param(self, value, dialect): if value is None: return None return value.value def process_result_value(self, value, dialect): if value is None: return None return self.enum.from_string(value.strip())
class Requirement(MappedBase): """Representation of a system requirement. """ # mapped table __tablename__ = 'Requirements' # field mapping req_id = Column(String, primary_key=True) description = Column(String) parent_id = Column(String, ForeignKey('Requirements.req_id', ondelete='CASCADE', onupdate='CASCADE')) req_type = Column(Enum(*TYPE_LIST)) priority = Column(Enum(*PRIORITY_LIST)) source_id = Column(Integer, ForeignKey('Sources.source_id', onupdate='CASCADE', ondelete='SET NULL')) # relationships use_cases = relationship('UseCase', secondary=_uc_req, cascade='all', lazy='joined', join_depth=1) tests = relationship('SystemTest', secondary=_req_test, cascade='all', lazy='joined', join_depth=1) source = relationship('Source', lazy='joined', join_depth=1, uselist=False) def __init__(self, req_id, description, req_type, priority, source_id, parent_id): super(Requirement, self).__init__() self.req_id = req_id self.description = description self.req_type = req_type self.priority = priority self.source_id = source_id self.type = type self.parent_id = parent_id
class LayerV1(Layer): # Deprecated in v2 __tablename__ = "layerv1" __table_args__ = {"schema": _schema} __acl__ = [ (Allow, AUTHORIZED_ROLE, ALL_PERMISSIONS), ] __mapper_args__ = {"polymorphic_identity": "layerv1"} id = Column(Integer, ForeignKey(_schema + ".layer.id"), primary_key=True) layer = Column(Unicode) is_checked = Column(Boolean, default=True) # by default icon = Column(Unicode) # on the tree layer_type = Column( Enum("internal WMS", "external WMS", "WMTS", "no 2D", native_enum=False)) url = Column(Unicode) # for externals image_type = Column(Enum("image/jpeg", "image/png", native_enum=False)) # for WMS style = Column(Unicode) dimensions = Column(Unicode) # for WMTS matrix_set = Column(Unicode) # for WMTS wms_url = Column(Unicode) # for WMTS wms_layers = Column(Unicode) # for WMTS query_layers = Column(Unicode) # for WMTS kml = Column(Unicode) # for kml 3D is_single_tile = Column(Boolean) # for extenal WMS legend = Column(Boolean, default=True) # on the tree legend_image = Column(Unicode) # fixed legend image legend_rule = Column(Unicode) # on wms legend only one rule is_legend_expanded = Column(Boolean, default=False) min_resolution = Column(Float) # for all except internal WMS max_resolution = Column(Float) # for all except internal WMS disclaimer = Column(Unicode) # data attribute field in which application can find a human identifiable name or number identifier_attribute_field = Column(Unicode) time_mode = Column( Enum("disabled", "value", "range", native_enum=False), default="disabled", nullable=False, ) time_widget = Column( Enum("slider", "datepicker", native_enum=False), default="slider", nullable=True, ) def __init__(self, name="", public=True, icon="", layer_type="internal WMS"): Layer.__init__(self, name=name, public=public) self.layer = name self.icon = icon self.layer_type = layer_type
def __init__(self, enum, name): self.enum = enum self.name = name members = (member.value for member in enum) kwargs = {'name': name} self.impl = SAEnum(*members, **kwargs)
def downgrade(): enum_type = Enum(u'by', u'for', u'of', name='user_artwork_relationship_type') enum_type.create(bind=op.get_bind()) op.add_column('user_artwork', Column('relationship_type', enum_type, primary_key=True, nullable=False, server_default=op.inline_literal('by'))) op.execute('ALTER TABLE user_artwork DROP CONSTRAINT user_artwork_pkey') op.execute('ALTER TABLE user_artwork ADD PRIMARY KEY (user_id, artwork_id, relationship_type)') op.drop_index('ix_user_artwork_user_id') op.drop_index('ix_user_artwork_artwork_id')
def __init__(self, enum): self.enum = enum self.impl = SAEnum( *[sym.value for sym in enum], name="enum%s" % re.sub( '([A-Z])', lambda m: "_" + m.group(1).lower(), enum.__name__) )
def __init__(self, enum): self.enum = enum self.impl = Enum( *enum.values(), name="ck%s" % re.sub( '([A-Z])', lambda m:"_" + m.group(1).lower(), enum.__name__) )
def __init__(self, enum, **kwargs): super(DeclEnumType, self).__init__(**kwargs) self.enum = enum self.impl = Enum( *enum.values(), name="ck%s" % re.sub( '([A-Z])', lambda m:"_" + m.group(1).lower(), enum.__name__) )
def __init__(self, enum, name=None): self.enum = enum enum_args = enum.__enum_args__.copy() if name is not None: enum_args['name'] = name elif 'name' not in enum_args: enum_args['name'] = 'ck_' + camelcase_to_underscore(enum.__name__) self.impl = Enum(*enum.values(), **enum_args)
def __init__(self, enum, *args, **kwargs): self.enum = enum self.impl = SQLAEnum( *enum.values(), name="ck%s" % re.sub( "([A-Z])", lambda m: "_" + m.group(1).lower(), enum.__name__)) super(EnumType, self).__init__(*args, **kwargs)
class ASEnumType(SchemaType, TypeDecorator): def __init__(self, enum, regex = None): self.enum = enum self.impl = Enum( *enum.values(), name="ck%s" % re.sub( '([A-Z])', lambda m:"_" + m.group(1).lower(), enum.__name__) ) self.regex = regex def _set_table(self, table, column): self.impl._set_table(table, column) def copy(self): return ASEnumType(self.enum) def process_bind_param(self, value, dialect): if value is None: return None if self.__checkValue(value): return value.value return None def process_result_value(self, value, dialect): if value is None: return None if self.__checkValue(self.enum.from_string(value.strip())): return self.enum.from_string(value.strip()) return None def __checkValue(self, value): if self.regex is not None: if (re.match(self.regex, value)): return value if value in self.enum: return True return False;
class DeclEnumType(SchemaType, TypeDecorator): def __init__(self, enum): self.enum = enum self.impl = Enum( *enum.values(), name="ck%s" % re.sub( '([A-Z])', lambda m: "_" + m.group(1).lower(), enum.__name__) ) def _set_table(self, table, column): self.impl._set_table(table, column) def copy(self): return DeclEnumType(self.enum) def process_bind_param(self, value, dialect): if value is None: return None return value.value def process_result_value(self, value, dialect): if value is None: return None return self.enum.from_string(value.strip()) def create(self, bind=None, checkfirst=False): """Issue CREATE ddl for this type, if applicable.""" super(DeclEnumType, self).create(bind, checkfirst) t = self.dialect_impl(bind.dialect) if t.impl.__class__ is not self.__class__ and isinstance(t, SchemaType): t.impl.create(bind=bind, checkfirst=checkfirst) def drop(self, bind=None, checkfirst=False): """Issue DROP ddl for this type, if applicable.""" super(DeclEnumType, self).drop(bind, checkfirst) t = self.dialect_impl(bind.dialect) if t.impl.__class__ is not self.__class__ and isinstance(t, SchemaType): t.impl.drop(bind=bind, checkfirst=checkfirst)
class DeclEnumType(SchemaType, TypeDecorator): """DeclEnum augmented so that it can persist to the database.""" def __init__(self, enum): import re self.enum = enum self.impl = Enum(*enum.names(), name="ck%s" % re.sub( '([A-Z])', lambda m: '_' + m.group(1).lower(), enum.__name__)) def _set_table(self, table, column): self.impl._set_table(table, column) def copy(self, **kw): return DeclEnumType(self.enum) def process_bind_param(self, value, dialect): if isinstance(value, EnumSymbol): value = value.name return value def process_result_value(self, value, dialect): if value is not None: return getattr(self.enum, value.strip())
def __init__(self, enum=None, enum_values=None, enum_name=None): self.enum = enum self.enum_values = enum_values self.enum_name = enum_name if enum: self.enum_values=enum.values() self.enum_name=enum.__name__ self.impl = Enum( *self.enum_values, name="ck%s" % re.sub( '([A-Z])', lambda m: "_" + m.group(1).lower(), self.enum_name) )
def __init__(self, enum): self.enum = enum constraint = 'ck{0}'.format(re.sub('([A-Z])', lambda m: '_' + m.group(1).lower(), enum.__name__)) self.impl = Enum(*enum.values(), name=constraint)
def __init__(self, enum): self.enum = enum # convert CamelCase to underscore_separated name = re.sub('.([A-Z])', lambda m: '_' + m.group(1).lower(), enum.__name__).lower() self.impl = Enum(*enum.values(), name=name)
def __init__(self, enum): import re self.enum = enum self.impl = Enum(*enum.names(), name="ck%s" % re.sub( '([A-Z])', lambda m: '_' + m.group(1).lower(), enum.__name__))