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, 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, 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, *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, 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