class Media(Document):
owner = LazyReferenceField('User', required=True)
folder = StringField(required=True)
filename = StringField(unique_with=('folder', 'private'))
file = FileField()
dir = BooleanField()
container = BooleanField(default=False)
metadata = DictField()
processing = BooleanField(default=False)
percentDone = FloatField()
private = BooleanField(default=False)
associatedMedia = ListField(
LazyReferenceField('Media', reverse_delete_rule=PULL))
if MongoSettings.DEFAULT_CONNECT_URI != MongoSettings.MEDIA_CONNECT_URI:
meta = {'db_alias': 'media-db'}
@classmethod
def post_save(cls, sender, document: Media, **kwargs):
message = None
if not (document.private or document.processing):
message = {
'type': 'update',
'payload': {
'folder': document.folder,
'created': kwargs['created']
}
}
elif document.processing:
message = {
'type': 'processing update',
'payload': {
'id': str(document.id),
'percentDone': document.percentDone
}
}
if message:
# Workaround to allow sending in normal and async methods as mediaBrowserManger.broadcast is async
try:
loop = asyncio.get_running_loop()
except RuntimeError:
loop = None
if loop and loop.is_running():
loop.create_task(mediaBrowserManager.broadcast(message))
else:
asyncio.run(mediaBrowserManager.broadcast(message))
def serialize(self, associatedMedia: Optional[bool] = False):
out = {
'id': str(self.id),
'owner': str(self.owner.id),
'folder': self.folder,
'filename': self.filename
}
if self.dir and not associatedMedia:
out['dir'] = self.dir
if self.container:
out['container'] = self.container
size = 0
for subMedia in self.associatedMedia:
subMedia = subMedia.fetch()
if subMedia.file:
size += subMedia.file.length
out['size'] = size
if self.file:
out['mimetype'] = self.file.content_type
out['size'] = self.file.length
if self.metadata:
out['metadata'] = self.metadata
if self.associatedMedia and not associatedMedia:
out['associatedMedia'] = list(
map(lambda m: m.fetch().serialize(True), self.associatedMedia))
if self.processing:
out['processing'] = self.processing
out['percentDone'] = self.percentDone
if self.private:
out['private'] = self.private
return out
class Trade(EmbeddedDocument):
quantity = FloatField()
trade_type = StringField()
price = FloatField()
timestamp = DateTimeField()
class DbBarData(Document):
"""
Candlestick bar data for database storage.
Index is defined unique with datetime, interval, symbol
"""
symbol: str = StringField()
exchange: str = StringField()
datetime: datetime = DateTimeField()
interval: str = StringField()
volume: float = FloatField()
open_interest: float = FloatField()
open_price: float = FloatField()
high_price: float = FloatField()
low_price: float = FloatField()
close_price: float = FloatField()
meta = {
"indexes": [
{
"fields": ("symbol", "exchange", "interval", "datetime"),
"unique": True,
}
]
}
@staticmethod
def from_bar(bar: BarData):
"""
Generate DbBarData object from BarData.
"""
db_bar = DbBarData()
db_bar.symbol = bar.symbol
db_bar.exchange = bar.exchange.value
db_bar.datetime = bar.datetime
db_bar.interval = bar.interval.value
db_bar.volume = bar.volume
db_bar.open_interest = bar.open_interest
db_bar.open_price = bar.open_price
db_bar.high_price = bar.high_price
db_bar.low_price = bar.low_price
db_bar.close_price = bar.close_price
return db_bar
def to_bar(self):
"""
Generate BarData object from DbBarData.
"""
bar = BarData(
symbol=self.symbol,
exchange=Exchange(self.exchange),
datetime=self.datetime,
interval=Interval(self.interval),
volume=self.volume,
open_interest=self.open_interest,
open_price=self.open_price,
high_price=self.high_price,
low_price=self.low_price,
close_price=self.close_price,
gateway_name="DB",
)
return bar
class Score(Document):
class_id = StringField()
qbank_code = StringField()
student_id = StringField()
student_name = StringField()
score = FloatField()
class CAIM(Request):
full_name = 'Cancelación de asignaturas con carga inferior a la mínima'
percentaje = FloatField(display='Porcentaje de avance de carrrera')
enrollments = IntField(display='Número de matrículas')
gpa = FloatField(display='P.A.P.A.')
available_credits = IntField(display='Créditos disponibles')
remaining_credits = IntField(display='Créditos restantes')
subjects = EmbeddedDocumentListField(
Subject, required=True, display='Asignaturas')
regulation_list = ['008|2008|CSU'] # List of regulations
str_cm = [
'cursar el periodo académico {} con un número de créditos inferior al mínimo exigido, ',
'cancelar la(s) siguiente(s) asignatura(s) inscrita(s) del periodo {}.',
'debido a que {}realiza debidamente la solicitud.',
'(Artículo 10 del {}).',
'(Artículo 15 del {}).'
]
str_pcm = [
'SIA: Porcentaje de avance en el plan: {}%. Número de matrículas: {}. P.A.P.A.: {}.',
'SIA: Créditos disponibles: {}. ',
'SIA: Al aprobar la cancelación de la(s) asignatura(s) solicitada(s) el estudiante ' +
'quedaría con {} créditos inscritos.'
]
def cm(self, docx):
if self.is_affirmative_response_approval_status():
self.cm_ap(docx)
else:
self.cm_na(docx)
def cm_ap(self, docx):
paragraph = docx.add_paragraph()
paragraph.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
paragraph.paragraph_format.space_after = Pt(0)
paragraph.add_run(self.str_council_header + ':')
paragraph = docx.add_paragraph()
paragraph.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
paragraph.style = 'List Bullet'
self.cm_answer(paragraph)
paragraph.add_run(self.str_cm[2].format('') + ' ')
paragraph.add_run(self.str_cm[3].format(
Request.regulations[self.regulation_list[0]][0]))
paragraph = docx.add_paragraph()
paragraph.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
paragraph.style = 'List Bullet'
paragraph.add_run(
# pylint: disable=no-member
self.get_approval_status_display().upper()).font.bold = True
paragraph.add_run(' ' + self.str_cm[1].format(
self.academic_period) + ' ')
paragraph.add_run(self.str_cm[4].format(
Request.regulations[self.regulation_list[0]][0]))
table_subjects(docx, Subject.subjects_to_array(self.subjects))
def cm_na(self, docx):
paragraph = docx.add_paragraph()
paragraph.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
paragraph.paragraph_format.space_after = Pt(0)
paragraph.add_run(self.str_council_header + ' ')
self.cm_answer(paragraph)
paragraph.add_run(self.str_cm[2].format('no ') + ' ')
paragraph.add_run(self.str_cm[3].format(
Request.regulations[self.regulation_list[0]][0]))
def cm_answer(self, paragraph):
paragraph.add_run(
# pylint: disable=no-member
self.get_approval_status_display().upper() + ' ').font.bold = True
# pylint: disable=no-member
paragraph.add_run(self.str_cm[0].format(self.academic_period))
def pcm(self, docx):
self.pcm_analysis(docx)
if self.is_affirmative_response_advisor_response():
self.pcm_ap(docx)
else:
self.pcm_na(docx)
def pcm_ap(self, docx):
paragraph = docx.add_paragraph()
paragraph.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
paragraph.paragraph_format.space_after = Pt(0)
paragraph.add_run(self.str_comittee_header + ':')
paragraph = docx.add_paragraph()
paragraph.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
paragraph.style = 'List Bullet'
self.pcm_answer(paragraph)
paragraph.add_run(self.str_cm[2].format('') + ' ')
paragraph.add_run(self.str_cm[3].format(
Request.regulations[self.regulation_list[0]][0]))
paragraph = docx.add_paragraph()
paragraph.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
paragraph.style = 'List Bullet'
paragraph.add_run(
# pylint: disable=no-member
self.get_advisor_response_display().upper()).font.bold = True
paragraph.add_run(' ' + self.str_cm[1].format(
self.academic_period) + ' ')
paragraph.add_run(self.str_cm[4].format(
Request.regulations[self.regulation_list[0]][0]))
table_subjects(docx, Subject.subjects_to_array(self.subjects))
def pcm_na(self, docx):
paragraph = docx.add_paragraph()
paragraph.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
paragraph.paragraph_format.space_after = Pt(0)
paragraph.add_run(self.str_comittee_header + ' ')
self.pcm_answer(paragraph)
paragraph.add_run(self.str_cm[2].format('no ') + ' ')
paragraph.add_run(self.str_cm[3].format(
Request.regulations[self.regulation_list[0]][0]))
def pcm_answer(self, paragraph):
paragraph.add_run(
# pylint: disable=no-member
self.get_advisor_response_display().upper() + ' ').font.bold = True
# pylint: disable=no-member
paragraph.add_run(self.str_cm[0].format(self.academic_period))
def pcm_analysis(self, docx):
analysis_list = []
analysis_list += [self.str_pcm[0].format(
self.percentaje,
self.enrollments,
self.gpa
)]
analysis_list += [self.str_pcm[1].format(
self.available_credits
)]
analysis_list += [self.str_pcm[2].format(
self.remaining_credits
)]
analysis_list += self.extra_analysis
add_analysis_paragraph(docx, analysis_list)
class Pokemon(Document):
name = StringField(required=True)
price = FloatField(required=True)
description = StringField(required=True)
class Meals(Document):
name = StringField(required=True)
description = StringField(max_length=240)
price = FloatField()
image_url = StringField()
class Grade(EmbeddedDocument):
name = StringField(required=True)
score = FloatField(required=True)
class BCCVesselTypeSizePrice(Document):
__tablename__ = 'bcc_vessel_size_price'
type = ReferenceField(BCCVesselType, required=True)
size = ReferenceField(BCCVesselSize, required=True)
fee = FloatField(required=True)
class EncodeStream(HardwareStream):
def __init__(self, *args, **kwargs):
super(EncodeStream, self).__init__(*args, **kwargs)
relay_video = BooleanField(default=constants.DEFAULT_RELAY_VIDEO,
required=True)
relay_audio = BooleanField(default=constants.DEFAULT_RELAY_AUDIO,
required=True)
deinterlace = BooleanField(default=constants.DEFAULT_DEINTERLACE,
required=True)
frame_rate = IntField(default=constants.INVALID_FRAME_RATE, required=True)
volume = FloatField(default=constants.DEFAULT_VOLUME, required=True)
video_codec = StringField(default=constants.DEFAULT_VIDEO_CODEC,
required=True)
audio_codec = StringField(default=constants.DEFAULT_AUDIO_CODEC,
required=True)
audio_channels_count = IntField(
default=constants.INVALID_AUDIO_CHANNELS_COUNT, required=True)
size = EmbeddedDocumentField(Size, default=Size())
video_bit_rate = IntField(default=constants.INVALID_VIDEO_BIT_RATE,
required=True)
audio_bit_rate = IntField(default=constants.INVALID_AUDIO_BIT_RATE,
required=True)
logo = EmbeddedDocumentField(Logo, default=Logo())
aspect_ratio = EmbeddedDocumentField(Rational, default=Rational())
def get_type(self):
return constants.StreamType.ENCODE
def get_relay_video(self):
return self.relay_video
def get_relay_audio(self):
return self.relay_audio
def config(self) -> dict:
conf = super(EncodeStream, self).config()
conf[ConfigFields.RELAY_VIDEO_FIELD] = self.get_relay_video()
conf[ConfigFields.RELAY_AUDIO_FIELD] = self.get_relay_audio()
conf[ConfigFields.DEINTERLACE_FIELD] = self.get_deinterlace()
frame_rate = self.get_frame_rate()
if frame_rate != constants.INVALID_FRAME_RATE:
conf[ConfigFields.FRAME_RATE_FIELD] = frame_rate
conf[ConfigFields.VOLUME_FIELD] = self.get_volume()
conf[ConfigFields.VIDEO_CODEC_FIELD] = self.get_video_codec()
conf[ConfigFields.AUDIO_CODEC_FIELD] = self.get_audio_codec()
audio_channels = self.get_audio_channels_count()
if audio_channels != constants.INVALID_AUDIO_CHANNELS_COUNT:
conf[ConfigFields.AUDIO_CHANNELS_COUNT_FIELD] = audio_channels
if self.size.is_valid():
conf[ConfigFields.SIZE_FIELD] = str(self.size)
vid_rate = self.get_video_bit_rate()
if vid_rate != constants.INVALID_VIDEO_BIT_RATE:
conf[ConfigFields.VIDEO_BIT_RATE_FIELD] = vid_rate
audio_rate = self.get_audio_bit_rate()
if audio_rate != constants.INVALID_AUDIO_BIT_RATE:
conf[ConfigFields.AUDIO_BIT_RATE_FIELD] = self.get_audio_bit_rate()
if self.logo.is_valid():
conf[ConfigFields.LOGO_FIELD] = self.logo.to_dict()
if self.aspect_ratio.is_valid():
conf[ConfigFields.ASPCET_RATIO_FIELD] = str(self.aspect_ratio)
return conf
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
def fixup_output_urls(self):
return self._fixup_http_output_urls()
@classmethod
def make_stream(cls, settings):
stream = cls()
stream._settings = settings
stream.input = InputUrls(urls=[InputUrl(id=InputUrl.generate_id())])
stream.output = OutputUrls(
urls=[OutputUrl(id=OutputUrl.generate_id())])
return stream
class Coordinates(EmbeddedDocument):
lat = FloatField(default=5)
lng = FloatField(default=5)
update_date = DateTimeField(default=datetime.datetime.now())
class IStream(Document):
meta = {
'collection': 'streams',
'allow_inheritance': True,
'auto_create_index': True
}
created_date = DateTimeField(default=datetime.now) # for inner use
name = StringField(default=constants.DEFAULT_STREAM_NAME,
max_length=constants.MAX_STREAM_NAME_LENGTH,
min_length=constants.MIN_STREAM_NAME_LENGTH,
required=True)
group = StringField(default=constants.DEFAULT_STREAM_GROUP_TITLE,
max_length=constants.MAX_STREAM_GROUP_TITLE_LENGTH,
min_length=constants.MIN_STREAM_GROUP_TITLE_LENGTH,
required=True)
tvg_id = StringField(default=constants.DEFAULT_STREAM_TVG_ID,
max_length=constants.MAX_STREAM_TVG_ID_LENGTH,
min_length=constants.MIN_STREAM_TVG_ID_LENGTH,
required=True)
tvg_name = StringField(default=constants.DEFAULT_STREAM_TVG_NAME,
max_length=constants.MAX_STREAM_NAME_LENGTH,
min_length=constants.MIN_STREAM_NAME_LENGTH,
required=True) #
tvg_logo = StringField(default=constants.DEFAULT_STREAM_ICON_URL,
max_length=constants.MAX_URL_LENGTH,
min_length=constants.MIN_URL_LENGTH,
required=True) #
price = FloatField(default=0.0,
min_value=constants.MIN_PRICE,
max_value=constants.MAX_PRICE,
required=True)
output = EmbeddedDocumentField(OutputUrls, default=OutputUrls()) #
def get_groups(self) -> list:
return self.group.split(';')
def to_dict(self) -> dict:
return {
StreamFields.NAME: self.name,
StreamFields.ID: self.get_id(),
StreamFields.TYPE: self.get_type(),
StreamFields.ICON: self.tvg_logo,
StreamFields.PRICE: self.price,
StreamFields.GROUP: self.group
}
def __init__(self, *args, **kwargs):
super(IStream, self).__init__(*args, **kwargs)
self._settings = None
def set_server_settings(self, settings):
self._settings = settings
def get_type(self):
raise NotImplementedError('subclasses must override get_type()!')
def get_id(self) -> str:
return str(self.id)
def config(self) -> dict:
return {
ConfigFields.ID_FIELD: self.get_id(), # required
ConfigFields.TYPE_FIELD: self.get_type(), # required
ConfigFields.OUTPUT_FIELD:
self.output.to_mongo() # required empty in timeshift_record
}
def fixup_output_urls(self):
return
def reset(self):
return
def generate_playlist(self, header=True) -> str:
result = '#EXTM3U\n' if header else ''
stream_type = self.get_type()
if stream_type == constants.StreamType.RELAY or \
stream_type == constants.StreamType.ENCODE or \
stream_type == constants.StreamType.TIMESHIFT_PLAYER or \
stream_type == constants.StreamType.VOD_ENCODE or \
stream_type == constants.StreamType.VOD_RELAY or \
stream_type == constants.StreamType.COD_ENCODE or \
stream_type == constants.StreamType.COD_RELAY or \
stream_type == constants.StreamType.PROXY:
for out in self.output.urls:
result += '#EXTINF:-1 tvg-id="{0}" tvg-name="{1}" tvg-logo="{2}" group-title="{3}",{4}\n{5}\n'.format(
self.tvg_id, self.tvg_name, self.tvg_logo, self.group,
self.name, out.uri)
return result
def generate_device_playlist(self,
uid: str,
passwd: str,
did: str,
lb_server_host_and_port: str,
header=True) -> str:
result = '#EXTM3U\n' if header else ''
stream_type = self.get_type()
if stream_type == constants.StreamType.PROXY or \
stream_type == constants.StreamType.VOD_PROXY or \
stream_type == constants.StreamType.RELAY or \
stream_type == constants.StreamType.ENCODE or \
stream_type == constants.StreamType.TIMESHIFT_PLAYER or \
stream_type == constants.StreamType.VOD_ENCODE or \
stream_type == constants.StreamType.VOD_RELAY or \
stream_type == constants.StreamType.COD_ENCODE or \
stream_type == constants.StreamType.COD_RELAY:
for out in self.output.urls:
parsed_uri = urlparse(out.uri)
if parsed_uri.scheme == 'http' or parsed_uri.scheme == 'https':
file_name = os.path.basename(parsed_uri.path)
url = 'http://{0}/{1}/{2}/{3}/{4}/{5}/{6}'.format(
lb_server_host_and_port, uid, passwd, did, self.id,
out.id, file_name)
result += '#EXTINF:-1 tvg-id="{0}" tvg-name="{1}" tvg-logo="{2}" group-title="{3}",{4}\n{5}\n'.format(
self.tvg_id, self.tvg_name, self.tvg_logo, self.group,
self.name, url)
return result
def generate_input_playlist(self, header=True) -> str:
raise NotImplementedError(
'subclasses must override generate_input_playlist()!')
def save(self, *args, **kwargs):
super(IStream, self).save(*args, **kwargs)
self.fixup_output_urls()
return super(IStream, self).save(*args, **kwargs)
class Coupon(Post):
code = StringField(unique=True)
discountType = StringField(choices=['percent', 'dollar'])
discount = FloatField()
storeWide = BooleanField(default=False)
applicableProducts = ListField(ReferenceField('Product'))
uses = IntField(default=0)
maxUses = IntField(default=-1)
@classmethod
def schema(cls):
return super().schema() + [{
'name': 'code',
'niceName': 'Code',
'controlType': 'input'
}, {
'name':
'discountType',
'niceName':
'Discount Type',
'controlType':
'select',
'options': [{
'key': 'Percent',
'value': 'percent'
}, {
'key': 'Dollar',
'value': 'dollar'
}]
}, {
'name': 'discount',
'niceName': 'Discount',
'controlType': 'input',
'type': 'number'
}, {
'name': 'storeWide',
'niceName': 'Store wide',
'controlType': 'checkbox'
}, {
'name': 'applicableProducts',
'niceName': 'Applicable Products',
'controlType': 'post-select',
'type': 'models.Product',
'multiple': True
}, {
'name': 'maxUses',
'niceName': 'Max Uses',
'controlType': 'input',
'type': 'number'
}]
def serialize(self):
return {
**super().serialize(), 'code':
self.code,
'discountType':
self.discountType,
'discount':
self.discount,
'storeWide':
self.storeWide,
'applicableProducts':
list(map(lambda p: str(p.id), self.applicableProducts)),
'uses':
self.uses,
'maxUses':
self.maxUses
}
class Product(Post):
sku = StringField()
img = ListField(ReferenceField('Media', reverse_delete_rule=PULL))
price = DecimalField(precision=2)
digital = BooleanField(default=False)
taxable = BooleanField(default=True)
hasStock = BooleanField(default=False)
stock = IntField()
totalReviews = IntField(default=0)
avgReviewScore = FloatField(default=0)
def addReview(self, score):
self.avgReviewScore = ((self.avgReviewScore * self.totalReviews) +
int(score)) / (self.totalReviews + 1)
self.totalReviews = self.totalReviews + 1
@classmethod
def schema(cls):
return super().schema() + [{
'name': 'sku',
'niceName': 'SKU',
'controlType': 'input'
}, {
'name': 'img',
'niceName': 'Images',
'controlType': 'media-browser',
'multiple': True
}, {
'name': 'price',
'niceName': 'Price',
'controlType': 'input',
'type': 'number'
}, {
'name': 'digital',
'niceName': 'Digital',
'controlType': 'checkbox'
}, {
'name': 'taxable',
'niceName': 'Taxable',
'controlType': 'checkbox'
}, {
'name': 'hasStock',
'niceName': 'Has Stock',
'controlType': 'checkbox'
}, {
'name': 'stock',
'niceName': 'Stock',
'controlType': 'input',
'type': 'number',
'validators': {
'required': True
}
}]
def serialize(self):
return {
**super().serialize(),
'sku': self.sku,
'img': list(map(lambda m: str(m.id), self.img)),
'price': float(self.price) if self.price else None,
"digital": self.digital,
"taxable": self.taxable,
'hasStock': self.hasStock,
'stock': self.stock,
'totalReviews': self.totalReviews,
'avgReviewScore': round(self.avgReviewScore,
1) # Round to 1 decimal place
}
class REINPRE(Request):
RL_ANSWER_RENOV_MATRICULA = 'RM'
RL_ANSWER_PAPA = 'PA'
RL_ANSWER_CUPO_CREDITOS = 'CC'
RL_ANSWER_SANCION = 'SA'
RL_ANSWER_OTRO = 'OT'
RL_ANSWER_CHOICES = ((
RL_ANSWER_RENOV_MATRICULA,
'No cumplir con los requisitos exigidos para la' +
' renovación de la matrícula, en los plazos señalados por la Universidad.'
), (
RL_ANSWER_PAPA,
'Presentar un Promedio Aritmético Ponderado Acumulado menor que tres punto cero (3.0).'
), (
RL_ANSWER_CUPO_CREDITOS,
'No disponer de un cupo de créditos suficiente para inscribir las asignaturas'
+ ' del plan de estudios pendientes de aprobación.'
), (RL_ANSWER_SANCION,
'Recibir sanción disciplinaria de expulsión o suspensión impuesta de acuerdo'
+ ' con las normas vigentes.'), (RL_ANSWER_OTRO, 'Otro.'))
full_name = 'Reingreso Pregrado'
regulation_list = ['008|2008|CSU', '239|2009|VAC', '012|2014|VAC']
reing_period = StringField(required=True,
display='Periodo de reingreso',
choices=Request.PERIOD_CHOICES,
default=Request.PERIOD_DEFAULT)
loss_period = StringField(
required=True,
display='Periodo de perdida de calidad de estudiante',
choices=Request.PERIOD_CHOICES,
default=Request.PERIOD_DEFAULT)
first_reing = BooleanField(required=True,
display='Primer reingreso',
default=True)
admission_period = StringField(required=True,
display='Periodo de admisión',
choices=Request.PERIOD_CHOICES,
default=Request.PERIOD_DEFAULT)
periods_since = IntField(
required=True,
display='periodos desde pérdida de calidad de estudiante',
default=0)
papa = FloatField(required=True, display='PAPA', default=0.0)
reason_of_loss = StringField(choices=RL_ANSWER_CHOICES,
default=RL_ANSWER_OTRO,
display='Razón pérdida calidad de estudiante')
credits_minus_remaining = IntField(
required=True,
display='Cupo de créditos menos créditos pendientes',
default=0)
credits_remaining = IntField(required=True,
display='Créditos restantes',
default=0)
credits_english = IntField(required=True,
display='Créditos inglés',
default=0)
credits_add = IntField(
required=True,
display='Créditos requeridos para inscribir asignaturas',
default=0)
min_grade_12c = StringField(
required=True,
display='Promedio semestral mínimo requerido para mantener la ' +
'calidad de estudiante con 12 créditos inscritos: ',
default='')
min_grade_15c = StringField(
required=True,
display='Promedio semestral mínimo requerido para mantener la ' +
'calidad de estudiante con 15 créditos inscritos: ',
default='')
min_grade_18c = StringField(
required=True,
display='Promedio semestral mínimo requerido para mantener la ' +
'calidad de estudiante con 18 créditos inscritos: ',
default='')
min_grade_21c = StringField(
required=True,
display='Promedio semestral mínimo requerido para mantener la ' +
'calidad de estudiante con 21 créditos inscritos: ',
default='')
# Exiged credits
exi_fund_m = IntField(
required=True,
display='Créditos de fundamentación obligatorios exigidos',
default=0)
exi_fund_o = IntField(
required=True,
display='Créditos de fundamentación optativos exigidos',
default=0)
exi_disc_m = IntField(
required=True,
display='Créditos disciplinares obligatorios exigidos',
default=0)
exi_disc_o = IntField(required=True,
display='Créditos disciplinares optativos exigidos',
default=0)
exi_free = IntField(required=True,
display='Créditos de libre elección exigidos',
default=0)
# Approved credits
app_fund_m = IntField(
required=True,
display='Créditos de fundamentación obligatorios aprobados',
default=0)
app_fund_o = IntField(
required=True,
display='Créditos de fundamentación optativos aprobados',
default=0)
app_disc_m = IntField(
required=True,
display='Créditos disciplinares obligatorios aprobados',
default=0)
app_disc_o = IntField(required=True,
display='Créditos disciplinares optativos aprobados',
default=0)
app_free = IntField(required=True,
display='Créditos de libre elección aprobados',
default=0)
# Remaining credits
rem_fund_m = IntField(
required=True,
display='Créditos de fundamentación obligatorios restantes',
default=0)
rem_fund_o = IntField(
required=True,
display='Créditos de fundamentación optativos restantes',
default=0)
rem_disc_m = IntField(
required=True,
display='Créditos disciplinares obligatorios restantes',
default=0)
rem_disc_o = IntField(required=True,
display='Créditos disciplinares optativos restantes',
default=0)
rem_free = IntField(required=True,
display='Créditos de libre elección restantes',
default=0)
comitee_act = StringField(required=True,
display='Número de acta de comité',
default='00')
comitee_date = DateField(required=True,
display='Fecha de reunión del comité',
default=datetime.date.today)
# Pre-cm variables
request_in_date = BooleanField(display='Solicitud a tiempo', default=True)
credits_granted = IntField(display='Créditos otorgados', default=0)
str_pcm_pre = [
# Used in pcm and cm:
'reingreso por única vez a partir del periodo académico ',
'Si el estudiante no renueva su matrícula en el semestre de reingreso, el acto'
+ ' académico expedido por el Consejo de Facultad queda sin efecto.',
'1. Datos Generales:',
'2. Información Académica:',
'3. Resumen general de créditos del plan de estudios:',
'*Sin incluir los créditos correspondientes al cumplimiento del requisito de'
+ ' suficiencia en idioma.',
# Used only in pcm:
'El estudiante ',
' tiene pendiente por aprobar ',
' créditos del plan de estudios de ',
' y ',
' créditos del requisito de nivelación',
' - inglés, con un cupo disponible para inscripción de ',
' créditos.',
'El parágrafo del artículo 11 del ',
'Superior Universitario establece: ',
'"Los créditos adicionales que como resultado del ' +
'proceso de clasificación en la admisión deba aprobar ' +
'un estudiante de pregrado, se sumarán por única vez al "' +
'cupo adicional de créditos para inscripción"',
', por lo tanto solo es viable otorgar ',
' crédito(s) para la inscripción de asignaturas pendientes del plan de estudios de ',
# Extra credits (optional):
'y otorga ',
' crédito(s) adicional(es) para culminar su plan de estudios. '
]
str_analysis = [
'{}a tenido otro reingreso después de 2009-01 (Artículo 46, {}). ' +
'Universitas y SIA: Revisado.',
'Si perdió calidad antes de 2009-01: Equivalencias incluyendo las asignaturas '
+
'perdidas. Comité Asesor asigna créditos a las que no tengan equivalencias '
+
'(Artículo 3, {}). Universitas y SIA: Pérdida de calidad de estudiante al '
+ 'finalizar {} por {}',
'{}iene PAPA superior o igual a 2.7 (literal 3b – Artículo 3, {}; Artículo 46, '
+ '{}). SIA: PAPA de {}.',
'{}ispone de un cupo suficiente de créditos: Cupo adicional de 10 créditos a lo sumo '
+
'(parágrafo 1 Artículo 46, {}). SIA: {} creditos. En caso de otorgarle un cupo adicional '
+
'de créditos, éste no podrá ser mayor que el requerido para inscribir las asignaturas '
+ 'pendientes del plan de estudios. (Artículo 6, {}).',
'La solicitud {}se hace en fechas de calendario de sede.'
]
str_pcm_pre_acadinfo = [
'Periodo para el cual fue admitido en este plan de estudios',
'¿Se trata de un primer reingreso?',
'Si la respuesta es NO, el Comité Asesor no debe recomendar al Consejo '
+ 'de Facultad el reingreso',
'Es caso de ser primer reingreso en ¿qué periodo académico perdió la '
+ 'calidad de estudiante?',
'Al momento de presentar la solicitud ¿cuántos periodos académicos (incluido'
+
' el periodo académico en que presentó la solicitud) han transcurridos a partir'
+ ' del periodo académico en que registró su última matrícula?',
'En caso que la respuesta sea mayor de 6 periodos académicos no se debe '
+ 'recomendar el reingreso',
'P.A.P.A.',
'Causa de la pérdida de la calidad de estudiante',
'Estudio de créditos',
'Cupo de créditos menos créditos pendientes',
'Créditos pendientes por ser aprobados del plan de estudios',
'Créditos pendientes por ser aprobados de nivelación – Inglés',
'¿Cuántos créditos adicionales requiere para inscribir asignaturas?',
# Optional: Grade needed with N credits to keep student condition.
'Al finalizar el semestre de reingreso para mantener la calidad de estudiante,'
+ ' deberá obtener un promedio semestral mínimo de:',
'Si inscribe 12 Créditos',
'Si inscribe 15 Créditos',
'Si inscribe 18 Créditos',
'Si inscribe 21 Créditos'
]
str_out_date = [
'reingreso por única vez a partir del periodo académico {}, porque el estudiante '
+
'presentó la solicitud fuera de las fechas establecidas en el Calendario Académico '
+ 'de la Sede Bogotá.'
]
def rein_general_data_table(self, docx):
# pylint: disable=no-member
general_data = [
['Estudiante', self.student_name], ['DNI', self.student_dni],
['Plan de estudios',
self.get_academic_program_display()],
['Código del plan de estudios', self.academic_program],
['Fecha de la solicitud',
string_to_date(str(self.date))]
]
case = 'REINGRESO'
paragraph = docx.add_paragraph()
paragraph.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
paragraph.paragraph_format.space_after = Pt(0)
bullet = paragraph.add_run(self.str_pcm_pre[2])
bullet.font.bold = True
bullet.font.size = Pt(8)
table_general_data(general_data, case, docx)
def rein_academic_info(self, docx):
paragraph = docx.add_paragraph()
paragraph.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
paragraph.paragraph_format.space_after = Pt(0)
bullet = paragraph.add_run(self.str_pcm_pre[3])
bullet.font.bold = True
bullet.font.size = Pt(8)
table = docx.add_table(rows=13, cols=3)
table.style = 'Table Grid'
table.style.font.size = Pt(8)
table.alignment = WD_ALIGN_PARAGRAPH.CENTER
for cell in table.columns[0].cells:
cell.width = 400000
for cell in table.columns[1].cells:
cell.width = 3200000
for cell in table.columns[2].cells:
cell.width = 1600000
table.columns[0].width = 400000
table.columns[1].width = 3200000
table.columns[2].width = 1600000
table.cell(0, 0).merge(table.cell(0, 1)).paragraphs[0].add_run(
self.str_pcm_pre_acadinfo[0])
table.cell(0, 2).paragraphs[0].add_run(self.admission_period)
table.cell(0, 2).paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
table.cell(1, 0).merge(table.cell(1, 1)).paragraphs[0].add_run(
self.str_pcm_pre_acadinfo[1])
if self.first_reing:
table.cell(1, 2).paragraphs[0].add_run('Sí')
else:
table.cell(1, 2).paragraphs[0].add_run('No')
table.cell(1, 2).paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
table.cell(2, 0).merge(table.cell(2, 2)).paragraphs[0].add_run(
self.str_pcm_pre_acadinfo[2])
table.cell(3, 0).merge(table.cell(3, 1)).paragraphs[0].add_run(
self.str_pcm_pre_acadinfo[3])
table.cell(3, 2).paragraphs[0].add_run(self.loss_period)
table.cell(3, 2).vertical_alignment = WD_ALIGN_VERTICAL.CENTER
table.cell(3, 2).paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
table.cell(4, 0).merge(table.cell(4, 1)).paragraphs[0].add_run(
self.str_pcm_pre_acadinfo[4])
table.cell(4, 2).paragraphs[0].add_run(str(self.periods_since))
table.cell(4, 2).vertical_alignment = WD_ALIGN_VERTICAL.CENTER
table.cell(4, 2).paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
table.cell(5, 0).merge(table.cell(5, 2)).paragraphs[0].add_run(
self.str_pcm_pre_acadinfo[5])
table.cell(6, 0).merge(table.cell(6, 1)).paragraphs[0].add_run(
self.str_pcm_pre_acadinfo[6])
table.cell(6, 2).paragraphs[0].add_run(str(self.papa))
table.cell(6, 2).paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
table.cell(7, 0).merge(table.cell(7, 1)).paragraphs[0].add_run(
self.str_pcm_pre_acadinfo[7])
table.cell(7, 0).merge(table.cell(
7, 1)).vertical_alignment = WD_ALIGN_VERTICAL.CENTER
table.cell(7, 2).paragraphs[0].add_run(
# pylint: disable=no-member
self.get_reason_of_loss_display())
table.cell(7, 2).paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
table.cell(8, 0).merge(table.cell(8, 2)).paragraphs[0].add_run(
self.str_pcm_pre_acadinfo[8]).font.bold = True
table.cell(9, 0).paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
table.cell(9, 0).paragraphs[0].add_run('1').font.bold = True
table.cell(10, 0).paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
table.cell(10, 0).paragraphs[0].add_run('2').font.bold = True
table.cell(11, 0).paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
table.cell(11, 0).paragraphs[0].add_run('3').font.bold = True
table.cell(12, 0).paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
table.cell(12, 0).paragraphs[0].add_run('4').font.bold = True
table.cell(9, 1).paragraphs[0].add_run(self.str_pcm_pre_acadinfo[9])
table.cell(10, 1).paragraphs[0].add_run(self.str_pcm_pre_acadinfo[10])
table.cell(11, 1).paragraphs[0].add_run(self.str_pcm_pre_acadinfo[11])
table.cell(12, 1).paragraphs[0].add_run(self.str_pcm_pre_acadinfo[12])
table.cell(9,
2).paragraphs[0].add_run(str(self.credits_minus_remaining))
table.cell(9, 2).paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
table.cell(10, 2).paragraphs[0].add_run(str(self.credits_remaining))
table.cell(10, 2).paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
table.cell(11, 2).paragraphs[0].add_run(str(self.credits_english))
table.cell(11, 2).paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
table.cell(12, 2).paragraphs[0].add_run(str(self.credits_add))
table.cell(12, 2).paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
# Optional: Grade needed with N credits to keep student condition.
if self.reason_of_loss == self.RL_ANSWER_CUPO_CREDITOS:
table = docx.add_table(rows=5, cols=2)
for col in table.columns:
for cell in col.cells:
cell.paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.CENTER
table.style = 'Table Grid'
table.style.font.size = Pt(8)
table.alignment = WD_ALIGN_PARAGRAPH.CENTER
for cell in table.columns[0].cells:
cell.width = 3100000
for cell in table.columns[1].cells:
cell.width = 2100000
table.columns[0].width = 3100000
table.columns[1].width = 2100000
table.cell(0, 0).merge(table.cell(
0, 1)).paragraphs[0].alignment = WD_ALIGN_PARAGRAPH.LEFT
table.cell(0, 0).merge(table.cell(0, 1)).paragraphs[0].add_run(
self.str_pcm_pre_acadinfo[13])
table.cell(1,
0).paragraphs[0].add_run(self.str_pcm_pre_acadinfo[14])
table.cell(2,
0).paragraphs[0].add_run(self.str_pcm_pre_acadinfo[15])
table.cell(3,
0).paragraphs[0].add_run(self.str_pcm_pre_acadinfo[16])
table.cell(4,
0).paragraphs[0].add_run(self.str_pcm_pre_acadinfo[17])
table.cell(1, 1).paragraphs[0].add_run(str(self.min_grade_12c))
table.cell(2, 1).paragraphs[0].add_run(str(self.min_grade_15c))
table.cell(3, 1).paragraphs[0].add_run(str(self.min_grade_18c))
table.cell(4, 1).paragraphs[0].add_run(str(self.min_grade_21c))
def rein_credits_summary(self, docx):
paragraph = docx.add_paragraph()
paragraph.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
paragraph.paragraph_format.space_after = Pt(0)
bullet = paragraph.add_run(self.str_pcm_pre[4])
bullet.font.bold = True
bullet.font.size = Pt(8)
credits_data = [[
self.exi_fund_m, self.exi_fund_o, self.exi_disc_m, self.exi_disc_o,
self.exi_free
],
[
self.app_fund_m, self.app_fund_o, self.app_disc_m,
self.app_disc_o, self.app_free
],
[
self.rem_fund_m, self.rem_fund_o, self.rem_disc_m,
self.rem_disc_o, self.rem_free
]]
case = 'REINGRESO'
table_credits_summary(docx, credits_data, case)
paragraph = docx.add_paragraph()
paragraph.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
paragraph.paragraph_format.space_after = Pt(0)
bullet = paragraph.add_run(self.str_pcm_pre[5])
bullet.font.size = Pt(8)
def rein_recommends(self, docx):
details = []
details.append(
# pylint: disable=no-member
self.get_academic_program_display())
# Migrate to case_utils?
year = str(self.comitee_date)[0:4]
month = str(self.comitee_date)[5:7]
day = str(self.comitee_date)[8:10]
details.append(day + '-' + month + '-' + year)
details.append(self.comitee_act)
details.append(str(self.comitee_date)[0:4])
if self.advisor_response == self.ARCR_APROBAR:
details.append(True)
else:
details.append(False)
table_recommend(docx, details)
def extra_credits(self, paragraph):
paragraph.add_run(self.str_pcm_pre[18] + str(self.credits_granted) +
self.str_pcm_pre[19])
def get_analysis(self):
analysis = []
modifier = 'No h' if self.first_reing else 'H'
analysis.append(self.str_analysis[0].format(
modifier, self.regulations['008|2008|CSU'][0]))
analysis.append(self.str_analysis[1].format(
self.regulations['239|2009|VAC'][0],
# pylint: disable=no-member
self.loss_period,
self.get_reason_of_loss_display()))
modifier = 'T' if self.papa >= 2.7 else 'No t'
analysis.append(self.str_analysis[2].format(
modifier, self.regulations['239|2009|VAC'][0],
self.regulations['008|2008|CSU'][0], self.papa))
modifier = 'D' if self.credits_remaining > 0 else 'No d'
analysis.append(self.str_analysis[3].format(
modifier, self.regulations['008|2008|CSU'][0],
self.credits_remaining, self.regulations['012|2014|VAC'][0]))
modifier = '' if self.request_in_date else 'no '
analysis.append(self.str_analysis[4].format(modifier))
return analysis + self.extra_analysis
def pcm(self, docx):
add_analysis_paragraph(docx, self.get_analysis())
paragraph = docx.add_paragraph()
paragraph.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
paragraph.paragraph_format.space_after = Pt(0)
self.pcm_answer(paragraph)
#if self.request_in_date: To ommit tables when the request isn't in time
self.cm_pcm_paragraph(docx)
self.rein_general_data_table(docx)
self.rein_academic_info(docx)
self.rein_credits_summary(docx)
self.rein_recommends(docx)
def cm(self, docx):
paragraph = docx.add_paragraph()
paragraph.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
paragraph.paragraph_format.space_after = Pt(0)
#if self.request_in_date: To ommit tables when the request isn't in time
self.cm_answer(paragraph)
self.rein_general_data_table(docx)
self.rein_academic_info(docx)
self.rein_credits_summary(docx)
self.rein_recommends(docx)
def pcm_answer(self, paragraph):
paragraph.add_run(self.str_answer + ':\n').font.bold = True
paragraph.add_run(self.str_comittee_header + ' ')
paragraph.add_run(
# pylint: disable=no-member
self.get_approval_status_display().upper() + ' ').font.bold = True
if not self.request_in_date:
self.out_of_date_answer(paragraph)
else:
aff = self.is_affirmative_response_advisor_response()
self.standard_answer(paragraph, aff)
def cm_pcm_paragraph(self, docx):
if not self.request_in_date:
return # Skip when it's out of date
para = docx.add_paragraph()
para.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
para.paragraph_format.space_after = Pt(0)
para.add_run(self.str_pcm_pre[6] + self.student_name +
self.str_pcm_pre[7] + str(self.credits_remaining))
para.add_run(self.str_pcm_pre[8] +
# pylint: disable=no-member
self.get_academic_program_display())
para.add_run(self.str_pcm_pre[9] + str(self.credits_english) +
self.str_pcm_pre[10])
para.add_run(self.str_pcm_pre[11])
para.add_run(str(self.credits_remaining +
self.credits_minus_remaining))
para.add_run(self.str_pcm_pre[12])
para = docx.add_paragraph()
para.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
para.paragraph_format.space_after = Pt(0)
para.add_run(self.str_pcm_pre[13] +
self.regulations['008|2008|CSU'][0])
para.add_run(self.str_pcm_pre[14])
para.add_run(self.str_pcm_pre[15]).font.italic = True
para.add_run(self.str_pcm_pre[16] + str(self.credits_granted))
para.add_run(self.str_pcm_pre[17])
para.add_run(
# pylint: disable=no-member
self.get_academic_program_display() + '.')
def cm_answer(self, paragraph):
paragraph.add_run(self.str_council_header + ' ')
paragraph.add_run(
# pylint: disable=no-member
self.get_approval_status_display().upper() + ' ').font.bold = True
aff = self.is_affirmative_response_approval_status()
self.standard_answer(paragraph, aff)
def standard_answer(self, paragraph, affirmative):
paragraph.add_run(self.str_pcm_pre[0])
paragraph.add_run(self.academic_period + ' ')
if self.credits_granted > 0:
# Y otorga n créditos adicionales:
self.extra_credits(paragraph)
if affirmative:
paragraph.add_run(self.str_pcm_pre[1])
else:
paragraph.add_run(self.council_decision + '.')
paragraph.add_run('({}).'.format(self.regulations['012|2014|VAC'][0] +
"; Artículo 46, " +
self.regulations['008|2008|CSU'][0]))
def out_of_date_answer(self, paragraph):
paragraph.add_run(self.str_out_date[0].format(self.reing_period))
class EMCA(Request):
full_name = 'Exención de matrícula por consideración atípica'
percentage = FloatField(
min_value=0.0,
max_value=100.0,
required=True,
display='Porcentaje de exención del valor de la matrícula',
default=0.0)
academic_period_exe = StringField(max_length=10,
display='Periodo de exención',
choices=Request.PERIOD_CHOICES,
default=Request.PERIOD_DEFAULT)
ha_active = BooleanField(default=True,
display='¿Tiene la historia académica activa?')
regulation_list = ['070|2009|CAC'] # List of regulations
str_cm = [
' otorgrar exención del pago de {}% del valor de la matrícula para el periodo '
+ 'académico {}, ', ' ({}).'
]
str_analysis = ['iene la historia académica activa.']
list_analysis = []
def cm(self, docx):
paragraph = docx.add_paragraph()
paragraph.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
paragraph.paragraph_format.space_after = Pt(0)
self.cm_answer(paragraph)
def cm_answer(self, paragraph):
# pylint: disable=no-member
paragraph.add_run(self.str_council_header + ' ')
paragraph.add_run(self.get_approval_status_display().upper() +
' ').font.bold = True
paragraph.add_run(self.str_cm[0].format(self.percentage,
self.academic_period_exe))
paragraph.add_run(self.council_decision)
paragraph.add_run(self.str_cm[1].format(
Request.regulations['070|2009|CAC'][0]))
def pcm(self, docx):
self.pcm_analysis(docx)
self.pcm_answer(docx)
def pcm_answer(self, docx):
# pylint: disable=no-member
paragraph = docx.add_paragraph()
paragraph.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
paragraph.paragraph_format.space_after = Pt(0)
paragraph.add_run(self.str_answer + ': ').font.bold = True
paragraph.add_run(self.str_comittee_header + ' ')
paragraph.add_run(
self.get_advisor_response_display().upper()).font.bold = True
paragraph.add_run(self.str_cm[0].format(self.percentage,
self.academic_period_exe))
paragraph.add_run(self.council_decision)
paragraph.add_run(self.str_cm[1].format(
Request.regulations['070|2009|CAC'][0]))
def pcm_analysis(self, docx):
final_analysis = []
aux = 'T' if self.ha_active else 'No t'
final_analysis += [aux + self.str_analysis[0]]
for extra_a in self.extra_analysis:
final_analysis += [extra_a]
add_analysis_paragraph(docx, final_analysis)
class NetworkModel(Document):
track_length = IntField(required=True)
track_time = FloatField(required=True)
history = DictField(required=False)
model_filename = StringField(required=False)
model_file = FileField(required=False)
hiperparams_opt = BooleanField(default=False)
keras_model = None
# Net params define optimal setup. Analysis params is for optimization
params_training = DictField(required=False)
analysis_params = {}
meta = {'allow_inheritance': True}
def __init__(self, *args, **values):
super().__init__(*args, **values)
if self.id is None:
self.save()
self.model_filename = ''.join(['Models/', str(self.id)])
def train_network(self):
pass
def evaluate_track_input(self, track):
pass
def validate_test_data_accuracy(self, n_axes, normalized=True):
pass
def validate_test_data_mse(self, n_axes):
pass
def build_model(self):
pass
def convert_history_to_db_format(self, history_training):
for k, v in history_training.history.items():
for i in range(len(history_training.history[k])):
history_training.history[k][i] = float(history_training.history[k][i])
self.history = history_training.history
def load_model_from_file(self, only_local_files=False):
load_success = False
try:
self.keras_model = load_model(self.model_filename, compile=True)
load_success = True
except (ValueError, OSError) as e:
if not only_local_files:
try:
print("Local model not available, loading from db")
self.keras_model = self.build_model()
weights = pickle.loads(self.model_file.read())
if weights is not None and self.keras_model is not None:
self.keras_model.set_weights(weights)
load_success = True
else:
raise TypeError
except TypeError:
print("Weights not available in DB")
return load_success
def save_model_file_to_db(self):
self.model_file.put(pickle.dumps(self.keras_model.get_weights()))
def update_model_file_to_db(self):
self.model_file.replace(pickle.dumps(self.keras_model.get_weights()))
def plot_loss_model(self, train=True, val=True):
plt.xlabel('Epoch')
plt.ylabel('Loss')
if train:
plt.plot(np.arange(1, len(self.history['loss']) + 1, 1), self.history['loss'], label="Train loss")
if val:
plt.plot(np.arange(1, len(self.history['val_loss']) + 1, 1), self.history['val_loss'], label="Val loss")
plt.legend()
plt.show()
def plot_mse_model(self, train=True, val=True):
plt.xlabel('Epoch')
plt.ylabel('MSE')
if train:
plt.plot(np.arange(1, len(self.history['mse']) + 1, 1), self.history['mse'], label="Train mse")
if val:
plt.plot(np.arange(1, len(self.history['val_mse']) + 1, 1), self.history['val_mse'], label="Val mse")
# plt.legend()
plt.show()
def plot_accuracy_model(self, train=True, val=True, categorical=False):
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Model Accuracy')
if categorical:
if train:
plt.plot(np.arange(1, len(self.history['categorical_accuracy']) + 1, 1),
self.history['categorical_accuracy'], label="Train categorical accuracy")
if val:
plt.plot(np.arange(1, len(self.history['val_categorical_accuracy']) + 1, 1),
self.history['val_categorical_accuracy'], label="Val categorical accuracy")
else:
if train:
plt.plot(np.arange(1, len(self.history['acc']) + 1, 1), self.history['acc'],
label="Train accuracy")
if val:
plt.plot(np.arange(1, len(self.history['val_acc']) + 1, 1), self.history['val_acc'],
label="Val accuracy")
plt.legend()
plt.show()
def is_valid_network_track_time(self, track_time):
if (self.track_time * 0.85) <= track_time <= (self.track_time * 1.15):
return True
else:
return False
class Country(Document):
name = StringField(required=True, primary_key=True)
code = StringField()
population = IntField()
area = IntField()
pop_density = FloatField()
life_expectancy = FloatField()
gdp = FloatField()
gdp_growth = FloatField()
poverty = FloatField()
literacy = FloatField()
birth_rate = FloatField()
death_rate = FloatField()
co2_emissions = FloatField()
happiness_score = FloatField()
happiness_rank = IntField()
hdi_score = FloatField()
hdi_rank = IntField()
def __init__(self,
name,
code,
population,
area,
pop_density,
life_expectancy,
gdp,
gdp_growth,
poverty,
literacy,
birth_rate,
death_rate,
co2_emissions,
happiness_score=None,
happiness_rank=None,
hdi_score=None,
hdi_rank=None,
*args,
**kwargs):
super().__init__(*args, **kwargs)
self.name = name
self.code = code
self.population = population
self.area = area
self.pop_density = pop_density
self.life_expectancy = life_expectancy
self.gdp = gdp
self.gdp_growth = gdp_growth
self.poverty = poverty
self.literacy = literacy
self.birth_rate = birth_rate
self.death_rate = death_rate
self.co2_emissions = co2_emissions
self.happiness_score = happiness_score
self.happiness_rank = happiness_rank
self.hdi_score = hdi_score
self.hdi_rank = hdi_rank
class MachineEngineSettings(EmbeddedDocument):
_key_brand = ReferenceField(Brand, required=True)
motor_gucu = FloatField(required=True)
class EncodeStream(Stream):
def __init__(self, *args, **kwargs):
super(EncodeStream, self).__init__(*args, **kwargs)
deinterlace = BooleanField(default=constants.DEFAULT_DEINTERLACE, required=True)
frame_rate = IntField(default=constants.INVALID_FRAME_RATE, required=True)
volume = FloatField(default=constants.DEFAULT_VOLUME, required=True)
video_codec = StringField(default=constants.DEFAULT_VIDEO_CODEC, required=True)
audio_codec = StringField(default=constants.DEFAULT_AUDIO_CODEC, required=True)
audio_channels_count = IntField(default=constants.INVALID_AUDIO_CHANNELS_COUNT, required=True)
size = EmbeddedDocumentField(Size, default=Size())
video_bit_rate = IntField(default=constants.INVALID_VIDEO_BIT_RATE, required=True)
audio_bit_rate = IntField(default=constants.INVALID_AUDIO_BIT_RATE, required=True)
logo = EmbeddedDocumentField(Logo, default=Logo())
aspect_ratio = EmbeddedDocumentField(Rational, default=Rational())
def get_type(self):
return constants.StreamType.ENCODE
def config(self) -> dict:
conf = super(EncodeStream, self).config()
conf[DEINTERLACE_FIELD] = self.get_deinterlace()
frame_rate = self.get_frame_rate()
if frame_rate != constants.INVALID_FRAME_RATE:
conf[FRAME_RATE_FIELD] = frame_rate
conf[VOLUME_FIELD] = self.get_volume()
conf[VIDEO_CODEC_FIELD] = self.get_video_codec()
conf[AUDIO_CODEC_FIELD] = self.get_audio_codec()
audio_channels = self.get_audio_channels_count()
if audio_channels != constants.INVALID_AUDIO_CHANNELS_COUNT:
conf[AUDIO_CHANNELS_COUNT_FIELD] = audio_channels
if self.size.is_valid():
conf[SIZE_FIELD] = str(self.size)
vid_rate = self.get_video_bit_rate()
if vid_rate != constants.INVALID_VIDEO_BIT_RATE:
conf[VIDEO_BIT_RATE_FIELD] = vid_rate
audio_rate = self.get_audio_bit_rate()
if audio_rate != constants.INVALID_AUDIO_BIT_RATE:
conf[AUDIO_BIT_RATE_FIELD] = self.get_audio_bit_rate()
if self.logo.is_valid():
conf[LOGO_FIELD] = self.logo.to_dict()
if self.aspect_ratio.is_valid():
conf[ASPCET_RATIO_FIELD] = str(self.aspect_ratio)
return conf
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 DbBarData(Document):
"""
Candlestick bar data for database storage.
Index is defined unique with datetime, interval, symbol
"""
symbol: str = StringField()
exchange: str = StringField()
datetime: datetime = DateTimeField()
interval: str = StringField()
volume: float = FloatField()
open_price: float = FloatField()
open_interest: float = FloatField()
high_price: float = FloatField()
low_price: float = FloatField()
close_price: float = FloatField()
build_time: datetime = DateTimeField()
remove_time: datetime = DateTimeField()
# 在集合上指定索引以加快查询速度。这是通过创建indexes在
# meta字典中调用的索引规范列表完成的，
# 其中索引规范可以是单个字段名称，
# 包含多个字段名称的元组或包含完整索引定义的字典。
meta = {
"indexes": [{
"fields": ("datetime", "interval", "symbol", "exchange"),
"unique": True,
}]
}
@staticmethod
def from_bar(bar: BarData):
"""
Generate DbBarData object from BarData.
"""
db_bar = DbBarData()
db_bar.symbol = bar.symbol
db_bar.exchange = bar.exchange.value
db_bar.datetime = bar.datetime
db_bar.interval = bar.interval.value
db_bar.volume = bar.volume
db_bar.open_price = bar.open_price
db_bar.high_price = bar.high_price
db_bar.low_price = bar.low_price
db_bar.close_price = bar.close_price
db_bar.open_interest = bar.open_interest
db_bar.build_time = bar.build_time
db_bar.remove_time = bar.remove_time
return db_bar
def to_bar(self):
"""
Generate BarData object from DbBarData.
"""
bar = BarData(
symbol=self.symbol,
exchange=Exchange(self.exchange),
datetime=self.datetime,
interval=Interval(self.interval),
volume=self.volume,
open_price=self.open_price,
open_interest=self.open_interest,
high_price=self.high_price,
low_price=self.low_price,
close_price=self.close_price,
build_time=self.build_time,
remove_time=self.remove_time,
gateway_name="DB",
)
return bar
class Configuration(EmbeddedDocument):
is_valid = BooleanField(default=False, required=True, null=False)
method = StringField(null=False,
required=True,
choices=('Li98', 'Kirkaldy83'))
grain_size = FloatField(null=False, required=True, validation=not_negative)
nucleation_start = FloatField(null=False,
required=True,
validation=within_percentage_bounds)
nucleation_finish = FloatField(null=False,
required=True,
validation=within_percentage_bounds)
auto_calculate_ms = BooleanField(default=True, null=False, required=True)
auto_calculate_bs = BooleanField(default=True, null=False, required=True)
auto_calculate_ae = BooleanField(default=True, null=False, required=True)
ms_temp = FloatField(default=0.0,
null=False,
required=True,
validation=not_negative)
ms_rate_param = FloatField(default=0.0,
null=False,
required=True,
validation=not_negative)
bs_temp = FloatField(default=0.0,
null=False,
required=True,
validation=not_negative)
ae1_temp = FloatField(default=0.0,
null=False,
required=True,
validation=not_negative)
ae3_temp = FloatField(default=0.0,
null=False,
required=True,
validation=not_negative)
start_temp = FloatField(default=900,
null=False,
required=True,
validation=not_negative)
cct_cooling_rate = FloatField(default=10,
null=False,
required=True,
validation=not_negative)
def to_dict(self) -> dict:
"""
Simple EmbeddedDocument.Configuration helper method to get a Python dict
"""
return {
'is_valid': self.is_valid,
'method': self.method,
'grain_size': self.grain_size,
'nucleation_start': self.nucleation_start,
'nucleation_finish': self.nucleation_finish,
'auto_calculate_ms': self.auto_calculate_ms,
'auto_calculate_bs': self.auto_calculate_bs,
'auto_calculate_ae': self.auto_calculate_ae,
'ms_temp': self.ms_temp,
'ms_rate_param': self.ms_rate_param,
'bs_temp': self.bs_temp,
'ae1_temp': self.ae1_temp,
'ae3_temp': self.ae3_temp,
'start_temp': self.start_temp,
'cct_cooling_rate': self.cct_cooling_rate
}
# noinspection PyMethodParameters
@queryset_manager
def as_dict(cls, queryset) -> list:
"""Adding an additional QuerySet context method to return a list of
`sim_api.models.Configuration` Documents instead of a QuerySet.
Usage:
config_list = Configuration.as_dict()
Args:
queryset: the queryset that must is accepted as part of the Mongo
BSON parameter.
Returns:
A list with every Configuration Document object converted to dict.
"""
return [obj.to_dict() for obj in queryset]
def __str__(self):
return self.to_json()
class EntriesDocument(VespaDocument):
indexes = [
'journal',
'journal_short',
'publication_date',
'has_full_text',
'origin',
'last_updated',
'has_year',
'has_month',
'has_day',
'is_preprint',
'is_covid19',
'cord_uid',
'who_covidence',
'version',
'copyright',
'document_type',
{
"fields": [
"doi",
],
"unique": True,
"partialFilterExpression": {
"doi": {
"$type": "string"
}
}
},
{
"fields": [
"#title",
]
},
{
"fields": [
"pmcid",
],
"unique": True,
"partialFilterExpression": {
"pmcid": {
"$type": "string"
}
}
},
{
"fields": [
"pubmed_id",
],
"unique": True,
"partialFilterExpression": {
"pubmed_id": {
"$type": "string"
}
}
},
{
"fields": [
"scopus_eid",
],
"unique": True,
"partialFilterExpression": {
"scopus_eid": {
"$type": "string"
}
}
},
{
"fields": [
"hashed_title",
],
"unique": True,
"partialFilterExpression": {
"hashed_title": {
"$type": "string"
}
}
},
]
meta = {
"collection": "entries_vespa2",
"indexes": indexes,
"allow_inheritance": False
}
source_documents = ListField(GenericReferenceField(), required=True)
embeddings = DictField(default={})
is_covid19_ML = FloatField()
keywords_ML = ListField(StringField(required=True), default=lambda: [])
synced = BooleanField(default=False)
#Titles are be default too long for a unique index, so we have to hash them
hashed_title = StringField(default=None)
last_twitter_search = DateTimeField()
tweets = ListField(ReferenceField(TweetDocument))
altmetric = DynamicField()
class RedditPost(Document):
post_id = StringField()
created = FloatField()
title = StringField()
text = StringField()
class Body(EmbeddedDocument):
body_id = LongField(required=True)
width = IntField(min_value=0, required=True)
height = IntField(min_value=0, required=True)
sharpness = FloatField(min_value=0, required=True)
class RedditComment(Document):
comment_id = StringField()
created = FloatField()
link_id = StringField()
text = StringField()
class DbTickData(Document):
"""
Tick data for database storage.
Index is defined unique with (datetime, symbol)
"""
symbol: str = StringField()
exchange: str = StringField()
datetime: datetime = DateTimeField()
name: str = StringField()
volume: float = FloatField()
open_interest: float = FloatField()
last_price: float = FloatField()
last_volume: float = FloatField()
limit_up: float = FloatField()
limit_down: float = FloatField()
open_price: float = FloatField()
high_price: float = FloatField()
low_price: float = FloatField()
close_price: float = FloatField()
pre_close: float = FloatField()
bid_price_1: float = FloatField()
bid_price_2: float = FloatField()
bid_price_3: float = FloatField()
bid_price_4: float = FloatField()
bid_price_5: float = FloatField()
ask_price_1: float = FloatField()
ask_price_2: float = FloatField()
ask_price_3: float = FloatField()
ask_price_4: float = FloatField()
ask_price_5: float = FloatField()
bid_volume_1: float = FloatField()
bid_volume_2: float = FloatField()
bid_volume_3: float = FloatField()
bid_volume_4: float = FloatField()
bid_volume_5: float = FloatField()
ask_volume_1: float = FloatField()
ask_volume_2: float = FloatField()
ask_volume_3: float = FloatField()
ask_volume_4: float = FloatField()
ask_volume_5: float = FloatField()
meta = {
"indexes": [
{
"fields": ("symbol", "exchange", "datetime"),
"unique": True,
}
],
}
@staticmethod
def from_tick(tick: TickData):
"""
Generate DbTickData object from TickData.
"""
db_tick = DbTickData()
db_tick.symbol = tick.symbol
db_tick.exchange = tick.exchange.value
db_tick.datetime = tick.datetime
db_tick.name = tick.name
db_tick.volume = tick.volume
db_tick.open_interest = tick.open_interest
db_tick.last_price = tick.last_price
db_tick.last_volume = tick.last_volume
db_tick.limit_up = tick.limit_up
db_tick.limit_down = tick.limit_down
db_tick.open_price = tick.open_price
db_tick.high_price = tick.high_price
db_tick.low_price = tick.low_price
db_tick.pre_close = tick.pre_close
db_tick.bid_price_1 = tick.bid_price_1
db_tick.ask_price_1 = tick.ask_price_1
db_tick.bid_volume_1 = tick.bid_volume_1
db_tick.ask_volume_1 = tick.ask_volume_1
if tick.bid_price_2:
db_tick.bid_price_2 = tick.bid_price_2
db_tick.bid_price_3 = tick.bid_price_3
db_tick.bid_price_4 = tick.bid_price_4
db_tick.bid_price_5 = tick.bid_price_5
db_tick.ask_price_2 = tick.ask_price_2
db_tick.ask_price_3 = tick.ask_price_3
db_tick.ask_price_4 = tick.ask_price_4
db_tick.ask_price_5 = tick.ask_price_5
db_tick.bid_volume_2 = tick.bid_volume_2
db_tick.bid_volume_3 = tick.bid_volume_3
db_tick.bid_volume_4 = tick.bid_volume_4
db_tick.bid_volume_5 = tick.bid_volume_5
db_tick.ask_volume_2 = tick.ask_volume_2
db_tick.ask_volume_3 = tick.ask_volume_3
db_tick.ask_volume_4 = tick.ask_volume_4
db_tick.ask_volume_5 = tick.ask_volume_5
return db_tick
def to_tick(self):
"""
Generate TickData object from DbTickData.
"""
tick = TickData(
symbol=self.symbol,
exchange=Exchange(self.exchange),
datetime=self.datetime,
name=self.name,
volume=self.volume,
open_interest=self.open_interest,
last_price=self.last_price,
last_volume=self.last_volume,
limit_up=self.limit_up,
limit_down=self.limit_down,
open_price=self.open_price,
high_price=self.high_price,
low_price=self.low_price,
pre_close=self.pre_close,
bid_price_1=self.bid_price_1,
ask_price_1=self.ask_price_1,
bid_volume_1=self.bid_volume_1,
ask_volume_1=self.ask_volume_1,
gateway_name="DB",
)
if self.bid_price_2:
tick.bid_price_2 = self.bid_price_2
tick.bid_price_3 = self.bid_price_3
tick.bid_price_4 = self.bid_price_4
tick.bid_price_5 = self.bid_price_5
tick.ask_price_2 = self.ask_price_2
tick.ask_price_3 = self.ask_price_3
tick.ask_price_4 = self.ask_price_4
tick.ask_price_5 = self.ask_price_5
tick.bid_volume_2 = self.bid_volume_2
tick.bid_volume_3 = self.bid_volume_3
tick.bid_volume_4 = self.bid_volume_4
tick.bid_volume_5 = self.bid_volume_5
tick.ask_volume_2 = self.ask_volume_2
tick.ask_volume_3 = self.ask_volume_3
tick.ask_volume_4 = self.ask_volume_4
tick.ask_volume_5 = self.ask_volume_5
return tick
class RedditUser(Document):
uname = StringField()
latest_comment = FloatField()
latest_post = FloatField()
comments = ListField(ReferenceField('RedditComment'))
posts = ListField(ReferenceField('RedditPost'))
class Worker(Document):
username = EmbeddedDocumentField(WorkerHandles)
reputation = FloatField(default=1)
email = EmailField()
credits = FloatField(default=0)
properties = EmbeddedDocumentField(WorkerProperties)
class Feedback(Document):
rating = FloatField(required=True)
scale = FloatField(default=5.0)
feedback = StringField(default=None)
user = StringField(required=True)
timestamp = DateTimeField(default=datetime.utcnow)
