class Post(MongoModel):
reddit_post_id = fields.CharField(required=True, primary_key=True)
subreddit = fields.CharField()
artist = fields.CharField()
album = fields.CharField()
album_type = fields.CharField()
total_tracks = fields.IntegerField()
spotify_album_uri = fields.CharField()
track = fields.CharField()
track_num = fields.IntegerField()
spotify_track_uri = fields.CharField()
created_utc = fields.DateTimeField()
upvotes = fields.IntegerField()
exists_in_playlist = fields.BooleanField(default=False)
parsed_artist = fields.CharField()
parsed_title = fields.CharField()
class Meta:
connection_alias = "FreshTracks"
collection_name = "post"
# Ensure that only one track per same album can exist in each subreddit
# playlist
indexes = [
IndexModel(keys=[("spotify_album_uri", pymongo.ASCENDING),
("subreddit", pymongo.ASCENDING)],
unique=True)
]
class User(MongoModel):
username = fields.CharField(primary_key=True)
hist_times = fields.IntegerField()
contrast_times = fields.IntegerField()
log_times = fields.IntegerField()
reverse_times = fields.IntegerField()
upload_time = fields.ListField(field=fields.DateTimeField())
hist_time = fields.ListField(field=fields.DateTimeField())
contrast_time = fields.ListField(field=fields.DateTimeField())
log_time = fields.ListField(field=fields.DateTimeField())
reverse_time = fields.ListField(field=fields.DateTimeField())
image_original = fields.ListField(field=fields.CharField())
image_hist = fields.ListField(field=fields.CharField())
image_contrast = fields.ListField(field=fields.CharField())
image_log = fields.ListField(field=fields.CharField())
image_reverse = fields.ListField(field=fields.CharField())
def vals(self):
"""
Returns dictionary of attributes for object
:return: dictionary of attributes
:rtype: dict
"""
vals = {
"username": self.username,
"user_upload_image": self.image_original,
"hist_times": self.hist_times,
"contrast_times": self.contrast_times,
"log_times": self.log_times,
"reverse_times": self.reverse_times,
"upload_time": self.upload_time
}
return vals
class User(MongoModel):
patient_id = fields.IntegerField(primary_key=True)
attending_email = fields.EmailField
age = fields.IntegerField()
heart_rate = fields.ListField
timestamps = fields.ListField
tach = fields.BooleanField
class test_User(MongoModel):
patient_id = fields.IntegerField(primary_key=True)
attending_email = fields.EmailField()
user_age = fields.FloatField()
time_stamp = fields.DateTimeField()
heart_rate = fields.ListField(field=fields.IntegerField())
time_stamp = fields.ListField(field=fields.DateTimeField())
class StrategyPosition(MongoModel):
""" 策略仓位信息 """
identifier = fields.IntegerField(primary_key=True)
# 策略的 ID
strategy_id = fields.IntegerField()
# 策略仓位信息
strategy_info = fields.DictField(default=None)
# 更新时间
update_date = fields.DateTimeField()
class Meta:
connection_alias = DB_POSITION
collection_name = CN_STRATEGY_POS
@classmethod
def position_with(cls, strategy_id):
"""获取仓位信息、无则创建 """
try:
obj = cls.objects.raw({'strategy_id': strategy_id}).first()
obj.update_date = datetime.now()
return obj
except Exception as e:
print(e)
position = cls(identifier=Sequence.fetch_next_id(CN_STRATEGY_POS),
strategy_id=strategy_id)
position.update_date = datetime.now()
position.save()
return position
class UserDetails(MongoModel):
'''Model to maintain user details.
Attributes:
createdOn: Datetime object
updatedOn: Datetime object
'''
createdOn = fields.DateTimeField(required=True, default=lambda: datetime.now())
updatedOn = fields.DateTimeField(required=True, default=lambda: datetime.now())
email = fields.EmailField(required=True, primary_key=False)
pincode = fields.CharField(required=False, blank=True)
district = fields.CharField(required=False, blank=True)
active = fields.BooleanField(required=True, default=False)
alertCount = fields.IntegerField(required=True, default=0)
age = fields.IntegerField(required=True)
objects = UserDetailsManager()
class Meta:
collection_name = 'UserDetails'
indexes = [
IndexModel(
[
('pincode', DESCENDING),
('district', DESCENDING)
],
background=True
)
]
final = True
class Parameters(EmbeddedMongoModel):
n_estimators = fields.IntegerField(required=True, default=100)
n_estimators.description = 'Number of boosted trees to fit.'
boosting_type = fields.CharField(
verbose_name="Boosting type",
required=True,
default='gbdt',
choices=[
('gbdt', 'traditional Gradient Boosting Decision Tree'),
('dart', 'Dropouts meet Multiple Additive Regression Trees'),
('goss', 'Gradient-based One-Side Sampling'),
('rf', 'Random Forest'),
])
boosting_type.description = 'Boosting type.'
max_depth = fields.IntegerField(required=True, default=-1)
max_depth.description = 'The maximum depth of the tree. -1 is unlimited.'
num_leaves = fields.IntegerField(required=True, default=31)
num_leaves.description = 'Maximum tree leaves for base learners.'
learning_rate = fields.FloatField(required=True, default=0.1)
learning_rate.description = 'Boosting learning rate.'
random_state = fields.IntegerField(required=True, default=42)
random_state.description = 'Enter an integer for a random seed.'
class MDBPermutationResults(EmbeddedMongoModel):
class Meta:
final = True
n_perms = fields.IntegerField(blank=True)
random_state = fields.IntegerField(blank=True)
metrics = fields.EmbeddedDocumentListField(MDBPermutationMetrics, blank=True)
class Round(MongoModel):
number = fields.IntegerField(primary_key=True)
round_id = fields.CharField()
tasks_to_allocate = fields.ListField(blank=True)
time_to_allocate = fields.FloatField()
allocated_task = fields.UUIDField()
n_received_bids = fields.IntegerField()
n_received_no_bids = fields.IntegerField()
objects = RoundManager()
class Meta:
ignore_unknown_fields = True
@classmethod
def create_new(cls, **kwargs):
kwargs.update(number=cls.get_number())
round_ = cls(**kwargs)
round_.save()
return round_
@classmethod
def get_number(cls):
numbers = [round_.number for round_ in cls.objects.all()]
if numbers:
previous_number = numbers.pop()
number = previous_number + 1
else:
number = 1
return number
class VodBasedStream(EmbeddedMongoModel):
MAX_DATE = datetime(2100, 1, 1)
MIN_DATE = datetime(1970, 1, 1)
DEFAULT_COUNTRY = 'Unknown'
def __init__(self, *args, **kwargs):
super(VodBasedStream, self).__init__(*args, **kwargs)
vod_type = fields.IntegerField(default=constants.VodType.VODS,
required=True)
description = fields.CharField(
default=constants.DEFAULT_VOD_DESCRIPTION,
min_length=constants.MIN_STREAM_DESCRIPTION_LENGTH,
max_length=constants.MAX_STREAM_DESCRIPTION_LENGTH,
required=True)
trailer_url = fields.CharField(default=constants.INVALID_TRAILER_URL,
max_length=constants.MAX_URL_LENGTH,
min_length=constants.MIN_URL_LENGTH,
required=True)
user_score = fields.FloatField(default=0,
min_value=0,
max_value=100,
required=True)
prime_date = fields.DateTimeField(default=MIN_DATE, required=True)
country = fields.CharField(default=DEFAULT_COUNTRY, required=True)
duration = fields.IntegerField(default=0,
min_value=0,
max_value=constants.MAX_VIDEO_DURATION_MSEC,
required=True)
class WC_Game(MongoModel):
year = fields.IntegerField()
home_team = fields.CharField()
home_team_score = fields.IntegerField()
away_team = fields.CharField()
away_team_score = fields.IntegerField()
winner = fields.CharField()
class Emergency(MongoModel):
etype = fields.CharField()
location = fields.ListField(fields.CharField())
num_victims = fields.IntegerField(min_value=0)
num_aggressors = fields.IntegerField(min_value=0)
pers_involved = fields.ListField(fields.ReferenceField(Person))
is_active = fields.BooleanField(default=True)
class UserMetrics(MongoModel):
username = fields.ReferenceField(LogIn, primary_key=True)
total_uploads = fields.IntegerField(min_value=0)
total_hist_equal = fields.IntegerField(min_value=0)
total_contrast_stretch = fields.IntegerField(min_value=0)
total_log_comp = fields.IntegerField(min_value=0)
total_inv_img = fields.IntegerField(min_value=0)
class Comp(MongoModel):
name = fields.CharField(required=True)
description = fields.CharField()
created_at = fields.DateTimeField(required=True)
deadline = fields.DateTimeField()
merger_deadline = fields.DateTimeField()
url = fields.URLField()
team_name = fields.CharField(required=False)
team_members = fields.ListField(fields.CharField())
max_team_size = fields.IntegerField()
max_daily_subs = fields.IntegerField()
subs_today = fields.IntegerField(default=0)
finished_on = fields.DateTimeField()
def status(self):
members = ",".join(self.team_members)
deadline = self.deadline if self.deadline > datetime.datetime.now(
) else "Passed"
merger_deadline = self.merger_deadline if self.merger_deadline > datetime.datetime.now(
) else "Passed"
status = (
f":triangular_flag_on_post:**\t{self.name}**\n***{self.description}.***\n**Merger Deadline:**\t{merger_deadline}"
+
f"\n**Deadline:**\t{deadline}\n**Team Name:**\t{self.team_name}\n:busts_in_silhouette:\t{members}\n"
+ f"**Team Size:**\t{self.max_team_size}\n:link:\t{self.url}")
return status
class CCXTConfiguration(MongoModel):
"""CCXT 配置"""
identifier = fields.IntegerField(primary_key=True)
app_key = fields.CharField(min_length=3)
app_secret = fields.CharField(min_length=3)
app_pw = fields.CharField(min_length=0)
e_type = fields.IntegerField(mongo_name='type')
desc = fields.CharField()
class Meta:
collection_name = CN_CCXT_CONFIG
connection_alias = DB_CONFIG
@classmethod
def configuration_with(cls, type: CCXTExchangeType, desc=None):
try:
ccxt_config = list(
cls.objects.raw({
'type': type.value,
'desc': desc
}).order_by([('identifier', 1)]).limit(1))[0]
return ccxt_config
except Exception as e:
print(str(e))
return None
@classmethod
def configuration_with_id(cls, cfg_id):
return cls.objects.get({'_id': cfg_id})
class Transaction(MongoModel):
# Номер транзакции
# В общем случе не уникален, так как это "код транзакции в другой системе"
transaction_id = fields.CharField(required=True)
# Номер бонусной карты того, кто летел
card_number = fields.IntegerField(required=True)
# Сколько начислено бонусных единиц (миль)
miles = fields.IntegerField(required=True)
# Дата полёта (храним и возвращаем в UTC)
date_flight = fields.DateTimeField(required=True)
# Откуда
from_flight = fields.CharField(required=True)
# Куда
to_flight = fields.CharField(required=True)
objects = TransactionManager()
class Meta:
# Для скорейшей выборки данных настраиваем индексы
indexes = [
IndexModel([('card_number', DESCENDING),
('date_flight', DESCENDING)]),
]
# Для снижения нагрузки на PRIMARY ноду читаем из SECONDARY
read_preference = ReadPreference.SECONDARY
class EncodeStream(HardwareStream):
def __init__(self, *args, **kwargs):
super(EncodeStream, self).__init__(*args, **kwargs)
relay_video = fields.BooleanField(default=constants.DEFAULT_RELAY_VIDEO,
required=True)
relay_audio = fields.BooleanField(default=constants.DEFAULT_RELAY_AUDIO,
required=True)
deinterlace = fields.BooleanField(default=constants.DEFAULT_DEINTERLACE,
required=True)
frame_rate = fields.IntegerField(default=constants.INVALID_FRAME_RATE,
required=True)
volume = fields.FloatField(default=constants.DEFAULT_VOLUME, required=True)
video_codec = fields.CharField(default=constants.DEFAULT_VIDEO_CODEC,
required=True)
audio_codec = fields.CharField(default=constants.DEFAULT_AUDIO_CODEC,
required=True)
audio_channels_count = fields.IntegerField(
default=constants.INVALID_AUDIO_CHANNELS_COUNT, required=True)
size = fields.EmbeddedDocumentField(Size, default=Size())
video_bit_rate = fields.IntegerField(
default=constants.INVALID_VIDEO_BIT_RATE, required=True)
audio_bit_rate = fields.IntegerField(
default=constants.INVALID_AUDIO_BIT_RATE, required=True)
logo = fields.EmbeddedDocumentField(Logo, default=Logo())
rsvg_logo = fields.EmbeddedDocumentField(RSVGLogo, default=RSVGLogo())
aspect_ratio = fields.EmbeddedDocumentField(Rational, default=Rational())
def get_type(self) -> constants.StreamType:
return constants.StreamType.ENCODE
def get_relay_video(self):
return self.relay_video
def get_relay_audio(self):
return self.relay_audio
def get_deinterlace(self):
return self.deinterlace
def get_frame_rate(self):
return self.frame_rate
def get_volume(self):
return self.volume
def get_video_codec(self):
return self.video_codec
def get_audio_codec(self):
return self.audio_codec
def get_audio_channels_count(self):
return self.audio_channels_count
def get_video_bit_rate(self):
return self.video_bit_rate
def get_audio_bit_rate(self):
return self.audio_bit_rate
class ImageDB(MongoModel):
"""
This class initializes the stored data fields for the image processor
MongoDB database.
Attributes:
patient_id (str): unique patient number.
original (list): associated original image for each upload
histogram_count (int): number of times histogram
equalization was conducted.
contrast_count (int): number of times contrast stretching
was conducted.
log_count (int): number of times log compression
was conducted.
reverse_count (int): number of times reverse video
was conducted.
images (list): list of original image and processed images.
processor (list): list of completed processor actions.
images_time_stamp (list): list of timestamps of completed
processor actions.
notes (list): extraneous notes provided by user.
"""
patient_id = fields.CharField(primary_key=True)
original = fields.ListField()
histogram_count = fields.IntegerField()
contrast_count = fields.IntegerField()
log_count = fields.IntegerField()
reverse_count = fields.IntegerField()
images = fields.ListField()
processor = fields.ListField()
images_time_stamp = fields.ListField()
notes = fields.ListField()
class MongoQueryIndexDocument(IterAssitant):
"""
process files from patentsview
"""
# summary is the same for the same query task
# all values should be str in summary of MongoQueryIndexDocument
summary = fields.DictField(default=None, required=True, blank=False)
# iter_index should in [boundary_lower, boundary_upper)
start_index = fields.IntegerField(default=0, required=True, blank=False)
boundary_lower = fields.IntegerField(default=0, required=True, blank=False)
boundary_upper = fields.IntegerField(default=0, required=True, blank=False)
max_num = fields.IntegerField(default=0, required=True, blank=False)
error_indices = fields.ListField(default=[], blank=True)
class Meta:
# https://pymodm.readthedocs.io/en/stable/api/index.html#metadata-attributes
collection_name = 'mongo_query_iter_index'
indexes = IterAssitant.Meta.indexes
ignore_unknown_fields = True
final=True
def clean(self):
# Custom validation that requires looking at several fields.
for v in self.summary.values():
if not isinstance(v, str):
raise pymodm.errors.ValidationError(
'Value in MongoQueryIndexDocument.summary should be str '
'instead of {}!'.format(type(v))
)
class User(MongoModel):
email = fields.EmailField(
primary_key=True
) # because primary_key is True, we will need to query this field using the label _id
age = fields.IntegerField()
heart_rate = fields.ListField(field=fields.IntegerField())
heart_rate_times = fields.ListField(field=fields.DateTimeField())
class Patient(MongoModel):
patient_id = fields.IntegerField(primary_key=True)
attending_email = fields.EmailField()
age = fields.IntegerField()
new_heart_rate = fields.IntegerField()
new_timestamp = fields.DateTimeField()
heart_rates = fields.ListField()
timestamps = fields.ListField()
class Patient(MongoModel):
patient_id = fields.IntegerField(primary_key=True)
attending_email = fields.EmailField()
user_age = fields.IntegerField()
heart_rate_data = fields.ListField()
REQUIRED_REQUEST_KEYS = ["user_id", "attending_email", "user_age"]
class TrialErrors(pymodm.EmbeddedMongoModel):
frame_errors = ReferenceListField(FrameError, required=True, blank=True)
frames_lost = fields.ListField(fields.IntegerField(), blank=True)
frames_found = fields.ListField(fields.IntegerField(), blank=True)
times_lost = fields.ListField(fields.FloatField(), blank=True)
times_found = fields.ListField(fields.FloatField(), blank=True)
distances_lost = fields.ListField(fields.FloatField(), blank=True)
distances_found = fields.ListField(fields.FloatField(), blank=True)
class Experiment(MongoModel):
experimentId = fields.CharField(primary_key=True)
userId = fields.ReferenceField('User')
config = fields.CharField()
totalCounts = fields.IntegerField()
pendingCounts = fields.IntegerField()
priorityClient = fields.CharField(default='')
priority = fields.IntegerField()
class User(MongoModel):
"""
Model for user recording
"""
email = fields.EmailField(primary_key=True)
age = fields.IntegerField()
heart_rate = fields.ListField(field=fields.IntegerField())
heart_rate_times = fields.ListField(field=fields.DateTimeField())
class Keys(MongoModel):
#密钥
key = fields.CharField(required=True)
#密钥创建时间
cdate = fields.DateTimeField(required=True)
#密钥状态0:无效 1：有效
status = fields.IntegerField(required=True)
#系统标识 0：用户密钥 1：平台密钥
sflag = fields.IntegerField(required=True)
class MDBPermutationResults(EmbeddedMongoModel):
class Meta:
final = True
connection_alias = "photon_core"
n_perms = fields.IntegerField(blank=True)
n_perms_done = fields.IntegerField(blank=True)
random_state = fields.IntegerField(blank=True)
metrics = fields.EmbeddedDocumentListField(MDBPermutationMetrics, blank=True)
class TradeDays(MongoModel):
exchange = fields.CharField(blank=True)
cal_date = fields.IntegerField(primary_key=True)
is_open = fields.IntegerField(blank=True)
class Meta:
write_concern = WriteConcern(j=True)
connection_alias = 'trade_days'
final = True
class Username(MongoModel):
idUsername = fields.IntegerField(primary_key=True)
username = fields.CharField(max_length=20)
numTweets = fields.IntegerField(default=False)
numMentions = fields.IntegerField()
username_lower = fields.CharField(max_length=20)
class Meta:
write_concern = WriteConcern(j=True)
class Provider(MongoModel):
class Status(IntEnum):
NO_ACTIVE = 0
ACTIVE = 1
BANNED = 2
class Type(IntEnum):
GUEST = 0,
USER = 1
class Meta:
collection_name = 'providers'
allow_inheritance = True
email = fields.CharField(max_length=64, required=True)
password = fields.CharField(required=True)
created_date = fields.DateTimeField(default=datetime.now)
status = fields.IntegerField(default=Status.NO_ACTIVE)
type = fields.IntegerField(default=Type.USER)
country = fields.CharField(min_length=2, max_length=3, required=True)
language = fields.CharField(default=constants.DEFAULT_LOCALE,
required=True)
servers = fields.ListField(fields.ReferenceField(
ServiceSettings, on_delete=fields.ReferenceField.PULL),
default=[])
def get_id(self) -> str:
return str(self.pk)
@property
def id(self):
return self.pk
def add_server(self, server):
self.servers.append(server)
self.save()
def remove_server(self, server):
self.servers.remove(server)
self.save()
@staticmethod
def generate_password_hash(password: str) -> str:
return generate_password_hash(password, method='sha256')
@staticmethod
def check_password_hash(hash_str: str, password: str) -> bool:
return check_password_hash(hash_str, password)
@classmethod
def make_provider(cls, email: str, password: str, country: str,
language: str):
return cls(email=email,
password=Provider.generate_password_hash(password),
country=country,
language=language)
