class RecipeDoc(Document):
title = StringField(required=True, min_length=3)
author = ReferenceField(UserDoc, required=True)
image = FileField()
ingredients = EmbeddedDocumentListField(IngredientDoc)
gear = ListField(StringField())
steps = EmbeddedDocumentListField(StepDoc)
meta = {
'collection': 'recipes'
}
class Table(EmbeddedDocument):
columns = EmbeddedDocumentListField(TableColumns)
pagination = EmbeddedDocumentListField(
PaginationNamespace,
default=[
PaginationNamespace(**{
'name': 'default',
'page_size': 5,
'page_options': [5, 10, 20, 30]
})
])
classes = EmbeddedDocumentListField(TableClasses)
filtered_by_owner = BooleanField(default=False)
view = EmbeddedDocumentField(TableView)
class Chats(Document):
"""
Chat document saves all words + language settings of a chat.
Most used word object is save here too
"""
language = StringField()
ID = IntField()
settings = EmbeddedDocumentField(Settings)
words = EmbeddedDocumentListField(Word)
topWord = EmbeddedDocumentField(Word)
sentWords = IntField()
sentMessages = IntField()
responses = DictField(default={})
@staticmethod
def getChat(chatID):
"""Will return a chat object when ID is provided"""
try:
return Chats.objects(ID=chatID).get()
except Chats.DoesNotExist:
return None
@staticmethod
def getSettings(chatID):
"""Will return a settings object to simplify querring the db"""
settingsObjects = Chats.objects(ID=chatID).get().settings
return settingsObjects
class Patients(Document):
meta = {"collection": "pacientes"}
folio = IntField(primary_key=True, db_field="folio")
name = StringField(required=True, db_field="nombre")
age = IntField(required=True, db_field="edad")
birth_date = DateField(required=True, db_field="fecha_nacimiento")
sex = StringField(required=True, db_field="sexo")
blood_type = StringField(required=True, db_field="tipo_sangre")
emergency_contact_name = StringField(required=True,
db_field="nombre_contacto_emergencia")
emergency_contact_num = StringField(required=True,
db_field="tel_contacto_emergencia")
medical_dx = StringField(required=True, db_field="dx_medico")
companion = BooleanField(required=True, db_field="acompañante")
shelter = BooleanField(required=True, db_field="shelter")
quimio = BooleanField(required=True, db_field="quimio")
form_history = EmbeddedDocumentListField(FormHistory,
required=False,
db_field="versiones_formulario")
def __str__(self):
return f"Patient({self.name + ' ' + self.paternal_last_name})"
def __repr__(self):
return self.__str__()
class Discussion(Document):
"""
Discussion representation.
"""
meta = {'collection': 'discussions'}
id = StringField(default=lambda: uuid.uuid4().hex, primary_key=True)
"""
:type: *str*
:required: False
:default: Automatically generated.
"""
document = StringField(required=True)
"""
:type: *str*
:required: True
:default: None
"""
chat = ListField(StringField(), default=[]) # unit ids
"""
:type: *List[str]*
:required: False
:default: []
"""
users = EmbeddedDocumentListField(User, default=[])
"""
class ProviderSSH(Provider):
type = 'SSH'
hosts = EmbeddedDocumentListField(HostSSH)
def list(self):
return self.hosts
def create(self, ip, hostname):
host = HostSSH(ip=ip, hostname=hostname)
self.hosts.append(host)
self.save()
return host
def destroy(self, hostname):
for host in self.hosts:
if host.hostname == hostname:
self.hosts.remove(host)
return host
return None
def update(self, hostname, new_ip=None, new_hostname=None):
for host in self.hosts:
if host.hostname == hostname:
host.ip = new_ip or host.ip
host.hostname = new_hostname or host.hostname
self.hosts.save()
return host
return None
class EmailJob(EmbeddedDocument):
job_id = ObjectIdField()
subject = StringField()
emails = EmbeddedDocumentListField(Email)
type = StringField(choices=["Manual", "Scheduled"])
initiated_at = DateTimeField(default=datetime.utcnow)
included_feedback = BooleanField()
class TableView(EmbeddedDocument):
shared_group = EmbeddedDocumentListField(SharedGroup)
name = StringField(required=True)
model = StringField(required=True)
is_default = BooleanField(default=False)
access = StringField(default='public')
query = ListField(ViewQuery)
class Appointment(db.Document):
creationDate = DateTimeField(required=True)
closedDate = DateTimeField()
nextAppointment = DateTimeField(required=True)
hospital = ReferenceField(Hospital, required=True)
patient = ReferenceField(User, required=True)
closed = BooleanField(default=False)
appointments = EmbeddedDocumentListField(AppointmentDetail, default=[])
def format(self):
response = {
"id":
str(self.id),
"creationDate":
datetime.strftime(self.creationDate, '%d/%m/%Y %H:%M'),
"nextAppointment":
datetime.strftime(self.nextAppointment, '%d/%m/%Y %H:%M'),
"hospital":
self.hospital.get_obj(),
"patient":
self.patient.format(),
"closed":
self.closed,
"visits":
[appointment.format() for appointment in self.appointments],
"cancellable":
len(self.appointments) == 0
}
if self.closedDate:
response["closedDate"] = datetime.strftime(self.closedDate,
'%d/%m/%Y %H:%M')
return response
class NodeConfig(Document):
version = IntField()
node_name = StringField(max_length=1000)
icon_link = URLField()
connection_method = DictField()
configures = EmbeddedDocumentListField(OperateFactor)
device_icons = DictField() # key:hid, value:URL
class Player(Document):
first_name = StringField(required=True)
last_name = StringField(required=True)
opponent = ReferenceField('Player')
players = ListField(ReferenceField('Player'))
articles = ListField(ReferenceField('Article'))
embedded_list_articles = EmbeddedDocumentListField(EmbeddedArticle)
class ModelDO(Document):
"""Model Plain Object.
The primary key of the model plain object is (engine, name, version) pair.
"""
# Model name
name = StringField(required=True)
# Supported engine enum (aka framework, e.g.: TensorFlow (0) or PyTorch (1))
framework = IntField(required=True)
# ONNX or TensorRT
engine = IntField(required=True)
# Version of the model. e.g.: `1`
version = IntField(required=True)
# Dataset
dataset = StringField(required=True)
# Model evaluation metric
metric = DictField(required=True)
# Model weights
weight = FileField()
# Model task
task = IntField(required=True)
# Parent Model ID
parent_model_id = StringField()
# inputs standard
inputs = EmbeddedDocumentListField(IOShapeDO)
# outputs standard
outputs = EmbeddedDocumentListField(IOShapeDO)
# Profile result
profile_result = EmbeddedDocumentField(ProfileResultDO)
# Status enum value
status = IntField(required=True)
# Model Status enum value
model_status = ListField()
# Model provider (uploader)
creator = StringField(required=True)
# Creation time of this record
create_time = DateTimeField(required=True)
meta = {
'indexes': [{
'fields':
('engine', 'name', 'framework', 'version', 'task', 'dataset'),
'unique':
True
}]
}
class Organization(BDocument):
name = StringField()
contact_full_name = StringField()
default_refund_amount = FloatField(default=0)
conventions = EmbeddedDocumentListField(OrganizationConvention)
address = StringField()
email = EmailField()
phone_numbers = ListField(field=StringField(), required=False, default=[])
class User(EmbeddedDocument):
"""
User representation.
"""
id = StringField(default=lambda: uuid.uuid4().hex, primary_key=True)
viewed_unit = StringField(required=True)
"""
:type: *str*
:required: True
:default: None
"""
start_time = DateTimeField(required=True) #StringField(required=True)
"""
:type: *datetime*
:required: True
:default: None
"""
name = StringField(required=True)
"""
:type: *str*
:required: True
:default: None
"""
cursor = EmbeddedDocumentField(Cursor, required=True)
"""
:type: *Cursor*
:required: True
:default: None
"""
active = BooleanField(default=False)
"""
:type: *bool*
:required: False
:default: False
"""
timeline = EmbeddedDocumentListField(TimeInterval, default=[])
"""
:type: *EmbeddedDocumentList[TimeInterval]*
:required: False
:default: []
"""
editing = ListField(StringField(), default=[]) # unit ids
"""
:type: *List[str]*
:required: False
:default: []
"""
moving = ListField(StringField(), default=[]) # unit ids
"""
class User(Document):
username = StringField(required=True, unique=True)
email = StringField(required=True, unique=True)
password = StringField(required=True)
watchList = EmbeddedDocumentListField(Stock)
balence = FloatField(default=10000.00)
# ownedStock = EmbeddedDocumentListField(OwnedStock)
totalStockValue = FloatField(default=0.00)
meta = {'ordering': ['+username']}
class Intent(Document):
name = StringField(max_length=100, required=True, unique=True)
intentId = StringField(required=True)
apiTrigger = BooleanField(required=True)
apiDetails = EmbeddedDocumentField(ApiDetails)
speechResponse = StringField(required=True)
parameters = ListField(EmbeddedDocumentField(Parameter))
labeledSentences = EmbeddedDocumentListField(LabeledSentences)
trainingData = ListField(required=False)
class BillingDocument(BDocument):
number = StringField(required=True)
beneficiary = DynamicField()
comment = StringField()
doc_date = DateTimeField()
attached_files = EmbeddedDocumentListField(AttachedFile)
states = EmbeddedDocumentField(DocumentState)
# owner=
meta = {'abstract': True}
class Business(mongoengine.DynamicDocument):
"""Business Document Schema"""
name = StringField(required=True)
yelp_id = StringField(required=True, unique=True)
location = EmbeddedDocumentField(Location)
latitude = FloatField()
longitude = FloatField()
image_url = StringField()
display_phone = StringField()
open_hours = EmbeddedDocumentListField(OpenHours)
class ProviderDO(Provider):
type = 'DO'
hosts = EmbeddedDocumentListField(HostDO)
# Hard coded for now
token = "Put_Your_Digital_Ocean_Api_Key_Here"
manager = digitalocean.Manager(token=token)
name = 'pythonApi'
region = 'ams2'
image = 'debian-8-x64'
size_slug = '512mb'
backups = False
def list(self):
return self.hosts
def create(self, hostname, ip):
droplet = digitalocean.Droplet(token=self.token,
name=self.name,
region=self.region,
image=self.image,
size_slug=self.size_slug,
backups=self.backups)
droplet.create()
# Wait droplet to start
action = digitalocean.Action(id=droplet.action_ids[0],
token=droplet.token,
droplet_id=droplet.id)
action.load()
action.wait(2)
droplet = self.manager.get_droplet(droplet.id)
host = HostDO(ip=droplet.ip_address, hostname=droplet.name)
self.hosts.append(host)
self.save()
return host
def destroy(self, hostname):
for host in self.hosts:
if host.hostname == hostname:
self.hosts.remove(host)
return host
return None
def update(self, hostname, new_ip=None, new_hostname=None):
for host in self.hosts:
if host.hostname == hostname:
host.ip = new_ip or host.ip
host.hostname = new_hostname or host.hostname
self.hosts.save()
return host
return None
class Reporter(Document):
meta = {'collection': 'test_repoter'}
id = StringField(primary_key=True)
first_name = StringField(required=True)
last_name = StringField(required=True)
email = EmailField()
articles = ListField(ReferenceField(Article))
embedded_articles = ListField(EmbeddedDocumentField(EmbeddedArticle))
embedded_list_articles = EmbeddedDocumentListField(EmbeddedArticle)
awards = ListField(StringField())
class AlertsLog(EmbeddedDocument):
"""Log of Alerts."""
log = EmbeddedDocumentListField('Alerts')
count = IntField(default=100)
# Meta
schema_version = IntField(default=1)
meta = {'strict': False}
def trim(self):
"""Trim the log to the specified size."""
if len(self.log) > self.count:
self.log = self.log[:self.count]
def record_alerts(self, alerts, timestamp):
"""Take in a new list of alerts.
alerts (list): [str]
"""
newalerts = Alerts(active=alerts)
newalerts.timestamp = timestamp
self.log = [newalerts] + self.log
def remove_alert(self, idx=0):
"""Delete the alert at the index. First by default."""
if self.log:
self.log.pop(idx)
def get_alerts(self, idx):
"""Get the alerts at the given lookback index."""
try:
return set(self.log[idx].active)
except IndexError:
return set()
@property
def newest(self):
"""Most recent alerts."""
return self.get_alerts(0)
@property
def newactive(self):
"""Newly active alerts."""
return self.get_alerts(0) - self.get_alerts(1)
@property
def newinactive(self):
"""Newly inactive alerts."""
return self.get_alerts(1) - self.get_alerts(0)
def clear(self):
"""Delete all alerts."""
self.log = []
class EmailSettings(EmbeddedDocument):
subject = StringField(required=True)
field = StringField(required=True)
fromName = StringField(null=True)
replyTo = StringField(required=True)
include_feedback = BooleanField()
feedback_list = BooleanField()
list_question = StringField()
list_options = EmbeddedDocumentListField(Option)
list_type = StringField(choices=("dropdown", "radio"))
feedback_textbox = BooleanField()
textbox_question = StringField()
class TableColumns(EmbeddedDocument):
label = StringField(required=True)
name = StringField(required=True)
type = StringField(default="text")
description = StringField(default=None)
unit = StringField(default=None)
order_by = StringField(default='')
is_orderable = BooleanField(default=False)
is_searchable = BooleanField(default=False)
is_editable = BooleanField(default=False)
is_required = BooleanField(default=False)
is_global_searchable = BooleanField(default=False)
rounded = BooleanField(default=False)
is_callable = BooleanField(default=False)
show_in = EmbeddedDocumentListField(
AllowPropertyNamespace,
default=[AllowPropertyNamespace(**{
"name": "default",
"allow": True
})])
order_in = EmbeddedDocumentListField(
ValuePropertyNamespace,
default=[ValuePropertyNamespace(**{
"name": "default",
"value": 0
})])
# is_icon = BooleanField(default=False)
icon_name = StringField()
is_extended = BooleanField(default=False)
colspan = IntField(default=1)
style_classes = EmbeddedDocumentListField(TableClasses)
# TO REMOVE
is_ref = BooleanField(default=False)
module = StringField(default=None)
model = StringField(default=None)
class Service(Document):
"""
Represents a service instance.
"""
id = UUIDField(primary_key=True, default=uuid4)
created_at = DateTimeField(default=datetime.utcnow)
status = StringField()
descriptor = DictField(required=True)
functions = EmbeddedDocumentListField(Function, required=True)
placement = DictField()
class TrainedModel(Document):
machine_name = StringField(required=True)
model_name = StringField(required=True)
dataset_name = StringField(required=True)
run = IntField(required=True)
train_temperature = StringField(required=True)
all_history = MapField(EmbeddedDocumentListField(MetricHistoryRecord))
best_history = MapField(EmbeddedDocumentListField(MetricHistoryRecord))
created_at = DateTimeField(required=True, default=datetime.datetime.now)
updated_at = DateTimeField(required=True, default=datetime.datetime.now)
meta = meta = {
'indexes': [
{
'fields':
['model_name', 'dataset_name', '+run', 'train_temperature'],
'unique':
True,
},
'#machine_name',
'#model_name',
'#dataset_name',
'+run',
'#train_temperature',
'-created_at',
'-updated_at',
],
}
def clean(self):
self.model_name = self.model_name.lower()
self.dataset_name = self.dataset_name.lower()
self.train_temperature = self.train_temperature.lower()
self.updated_at = datetime.datetime.now()
super().clean()
class Company(Document):
name = StringField(required=True, unique=True)
products = EmbeddedDocumentListField(Product, default=list)
@staticmethod
def buildOne(company):
return {
'id': str(company.id),
'name': company.name,
'products': Product.buildMany(company.products)
}
@staticmethod
def buildMany(companies):
return list(map(lambda company: Company.buildOne(company), companies))
class Field(EmbeddedDocument):
name = StringField(required=True)
type = StringField(required=True)
textDisplay = StringField(null=True)
textArea = BooleanField(null=True)
maxLength = IntField(null=True)
multiSelect = BooleanField(null=True)
options = EmbeddedDocumentListField(Option)
listStyle = StringField(null=True)
alignment = StringField(null=True)
minimum = IntField(null=True)
maximum = IntField(null=True)
precision = IntField(null=True)
interval = FloatField(null=True)
numberDisplay = StringField(null=True)
useIcon = BooleanField(null=True)
columns = ListField(StringField())
class Connection(EmbeddedDocument):
dbType = StringField(
choices=(
"mysql",
"postgresql",
"sqlite",
"mssql",
"csvTextFile",
"xlsXlsxFile",
"s3BucketFile",
),
required=True,
)
host = StringField()
port = IntField()
database = StringField()
user = StringField()
password = StringField()
query = StringField()
bucket = StringField()
files = EmbeddedDocumentListField(File)
class Person(Document):
"""Model to hold the information of the people in Paranuara"""
meta = {'collection': 'people'}
index = IntField(required=True)
guid = StringField()
has_died = BooleanField(required=True)
balance = StringField()
picture = URLField()
age = IntField()
eyeColor = StringField(required=True)
name = StringField(required=True)
gender = StringField(choices=['male', 'female'])
company_id = IntField(required=True)
email = EmailField()
phone = StringField()
address = StringField()
about = StringField()
registered = StringField()
tags = ListField(StringField())
friends = EmbeddedDocumentListField(Friend)
greeting = StringField()
favouriteFood = ListField(StringField())
class Form(Document):
container = ReferenceField(
Container, required=True,
reverse_delete_rule=2) # Cascade delete if container is deleted
datalab = ReferenceField(
Datalab, required=True,
reverse_delete_rule=2) # Cascade delete if view is deleted
name = StringField(required=True)
description = StringField(null=True)
primary = StringField(required=True)
visibleFields = ListField(StringField())
fields = EmbeddedDocumentListField(Field, required=True)
layout = StringField(choices=("vertical", "table"), default="table")
activeFrom = DateTimeField(null=True)
activeTo = DateTimeField(null=True)
ltiAccess = BooleanField(default=False)
emailAccess = BooleanField(default=False)
permission = StringField(null=True)
groupBy = StringField(null=True)
searchBy = ListField(StringField())
data = ListField(DictField())
permitted_users = ListField(StringField())
restriction = StringField(choices=("private", "limited", "open"),
default="private")
# Flat representation of which users should see this form when they load the dashboard
def refresh_access(self):
users = set(
record.get(self.permission, "").lower()
for record in self.datalab.relations)
for invalid_value in [None, ""]:
if invalid_value in users:
users.remove(invalid_value)
self.permitted_users = list(users)
self.save()