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
