class Truck(MySQLModel):
truck_id = pw.IntegerField(primary_key=True)
name = pw.FixedCharField()
description = pw.TextField()
logo = pw.CharField()
class SomeModel(pw.Model):
some_field = pw.FixedCharField(default='woot', max_length=4)
class Meta:
database = self.db
class Reading(BaseModel):
"""A reading of <temperature> from sensor <sensor>."""
timestamp = peewee.DateTimeField(default=datetime.datetime.now)
sensor = peewee.FixedCharField(max_length=15)
temperature = peewee.FloatField()
class fdfs_info(peewee.Model):
file_name = peewee.FixedCharField(max_length=255)
file_size = peewee.IntegerField()
file_md5 = peewee.CharField(default='', max_length=32)
file_crc32 = peewee.CharField(default='', max_length=8)
file_group = peewee.CharField(max_length=64)
file_local_path = peewee.CharField(max_length=255)
domain_id = peewee.IntegerField()
class Meta:
database = db
primary_key = CompositeKey('file_name', 'domain_id')
indexes = ((('domain_id', 'file_name'), True), ) #
def conn_finish(self):
if not db.is_closed():
db.close()
def fdfs_insert(self, in_dict):
"""
数据插入
:param in_dict: 插入的数据 dict
:return: 成功返回 true ,失败返回 false
"""
try:
iq = (fdfs_info
.insert(**in_dict))
iq.execute()
return True, None
except Exception as error:
return False, str(error)
finally:
self.conn_finish()
def fdfs_update(self, up_dict, file_name, domain_id):
"""
数据更新
:param up_dict: 需要更新的数据 dict
:param file_name: 文件名 str
:param domain_id: 域空间ID int
:return: 成功返回 true ,失败返回 false
"""
try:
uq = (fdfs_info
.update(**up_dict)
.where(fdfs_info.domain_id == domain_id, fdfs_info.file_name == file_name))
uq.execute()
return True, None
except Exception as error:
return False, str(error)
finally:
self.conn_finish()
def fdfs_delete(self, file_name, domain_id):
"""
数据删除
:param file_name: 文件名 str
:param domain: 域空间名 str
:return: 成功返回 true ,失败返回 false
"""
try:
d = (fdfs_info
.delete()
.where(fdfs_info.domain_id == domain_id, fdfs_info.file_name == file_name))
d.execute()
return True, None
except Exception as error:
return False, str(error)
finally:
self.conn_finish()
def fdfs_exist(self, file_name, domain_id):
"""
判断数据是否存在
:param file_name: 文件名 str
:param domain: 域空间名 str
:return:
0 数据存在
1 数据不存在
2 查询错误
"""
try:
query_data = fdfs_info.select(fdfs_info.file_group, fdfs_info.file_local_path).\
where(fdfs_info.domain_id == domain_id, fdfs_info.file_name == file_name)
if query_data:
return 0, query_data.dicts().get()
else:
return 1, None
except Exception as error:
return 2, str(error)
finally:
self.conn_finish()
def fdfs_file_info(self, file_name, domain_id):
"""
数据查询
:param file_name: 文件名 str
:param domain: 域空间名 str
:return:
0 查询成功
1 未查询到数据
2 查询错误
"""
try:
query_data = fdfs_info.select().where(fdfs_info.domain_id == domain_id, fdfs_info.file_name == file_name)
if query_data:
return 0, query_data.dicts().get()
else:
return 1, None
except Exception as error:
return 2, str(error)
finally:
self.conn_finish()
def fdfs_download(self, file_name, domain_id):
"""
获取下载地址
:param file_name: 文件名 str
:param domain: 域空间名 str
:return: 成功返回 true ,失败返回 false
"""
try:
query_data = fdfs_info.select(fdfs_info.file_group, fdfs_info.file_local_path).\
where(fdfs_info.domain_id == domain_id, fdfs_info.file_name == file_name)
if query_data:
query_info = query_data.dicts().get()
group_info = query_info.get('file_group', '')
group_local_info = query_info.get('file_local_path', '')
http_info = FDFS_DOMAIN.get(group_info, '')
redirect_http = "%s/%s/%s?filename=%s" % (http_info, group_info, group_local_info, file_name)
return True, redirect_http
else:
return False, None
except Exception as error:
return False, str(error)
finally:
self.conn_finish()
def fdfs_empty(self, domain_id):
"""
判断某个domain是否为空
:param domain_id:
:return:
0 domain为空
1 domain中有文件
2 查询错误
"""
try:
result = fdfs_info.select().where(fdfs_info.domain_id == domain_id).count()
if result == 0:
return 0, None
else:
return 1, None
except Exception as error:
return 2, str(error)
finally:
self.conn_finish()
def list_file(self, domain_id, limit):
"""
列出domain 文件列表
:param domain_id:
:param limit:
:return:
0 文件列表
1 domain没有文件
2 查询错误
"""
try:
result = []
query_data = fdfs_info.select(fdfs_info.file_name).where(fdfs_info.domain_id == domain_id).limit(limit)
if query_data:
for i in query_data.dicts():
result.append(i.get('file_name'))
return 0, result
else:
return 1, []
except Exception as error:
return 2, str(error)
finally:
self.conn_finish()
class Users(BaseModel):
id = peewee.IntegerField(index=True, primary_key=True)
name = peewee.CharField()
email = peewee.CharField(unique=True)
password = peewee.FixedCharField(max_length=30)
created_date = peewee.DateTimeField(default=datetime.now)
class Sensor(BaseModel):
"""Representation of a sensor."""
serial = peewee.FixedCharField(max_length=15)
name = peewee.CharField()
connected = peewee.BooleanField()
title = peewee.CharField(max_length=5)
speed = peewee.IntegerField()
@pytest.mark.parametrize('field,value,expected,expected_type', [
(peewee.IntegerField(), 5, 5, int),
(peewee.BigIntegerField(), 5, 5, int),
(peewee.SmallIntegerField(), 5, 5, int),
(peewee.AutoField(), 5, 5, int),
(peewee.BigAutoField(), 5, 5, int),
(peewee.IdentityField(), 5, 5, int),
(peewee.FloatField(), 5.5, 5.5, float),
(peewee.DoubleField(), 5.5, 5.5, float),
(peewee.DecimalField(), Decimal('13.37'), '13.37', str),
(peewee.CharField(), 'foo', 'foo', str),
(peewee.FixedCharField(), 'foo', 'foo', str),
(peewee.TextField(), 'foo', 'foo', str),
(peewee.BooleanField(), True, True, bool),
(peewee.DateTimeField(), datetime(2018, 11,
1), '2018-11-01T00:00:00', str),
(postgres_ext.HStoreField(), {
'foo': 'bar'
}, {
'foo': 'bar'
}, dict),
])
def test_field_is_correctly_serialized(field, value, expected, expected_type):
class TestModel(peewee.Model):
foo = field
class TestSerializer(PeeWeeModelSerializer):
class Tweet(BaseModel):
tweet_id = peewee.BigIntegerField(db_column=Column.Tweet.tweet_id)
created_at_str = peewee.FixedCharField(
db_column=Column.Tweet.created_at_str,
null=False,
)
created_at = peewee.DateTimeField(db_column=Column.Tweet.created_at,
null=False,
formats=["%Y/%m/%d %H:%M:%S"])
tweet_text = peewee.TextField(
db_column=Column.Tweet.tweet_text,
null=False,
)
truncated = peewee.BooleanField(
db_column=Column.Tweet.truncated,
null=False,
)
entities_hashtags = peewee.TextField(
db_column=Column.Tweet.entities_hashtags,
null=True,
)
entities_symbols = peewee.TextField(
db_column=Column.Tweet.entities_symbols,
null=True,
)
entities_user_mentions = peewee.TextField(
db_column=Column.Tweet.entities_user_mentions,
null=True,
)
entities_urls = peewee.TextField(
db_column=Column.Tweet.entities_urls,
null=True,
)
iso_language_code = peewee.FixedCharField(
db_column=Column.Tweet.iso_language_code,
null=False,
)
metadata_result_type = peewee.FixedCharField(
db_column=Column.Tweet.metadata_result_type,
null=False,
)
source = peewee.TextField(
db_column=Column.Tweet.source,
null=False,
)
user_id = peewee.BigIntegerField(
db_column=Column.Tweet.user_id,
null=False,
)
user_name = peewee.TextField(
db_column=Column.Tweet.user_name,
null=True,
)
user_screen_name = peewee.TextField(
db_column=Column.Tweet.user_screen_name,
null=True,
)
user_location = peewee.TextField(
db_column=Column.Tweet.user_location,
null=True,
)
user_description = peewee.TextField(
db_column=Column.Tweet.user_description,
null=True,
)
user_url = peewee.TextField(
db_column=Column.Tweet.user_url,
null=True,
)
user_protected = peewee.BooleanField(
db_column=Column.Tweet.user_protected,
null=False,
)
user_followers_count = peewee.IntegerField(
db_column=Column.Tweet.user_followers_count,
null=False,
)
user_friends_count = peewee.IntegerField(
db_column=Column.Tweet.user_friends_count,
null=False,
)
user_listed_count = peewee.IntegerField(
db_column=Column.Tweet.user_listed_count,
null=False,
)
user_created_at_str = peewee.FixedCharField(
db_column=Column.Tweet.user_created_at_str,
null=False,
)
user_created_at = peewee.DateTimeField(
db_column=Column.Tweet.user_created_at,
null=False,
formats=["%Y/%m/%d %H:%M:%S"])
user_favourites_count = peewee.IntegerField(
db_column=Column.Tweet.user_favourites_count,
null=False,
)
# deprecated
user_utc_offset = peewee.FixedCharField(
db_column=Column.Tweet.user_utc_offset,
null=True,
)
# deprecated
user_time_zone = peewee.FixedCharField(
db_column=Column.Tweet.user_time_zone,
null=True,
)
# deprecated
user_geo_enabled = peewee.FixedCharField(
db_column=Column.Tweet.user_geo_enabled,
null=True,
)
user_verified = peewee.BooleanField(
db_column=Column.Tweet.user_verified,
null=True,
)
user_statuses_count = peewee.IntegerField(
db_column=Column.Tweet.user_statuses_count,
null=True,
)
# deprecated
user_lang = peewee.FixedCharField(
db_column=Column.Tweet.user_lang,
null=True,
)
search_metadata_completed_in = peewee.DoubleField(
db_column=Column.Tweet.search_metadata_completed_in,
null=False,
)
search_metadata_max_id = peewee.BigIntegerField(
db_column=Column.Tweet.search_metadata_max_id,
null=False,
)
search_metadata_count = peewee.IntegerField(
db_column=Column.Tweet.search_metadata_count,
null=False,
)
search_metadata_since_id = peewee.BigIntegerField(
db_column=Column.Tweet.search_metadata_since_id,
null=False,
)
check = peewee.BooleanField(
db_column=Column.Tweet.check,
null=False,
)
nl_score = peewee.DoubleField(
db_column=Column.Tweet.nl_score,
null=True,
)
nl_magnitude = peewee.DoubleField(
db_column=Column.Tweet.nl_magnitude,
null=True,
)
nl_sentences_text_content = peewee.TextField(
db_column=Column.Tweet.nl_sentences_text_content,
null=True,
)
nl_sentences_sentiment_magnitude = peewee.DoubleField(
db_column=Column.Tweet.nl_sentences_sentiment_magnitude,
null=True,
)
nl_sentences_sentiment_score = peewee.DoubleField(
db_column=Column.Tweet.nl_sentences_sentiment_score,
null=True,
)
class FMIWeatherData(WeatherData):
source = pw.FixedCharField(max_length=4, default='FMI')
class EgainWeatherData(WeatherData):
source = pw.FixedCharField(max_length=4, default='EGSE')
class RDMWeatherData(WeatherData):
source = pw.FixedCharField(max_length=4, default='RDM')
class DWDWeatherData(WeatherData):
source = pw.FixedCharField(max_length=4, default='DWD')
class Device(BaseModel):
type = pw.ForeignKeyField(model=DeviceType, backref='devices')
identifier = pw.FixedCharField(max_length=44)
class Follower(peewee.Model):
# Required fields.
uid = peewee.CharField(primary_key=True)
state = peewee.FixedCharField(max_length=10)
# Optional.
weibo_count = peewee.IntegerField(null=True)
follower_count = peewee.IntegerField(null=True)
class Meta:
database = db
class State(object):
NEW = 'new' # Only has UID, no info populated.
FILLED = 'filled' # Info populated, but didn't go thorough analysis.
DELETED = 'deleted' # Already deleted.
# TODO: Not used for now.
CLEAR = 'clear' # Analyzed and decided to keep.
@classmethod
def save_uids(cls, uids):
# type: (list[str]) -> None
total_created, total_updated = 0, 0
try:
with db.atomic():
for uid in uids:
f, created = cls.create_or_get(uid=uid,
state=cls.State.NEW)
if created:
total_created += 1
else:
# Already have the data, but re-followed.
if f.weibo_count is not None:
# No need to re-fetch info.
f.state = cls.State.FILLED
else:
f.state = cls.State.NEW
f.save()
total_updated += 1
logging.info('Total created: %d, total updated: %d' %
(total_created, total_updated))
except Exception:
logging.exception('Failed to update db')
@classmethod
def save_follower_info(cls, info_list):
# type: (list[{uid, weibo_count, follower_count}]) -> None
total_created, total_updated = 0, 0
try:
with db.atomic():
for uid, weibo_count, follower_count in info_list:
f, created = cls.get_or_create(uid=uid)
if created:
total_created += 1
else:
total_updated += 1
f.state = cls.State.FILLED
f.weibo_count = weibo_count
f.follower_count = follower_count
f.save()
logging.info('Total created: %d, total updated: %d' %
(total_created, total_updated))
except Exception:
logging.exception('Failed to update db')
@classmethod
def get_unfilled_uids(cls):
rows = cls.select(cls.uid).where(cls.state == cls.State.NEW)
return [row.uid for row in rows]
@classmethod
def get_zombie_uids(cls, limit):
rows = cls.select(cls.uid).where(cls.state == cls.State.FILLED,
cls.weibo_count == 0,
cls.follower_count <= 1)
return [row.uid for row in rows.limit(limit)]
@classmethod
def confirm_uid_deleted(cls, uids):
# type: (list[str]) -> None
success, failure = 0, 0
try:
with db.atomic():
for uid in uids:
try:
row = cls.get(cls.uid == uid)
row.state = cls.State.DELETED
row.save()
success += 1
except cls.DoesNotExist:
failure += 1
continue
logging.info('Updated state to delete: %d, failed: %d' %
(success, failure))
except Exception:
logging.exception('Failed to update db')
class Branch(BaseModel):
code = peewee.FixedCharField(unique=True)
name = peewee.CharField()
class Products(BaseModel):
id_product = peewee.AutoField(primary_key=True, unique=True)
name_product_fr = peewee.CharField(150)
grade = peewee.FixedCharField(1)
store = peewee.CharField(150)
url = peewee.CharField(150)
class School(BaseModel):
''' Defines the School class and table '''
name = peewee.FixedCharField(max_length=128, null=False)
def __str__(self):
return "School: " + self.name + " (" + str(self.id) + ")"
class Tag(S.BgmIpViewer):
subject_id = pw.IntegerField(primary_key=True)
text = pw.FixedCharField(max_length=32)
count = pw.IntegerField()
class Nutriscore(Database):
nutriscores = peewee.FixedCharField(1, unique=True, null=False)
