class Guild(BaseModel): guild_id = BigIntegerField(primary_key=True) owner_id = BigIntegerField(null=False) prefix = TextField(default="+", null=False) dj_roles = ArrayField(BigIntegerField, null=True, index=False) mod_role = BigIntegerField(null=True) commands_disabled_channels = ArrayField(BigIntegerField, null=True, index=False) logs_enabled = BooleanField(default=True) log_channel = BigIntegerField(null=True) class Meta: db_table = 'guilds' @classmethod def get_settings(cls, guild_id): try: return Guild.get(guild_id=guild_id) except Guild.DoesNotExist: return @classmethod def using_id(cls, guild_id): return Guild.get(guild_id=guild_id)
class Group(BaseModel): DEFAULT_PERMISSIONS = [ 'create_dashboard', 'create_query', 'edit_dashboard', 'edit_query', 'view_query', 'view_source', 'execute_query' ] id = peewee.PrimaryKeyField() name = peewee.CharField(max_length=100) permissions = ArrayField(peewee.CharField, default=DEFAULT_PERMISSIONS) tables = ArrayField(peewee.CharField) created_at = DateTimeTZField(default=datetime.datetime.now) class Meta: db_table = 'groups' def to_dict(self): return { 'id': self.id, 'name': self.name, 'permissions': self.permissions, 'tables': self.tables, 'created_at': self.created_at } def __unicode__(self): return unicode(self.id)
class Recipe(Model): url = CharField() title = CharField() ingredients = ArrayField(CharField) instructions = ArrayField(TextField) avg_rating = FloatField(default=0) class Meta: database = DATABASE
class THN(peewee.Model): class Meta: database = database ordering = ("thn_id", ) table_name = "vulnerabilities_thn" id = peewee.PrimaryKeyField(null=False) index = peewee.TextField(default="") thn_id = peewee.TextField(default="") score = peewee.TextField(default="") sort = peewee.TextField(default="") lastseen = peewee.TextField(default="") object_type = peewee.TextField(default="") object_types = ArrayField(peewee.TextField, default=[]) description = peewee.TextField(default="") published = peewee.TextField(default="") reporter = peewee.TextField(default="") type = peewee.TextField(default="") title = peewee.TextField(default="") enchantments_score_vector = peewee.TextField(default="") enchantments_score_value = peewee.TextField(default="") bulletin_family = peewee.TextField(default="") cvelist = ArrayField(peewee.TextField, default=[]) modified = peewee.TextField(default="") href = peewee.TextField(default="") cvss_score = peewee.TextField(default="") cvss_vector = peewee.TextField(default="") def __unicode__(self): return "thn" def __str__(self): return str(self.thn_id) @property def to_json(self): return dict(id=self.id, index=self.index, thn_id=self.thn_id, score=self.score, lastseen=self.lastseen, object_type=self.object_type, object_types=self.object_types, description=self.description, published=self.published, reporter=self.reporter, type=self.type, title=self.title, enchantments_score_vector=self.enchantments_score_vector, enchantments_score_value=self.enchantments_score_value, bulletin_family=self.bulletin_family, cvelist=self.cvelist, modified=self.modified, href=self.href, cvss_score=self.cvss_score, cvss_vector=self.cvss_vector)
class Flux_surface(BaseModel): ids_properties = ForeignKeyField(Ids_properties, related_name='flux_surface') r_minor_norm = FloatField( help_text='Minor radius of the flux surface of interest') q = FloatField(help_text='Safety factor') magnetic_shear_r_minor = FloatField(help_text='Magnetic shear') pressure_gradient_norm = FloatField( help_text= 'Total pressure gradient (with respect to r_minor) used to characterise the local magnetic equilibrium' ) ip_sign = SmallIntegerField( help_text= 'Direction of the toroidal plasma current, positive when anticlockwise from above' ) b_field_tor_sign = SmallIntegerField( help_text= 'Direction of the toroidal magnetic field, positive when anticlockwise from above' ) # Original shape shape_coefficients_c = ArrayField( FloatField, help_text= 'Array containing the c_n coefficients parametrising the flux surface of interest. ' ) shape_coefficients_s = ArrayField( FloatField, help_text= 'Array containing the s_n coefficients parametrising the flux surface of interest. The first element is always zero.' ) dc_dr_minor_norm = ArrayField( FloatField, help_text= 'Radial derivative (with respect to r_minor) of the c_n coefficients') ds_dr_minor_norm = ArrayField( FloatField, help_text= 'Radial derivative (with respect to r_minor) of the s_n coefficients. The first element is always zero.' ) # Derived from original shape elongation = FloatField( null=True, help_text= 'Elongation of the flux surface of interest. Computed internally from the shape parameters (c_n,s_n)' ) triangularity_upper = FloatField( null=True, help_text= 'Upper triangularity of the flux surface of interest. Computed internally from the shape parameters (c_n,s_n)' ) triangularity_lower = FloatField( null=True, help_text= 'Lower triangularity of the flux surface of interest. Computed internally from the shape parameters (c_n,s_n)' )
class Member(CommonModel): id = IntegerField(index=True, unique=True) username = TextField(unique=True) name = TextField() email = TextField(null=True) enabled = BooleanField(default=True) badges = ArrayField(default=[]) groups = ArrayField(CharField, default=[]) bio = TextField(null=True) web = TextField(null=True) verified = BooleanField(default=False)
class Cadence(TargetdbBase): delta = ArrayField(field_class=FloatField, null=True) delta_max = ArrayField(field_class=FloatField, null=True) delta_min = ArrayField(field_class=FloatField, null=True) instrument_pk = ArrayField(field_class=IntegerField, null=True) label = TextField(null=False) nexposures = SmallIntegerField(null=True) pk = AutoField() skybrightness = ArrayField(field_class=FloatField, null=True) class Meta: table_name = 'cadence'
class Relayer(PwModel): owner = pw.CharField(max_length=200) name = pw.CharField(unique=True, max_length=200) coinbase = pw.CharField(unique=True, max_length=200) deposit = pw.IntegerField() trade_fee = pw.IntegerField(default=1) from_tokens = ArrayField(pw.CharField, default=[]) to_tokens = ArrayField(pw.CharField, default=[]) logo = pw.CharField(max_length=200, null=True) link = pw.CharField(max_length=255, null=True) resigning = pw.BooleanField(default=False) lock_time = pw.IntegerField(null=True)
class InstALModel(BaseModel): institutions = ArrayField(TextField, index=False) bridges = ArrayField(TextField, index=False) logic_programming = ArrayField(TextField, index=False) facts = ArrayField(TextField, index=False) @classmethod def get_marshelled_dict(cls, data): return cls.ModelSchema().load(data) @classmethod def new_from_form_data(cls, data) -> "InstALModel": marshelled = cls.get_marshelled_dict(data) di = marshelled.data new_model = cls(institutions=di.get("institutions", []), bridges=di.get("bridges", []), logic_programming=di.get("logic_programs", []), facts=di.get("facts", [])) new_model.save() return new_model class ModelSchema(schema.Schema): institutions = fields.List(fields.String(), required=True) bridges = fields.List(fields.String()) logic_programs = fields.List(fields.String()) facts = fields.List(fields.String()) @post_load def make_model(self, data): pass def to_dict(self): return model_to_dict(self, recurse=True) def to_json(self): return json.dumps(self.to_dict()) def get_inspect(self): ial_files = [StringIO(s) for s in self.institutions] bridge_files = [StringIO(s) for s in self.bridges] logic_programs = [StringIO(s) for s in self.logic_programming] inspect = instal.instalinspect.instal_inspect_files( ial_files=ial_files, bridge_files=bridge_files, lp_files=logic_programs, domain_files=[], query_file=[], fact_files=[]) return inspect
class User(ModelTimestampsMixin, BaseModel, UserMixin, PermissionsCheckMixin): DEFAULT_GROUPS = ['default'] id = peewee.PrimaryKeyField() name = peewee.CharField(max_length=320) email = peewee.CharField(max_length=320, index=True, unique=True) password_hash = peewee.CharField(max_length=128, null=True) groups = ArrayField(peewee.CharField, default=DEFAULT_GROUPS) class Meta: db_table = 'users' def to_dict(self): return { 'id': self.id, 'name': self.name, 'email': self.email, 'updated_at': self.updated_at, 'created_at': self.created_at } def __init__(self, *args, **kwargs): super(User, self).__init__(*args, **kwargs) self._allowed_tables = None @property def permissions(self): # TODO: this should be cached. return list( itertools.chain(*[ g.permissions for g in Group.select().where(Group.name << self.groups) ])) @property def allowed_tables(self): # TODO: cache this as weel if self._allowed_tables is None: self._allowed_tables = set([ t.lower() for t in itertools.chain(*[ g.tables for g in Group.select().where(Group.name << self.groups) ]) ]) return self._allowed_tables @classmethod def get_by_email(cls, email): return cls.get(cls.email == email) def __unicode__(self): return '%r, %r' % (self.name, self.email) def hash_password(self, password): self.password_hash = pwd_context.encrypt(password) def verify_password(self, password): return self.password_hash and pwd_context.verify( password, self.password_hash)
class PostModel(Model): """Model for posts.""" class Meta: """TODO document this.""" database = db table_name = POSTS_TABLE id = UUIDField(unique=True, null=False, column_name="id", primary_key=True) user_id = ForeignKeyField( UserModel, on_delete="CASCADE", on_update="CASCADE", column_name="user_id", ) image_id = ForeignKeyField( ImageModel, on_delete="CASCADE", on_update="CASCADE", column_name="image_id", null=True, ) content = CharField(null=True) create_time = TimestampField(default=None, resolution=0, utc=False) edited = BooleanField(null=False, default=False) edit_time = TimestampField(default=None, resolution=0, utc=False) visibility = CharField(null=False, default="public") likes = ArrayField(null=True, field_class=TextField)
class Video(BaseModel): id = CharField(max_length=32, unique=True, primary_key=True) etag = CharField(max_length=64) published = DateTimeField() # channel_id = CharField(max_length=32) title = CharField(max_length=128) thumbnails = JSONField(default={}) topic_details = JSONField(default={}) meta = JSONField(default={}) description = CharField(max_length=6000) ''' search_description=fn.to_tsvector(description)) ''' # search_description = TSVectorField() tags = ArrayField(CharField) category_id = IntegerField(default=0) duration = IntervalField() # timedelta caption = BooleanField(default=False) license_content = BooleanField(default=False) defintion = CharField(max_length=8) projection = CharField(max_length=15) dimension = CharField(max_length=3) localization = JSONField(default={}) channel = ForeignKeyField(Channel, backref='videos')
class Order(BaseModel): volunteer = peewee.ForeignKeyField(Volunteer, backref='volunteers') user = peewee.ForeignKeyField(Isolated, backref='isolated') address = peewee.CharField(null=False, index=True) order = ArrayField(peewee.CharField, index=False) status = peewee.CharField(null=False, index=False) updated = peewee.DateTimeField(default=datetime.utcnow, index=True)
class CAPEC(peewee.Model): class Meta: database = database ordering = ("capec_id", ) table_name = "capec" id = peewee.PrimaryKeyField(null=False, ) capec_id = peewee.TextField(default="", ) name = peewee.TextField(default="", ) summary = peewee.TextField(default="", ) prerequisites = peewee.TextField(default="", ) solutions = peewee.TextField(default="", ) related_weakness = ArrayField(peewee.TextField, default=[], verbose_name='related_weakness') def __unicode__(self): return "capec" def __str__(self): return self.capec_id @property def to_json(self): return dict(id=self.id, capec_id=self.capec_id, name=self.name, summary=self.summary, prerequisites=self.prerequisites, solutions=self.solutions, related_weakness=self.related_weakness)
class CPE_VULNERS(peewee.Model): class Meta: database = database table_name = "cpe_vulners" id = peewee.PrimaryKeyField(null=False) item = peewee.TextField(default="", verbose_name="CPE ID") title = peewee.TextField(default="", verbose_name="CPE Title") refs = ArrayField(peewee.TextField, default=[], verbose_name="CPE references array") cpe22 = peewee.TextField(default="", verbose_name="CPE 2.2 Metrics") cpe23 = peewee.TextField(default="", verbose_name="CPE 2.3 Metrics") def __unicode__(self): return "CPE" def __str__(self): return self.item @property def data(self): cpe_data = {} cpe_data["id"] = self.id cpe_data["item"] = self.item cpe_data["title"] = self.title cpe_data["references"] = self.refs cpe_data["cpe22"] = self.cpe22 cpe_data["cpe23"] = self.cpe23 return cpe_data
class Image(BaseModel): feed_id = CharField(unique=True) images = ArrayField(TextField) class Meta: db_table = 'images' order_by = ('feed_id', )
class Citation(BaseModel): text = ForeignKeyField(Text) document = ForeignKeyField(Document) tokens = ArrayField(CharField) class Meta: database = config.get_table_db('citation') indexes = ((('document', 'text'), True), ) @property def subfield(self): """ Get the document's subfield, if any. Returns: Subfield """ return (Subfield.select().join(Subfield_Document).join(Document).where( Document.id == self.document).order_by( Subfield_Document.offset.asc()).first()) @property def institution(self): """ Get the document's institution, if any. Returns: Institution """ return (Institution.select().join(Institution_Document).join( Document).where(Document.id == self.document).first())
class Dataset(BaseModel): """ORM model of the Dataset table""" project = pw.ForeignKeyField(Project, on_delete='CASCADE', related_name='datasets') name = pw.CharField() created = pw.DateTimeField(default=datetime.datetime.now) meta_features = ArrayField(pw.CharField) @staticmethod def add(name, project, file_uris=[], meta_features=[]): with db.atomic(): d = Dataset.create(name=name, project=project, meta_features=meta_features) files, created = zip(*( File.create_or_get(uri=uri) for uri in file_uris) ) for f in files: DatasetFile.create(dataset=d, file=f) return d @property def uris(self): query = File.select().join(DatasetFile).join(Dataset).where(Dataset.id == self.id) return [f.uri for f in query] def is_owned_by(self, username): return self.project.is_owned_by(username) def display_info(self): info = self.__dict__() info['files'] = [os.path.basename(uri).split('.nc')[0] for uri in self.uris] return info
class User(BaseModel, UserMixin): DEFAULT_PERMISSIONS = ['create_dashboard', 'create_query', 'edit_dashboard', 'edit_query', 'view_query', 'view_source', 'execute_query'] id = peewee.PrimaryKeyField() name = peewee.CharField(max_length=320) email = peewee.CharField(max_length=320, index=True, unique=True) password_hash = peewee.CharField(max_length=128, null=True) is_admin = peewee.BooleanField(default=False) permissions = ArrayField(peewee.CharField, default=DEFAULT_PERMISSIONS) class Meta: db_table = 'users' def to_dict(self): return { 'id': self.id, 'name': self.name, 'email': self.email, 'is_admin': self.is_admin } def __unicode__(self): return '%r, %r' % (self.name, self.email) def hash_password(self, password): self.password_hash = pwd_context.encrypt(password) def verify_password(self, password): return self.password_hash and pwd_context.verify(password, self.password_hash)
class Link(BaseModel): feed_id = CharField(unique=True) links = ArrayField(TextField) class Meta: db_table = 'links' order_by = ('feed_id', )
class Event(Model): id: int = PrimaryKeyField() received: datetime = DateTimeField(default=fn.now) received_from: Server = ForeignKeyField(Server, null=True, on_update='cascade') """ Server that we got this Event from. In general, this has nothing to do with which server produced the event originally. """ server: str = TextField() """Name of the server on which the post affected by this event is published.""" authors: List[str] = ArrayField(TextField) """Name of the user who should be the «owner» of the post.""" parent: str = TextField(null=True) """Full identifier of parent post.""" path: str = TextField(null=True) """ Identification of the post affected by this event. This is the same path as in :data:`Post.path`. """ diff: Dict[str, Any] = BinaryJSONField( default={}, constraints=[Check("jsonb_typeof(diff) = 'object'")]) """Changes which should be applied to the post.""" signatures: Dict[str, str] = BinaryJSONField( default={}, constraints=[Check("jsonb_typeof(signatures) = 'object'")]) """
class Quickred(OperationsDBModel): bscale = FloatField(null=True) bzero = FloatField(null=True) data = ArrayField(field_class=IntegerField, null=True) dither_pixpos = DecimalField(null=True) exposure_pk = IntegerField(index=True, null=True) last_quicklook_pk = IntegerField(index=True) logsnr_hmag_coef = UnknownField(null=True) # ARRAY pk = IntegerField( constraints=[SQL('DEFAULT nextval(\'quickred_pk_seq\'::regclass)')], primary_key=True, unique=True) snr_goals_version = IntegerField(null=True) snr_standard = DecimalField(null=True) zscale1 = DecimalField(null=True) zscale2 = DecimalField(null=True) exposure = ForeignKeyField(column_name='exposure_pk', model=platedb.Exposure, backref='apogeeqldb_quickreds', field='pk') last_quicklook = ForeignKeyField(column_name='last_quicklook_pk', model=Quicklook, backref='quickreds', field='pk') class Meta: table_name = 'quickred' schema = 'apogeeqldb' primary_key = False
class Games(BaseModel): Types = GamesTypes guild_id = BigIntegerField(null=False) game_channel = BigIntegerField(null=True, default=None) players = ArrayField(BigIntegerField, null=True, index=False) type_ = IntegerField(db_column='type') turn_count = IntegerField(null=True, default=0) ended = BooleanField(default=False) winner = BigIntegerField(null=True) cards_played = IntegerField(default=0) cards_drawn = IntegerField(default=0) phrase = TextField(null=True) guesses_correct = IntegerField(default=0) guesses_incorrect = IntegerField(default=0) questions_answered = IntegerField(default=0) trivia_category = TextField(null=True) class Meta: db_table = 'games' @classmethod def with_id(cls, game_id): return Games.get(id=game_id) @classmethod def start(cls, event, game_channel, players, game_type): return cls.create( guild_id = event.guild.id, game_channel = game_channel, players = [x.id for x in players], type_= game_type, )
class PostgresStorage(BaseModel, PrintStorage): """Storage container for Postgresql database.""" date = DateTimeTZField() url = TextField(null=True) scheme = TextField(null=True) host = TextField(null=True) path = TextField(null=True) method = CharField(null=True) referrer = TextField(null=True) remote_addr = TextField(null=True) real_ip = CharField(null=True) forwarded_proto = CharField(null=True) connecting_ip = CharField(null=True) ip_country = CharField(null=True) visitor = TextField(null=True) status = IntegerField(null=True) args = PickleField(null=True) user_agent = PickleField(null=True) access_route = ArrayField(CharField, null=True) headers = PickleField(null=True) cookies = PickleField(null=True) speed = FloatField(null=True) class Meta: table_name = 'tracking'
class GuildEmoji(BaseModel): emoji_id = BigIntegerField(primary_key=True) guild_id = BigIntegerField() name = CharField(index=True) require_colons = BooleanField() managed = BooleanField() roles = ArrayField(BigIntegerField, default=[], null=True) deleted = BooleanField(default=False) class Meta: db_table = 'guild_emojis' @classmethod def from_disco_guild_emoji(cls, emoji, guild_id=None): try: ge = cls.get(emoji_id=emoji.id) new = False except cls.DoesNotExist: ge = cls(emoji_id=emoji.id) new = True ge.guild_id = guild_id or emoji.guild_id ge.name = emoji.name ge.require_colons = emoji.require_colons ge.managed = emoji.managed ge.roles = emoji.roles ge.save(force_insert=new) return ge
class Combinations(BaseModel): user = ForeignKeyField(Users, backref='combinations') name = CharField() items = ArrayField() info = JSONField(null=True) is_private = BooleanField(default=False) is_buyable = BooleanField(default=False)
class Object(pw.Model): array_field = ArrayField() binary_json_field = BinaryJSONField() dattime_tz_field = DateTimeTZField() hstore_field = HStoreField() interval_field = IntervalField() json_field = JSONField() ts_vector_field = TSVectorField()
class Heading(peewee.Model): line = peewee.CharField() way = peewee.IntegerField() stops = ArrayField(field_class=peewee.BooleanField) timestamp = peewee.DateTimeField() class Meta: database = db
class ImageVectorBaseModel(Model): id = AutoField() url = TextField(unique=True) vector = ArrayField(DoubleField) class Meta: database = db table_function = get_table_name
class Notification(BaseModel): id = BlobField(primary_key=True) sender_ids = ArrayField(BlobField) receiver_id = BlobField(index=True) type = IntegerField(index=True) time = MyTimestampField(index=True) # 发布时间 data = BinaryJSONField(dumps=json_ex_dumps) is_read = BooleanField(default=False) @classmethod def count(cls, user_id): return cls.select().where(cls.receiver_id == user_id, cls.is_read == False).count() @classmethod def set_read(cls, user_id): cur = db.execute_sql( ''' WITH updated_rows as ( UPDATE notif SET is_read = TRUE WHERE "receiver_id" = %s AND "is_read" = FALSE RETURNING is_read ) SELECT count(is_read) FROM updated_rows; ''', (user_id, )) return cur.fetchone()[0] @classmethod def refresh(cls, user_id, cooldown=config.NOTIF_FETCH_COOLDOWN): new = [] r: UserNotifRecord = UserNotifRecord.get_by_pk(user_id) if not r: return if cooldown and (time.time() - r.update_time < cooldown): return for i in r.get_notifications(True): if i['type'] == NOTIF_TYPE.BE_COMMENTED: new.append({ 'id': config.LONG_ID_GENERATOR().to_bin(), 'sender_ids': (i['comment']['user']['id'], ), 'receiver_id': user_id, 'type': NOTIF_TYPE.BE_COMMENTED, 'time': i['time'], 'data': i, }) elif i['type'] == NOTIF_TYPE.BE_REPLIED: new.append({ 'id': config.LONG_ID_GENERATOR().to_bin(), 'sender_ids': (i['comment']['user']['id'], ), 'receiver_id': user_id, 'type': NOTIF_TYPE.BE_REPLIED, 'time': i['time'], 'data': i, }) if new: cls.insert_many(new).execute() return len(new) class Meta: db_table = 'notif'