def String(maxlen: int=None, minlen: int=None, args: tuple=None, as_property: bool=True, info: dict=None, **kwargs): """ SQLAlchemy Column representing a string :param minlen: minimum string len :param maxlen: maximum string len :param as_property: Returns :class:`sqlalchemy.ColumnProperty` otherwise :class:`sqlalchemy.Column` :param args: positional arguments passed to the sqlalchemy.Column constructor :param info: Passed into info dictionary of the column for usage with form maker or similiar libaries :param kwargs: * min: passed to formencode.validators.String (and overrides minlen) * max: passed to formencode.validators.String (and overrides maxlen) * length: passed to sqlalchemy.String (and overrides maxlen) * collation: passed to sqlalchemy.Unicode * convert_unicode: passed to sqlalchemy.Unicode * unicode_error: passed to sqlalchemy.Unicode * else: passed to sqlalchemy.Column :returns: >>> column_property(Column(Unicode(maxlen), nullable=False, server_default=''), info={type='string', validator=String(min=minlen, max=maxlen)}) :rtype: :class:`str` """ fvargs = dict(min=minlen, max=maxlen) fvargs.update({k: v for k, v in kwargs.items() if k in fvargs}) sqargs = dict(length=maxlen, collation=None, convert_unicode=True, unicode_error=None) sqargs.update({k: v for k, v in kwargs.items() if k in sqargs}) dwargs = dict(nullable=False, server_default='') dwargs.update({k: v for k, v in kwargs.items() if k not in fvargs and k not in sqargs}) args = isinstance(args, tuple) and args or [args] column = Column(sqUnicode(**sqargs), *args, **dwargs) column.validator = fvString(**fvargs) fmargs = {'type': 'Text', 'dataType': 'text'} fmargs.update(info and info or {}) if as_property: return column_property(column, info=fmargs) else: column.info.update(fmargs) return column, fmargs
def Boolean(default: bool=False, nullable=False, args: tuple=None, as_property: bool=True, info: dict=None, **kwargs): """ SQLAlchemy Column representing a boolean :param default: default of this column :param nullable: accept None -> NULL values :param as_property: Returns :class:`sqlalchemy.ColumnProperty` otherwise :class:`sqlalchemy.Column` :param args: positional arguments passed to the sqlalchemy.Column constructor :param info: Passed into info dictionary of the column for usage with form maker or similiar libaries :param kwargs: * true_values: list of true string values, passed to formencode validator * false_values: list of false string values, passed to formencode validator * create_constraint: create a CHECK constraint if required, passed to sqlalchemy.Boolean * else: passed to sqlalchemy.Column :returns: >>> column_property(Column(Boolean, nullable=False, default=default, server_default=default), info={type='boolean', validator=Boolean()}) :rtype: :class:`bool` """ fvargs = dict(true_values=fvBoolean.true_values, false_values=fvBoolean.false_values) fvargs.update({k: v for k, v in kwargs.items() if k in fvargs}) sqargs = dict(create_constraint=True) sqargs.update({k: v for k, v in kwargs.items() if k in sqargs}) dwargs = dict(default=default, nullable=nullable) if default is not None: dwargs['server_default'] = "%s" % int(default) dwargs.update({k: v for k, v in kwargs.items() if k not in fvargs and k not in sqargs}) args = isinstance(args, tuple) and args or [args] column = Column(sqBoolean(**sqargs), *args, **dwargs) column.validator = fvBoolean(**fvargs) fmargs = {'type': 'CheckBox'} fmargs.update(info and info or {}) if as_property: return column_property(column, info=fmargs) else: column.info.update(fmargs) return column, fmargs
def Integer(minval: int=None, maxval: int=None, default: int=None, args: tuple=None, as_property: bool=True, info: dict=None, **kwargs): """ SQLAlchemy Column representing an integer :param minval: minimum allowed for value :param maxval: maximum allowed for value :param default: default value (if None, nullable becomes True) :param as_property: Returns :class:`sqlalchemy.ColumnProperty` otherwise :class:`sqlalchemy.Column` :param args: positional arguments passed to the sqlalchemy.Column constructor :param info: Passed into info dictionary of the column for usage with form maker or similiar libaries :param kwargs: * min: passed to :class:`formencode.validators.Integer` (and overrides minval) * max: passed to :class:`formencode.validators.Integer` (and overrides maxval) * else: passed to :class:`sqlalchemy.Column` :returns: >>> column_property(Column(Integer, nullable=False, default=default), info={type='integer', min=minval, max=maxval, validator=Integer(min=minval, max=maxval)}) :rtype: :class:`int` """ fvargs = dict(min=minval, max=maxval) fvargs.update({k: v for k, v in kwargs.items() if k in fvargs}) sqargs = dict() sqargs.update({k: v for k, v in kwargs.items() if k in sqargs}) dwargs = dict(nullable=default is None, default=default) dwargs.update({k: v for k, v in kwargs.items() if k not in fvargs and k not in sqargs}) args = isinstance(args, tuple) and args or [args] column = Column(sqInteger(**sqargs), *args, **dwargs) column.validator = fvInteger(**fvargs) fmargs = {'type': 'Number', 'dataType': 'number', 'min': minval, 'max': maxval, 'step': 1.0} fmargs.update(info and info or {}) if as_property: return column_property(column, info=fmargs) else: column.info.update(fmargs) return column, fmargs
def Time(*args, use_datetime: bool=True, as_property:bool=True, info:dict=None, **kwargs): """ SQLAlchemy Column representing a time :param use_datetime: passed to :class:`formencode.validators.DateConverter` :param as_property: Returns :class:`sqlalchemy.ColumnProperty` otherwise :class:`sqlalchemy.Column` :param args: any positional arguments are passed to the :class:`sqlalchemy.Column` constructor :param info: Passed into info dictionary of the column for usage with form maker or similiar libaries :param kwargs: passed to :class:`sqlalchemy.Column` :returns: >>> column_property(Column(Date, nullable=False), info={type='date', validator=TimeConverter(use_datetime=True)}) :rtype: :class:`datetime.time` """ fvargs = dict(use_datetime=use_datetime) fvargs.update({k: v for k, v in kwargs.items() if k in fvargs}) sqargs = dict() sqargs.update({k: v for k, v in kwargs.items() if k in sqargs}) dwargs = dict(nullable=False) dwargs.update({k: v for k, v in kwargs.items() if k not in fvargs and k not in sqargs}) column = Column(sqTime(**sqargs), *args, **dwargs) column.validator = fvTime(**fvargs) fmargs = {'type': 'Time'} fmargs.update(info and info or {}) if as_property: return column_property(column, info=fmargs) else: column.info.update(fmargs) return column, fmargs
def Date(*args, month_style: str='dd/mm/yyyy', as_property:bool=True, info:dict=None, **kwargs) -> ColumnProperty: """ SQLAlchemy Column representing a date :param month_style: passed to formencode.validators.DateConverter :param as_property: Returns :class:`sqlalchemy.ColumnProperty` otherwise :class:`sqlalchemy.Column` :param args: any positional arguments are passed to the sqlalchemy.Column constructor :param info: Passed into info dictionary of the column for usage with form maker or similiar libaries :param kwargs: passed to sqlalchemy.Column :returns: >>> column_property(Column(Date, nullable=False), info={type='date', validator=DateConverter()}) :rtype: :class:`datetime.date` """ fvargs = dict(month_style=month_style) fvargs.update({k: v for k, v in kwargs.items() if k in fvargs}) sqargs = dict() sqargs.update({k: v for k, v in kwargs.items() if k in sqargs}) dwargs = dict(nullable=False) dwargs.update({k: v for k, v in kwargs.items() if k not in fvargs and k not in sqargs}) column = Column(sqDate(**sqargs), *args, **dwargs) column.validator = fvDate(**fvargs) fmargs = {'type': 'Date'} fmargs.update(info and info or {}) if as_property: return column_property(column, info=fmargs) else: column.info.update(fmargs) return column, fmargs