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()