def __init__(self, column, name_template, attribute_name=None, **options):
super(FileProperty, self).__init__()
self.column = column
self._attribute_name = attribute_name
self.name_template = name_template
self._set_options(options)
set_creation_order(self)
def __init__(self, f, args, kwargs):
self.f = f
self.args = args
self.kwargs = kwargs
self._cascading = False
set_creation_order(self)
def __init__(self, f, args, kwargs):
self.f = f
self.args = args
self.kwargs = kwargs
self._cascading = False
set_creation_order(self)
def __init__(self, column, name_template, attribute_name=None, **options):
super(FileProperty, self).__init__()
self.column = column
self._attribute_name = attribute_name
self.name_template = name_template
self._set_options(options)
set_creation_order(self)
def __init__(self, discriminator, id, doc=None):
self._discriminator_col = discriminator
self._id_cols = id
self._id = None
self._discriminator = None
self.doc = doc
set_creation_order(self)
def __init__(self, class_, *attrs, **kwargs):
self.attrs = attrs
self.composite_class = class_
self.active_history = kwargs.get('active_history', False)
self.deferred = kwargs.get('deferred', False)
self.group = kwargs.get('group', None)
util.set_creation_order(self)
self._create_descriptor()
def __init__(self, class_, *attrs, **kwargs):
self.attrs = attrs
self.composite_class = class_
self.active_history = kwargs.get('active_history', False)
self.deferred = kwargs.get('deferred', False)
self.group = kwargs.get('group', None)
util.set_creation_order(self)
self._create_descriptor()
def __init__(self, discriminator, id, doc=None):
self._discriminator_col = discriminator
self._id_cols = id
self._id = None
self._discriminator = None
self.doc = doc
set_creation_order(self)
def __init__(self, discriminator, id, doc=None):
super(GenericRelationshipProperty, self).__init__()
self._discriminator_col = discriminator
self._id_cols = id
self._id = None
self._discriminator = None
self.doc = doc
set_creation_order(self)
def __init__(self, discriminator, id, doc=None):
super(GenericRelationshipProperty, self).__init__()
self._discriminator_col = discriminator
self._id_cols = id
self._id = None
self._discriminator = None
self.doc = doc
set_creation_order(self)
def __init__(self, name, map_column=None,
descriptor=None, comparator_factory=None,
doc=None):
self.name = name
self.map_column = map_column
self.descriptor = descriptor
self.comparator_factory = comparator_factory
self.doc = doc or (descriptor and descriptor.__doc__) or None
util.set_creation_order(self)
def __init__(self,
name,
map_column=None,
descriptor=None,
comparator_factory=None):
self.name = name
self.map_column = map_column
self.descriptor = descriptor
self.comparator_factory = comparator_factory
util.set_creation_order(self)
def __init__(self, name, map_column=None,
descriptor=None, comparator_factory=None,
doc=None):
self.name = name
self.map_column = map_column
self.descriptor = descriptor
self.comparator_factory = comparator_factory
self.doc = doc or (descriptor and descriptor.__doc__) or None
util.set_creation_order(self)
def __init__(self, *columns, **kwargs):
"""The list of `columns` describes a single object
property. If there are multiple tables joined together for the
mapper, this list represents the equivalent column as it
appears across each table.
"""
self.columns = [expression._labeled(c) for c in columns]
self.group = kwargs.pop("group", None)
self.deferred = kwargs.pop("deferred", False)
self.comparator_factory = kwargs.pop("comparator_factory", self.__class__.Comparator)
self.extension = kwargs.pop("extension", None)
util.set_creation_order(self)
if self.deferred:
self.strategy_class = strategies.DeferredColumnLoader
else:
self.strategy_class = strategies.ColumnLoader
def __init__(self, *columns, **kwargs):
"""The list of `columns` describes a single object
property. If there are multiple tables joined together for the
mapper, this list represents the equivalent column as it
appears across each table.
"""
self.columns = [expression._labeled(c) for c in columns]
self.group = kwargs.pop('group', None)
self.deferred = kwargs.pop('deferred', False)
self.comparator_factory = kwargs.pop('comparator_factory',
self.__class__.Comparator)
self.extension = kwargs.pop('extension', None)
util.set_creation_order(self)
if self.deferred:
self.strategy_class = strategies.DeferredColumnLoader
else:
self.strategy_class = strategies.ColumnLoader
def __init__(self, *columns, **kwargs):
"""The list of `columns` describes a single object
property. If there are multiple tables joined together for the
mapper, this list represents the equivalent column as it
appears across each table.
"""
self.columns = list(columns)
self.group = kwargs.pop('group', None)
self.deferred = kwargs.pop('deferred', False)
self.comparator = ColumnProperty.ColumnComparator(self)
util.set_creation_order(self)
if self.deferred:
self.strategy_class = strategies.DeferredColumnLoader
else:
self.strategy_class = strategies.ColumnLoader
# sanity check
for col in columns:
if not isinstance(col, ColumnElement):
raise ArgumentError('column_property() must be given a ColumnElement as its argument. Try .label() or .as_scalar() for Selectables to fix this.')
def __init__(self, *columns, **kwargs):
"""Construct a ColumnProperty.
:param \*columns: The list of `columns` describes a single
object property. If there are multiple tables joined
together for the mapper, this list represents the equivalent
column as it appears across each table.
:param group:
:param deferred:
:param comparator_factory:
:param descriptor:
:param extension:
"""
self.columns = [expression._labeled(c) for c in columns]
self.group = kwargs.pop('group', None)
self.deferred = kwargs.pop('deferred', False)
self.no_instrument = kwargs.pop('_no_instrument', False)
self.comparator_factory = kwargs.pop('comparator_factory', self.__class__.Comparator)
self.descriptor = kwargs.pop('descriptor', None)
self.extension = kwargs.pop('extension', None)
if kwargs:
raise TypeError(
"%s received unexpected keyword argument(s): %s" % (
self.__class__.__name__, ', '.join(sorted(kwargs.keys()))))
util.set_creation_order(self)
if self.no_instrument:
self.strategy_class = strategies.UninstrumentedColumnLoader
elif self.deferred:
self.strategy_class = strategies.DeferredColumnLoader
else:
self.strategy_class = strategies.ColumnLoader
def __init__(self, *columns, **kwargs):
"""The list of `columns` describes a single object
property. If there are multiple tables joined together for the
mapper, this list represents the equivalent column as it
appears across each table.
"""
self.columns = list(columns)
self.group = kwargs.pop('group', None)
self.deferred = kwargs.pop('deferred', False)
self.comparator = ColumnProperty.ColumnComparator(self)
util.set_creation_order(self)
if self.deferred:
self.strategy_class = strategies.DeferredColumnLoader
else:
self.strategy_class = strategies.ColumnLoader
# sanity check
for col in columns:
if not isinstance(col, ColumnElement):
raise ArgumentError(
'column_property() must be given a ColumnElement as its argument. Try .label() or .as_scalar() for Selectables to fix this.'
)
def __init__(self, argument, secondary=None, primaryjoin=None, secondaryjoin=None, entity_name=None, foreign_keys=None, foreignkey=None, uselist=None, private=False, association=None, order_by=False, attributeext=None, backref=None, is_backref=False, post_update=False, cascade=None, viewonly=False, lazy=True, collection_class=None, passive_deletes=False, passive_updates=True, remote_side=None, enable_typechecks=True, join_depth=None, strategy_class=None, _local_remote_pairs=None):
self.uselist = uselist
self.argument = argument
self.entity_name = entity_name
self.secondary = secondary
self.primaryjoin = primaryjoin
self.secondaryjoin = secondaryjoin
self.post_update = post_update
self.direction = None
self.viewonly = viewonly
self.lazy = lazy
self.foreign_keys = util.to_set(foreign_keys)
self._legacy_foreignkey = util.to_set(foreignkey)
if foreignkey:
util.warn_deprecated('foreignkey option is deprecated; see docs for details')
self.collection_class = collection_class
self.passive_deletes = passive_deletes
self.passive_updates = passive_updates
self.remote_side = util.to_set(remote_side)
self.enable_typechecks = enable_typechecks
self.comparator = PropertyLoader.Comparator(self)
self.join_depth = join_depth
self._arg_local_remote_pairs = _local_remote_pairs
util.set_creation_order(self)
if strategy_class:
self.strategy_class = strategy_class
elif self.lazy == 'dynamic':
from sqlalchemy.orm import dynamic
self.strategy_class = dynamic.DynaLoader
elif self.lazy is False:
self.strategy_class = strategies.EagerLoader
elif self.lazy is None:
self.strategy_class = strategies.NoLoader
else:
self.strategy_class = strategies.LazyLoader
self._reverse_property = None
if cascade is not None:
self.cascade = CascadeOptions(cascade)
else:
if private:
util.warn_deprecated('private option is deprecated; see docs for details')
self.cascade = CascadeOptions("all, delete-orphan")
else:
self.cascade = CascadeOptions("save-update, merge")
if self.passive_deletes == 'all' and ("delete" in self.cascade or "delete-orphan" in self.cascade):
raise exceptions.ArgumentError("Can't set passive_deletes='all' in conjunction with 'delete' or 'delete-orphan' cascade")
self.association = association
if association:
util.warn_deprecated('association option is deprecated; see docs for details')
self.order_by = order_by
self.attributeext=attributeext
if isinstance(backref, str):
# propigate explicitly sent primary/secondary join conditions to the BackRef object if
# just a string was sent
if secondary is not None:
# reverse primary/secondary in case of a many-to-many
self.backref = BackRef(backref, primaryjoin=secondaryjoin, secondaryjoin=primaryjoin, passive_updates=self.passive_updates)
else:
self.backref = BackRef(backref, primaryjoin=primaryjoin, secondaryjoin=secondaryjoin, passive_updates=self.passive_updates)
else:
self.backref = backref
self.is_backref = is_backref
def __init__(self, comparator_factory, descriptor=None, doc=None):
self.descriptor = descriptor
self.comparator_factory = comparator_factory
self.doc = doc or (descriptor and descriptor.__doc__) or None
util.set_creation_order(self)
def __init__(self, comparator_factory, descriptor=None):
self.descriptor = descriptor
self.comparator_factory = comparator_factory
util.set_creation_order(self)
def __init__(self, name, map_column=None, descriptor=None, comparator_factory=None):
self.name = name
self.map_column = map_column
self.descriptor = descriptor
self.comparator_factory = comparator_factory
util.set_creation_order(self)
def __init__(self, comparator_factory, descriptor=None, doc=None):
self.descriptor = descriptor
self.comparator_factory = comparator_factory
self.doc = doc or (descriptor and descriptor.__doc__) or None
util.set_creation_order(self)
def __init__(
self,
argument,
secondary=None,
primaryjoin=None,
secondaryjoin=None,
foreign_keys=None,
uselist=None,
order_by=False,
backref=None,
_is_backref=False,
post_update=False,
cascade=False,
extension=None,
viewonly=False,
lazy=True,
collection_class=None,
passive_deletes=False,
passive_updates=True,
remote_side=None,
enable_typechecks=True,
join_depth=None,
comparator_factory=None,
strategy_class=None,
_local_remote_pairs=None,
query_class=None,
):
self.uselist = uselist
self.argument = argument
self.secondary = secondary
self.primaryjoin = primaryjoin
self.secondaryjoin = secondaryjoin
self.post_update = post_update
self.direction = None
self.viewonly = viewonly
self.lazy = lazy
self._foreign_keys = foreign_keys
self.collection_class = collection_class
self.passive_deletes = passive_deletes
self.passive_updates = passive_updates
self.remote_side = remote_side
self.enable_typechecks = enable_typechecks
self.query_class = query_class
self.join_depth = join_depth
self.local_remote_pairs = _local_remote_pairs
self.extension = extension
self.__join_cache = {}
self.comparator_factory = comparator_factory or RelationProperty.Comparator
self.comparator = self.comparator_factory(self, None)
util.set_creation_order(self)
if strategy_class:
self.strategy_class = strategy_class
elif self.lazy == "dynamic":
from sqlalchemy.orm import dynamic
self.strategy_class = dynamic.DynaLoader
elif self.lazy is False:
self.strategy_class = strategies.EagerLoader
elif self.lazy is None:
self.strategy_class = strategies.NoLoader
else:
self.strategy_class = strategies.LazyLoader
self._reverse_property = None
if cascade is not False:
self.cascade = CascadeOptions(cascade)
else:
self.cascade = CascadeOptions("save-update, merge")
if self.passive_deletes == "all" and ("delete" in self.cascade or "delete-orphan" in self.cascade):
raise sa_exc.ArgumentError(
"Can't set passive_deletes='all' in conjunction with 'delete' or 'delete-orphan' cascade"
)
self.order_by = order_by
if isinstance(backref, str):
# propagate explicitly sent primary/secondary join conditions to the BackRef object if
# just a string was sent
if secondary is not None:
# reverse primary/secondary in case of a many-to-many
self.backref = BackRef(
backref, primaryjoin=secondaryjoin, secondaryjoin=primaryjoin, passive_updates=self.passive_updates
)
else:
self.backref = BackRef(
backref, primaryjoin=primaryjoin, secondaryjoin=secondaryjoin, passive_updates=self.passive_updates
)
else:
self.backref = backref
self._is_backref = _is_backref
def __init__(self, value, description=None):
self.value = value
self.description = description
set_creation_order(self)
def __init__(self, comparator_factory, descriptor=None):
self.descriptor = descriptor
self.comparator = comparator_factory(self)
util.set_creation_order(self)
def __init__(self, name, map_column=None, descriptor=None):
self.name = name
self.map_column=map_column
self.descriptor = descriptor
util.set_creation_order(self)
def __init__(self, name, map_column=None, descriptor=None):
self.name = name
self.map_column = map_column
self.descriptor = descriptor
util.set_creation_order(self)
def __init__(self, f, args, kwargs):
self.f = f
self.args = args
self.kwargs = kwargs
set_creation_order(self)
def __init__(self, argument,
secondary=None, primaryjoin=None,
secondaryjoin=None,
foreign_keys=None,
uselist=None,
order_by=False,
backref=None,
back_populates=None,
post_update=False,
cascade=False, extension=None,
viewonly=False, lazy=True,
collection_class=None, passive_deletes=False,
passive_updates=True, remote_side=None,
enable_typechecks=True, join_depth=None,
comparator_factory=None,
strategy_class=None, _local_remote_pairs=None, query_class=None):
self.uselist = uselist
self.argument = argument
self.secondary = secondary
self.primaryjoin = primaryjoin
self.secondaryjoin = secondaryjoin
self.post_update = post_update
self.direction = None
self.viewonly = viewonly
self.lazy = lazy
self._foreign_keys = foreign_keys
self.collection_class = collection_class
self.passive_deletes = passive_deletes
self.passive_updates = passive_updates
self.remote_side = remote_side
self.enable_typechecks = enable_typechecks
self.query_class = query_class
self.join_depth = join_depth
self.local_remote_pairs = _local_remote_pairs
self.extension = extension
self.comparator_factory = comparator_factory or RelationProperty.Comparator
self.comparator = self.comparator_factory(self, None)
util.set_creation_order(self)
if strategy_class:
self.strategy_class = strategy_class
elif self.lazy == 'dynamic':
from sqlalchemy.orm import dynamic
self.strategy_class = dynamic.DynaLoader
elif self.lazy is False:
self.strategy_class = strategies.EagerLoader
elif self.lazy is None:
self.strategy_class = strategies.NoLoader
else:
self.strategy_class = strategies.LazyLoader
self._reverse_property = set()
if cascade is not False:
self.cascade = CascadeOptions(cascade)
else:
self.cascade = CascadeOptions("save-update, merge")
if self.passive_deletes == 'all' and ("delete" in self.cascade or "delete-orphan" in self.cascade):
raise sa_exc.ArgumentError("Can't set passive_deletes='all' in conjunction with 'delete' or 'delete-orphan' cascade")
self.order_by = order_by
self.back_populates = back_populates
if self.back_populates:
if backref:
raise sa_exc.ArgumentError("backref and back_populates keyword arguments are mutually exclusive")
self.backref = None
elif isinstance(backref, str):
# propagate explicitly sent primary/secondary join conditions to the BackRef object if
# just a string was sent
if secondary is not None:
# reverse primary/secondary in case of a many-to-many
self.backref = BackRef(backref, primaryjoin=secondaryjoin,
secondaryjoin=primaryjoin, passive_updates=self.passive_updates)
else:
self.backref = BackRef(backref, primaryjoin=primaryjoin,
secondaryjoin=secondaryjoin, passive_updates=self.passive_updates)
else:
self.backref = backref
def __init__(self,
argument,
secondary=None,
primaryjoin=None,
secondaryjoin=None,
entity_name=None,
foreign_keys=None,
foreignkey=None,
uselist=None,
private=False,
association=None,
order_by=False,
attributeext=None,
backref=None,
is_backref=False,
post_update=False,
cascade=None,
viewonly=False,
lazy=True,
collection_class=None,
passive_deletes=False,
passive_updates=True,
remote_side=None,
enable_typechecks=True,
join_depth=None,
strategy_class=None,
_local_remote_pairs=None):
self.uselist = uselist
self.argument = argument
self.entity_name = entity_name
self.secondary = secondary
self.primaryjoin = primaryjoin
self.secondaryjoin = secondaryjoin
self.post_update = post_update
self.direction = None
self.viewonly = viewonly
self.lazy = lazy
self.foreign_keys = util.to_set(foreign_keys)
self._legacy_foreignkey = util.to_set(foreignkey)
if foreignkey:
util.warn_deprecated(
'foreignkey option is deprecated; see docs for details')
self.collection_class = collection_class
self.passive_deletes = passive_deletes
self.passive_updates = passive_updates
self.remote_side = util.to_set(remote_side)
self.enable_typechecks = enable_typechecks
self.comparator = PropertyLoader.Comparator(self)
self.join_depth = join_depth
self._arg_local_remote_pairs = _local_remote_pairs
util.set_creation_order(self)
if strategy_class:
self.strategy_class = strategy_class
elif self.lazy == 'dynamic':
from sqlalchemy.orm import dynamic
self.strategy_class = dynamic.DynaLoader
elif self.lazy is False:
self.strategy_class = strategies.EagerLoader
elif self.lazy is None:
self.strategy_class = strategies.NoLoader
else:
self.strategy_class = strategies.LazyLoader
self._reverse_property = None
if cascade is not None:
self.cascade = CascadeOptions(cascade)
else:
if private:
util.warn_deprecated(
'private option is deprecated; see docs for details')
self.cascade = CascadeOptions("all, delete-orphan")
else:
self.cascade = CascadeOptions("save-update, merge")
if self.passive_deletes == 'all' and ("delete" in self.cascade or
"delete-orphan" in self.cascade):
raise exceptions.ArgumentError(
"Can't set passive_deletes='all' in conjunction with 'delete' or 'delete-orphan' cascade"
)
self.association = association
if association:
util.warn_deprecated(
'association option is deprecated; see docs for details')
self.order_by = order_by
self.attributeext = attributeext
if isinstance(backref, str):
# propigate explicitly sent primary/secondary join conditions to the BackRef object if
# just a string was sent
if secondary is not None:
# reverse primary/secondary in case of a many-to-many
self.backref = BackRef(backref,
primaryjoin=secondaryjoin,
secondaryjoin=primaryjoin,
passive_updates=self.passive_updates)
else:
self.backref = BackRef(backref,
primaryjoin=primaryjoin,
secondaryjoin=secondaryjoin,
passive_updates=self.passive_updates)
else:
self.backref = backref
self.is_backref = is_backref
