class OCRRequest(Schema):
"""Parameter definition for OCR requests"""
FILE_TYPE = "fileType"
LANGUAGE = "language"
DETECT_ORIENTATION = "detectOrientation"
BODY = "body"
language = fields.Str(
attribute=FILE_TYPE,
description="File type as a ",
missing="en",
required=False,
)
language = fields.Str(
attribute=LANGUAGE,
description=
"The BCP-47 language code of the text to be detected. The default is 'en'.",
missing="en",
required=False,
)
detect_orientation = fields.Boolean(
attribute=DETECT_ORIENTATION,
required=False,
missing=False,
description="Whether detect the text orientation in the image.",
)
body = fields.Raw(
attribute=BODY,
required=True,
description="File data to be processed",
)
class TaskSchema(EndDateValidationMixin, Schema):
_id = fields.Str(dump_only=True, required=True)
description = fields.Str(required=True,
allow_none=False,
validate=not_empty)
end_date = fields.DateTime(required=True)
created_at = fields.DateTime(missing=datetime.utcnow())
done = fields.Boolean(missing=False)
user_id = fields.String()
class ProfilesSerializer(ma.SQLAlchemyAutoSchema):
id = fields.Integer()
uuid = fields.Str()
doc_id = fields.Str(required=True)
score = fields.Float(required=True)
revenue = fields.Float(required=True)
class Meta:
model = Profiles
class GenericRequestSchemaLocal(Schema):
class Meta:
strict = True
organisation_id = fields.Str()
response = fields.Str()
@post_load
def get_request(self, data):
return GenericResponse(**data)
class EmailNotificationSchema(NotificationSchema):
to = fields.Str(required=True)
template = fields.Str(required=True)
@validates('to')
def validate_to(self, value):
try:
validate_email_address(value)
except InvalidEmailError as e:
raise ValidationError(str(e))
class AccountSchema(Schema):
account_number = fields.Str()
buying_power = fields.Float()
cash = fields.Float()
daytrade_count = fields.Float()
daytrading_buying_power = fields.Float()
equity = fields.Float()
id =fields.Str()
last_equity = fields.Float()
portfolio_value = fields.Float()
status = fields.Str()
trading_blocked = fields.Boolean()
class GenericRequestSchema(Schema):
class Meta:
strict = True
required = True
allow_none = False
organisation_id = fields.Str(validate=[validate.Length(min=1)])
data = fields.Str(validate=[validate.Length(min=1)])
@post_load
def get_request(self, data):
return Generic(**data)
class TransactionsSerializer(ma.SQLAlchemyAutoSchema):
id = fields.Str()
customer_id = fields.Str(required=True)
doc_id = fields.Str(required=True)
score = fields.Float(required=True, default=0.0)
income = fields.Float(required=True, default=0.0)
requested_value = fields.Float(required=True, default=0.0)
installments = fields.Integer(required=True, default=0)
status = fields.Integer(required=True, default=400)
time = fields.DateTime(requested=True, default=datetime.now)
class Meta:
model = Transactions
include_fk = True
class OCRResponse(Schema):
"""Response for OCR endpoint"""
TEXT = "text"
FILE_NAME = "filename"
CONTENT_TYPE = "content_type"
CONTENT_LENGTH = "content_length"
MIMETYPE = "mimetype"
text = fields.Str()
filename = fields.Str()
content_type = fields.Str()
content_length = fields.Str()
mimetype = fields.Str()
class CVTextMatchRequest(Schema):
"""Similar to CVTemplateRequest, but takes text to be matched and rasterizes it."""
DOCUMENT = "document"
TEXT = "text"
THRESHOLD = "threshold"
document = fields.Raw(
attribute=DOCUMENT,
required=True,
description=
"A PDF or image to be used as the target for multi-resolution matching.",
)
text = fields.Str(
attribute=TEXT,
required=True,
description="A string to be rasterized and used to search the document."
)
threshold = fields.Float(
attribute=THRESHOLD,
required=False,
missing=0.9,
description=
"Matches which fall below this value will be culled and not returned.")
class UserSchema(ma.Schema):
"""
User serialization/deserialization schema
"""
class Meta:
ordered = True
first_name = fields.Str(required=False)
last_name = fields.Str(required=False)
email = fields.Email(required=False)
username = fields.Str(required=False, validate=username_is_valid)
public_key = fields.Str(dump_only=True)
@validates_schema
def check_for_username_or_email(self, data, **kwargs):
if not any(lambda x: x in data.keys() for x in ["username", "email"]):
raise ValidationError(
'At least one of "email" or "username" should be informed')
class CVTemplateMatchResponse(Schema):
"""Response for CV Template match endpoint"""
MATCHES = "matches"
DOCUMENT_FILENAME = "document_filename"
# This could be a nested schema, but that seems messier for the scope.
matches = fields.List(
fields.Dict) # [{'template_text':str, 'bbox':[x,y,w,h], 'conf':#.#}]
document_filename = fields.Str()
class SupportEmailDataSchema(ma.Schema):
class Meta:
strict = True
email = fields.Str(required=True)
message = fields.Str(required=True)
sender = fields.Str(required=False)
support_type = fields.Str(required=False)
def __init__(self, partial_email=False):
super().__init__()
self.partial_email = partial_email
@validates('email')
def validate_email(self, value):
if self.partial_email:
return
try:
validate_email_address(value)
except InvalidEmailError as e:
raise ValidationError(str(e))
class BrandingRequestDataSchema(ma.Schema):
class Meta:
strict = True
email = fields.Str(required=True)
serviceID = fields.Str(required=True)
service_name = fields.Str(required=True)
filename = fields.Str(required=True)
def __init__(self, partial_email=False):
super().__init__()
self.partial_email = partial_email
@validates('email')
def validate_email(self, value):
if self.partial_email:
return
try:
validate_email_address(value)
except InvalidEmailError as e:
raise ValidationError(str(e))
class EmailDataSchema(ma.Schema):
class Meta:
strict = True
email = fields.Str(required=True)
@validates('email')
def validate_email(self, value):
try:
validate_email_address(value)
except InvalidEmailError as e:
raise ValidationError(str(e))
class Location(MA.Schema):
class Meta:
fields = ('name', 'county', 'state', 'country', 'last_confirmed',
'last_deaths', 'chart_data')
ordered = True
name = fields.Str()
county = fields.Str()
state = fields.Str()
country = fields.Str()
chart_data = fields.Method('obj_chart_data')
last_confirmed = fields.Method('obj_last_confirmed')
last_deaths = fields.Method('obj_last_deaths')
def obj_chart_data(self, obj):
return formatters.format_chart_data([obj])
def obj_last_confirmed(self, obj):
return formatters.last_confirmed([obj])
def obj_last_deaths(self, obj):
return formatters.last_deaths([obj])
class SmsNotificationSchema(NotificationSchema):
to = fields.Str(required=True)
@validates('to')
def validate_to(self, value):
try:
validate_phone_number_and_allow_international(value)
except InvalidPhoneError as error:
raise ValidationError('Invalid phone number: {}'.format(error))
@post_load
def format_phone_number(self, item):
item['to'] = validate_and_format_phone_number_and_allow_international(item['to'])
return item
class PaymentIsoClientRequestSchema(Schema):
class Meta:
strict = True
required = True
allow_none = False
organisation_id = fields.Integer()
trx_type_id = fields.Integer()
trx_amount = fields.Number()
va_number = fields.Str()
location = fields.Str()
transaction_date = fields.DateTime()
description = fields.Str()
trace_number = fields.Str()
username = fields.Str()
customer_name = fields.Str()
obu_wallet_id = fields.Integer()
customer_id = fields.Integer()
@post_load
def get_payment_isoclient_request(self, data):
return PaymentIsoClientData(**data)
class PingResponse(Schema):
"""Reponse from ping endpoint."""
status = fields.Str()
class UserSchema(Schema):
email = fields.Email(required=True)
password = fields.Str(required=True, validate=not_empty, allow_none=False)
class SmsAdminNotificationSchema(SmsNotificationSchema):
content = fields.Str(required=True)
class PrecipitationSchema(ma.Schema):
city_id = fields.Int()
city = fields.Str()
state = fields.Str()
mean = fields.Float()
class JobEmailTemplateNotificationSchema(EmailNotificationSchema):
template = fields.Str(required=True)
job = fields.String(required=True)
class JobSmsTemplateNotificationSchema(SmsNotificationSchema):
template = fields.Str(required=True)
job = fields.String(required=True)
class OrderStatusSchema(ma.Schema):
status = fields.Str(
validate=validate.OneOf(["Solicitada", "Aprobada", "Cancelada"]))
class PortfolioSchema(Schema):
quantity = fields.Float()
symbol = fields.Str()
class UpdateTaskSchema(EndDateValidationMixin, Schema):
description = fields.Str(allow_none=False, validate=not_empty)
end_date = fields.DateTime()
done = fields.Boolean()
