def validate_type(value: Any) -> None: if not isinstance(value, list): raise error.ValidationError('{} is not of type list'.format(value)) for item in value: if not isinstance(item, str): raise error.ValidationError( '{} is not of type str'.format(item))
def _validate(self, model_class: Type[Any]) -> None: if self.column not in model_class.fields: raise error.ValidationError('{} is not a column on {}'.format( self.column, model_class.table)) if self.field and self.field != model_class.fields[self.column]: raise error.ValidationError('{} does not belong to {}'.format( self.column, model_class.table)) model_class.fields[self.column].validate(self.value)
def validate_type(value: Any) -> None: if not isinstance(value, list): raise error.ValidationError("{} is not of type list".format(value)) for item in value: try: datetime.datetime.strptime(item, "%Y-%m-%d") except: raise error.ValidationError( "{} is not of type date (YYYY-[M]M-[D]D)".format(item) )
def _validate(self, model_class: Type[Any]) -> None: if self.name not in model_class.relations: raise error.ValidationError("{} is not a relation on {}".format( self.name, model_class.table)) if self.relation and self.relation != model_class.relations[self.name]: raise error.ValidationError("{} does not belong to {}".format( self.relation.name, model_class.table)) other_model_class = model_class.relations[self.name].destination for condition in self._conditions: condition._validate(other_model_class) # pylint: disable=protected-access
def _validate(self, model_class: Type[Any]) -> None: if self.name not in model_class.indexes: raise error.ValidationError('{} is not an index on {}'.format( self.name, model_class.table)) if self.index and self.index != model_class.indexes[self.name]: raise error.ValidationError('{} does not belong to {}'.format( self.index.name, model_class.table)) if model_class.indexes[self.name].primary: raise error.ValidationError( 'Cannot force query using primary index')
def _validate(self, model_class: Type[Any]) -> None: if not isinstance(self.value, list): raise error.ValidationError("{} is not a list".format(self.value)) if self.column not in model_class.fields: raise error.ValidationError("{} is not a column on {}".format( self.column, model_class.table)) if self.field and self.field != model_class.fields[self.column]: raise error.ValidationError("{} does not belong to {}".format( self.column, model_class.table)) for value in self.value: model_class.fields[self.column].validate(value)
def _validate(self, model_class: Type[Any]) -> None: for idx in model_class.indexes.values(): if idx.name == self.name and (self.index is None or self.index == idx): if idx.primary: raise error.ValidationError( "Cannot force query using primary index") self.index = idx break else: raise error.ValidationError("{} is not an index on {}".format( self.name, model_class.table))
def _validate(self, model_class: Type[Any]) -> None: """See base class.""" for substitution in self._substitutions.values(): if isinstance(substitution, field.Field): if substitution not in model_class.fields.values(): raise error.ValidationError( f'Field {substitution.name!r} does not belong to the Model for ' f'table {model_class.table!r}.') elif isinstance(substitution, Column): if substitution.name not in model_class.fields: raise error.ValidationError( f'Column {substitution.name!r} does not exist in the Model for ' f'table {model_class.table!r}.')
def _validate(self, model_class: Type[Any]) -> None: if self.column not in model_class.fields: raise error.ValidationError("{} is not a column on {}".format( self.column, model_class.table)) origin = model_class.fields[self.column] if self.destination_column not in self.destination_model_class.fields: raise error.ValidationError("{} is not a column on {}".format( self.destination_column, self.destination_model_class.table)) dest = self.destination_model_class.fields[self.destination_column] if origin.field_type != dest.field_type or origin.nullable != dest.nullable: raise error.ValidationError( "Types of {} and {} do not match".format( origin.name, dest.name))
def _validate(self, model_class: Type[Any]) -> None: for (column, _) in self.orderings: if isinstance(column, field.Field): column = column.name if column not in model_class.fields: raise error.ValidationError('{} is not a column on {}'.format( column, model_class.table))
def validate_type(value) -> None: try: datetime.datetime.strptime(value, "%Y-%m-%d") except: raise error.ValidationError( "{} is not of type date (YYYY-[M]M-[D]D)".format(value) )
def validate(self, value) -> None: if value is None: if not self._nullable: raise error.ValidationError("None set for non-nullable field") elif self._allow_commit_timestamp and value == COMMIT_TIMESTAMP: return else: self._type.validate_type(value)
def _parse_constraints(self) -> List[RelationshipConstraint]: """Validates the dictionary of constraints and turns it into Conditions.""" constraints = [] for origin_column, destination_column in self._constraints.items(): if origin_column not in self.origin.fields: raise error.ValidationError( 'Origin column must be present in origin model') if destination_column not in self.destination.fields: raise error.ValidationError( 'Destination column must be present in destination model') constraints.append( RelationshipConstraint(self.destination, destination_column, self.origin, origin_column)) return constraints
def _validate(self, model_class: Type[Any]) -> None: if self.foreign_key_relation: model_class_relations = model_class.foreign_key_relations referenced_table_fn = lambda x: x.constraint.referenced_table else: model_class_relations = model_class.relations referenced_table_fn = lambda x: x.destination if self.name not in model_class_relations: raise error.ValidationError('{} is not a relation on {}'.format( self.name, model_class.table)) if self.relation and self.relation != model_class_relations[self.name]: raise error.ValidationError('{} does not belong to {}'.format( self.relation.name, model_class.table)) other_model_class = referenced_table_fn( model_class_relations[self.name]) for condition in self._conditions: condition._validate(other_model_class) # pylint: disable=protected-access
def _parse_constraints(self) -> List[RelationshipConstraint]: """Validates the dictionary of constraints and turns it into Conditions.""" constraints = [] for origin_column, destination_column in self._constraints.items(): if origin_column not in self.origin.fields: raise error.ValidationError( "Origin column must be present in origin model") if destination_column not in self.destination.fields: raise error.ValidationError( "Destination column must be present in destination model") # TODO(dbrandao): remove when pytype #234 is fixed constraints.append( RelationshipConstraint(self.destination, destination_column, self.origin, origin_column)) # type: ignore return constraints
def __init__( self, columns: List[str], parent: Optional[str] = None, null_filtered: bool = False, unique: bool = False, storing_columns: Optional[List[str]] = None, name: Optional[str] = None, column_ordering: Union[Dict[str, bool], bool] = None, ): """ Represents an index on the table :param columns: List of columns in the index :param parent: :param null_filtered: Should null values be filtered? :param unique: Enforce unique constraint? :param storing_columns: Additional columns to store with this index. This can help performance if fields are accessed together :param name: Name of the index (this may be used to customize default index name) :param column_ordering: Map of column names to bool (True for ASC, and False for DESC) indicating order for the field (defaults to ASC). For single column indexes, this can be a single bool value as well. """ if not columns: raise error.ValidationError("An index must have at least one column") if isinstance(column_ordering, bool): if len(columns) != 1: raise error.ValidationError( "column_ordering can be set to a bool only if single-column index" ) column_ordering = {columns[0]: column_ordering} self._columns = columns self._name = name self._parent = parent self._null_filtered = null_filtered self._unique = unique self._storing_columns = storing_columns or [] self._column_ordering = column_ordering or {}
def __init__(self, columns: List[str], parent: Optional[str] = None, null_filtered: bool = False, unique: bool = False, storing_columns: Optional[List[str]] = None): if not columns: raise error.ValidationError('An index must have at least one column') self.columns = columns self.name = None self.parent = parent self.null_filtered = null_filtered self.unique = unique self.storing_columns = storing_columns or []
def __init__( self, field_type: Type[FieldType], nullable: bool = False, primary_key: bool = False, allow_commit_timestamp: bool = False, name: Optional[str] = None, size: Optional[int] = None, ): self._name = name self._size = size self._type = field_type self._nullable = nullable self._primary_key = primary_key self._allow_commit_timestamp = allow_commit_timestamp if self._type.ddl() != "TIMESTAMP" and self._allow_commit_timestamp: raise error.ValidationError( "allow_commit_timestamp can not be set on field {}".format(self._type) )
def validate_type(value: Any) -> None: if not isinstance(value, bool): raise error.ValidationError('{} is not of type bool'.format(value))
def validate(self, value) -> None: if value is None: if not self._nullable: raise error.ValidationError('None set for non-nullable field') else: self._type.validate_type(value)
def validate_type(value: Any) -> None: if not isinstance(value, datetime.datetime): raise error.ValidationError( '{} is not of type datetime'.format(value))
def _validate(self, model_class: Type[Any]) -> None: if self.field in model_class.columns: raise error.ValidationError( f"Invalid alias name: {self.field} already in in model class: {model_class}" )
def validate_type(value) -> None: if not isinstance(value, str): raise error.ValidationError('{} is not of type str'.format(value))
def constraints(self) -> List[RelationshipConstraint]: if not self.origin: raise error.ValidationError( "Origin must be set before constraints is called") return self._parse_constraints()
def validate_type(value: Any) -> None: if not isinstance(value, list): raise error.ValidationError("{} is not of type list".format(value)) for item in value: if not isinstance(item, float): raise error.ValidationError("{} is not of type float".format(item))
def validate_type(value: Any) -> None: if not isinstance(value, (int, float)): raise error.ValidationError( "{} is not of type float".format(value))
def _validate(self, model_class: Type[Any]) -> None: for column in self.columns: if column not in model_class.columns: raise error.ValidationError( f"Invalid column name: {column} not in model class: {model_class}" )