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)