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)
class Course(MongoModel):
course_id = fields.CharField()
course_name = fields.CharField()
textbook = fields.URLField()
topics = fields.ListField()
students = fields.EmbeddedDocumentListField(Student)
quiz = fields.EmbeddedDocumentListField(Quiz)
class Student(EmbeddedMongoModel):
name = fields.CharField()
email_id = fields.CharField()
chat_history = fields.EmbeddedDocumentListField(Chat_History)
net_id = fields.CharField()
role = fields.CharField()
quiz_result = fields.EmbeddedDocumentListField(Quiz_record)
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 Equipment(MongoModel):
machineID = fields.IntegerField()
model = fields.CharField()
revised_on = fields.DateTimeField()
repair_predict = fields.IntegerField()
errors = fields.EmbeddedDocumentListField(Error)
failures = fields.EmbeddedDocumentListField(Failure)
services = fields.EmbeddedDocumentListField(Service)
telemetry = fields.EmbeddedDocumentListField(Telemetry)
class S_input_output(EmbeddedMongoModel):
name = fields.CharField(required=True)
display_name = fields.CharField(required=True)
stage = fields.CharField(required=True,
choices=["stepstart",
"stepend"]) # stepstart/stepend
input_values = fields.EmbeddedDocumentListField(S_value)
output_values = fields.EmbeddedDocumentListField(S_value)
script = fields.CharField()
class Hospital(MongoModel):
name = fields.CharField()
location = fields.PointField()
city = fields.CharField()
state = fields.CharField()
avg_reported = fields.EmbeddedDocumentListField(DRGData)
avg_user = fields.EmbeddedDocumentListField(DRGData)
class Meta:
# Text index on content can be used for text search.
indexes = [IndexModel([('name', TEXT)]), IndexModel([('location', GEOSPHERE)])]
class MDBDummyResults(EmbeddedMongoModel):
class Meta:
final = True
connection_alias = 'photon_core'
strategy = fields.CharField(blank=True)
train = fields.EmbeddedDocumentListField(MDBFoldMetric, default=[], blank=True)
test = fields.EmbeddedDocumentListField(MDBFoldMetric, default=[], blank=True)
def get_test_metrics(self):
return {m.metric_name: m.value for m in self.test if m.operation == "FoldOperations.MEAN"}
class ConcreteState(MongoModel):
def generate_title():
return 'document-' + ''.join(
random.SystemRandom().choice(string.ascii_uppercase +
string.digits) for _ in range(12))
url = fields.CharField()
title = fields.CharField(default=generate_title)
original = fields.BooleanField()
widgets = fields.EmbeddedDocumentListField(Widget)
targets = fields.EmbeddedDocumentListField(Target, blank=True)
mutated = fields.EmbeddedDocumentField(Target, blank=True)
class ClassificationProject(MongoModel):
_id = fields.CharField(primary_key=True, required=True, default=uuid.uuid4)
user = fields.ReferenceField(User, required=True)
name = fields.CharField(required=True, blank=False)
created = fields.DateTimeField(required=True,
default=datetime.datetime.now)
description = fields.CharField()
classes = fields.EmbeddedDocumentListField(ClassData, default=[])
training_instances = fields.EmbeddedDocumentListField(TrainingInstance,
default=[])
data_gathering_runs = fields.EmbeddedDocumentListField(GatheringRun,
default=[])
class MDBHyperpipe(MongoModel):
class Meta:
final = True
name = fields.CharField(primary_key=True)
best_config_metric = fields.CharField()
eval_final_performance = fields.BooleanField(default=True)
outer_folds = fields.EmbeddedDocumentListField(MDBOuterFold, default=[], blank=True)
time_of_results = fields.DateTimeField(blank=True)
permutation_test = fields.EmbeddedDocumentField(MDBPermutationResults, blank=True)
best_config = fields.EmbeddedDocumentField(MDBConfig, blank=True)
metrics_train = fields.EmbeddedDocumentListField(MDBFoldMetric, default=[], blank=True)
metrics_test = fields.EmbeddedDocumentListField(MDBFoldMetric, default=[], blank=True)
class RequestValidationConfig(MongoModel):
'''Mongo model for request validation config.
'''
routeName = fields.CharField(required=True)
method = fields.CharField(required=True)
isActive = fields.BooleanField(required=True)
queryParams = fields.EmbeddedDocumentListField(Params, blank=True)
urlParams = fields.EmbeddedDocumentListField(Params, blank=True)
requestBodySchema = fields.DictField(blank=True)
objects = DefaultManager()
class Meta:
collection_name = 'RequestValidationConfig'
final = True
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 TrainingInstance(EmbeddedMongoModel):
_id = fields.CharField(required=True, default=uuid.uuid4, primary_key=True)
status = fields.CharField(default="pending_training")
created = fields.DateTimeField(default=datetime.datetime.now())
training_start_time = fields.DateTimeField()
training_end_time = fields.DateTimeField()
training_runs = fields.EmbeddedDocumentListField(TrainingRun, default=[])
class CategoriaModel(EmbeddedMongoModel):
codigo = fields.CharField()
nombre = fields.CharField()
descripcion = fields.CharField()
subcategoria = fields.EmbeddedDocumentListField(SubCategoriaModel,
default=[])
imagen = fields.CharField()
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 Post(MongoModel):
# We set "blank=False" so that values like the empty string (i.e. u'')
# aren't considered valid. We want a real title. As above, we also make
# most fields required here.
title = fields.CharField(required=True, blank=False)
body = fields.CharField(required=True)
date = fields.DateTimeField(required=True)
author = fields.ReferenceField(User, required=True)
# Comments will be stored as a list of embedded documents, rather than
# documents in their own collection. We also set "default=[]" so that we can
# always do:
#
# post.comments.append(Comment(...))
#
# instead of:
#
# if post.comments:
# post.comments.append(Comment(...))
# else:
# post.comments = [Comment(...)]
comments = fields.EmbeddedDocumentListField(Comment, default=[])
@property
def summary(self):
"""Return at most 100 characters of the body."""
if len(self.body) > 100:
return self.body[:97] + '...'
return self.body
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 Post(MongoModel):
title = fields.CharField()
author = fields.ReferenceField(User)
revised_on = fields.DateTimeField()
content = fields.CharField()
comments = fields.EmbeddedDocumentListField(Comment)
tags = fields.ListField(fields.CharField(max_length=20))
class Departament(MongoModel):
city = fields.CharField()
count_of_workers = fields.IntegerField()
clients = fields.EmbeddedDocumentListField(Client)
def __str__(self):
return f'{self.city}, {self.count_of_workers}'
class User(MongoModel):
# Make all these fields required, so that if we try to save a User instance
# that lacks one of these fields, we'll get a ValidationError, which we can
# catch and render as an error on a form.
#
# Use the email as the "primary key" (will be stored as `_id` in MongoDB).
email = fields.EmailField(primary_key=True, required=True)
user_type = fields.CharField(required=True)
image_url = fields.CharField(blank=True)
# `password` here will be stored in plain text! We do this for simplicity of
# the example, but this is not a good idea in general. A real authentication
# system should only store hashed passwords, and queries for a matching
# user/password will need to hash the password portion before of the query.
password = fields.CharField(required=True)
user_promos = fields.EmbeddedDocumentListField(UserPromo)
def hash_password(self, password_input):
salt = uuid.uuid4().hex
self.password = hashlib.sha256(
salt.encode() + password_input.encode()).hexdigest() + ':' + salt
def verify_password(self, hashed_password, user_password):
password, salt = hashed_password.split(':')
return password == hashlib.sha256(salt.encode() +
user_password.encode()).hexdigest()
class CTF(MongoModel):
name = fields.CharField(required=True)
description = fields.CharField()
created_at = fields.DateTimeField(required=True)
finished_at = fields.DateTimeField()
start_date = fields.DateTimeField()
end_date = fields.DateTimeField()
url = fields.URLField()
username = fields.CharField()
password = fields.CharField()
challenges = fields.EmbeddedDocumentListField(Challenge,
default=[],
blank=True)
pending_reminders = fields.ListField(blank=True, default=[])
def status(self, members_joined_count):
description_str = self.description + "\n" if self.description else ""
solved_count = len(
list(filter(lambda x: x.solved_at is not None, self.challenges)))
total_count = len(self.challenges)
status = (
f":triangular_flag_on_post: **{self.name}** ({members_joined_count} Members joined)\n{description_str}"
+ f"```CSS\n{draw_bar(solved_count, total_count, style=5)}\n" +
f" {solved_count} Solved / {total_count} Total")
if self.start_date:
fmt_str = "%d/%m %H:\u200b%M"
start_date_str = self.start_date.strftime(fmt_str)
end_date_str = self.end_date.strftime(
fmt_str) if self.end_date else "?"
status += f"\n {start_date_str} - {end_date_str}\n"
status += "```"
return status
def credentials(self):
response = f":busts_in_silhouette: **Username**: {self.username}\n:key: **Password**: {self.password}"
if self.url is not None:
response += f"\n\nLogin Here: {self.url}"
return response
def challenge_summary(self):
if not self.challenges:
return "No challenges found. Try adding one with `!ctf addchallenge <name> <category>`"
solved_response, unsolved_response = "", ""
for challenge in self.challenges:
challenge_details = f'**{escape_md(challenge.name[len(self.name)+1:])}** [{", ".join(challenge.tags)}]'
if challenge.solved_at:
solved_response += f':white_check_mark: {challenge_details} Solved by: [{", ".join(challenge.solved_by)}]\n'
else:
unsolved_response += f':thinking: {challenge_details} Attempted by: [{escape_md(", ".join(challenge.attempted_by))}]\n'
return (f"\\>>> Solved\n{solved_response}" +
f"\\>>> Unsolved\n{unsolved_response}")
class Meta:
collection_name = "ctf"
ignore_unknown_fields = 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 User(MongoModel):
username = fields.CharField(primary_key=True)
name = fields.CharField()
surname = fields.CharField()
email = fields.CharField()
password = fields.CharField()
databases = fields.EmbeddedDocumentListField('DatabaseInfo')
class Location(MongoModel):
"""
A model defining location entity with embedded province and town
information.
"""
country = fields.CharField(max_length=30, required=True)
province = fields.EmbeddedDocumentListField('Province', required=True)
class Member(MongoModel):
_karma_list = fields.EmbeddedDocumentListField(Karma)
karma_expiry_days = 30
def __get_recent_karma(self):
cut_off = datetime.today() - timedelta(days=Member.karma_expiry_days)
return list(filter((lambda k: k.awarded > cut_off), self._karma_list))
def get_current_karma(self):
recent_karma = list(map((lambda k: k.karma_type), self.__get_recent_karma()))
positive_karma = len(list(filter((lambda k: k == str(KarmaType.POZZYPOZ)), recent_karma)))
negative_karma = len(list(filter((lambda k: k == str(KarmaType.NEGGYNEG)), recent_karma)))
net_karma = positive_karma - negative_karma
return net_karma
def add_karma(self, new_karma):
self._karma_list.append(new_karma)
def get_karma_reasons(self):
recent_karma = self.__get_recent_karma()
karma_with_reasons = list(filter((lambda k: k.reason != Karma.default_reason), recent_karma))
karma_without_reasons = list(filter((lambda k: k.reason == Karma.default_reason), recent_karma))
return {'reasonless':len(karma_without_reasons), 'reasoned':karma_with_reasons}
def __init__(self, karma_list):
super(Member, self).__init__()
self._karma_list = karma_list
class Trails(MongoModel):
"""
A model defining trails entity undertaken by hikers. It has embedded
comments which reference the hiker.
"""
trail_name = fields.CharField(max_length=100, required=True)
distance = fields.FloatField(max_value=50, required=True)
elevation = fields.FloatField(required=True)
route_type = fields.CharField(max_length=20,
choices=('Point to Point', 'Loop',
'Out and Back'),
required=True)
difficulty = fields.CharField(max_length=20,
choices=('Easy', 'Moderate', 'Difficult'),
required=True)
description = fields.CharField(max_length=600, required=True)
centrepoint = fields.PointField(required=False)
waypoints = fields.LineStringField(required=False)
image = fields.URLField(required=True)
embed_route = fields.CharField(max_length=800, required=True)
location = fields.ReferenceField(Location)
comments = fields.EmbeddedDocumentListField('Comment', required=False)
def __str__(self):
return self.trail_name
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 MDBOuterFold(EmbeddedMongoModel):
class Meta:
final = True
fold_nr = fields.IntegerField(blank=True)
best_config = fields.EmbeddedDocumentField(MDBConfig, blank=True)
tested_config_list = fields.EmbeddedDocumentListField(MDBConfig, default=[], blank=True)
class TopicVersion(PageVersion):
sections = fields.EmbeddedDocumentListField(Section, blank=True)
summary = fields.CharField(blank=True)
name = fields.CharField(blank=True)
@property
def title(self):
return name_to_title(self.name)
