class User(MongoModel):
id = fields.CharField(primary_key=True)
uuid = fields.CharField()
email = fields.EmailField()
name = fields.CharField()
surname = fields.CharField()
authmethod = fields.CharField()
password = fields.CharField(required=True)
mfa_hash = fields.CharField()
first_login = fields.DateTimeField(blank=True)
last_login = fields.DateTimeField(blank=True)
last_password_change = fields.DateTimeField(blank=True)
is_active = fields.BooleanField(default=True)
privacy_accepted = fields.BooleanField(default=True)
expiration = fields.DateTimeField(blank=True)
roles = fields.EmbeddedDocumentListField(Role, blank=True)
belongs_to = fields.EmbeddedDocumentField("Group", blank=True)
class Meta:
# write_concern = WriteConcern(j=True)
connection_alias = AUTH_DB
indexes = [
IndexModel("uuid", unique=True),
IndexModel("email", unique=True)
]
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 Person(EmbeddedMongoModel):
name = fields.CharField(blank=True)
dietary_vegetarian = fields.BooleanField(default=False)
dietary_gluten_free = fields.BooleanField(default=False)
dietary_other = fields.CharField(blank=True)
class UserStream(EmbeddedMongoModel):
FAVORITE_FIELD = 'favorite'
PRIVATE_FIELD = 'private'
RECENT_FIELD = 'recent'
sid = fields.ReferenceField(IStream, required=True)
favorite = fields.BooleanField(default=False)
private = fields.BooleanField(default=False)
recent = fields.DateTimeField(default=datetime.utcfromtimestamp(0))
interruption_time = fields.IntegerField(
default=0,
min_value=0,
max_value=constants.MAX_VIDEO_DURATION_MSEC,
required=True)
def get_id(self) -> str:
return str(self.pk)
@property
def id(self):
return self.pk
def to_front_dict(self):
res = self.sid.to_front_dict()
res[UserStream.FAVORITE_FIELD] = self.favorite
res[UserStream.PRIVATE_FIELD] = self.private
res[UserStream.RECENT_FIELD] = date_to_utc_msec(self.recent)
return res
class Repair(MongoModel):
deadline = fields.DateTimeField()
machineID = fields.IntegerField()
rtype = fields.CharField()
description = fields.CharField()
in_progress = fields.BooleanField()
completed = fields.BooleanField()
class S_value(EmbeddedMongoModel):
name = fields.CharField(required=True)
display_name = fields.CharField(required=True)
scope = fields.CharField(required=True) # sample/all
type_ = fields.CharField(required=True) # number/text/date/file
showuser = fields.BooleanField(required=True)
required = fields.BooleanField(required=False, default=True)
class Application(MongoModel):
_id = fields.CharField(required=True, primary_key=True)
app_id = fields.CharField(required=True,
verbose_name='app_id',
mongo_name='appId')
app_hash = fields.CharField(required=True,
verbose_name='app_hash',
mongo_name='appHash')
app_secure = fields.BinaryField(required=True,
verbose_name='app_secure',
mongo_name='appCrypt')
app_manager = fields.EmbeddedDocumentField(AppManager,
required=True,
verbose_name='app_manager_info',
mongo_name='appManager')
created_date = fields.DateTimeField(verbose_name='app_created_date',
mongo_name='createdDate',
required=True)
app_is_valid = fields.BooleanField(required=True,
verbose_name='app_is_valid',
mongo_name='isValid',
default=True)
valid_until = fields.DateTimeField(required=True,
verbose_name='app_valid_until',
mongo_name='validUntil')
is_deleted = fields.BooleanField(verbose_name='app_is_deleted',
mongo_name='isDeleted',
default=False)
deleted_date = fields.DateTimeField(verbose_name='user_deleted_date',
mongo_name='deletedDate',
default=None)
class Meta:
connection_alias = 'Application'
collection_name = 'registeredApps'
cascade = True
write_concern = wc.WriteConcern(j=True)
read_preference = ReadPreference.NEAREST
read_concern = rc.ReadConcern(level='majority')
indexes = [
IndexModel('appId', name='appIdIndex', unique=True, sparse=True),
IndexModel('appHash',
name='appHashIndex',
unique=True,
sparse=True),
IndexModel('appCrypt',
name='appCryptIndex',
unique=True,
sparse=True),
IndexModel('createdDate', name='createdDateIndex', sparse=True),
IndexModel('validUntil', name='validUntilIndex', sparse=True),
IndexModel('appManager.email',
name='managerEmailIndex',
sparse=True,
unique=True)
]
ignore_unknown_fields = True
class MessageFilter(MongoModel):
name = fields.CharField()
text = fields.CharField()
exclude = fields.BooleanField()
full_text = fields.BooleanField()
class Meta:
connection_alias = 'mongobot'
write_concern = WriteConcern(j=True)
class User(MongoModel):
email = fields.EmailField(required=False, mongo_name='email')
name = fields.CharField(required=False, mongo_name='name')
mobile_no = fields.CharField(min_length=10,
max_length=10,
required=False,
mongo_name='mobile_no')
role = fields.CharField(choices=('mentor', 'student', 'admin'),
required=False,
mongo_name='role')
photo_url = fields.CharField(mongo_name='photo_url', default=None)
uploaded_photo_url = fields.CharField(mongo_name='uploaded_photo_url',
default=None)
user_token = fields.CharField(mongo_name='user_token')
user_group = fields.CharField(mongo_name='user_group', default=None)
nickname = fields.CharField(mongo_name='nickname')
preferences = fields.ListField(mongo_name='preferences')
created_at = fields.DateTimeField(mongo_name='created_at')
updated_at = fields.DateTimeField(mongo_name='updated_at')
linkedin = fields.CharField(mongo_name='linkedin')
certificates = fields.CharField(mongo_name='certificates')
courses = fields.CharField(mongo_name='courses')
background = fields.CharField(mongo_name='background')
mentor_verified = fields.BooleanField(mongo_name='mentor_verified',
default=False)
hours_per_day = fields.CharField(mongo_name='hours_per_day')
login_status = fields.BooleanField(mongo_name='login_status', default=True)
sessions = fields.BigIntegerField(mongo_name='sessions', default=0)
class Meta:
write_concern = WriteConcern(j=True)
ignore_unknown_fields = True
connection_alias = 'onx-app'
final = True
def clean(self):
if self.email != None:
self.check_duplicate_user()
self.validate_user_group()
def check_duplicate_user(self):
try:
User.objects.get({'email': self.email})
raise ValidationError('User with this email already exist')
except User.DoesNotExist:
pass
def validate_user_group(self):
try:
if self.user_group != None:
group = CorporateGroup.objects.get({'code': self.user_group})
self.user_group = str(group._id)
else:
pass
except Exception as e:
message = "Invalid corporate code." if str(e) == "" else str(e)
raise ValidationError(message)
class SoftwareComponent(EmbeddedMongoModel):
name = fields.CharField(primary_key=True)
package = fields.CharField()
version = fields.CharField()
version_uid = fields.CharField()
update_available = fields.BooleanField()
config_mismatch = fields.BooleanField()
uncommitted_changes = fields.BooleanField()
class ChannelAdmin(EmbeddedMongoModel):
uid = fields.ReferenceField(User, on_delete=fields.ReferenceField.CASCADE, verbose_name='user_id',
mongo_name='userId', required=True)
admin_since = fields.DateTimeField(verbose_name='admin_since', mongo_name='adminJoinDate', required=True)
can_post = fields.BooleanField(verbose_name='admin_can_post', mongo_name='adminCanPost',
default=True)
can_edit_others = fields.BooleanField(verbose_name='admin_can_edit_others', mongo_name='adminCanEditOthers',
default=False)
can_delete_others = fields.BooleanField(verbose_name='admin_can_delete_others', mongo_name='adminCanDeleteOthers',
default=False)
can_update_channel_info = fields.BooleanField(verbose_name='admin_can_update_channel_info',
mongo_name='adminCanUpdateChannelInfo', default=False)
class Result(MongoModel):
# "doi": "The DOI of the record",
doi = fields.CharField(primary_key=True)
scores = fields.EmbeddedDocumentListField('Score')
persisted = fields.BooleanField(required=True)
# "contentType": "Type of the content (e.g. Article)",
contentType = fields.CharField(blank=True)
# "title": "The title of the record",
title = fields.CharField(blank=True)
# "authors": ["Full name of one creator"],
authors = fields.ListField(blank=True)
# "publicationName": "Name of the publication",
publicationName = fields.CharField(blank=True)
# "openAccess": "Bool: Belongs to openaccess collection",
openAccess = fields.BooleanField(blank=True)
# "publisher": "Name of the publisher",
publisher = fields.CharField(blank=True)
# "publicationDate": "Date of publication",
publicationDate = fields.CharField(blank=True)
# "publicationType": "Type of publication",
publicationType = fields.CharField(blank=True)
# "issn": "International Standard Serial Number",
issn = fields.CharField(blank=True)
# "volume": "Volume of the publication",
volume = fields.CharField(blank=True)
# "number": "Number of the publication",
number = fields.CharField(blank=True)
# "genre": ["Name of one genre"],
genre = fields.ListField(blank=True)
# "pages": {
# "first": "First page in publication",
# "last": "Last page in publication"
# },
pages = fields.ListField(blank=True)
# "journalId": "ID of the publication journal",
journalId = fields.CharField(blank=True)
# "copyright": "Copyright notice",
copyright = fields.CharField(blank=True)
# "abstract": "Abstract (Summary)",
abstract = fields.CharField(blank=True)
# "uri": "Link to the record"
uri = fields.CharField(blank=True)
#
printIsbn = fields.CharField(blank=True)
electronicIsbn = fields.CharField(blank=True)
isbn = fields.CharField(blank=True)
class Meta:
ignore_unknown_fields = True
class MDBHyperpipeInfo(EmbeddedMongoModel):
class Meta:
final = True
connection_alias = "photon_core"
data = fields.DictField(blank=True)
cross_validation = fields.DictField(blank=True)
optimization = fields.DictField(blank=True)
flowchart = fields.CharField(blank=True)
metrics = fields.ListField(blank=True)
best_config_metric = fields.CharField(blank=True)
maximize_best_config_metric = fields.BooleanField(blank=True)
estimation_type = fields.CharField(blank=True)
eval_final_performance = fields.BooleanField(blank=True)
class SectionDiff(EmbeddedMongoModel):
heading = fields.CharField()
level = fields.IntegerField()
body = fields.CharField(blank=True)
body_diff = fields.CharField(blank=True)
inserted = fields.BooleanField(default=False)
deleted = fields.BooleanField(default=False)
edited = fields.BooleanField(default=False)
idx = fields.IntegerField(default=None)
@property
def is_empty(self):
return not (self.inserted or self.deleted or self.edited)
class Pipeline(CreatedUpdated, DeleteObjectsMixin, MongoModel):
from newsgac.users.models import User
from newsgac.data_sources.models import DataSource
from newsgac.tasks.models import TrackedTask
user = fields.ReferenceField(User, required=True)
display_title = fields.CharField(required=True)
created = fields.DateTimeField()
updated = fields.DateTimeField()
data_source = fields.ReferenceField(DataSource, required=True, blank=False)
stop_words = fields.ReferenceField(StopWords, required=False, blank=True)
lowercase = fields.BooleanField(required=True, default=False)
lemmatization = fields.BooleanField(required=True, default=False)
quote_removal = fields.BooleanField(required=True, default=True)
nlp_tool = fields.EmbeddedDocumentField(NlpTool, blank=True, required=True, default=TFIDF.create())
learner = fields.EmbeddedDocumentField(Learner)
sk_pipeline = ObjectField()
result = fields.EmbeddedDocumentField(Result, blank=True)
grid_search_result = ObjectField()
task = fields.EmbeddedDocumentField(TrackedTask, default=TrackedTask())
@classmethod
def create(cls):
return cls(
display_title="",
data_source=None,
stop_words=cls.stop_words.default,
lowercase=cls.lowercase.default,
lemmatization=cls.lemmatization.default,
nlp_tool=cls.nlp_tool.default,
learner=LearnerSVC.create()
)
def get_feature_extractor(self):
raise NotImplementedError('Subclass should implement get_feature_extractor')
def get_sk_pipeline(self):
return get_sk_pipeline(self)
def delete(self):
from newsgac.ace import ACE
# delete this pipeline from related ace runs
for ace in ACE.objects.raw({'pipelines': {'$in': [self.pk]}}):
ace.delete_pipeline(self)
super(Pipeline, self).delete()
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 TopicVersionDiff(VersionDiff):
sections = fields.EmbeddedDocumentListField(SectionDiff, blank=True)
summary = fields.CharField(blank=True)
summary_diff = fields.CharField(blank=True)
summary_changed = fields.BooleanField()
name = fields.CharField(blank=True)
prev_name = fields.CharField(blank=True)
@property
def is_empty(self):
return not (self.summary_changed or self.name_changed
or any(not section.is_empty for section in self.sections))
@property
def name_changed(self):
return self.name != self.prev_name
@staticmethod
def compute(version_a, version_b):
sections = diff_sections(version_a.sections, version_b.sections)
summary_diff = markup_changes(version_a.summary, version_b.summary)
name = version_b.name
prev_name = version_a.name
return TopicVersionDiff(
version_a=version_a,
version_b=version_b,
sections=sections,
summary=version_b.summary,
summary_diff=summary_diff,
summary_changed=version_a.summary != version_b.summary,
name=name,
prev_name=prev_name,
)
class Response(BaseMongoModel):
id = fields.ObjectIdField(primary_key=True)
form = fields.ReferenceField(Form, on_delete=fields.ReferenceField.CASCADE)
user = fields.ReferenceField(User,
on_delete=fields.ReferenceField.CASCADE,
blank=True)
# paymentInfo = fields.EmbeddedDocumentField(PaymentInfo)
paymentInfo = fields.DictField()
payment_status_detail = fields.EmbeddedDocumentListField(
PaymentStatusDetailItem, blank=True, default=list)
paid = fields.BooleanField(default=False)
amount_paid = fields.CharField(default="0")
payment_trail = fields.EmbeddedDocumentListField(PaymentTrailItem,
blank=True,
default=list)
update_trail = fields.EmbeddedDocumentListField(UpdateTrailItem,
blank=True,
default=list)
email_trail = fields.EmbeddedDocumentListField(EmailTrailItem,
blank=True,
default=list)
value = fields.DictField()
date_created = fields.DateTimeField(required=True)
date_modified = fields.DateTimeField(required=True)
pending_update = fields.DictField(blank=True)
admin_info = fields.DictField()
modify_link = fields.CharField(blank=True)
predicate = fields.DictField()
counter = fields.IntegerField(blank=True)
class Batch(EmbeddedMongoModel):
workflow = fields.ReferenceField(Workflow, required=True)
step_cat = fields.CharField(required=True)
batch_name = fields.CharField(required=True)
batch_created_on = fields.DateTimeField(required=True)
position = fields.EmbeddedDocumentField(PositionInPlate, required=True)
archived = fields.BooleanField(required=True, default=False)
class Activity(MongoModel):
user_id = fields.CharField(mongo_name='user_id')
session_id = fields.CharField(mongo_name='session_id')
is_dynamic = fields.BooleanField(mongo_name='is_dynamic')
content = fields.CharField(mongo_name='content')
created_at = fields.DateTimeField(required=False, mongo_name='created_at')
updated_at = fields.DateTimeField(mongo_name='updated_at')
class Meta:
write_concern = WriteConcern(j=True)
ignore_unknown_fields = True
connection_alias = 'onx-app'
def clean(self):
# self.validate_user()
pass
def validate_user(self):
try:
if self.user_id != None:
user = User.objects.get({'_id': ObjectId(self.user_id)})
# else:
# raise ValidationError("user_id is mandatory for creating an activity.")
except Exception as e:
message = 'User does not exists' if str(e) == "" else str(e)
raise ValidationError(message)
class BookmarksDiff(MongoModel):
version_a = fields.ReferenceField(BookmarksVersion)
version_b = fields.ReferenceField(BookmarksVersion)
sections = fields.EmbeddedDocumentListField(SectionDiff, blank=True)
summary = fields.CharField(blank=True)
summary_diff = fields.CharField(blank=True)
summary_changed = fields.BooleanField()
@property
def is_empty(self):
return not (
self.summary_changed
or any(not section.is_empty for section in self.sections)
)
@staticmethod
def compute(version_a, version_b):
sections = diff_sections(version_a.sections, version_b.sections)
summary_diff = markup_changes(version_a.summary, version_b.summary)
return BookmarksDiff(
version_a=version_a,
version_b=version_b,
sections=sections,
summary=version_b.summary,
summary_diff=summary_diff,
summary_changed=version_a.summary != version_b.summary,
)
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 LogInfo(MongoModel):
"""日志记录"""
log = fields.CharField()
create = fields.DateTimeField()
fetched = fields.BooleanField(default=False)
log_type = fields.IntegerField(mongo_name='type')
class Meta:
connection_alias = DB_LOG
collection_name = CN_COMMON_LOG
@classmethod
def grouped_unfetched_logs(cls, types):
try:
all_unfetcheds = list(cls.objects.raw({'fetched': False, 'type': {'$in': types}}).order_by([('log', 1)]))
if not all_unfetcheds:
return []
else:
grouped = dict()
for log in all_unfetcheds:
l_type = log.log_type
grouped[l_type] = grouped[l_type] + [log] if grouped.get(l_type) else [log]
return list(grouped.values())
except Exception as e:
print("Get logs failed, " + str(e))
return []
class PersonSpecialization(MongoModel):
person_id = ValidatedReferenceField(Person,
on_delete=ReferenceField.CASCADE)
department_id = ValidatedReferenceField(Department,
on_delete=ReferenceField.CASCADE)
specialization_id = ValidatedReferenceField(
Specialization, on_delete=ReferenceField.CASCADE)
level = fields.FloatField(default=None, blank=True)
details = fields.DictField()
is_active = fields.BooleanField(required=True, default=True)
def save(self, cascade=None, full_clean=True, force_insert=False):
super().save(cascade, full_clean, force_insert)
update_person_subrating(PersonSpecialization, self.person_id)
class Meta:
write_concern = WriteConcern(w=1)
connection_alias = "reviewer"
final = True
indexes = [
IndexModel([("person_id", pymongo.DESCENDING),
("department_id", pymongo.DESCENDING),
("specialization_id", pymongo.DESCENDING)],
unique=True),
IndexModel("department_id"),
IndexModel("specialization_id")
]
class HealthContext(EmbeddedMongoModel):
status = fields.CharField()
isPhysicallyHurt = fields.BooleanField(default=False)
diseases = fields.ListField(fields.CharField())
aggressions = fields.ListField(fields.CharField())
injuries = fields.ListField(fields.CharField())
disorders = fields.DictField()
class UsuarioModel(MongoModel):
username = fields.CharField()
password = fields.CharField()
estatus = fields.BooleanField()
fecha_alta = fields.DateTimeField()
fecha_baja = fields.DateTimeField()
dbreferencia = fields.ReferenceField(CajeroModel)
class TaskStatus(MongoModel):
task = fields.ReferenceField(Task, primary_key=True, required=True)
status = fields.IntegerField(default=TaskStatusConst.UNALLOCATED)
delayed = fields.BooleanField(default=False)
progress = fields.EmbeddedDocumentField(TaskProgress)
objects = TaskStatusManager()
class Meta:
archive_collection = 'task_status_archive'
ignore_unknown_fields = True
def archive(self):
with switch_collection(TaskStatus, TaskStatus.Meta.archive_collection):
super().save()
self.delete()
def update_progress(self, action_id, action_status, **kwargs):
self.refresh_from_db()
if not self.progress:
self.progress = TaskProgress()
self.progress.initialize(action_id, self.task.plan)
self.save()
self.progress.update(action_id, action_status, **kwargs)
self.save(cascade=True)
class BotConfig(MongoModel):
REMINDERS_CHANNEL = fields.IntegerField(blank=True)
IS_MAINTENANCE = fields.BooleanField()
CTFTIME_TEAM_ID = fields.CharField()
HTB_TEAM_ID = fields.CharField()
ADMIN_ROLE = fields.CharField()
EXTENSIONS = fields.EmbeddedDocumentListField(CogDetails, default=[])
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 MDBHyperpipe(MongoModel):
class Meta:
final = True
connection_alias = 'photon_core'
name = fields.CharField()
version = fields.CharField()
output_folder = fields.CharField(blank=True)
permutation_id = fields.CharField(blank=True)
permutation_failed = fields.CharField(blank=True)
permutation_test = fields.EmbeddedDocumentField(MDBPermutationResults, blank=True)
computation_completed = fields.BooleanField(default=False)
computation_start_time = fields.DateTimeField(blank=True)
computation_end_time = fields.DateTimeField(blank=True)
outer_folds = fields.EmbeddedDocumentListField(MDBOuterFold, default=[], blank=True)
best_config = fields.EmbeddedDocumentField(MDBConfig, blank=True)
best_config_feature_importances = fields.ListField(blank=True)
metrics_train = fields.EmbeddedDocumentListField(MDBFoldMetric, default=[], blank=True)
metrics_test = fields.EmbeddedDocumentListField(MDBFoldMetric, default=[], blank=True)
hyperpipe_info = fields.EmbeddedDocumentField(MDBHyperpipeInfo)
# dummy estimator
dummy_estimator = fields.EmbeddedDocumentField(MDBDummyResults, blank=True)
# stuff for wizard connection
user_id = fields.CharField(blank=True)
wizard_object_id = fields.ObjectIdField(blank=True)
wizard_system_name = fields.CharField(blank=True)
