def __init__(self, db_column="", db_index=False, null=False, protocol="both", unique=False, unpack_protocol="same"): if protocol.lower() not in ("both", "ipv6", "ipv4"): raise AsyncOrmFieldError( '"{}" is not a recognized protocol'.format(protocol)) if unpack_protocol.lower() not in ("same", "ipv6", "ipv4"): raise AsyncOrmFieldError( '"{}" is not a recognized unpack_protocol'.format( unpack_protocol)) if protocol.lower() != "both" and unpack_protocol != "same": raise AsyncOrmFieldError( "if the protocol is restricted the output will always be in the same protocol version, " 'so unpack_protocol should be default value, "same"') super().__init__( db_column=db_column, db_index=db_index, default=None, null=null, protocol=protocol, unique=unique, unpack_protocol=unpack_protocol, )
def set_field_name(self, db_column): if "__" in db_column: raise AsyncOrmFieldError('db_column can not contain "__"') if db_column.startswith("_"): raise AsyncOrmFieldError('db_column can not start with "_"') if db_column.endswith("_"): raise AsyncOrmFieldError('db_column can not end with "_"') self.db_column = db_column
def validate(self, value): try: IPNetwork(value) except AddrFormatError: raise AsyncOrmFieldError("Not a correct IP address") if self.protocol.lower() != "both" and IPNetwork(value).version != int(self.protocol[-1:]): raise AsyncOrmFieldError("{} is not a correct {} IP address".format(value, self.protocol))
def validate(self, value): super().validate(value) if value: items_type = self.homogeneous_type(value) if not items_type: raise AsyncOrmFieldError("Array elements are not of the same type") if items_type == list: if not all(len(item) == len(value[0]) for item in value): raise AsyncOrmFieldError("Multi-dimensional arrays must have items of the same size") return value
def validate(self, value): super(EmailField, self).validate(value) # now validate the emailfield here email_regex = r"^[\w][\w0-9_.+-]+@[\w0-9-]+\.[\w0-9-.]+$" if not re.match(email_regex, value): raise AsyncOrmFieldError( '"{}" not a valid email address'.format(value))
def sanitize_data(self, value): value = super().sanitize_data(value) if len(value) > self.max_length: raise AsyncOrmFieldError( 'The string entered is bigger than the "max_length" defined ({})'.format(self.max_length) ) return str(value)
def __init__(self, db_column="", db_index=False, default=None, dialect="unix", null=False, unique=True): if dialect not in (self.mac_dialects.keys()): raise AsyncOrmFieldError('"{}" is not a correct mac dialect'.format(dialect)) super().__init__( db_column=db_column, db_index=db_index, default=default, dialect=dialect, null=null, unique=unique )
def sanitize_data(self, value): value = super().sanitize_data(value) exp = r"^[a-zA-Z0-9\-\b]{36}$" if re.match(exp, value): return value raise AsyncOrmFieldError( "The expression doesn't validate as a correct {}".format( self.__class__.__name__))
def sanitize_data(self, value): self.validate(value) if value is not None: if isinstance(value, str): try: value = json.loads(value) except JSONDecodeError: raise AsyncOrmFieldError("The data entered can not be converted to json") value = json.dumps(value) if len(value) > self.max_length: raise AsyncOrmFieldError( 'The string entered is bigger than the "max_length" defined ({})'.format(self.max_length) ) return value
def __init__(self, db_column="", db_index=False, null=False, unique=True, uuid_type="v4"): self.field_requirement = 'CREATE EXTENSION IF NOT EXISTS "uuid-ossp";' if uuid_type not in ["v1", "v4"]: raise AsyncOrmFieldError("{} is not a recognized type".format(uuid_type)) super().__init__( db_column=db_column, db_index=db_index, default=None, null=null, unique=unique, uuid_type=uuid_type )
def validate_kwargs(self, kwargs): """Validate the kwargs provided. :param kwargs: Field creation kwargs :type kwargs: dict :raises AsyncOrmFieldError: If a required field is not provided or when a value provided doesn't comply to Field requirements. """ for kw in self.required_kwargs: if not kwargs.get(kw, None): raise AsyncOrmFieldError('"{cls}" field requires {kw}'.format(cls=self.__class__.__name__, kw=kw)) for k, v in kwargs.items(): null_choices = v is None and k == "choices" if not isinstance(v, KWARGS_TYPES[k]) and not null_choices: raise AsyncOrmFieldError("Wrong value for {k}".format(k=k)) if kwargs.get("db_column", ""): self.set_field_name(kwargs["db_column"])
def validate(self, value): """Validate the value. :param value: value in the field :type value: self.internal_type :raises AsyncOrmFieldError: * When a null value sent to a non nullable field. * When the value provided is not in the field choices. * When the value provided is not in the self.internal_type """ if value is None and not self.null: raise AsyncOrmFieldError("null value in NOT NULLABLE field") if hasattr(self, "choices") and self.choices is not None: if value not in self.choices.keys(): raise AsyncOrmFieldError('"{}" not in field choices'.format(value)) if value is not None and not isinstance(value, self.internal_type): raise AsyncOrmFieldError( "{value} is a wrong datatype for field {cls}".format(value=value, cls=self.__class__.__name__) )
def sanitize_data(self, value): if value is not None: if isinstance(value, str): try: value = json.loads(value) except JSONDecodeError: raise AsyncOrmFieldError( "The data entered can not be converted to json") value = json.dumps(value) value = super().sanitize_data(value) return value
def validate_kwargs(self, kwargs): """validate the kwargs on object instantiation only""" attr_errors = [k for k in kwargs.keys() if k not in self.fields.keys()] if attr_errors: err_string = '"{}" is not an attribute for {}' error_list = [err_string.format(k, self.__class__.__name__) for k in attr_errors] raise AsyncOrmModelError(error_list) for k, v in kwargs.items(): att_field = getattr(self.__class__, k) att_field.validate(v) if att_field.__class__ is AutoField and v: raise AsyncOrmFieldError("Models can not be generated with forced id")
def validate(self, value): try: EUI(value) except AddrFormatError: raise AsyncOrmFieldError("Not a correct MAC address")
def sanitize_data(self, value): """method used to convert to SQL data""" if isinstance(value, bool) or value is None: return value raise AsyncOrmFieldError("not correct data for BooleanField")