{"p1": self._temp_table_name_like_pattern(tablename)},
).one()
except exc.MultipleResultsFound as me:
- util.raise_(
- exc.UnreflectableTableError(
- "Found more than one temporary table named '%s' in tempdb "
- "at this time. Cannot reliably resolve that name to its "
- "internal table name." % tablename
- ),
- replace_context=me,
- )
+ raise exc.UnreflectableTableError(
+ "Found more than one temporary table named '%s' in tempdb "
+ "at this time. Cannot reliably resolve that name to its "
+ "internal table name." % tablename
+ ) from me
except exc.NoResultFound as ne:
- util.raise_(
- exc.NoSuchTableError(
- "Unable to find a temporary table named '%s' in tempdb."
- % tablename
- ),
- replace_context=ne,
- )
+ raise exc.NoSuchTableError(
+ "Unable to find a temporary table named '%s' in tempdb."
+ % tablename
+ ) from ne
@reflection.cache
@_db_plus_owner
).exec_driver_sql(st)
except exc.DBAPIError as e:
if self._extract_error_code(e.orig) == 1146:
- util.raise_(exc.NoSuchTableError(full_name), replace_context=e)
+ raise exc.NoSuchTableError(full_name) from e
else:
raise
row = self._compat_first(rp, charset=charset)
except exc.DBAPIError as e:
code = self._extract_error_code(e.orig)
if code == 1146:
- util.raise_(
- exc.NoSuchTableError(full_name), replace_context=e
- )
+ raise exc.NoSuchTableError(full_name) from e
+
elif code == 1356:
- util.raise_(
- exc.UnreflectableTableError(
- "Table or view named %s could not be "
- "reflected: %s" % (full_name, e)
- ),
- replace_context=e,
- )
+ raise exc.UnreflectableTableError(
+ "Table or view named %s could not be "
+ "reflected: %s" % (full_name, e)
+ ) from e
+
else:
raise
rows = self._compat_fetchall(rp, charset=charset)
isinstance(error, ValueError)
and error.args[0] == "no active connection"
):
- util.raise_(
- self.dbapi.sqlite.OperationalError("no active connection"),
- from_=error,
- )
+ raise self.dbapi.sqlite.OperationalError(
+ "no active connection"
+ ) from error
else:
raise error
self.process(extract.expr, **kw),
)
except KeyError as err:
- util.raise_(
- exc.CompileError(
- "%s is not a valid extract argument." % extract.field
- ),
- replace_context=err,
- )
+ raise exc.CompileError(
+ "%s is not a valid extract argument." % extract.field
+ ) from err
def limit_clause(self, select, **kw):
text = ""
import datetime
import re
-from .. import util
-
def str_to_datetime_processor_factory(regexp, type_):
rmatch = regexp.match
try:
m = rmatch(value)
except TypeError as err:
- util.raise_(
- ValueError(
- "Couldn't parse %s string '%r' "
- "- value is not a string." % (type_.__name__, value)
- ),
- from_=err,
- )
+ raise ValueError(
+ "Couldn't parse %s string '%r' "
+ "- value is not a string." % (type_.__name__, value)
+ ) from err
if m is None:
raise ValueError(
"Couldn't parse %s string: "
try:
meth = statement._execute_on_connection
except AttributeError as err:
- util.raise_(
- exc.ObjectNotExecutableError(statement), replace_context=err
- )
+ raise exc.ObjectNotExecutableError(statement) from err
else:
return meth(
self,
invalidate_pool_on_disconnect = not is_exit_exception
if self._reentrant_error:
- util.raise_(
- exc.DBAPIError.instance(
- statement,
- parameters,
- e,
- self.dialect.dbapi.Error,
- hide_parameters=self.engine.hide_parameters,
- dialect=self.dialect,
- ismulti=context.executemany
- if context is not None
- else None,
- ),
- with_traceback=exc_info[2],
- from_=e,
- )
+ raise exc.DBAPIError.instance(
+ statement,
+ parameters,
+ e,
+ self.dialect.dbapi.Error,
+ hide_parameters=self.engine.hide_parameters,
+ dialect=self.dialect,
+ ismulti=context.executemany if context is not None else None,
+ ).with_traceback(exc_info[2]) from e
self._reentrant_error = True
try:
# non-DBAPI error - if we already got a context,
self._rollback_impl()
if newraise:
- util.raise_(newraise, with_traceback=exc_info[2], from_=e)
+ raise newraise.with_traceback(exc_info[2]) from e
elif should_wrap:
- util.raise_(
- sqlalchemy_exception, with_traceback=exc_info[2], from_=e
- )
+ raise sqlalchemy_exception.with_traceback(exc_info[2]) from e
else:
- util.raise_(exc_info[1], with_traceback=exc_info[2])
-
+ raise exc_info[1].with_traceback(exc_info[2])
finally:
del self._reentrant_error
if self._is_disconnect:
) = ctx.is_disconnect
if newraise:
- util.raise_(newraise, with_traceback=exc_info[2], from_=e)
+ raise newraise.with_traceback(exc_info[2]) from e
elif should_wrap:
- util.raise_(
- sqlalchemy_exception, with_traceback=exc_info[2], from_=e
- )
+ raise sqlalchemy_exception.with_traceback(exc_info[2]) from e
else:
- util.raise_(exc_info[1], with_traceback=exc_info[2])
+ raise exc_info[1].with_traceback(exc_info[2])
def _run_ddl_visitor(self, visitorcallable, element, **kwargs):
"""run a DDL visitor.
if raiseerr:
if self._unpickled and isinstance(key, elements.ColumnElement):
- util.raise_(
- exc.NoSuchColumnError(
- "Row was unpickled; lookup by ColumnElement "
- "is unsupported"
- ),
- replace_context=err,
- )
+ raise exc.NoSuchColumnError(
+ "Row was unpickled; lookup by ColumnElement "
+ "is unsupported"
+ ) from err
else:
- util.raise_(
- exc.NoSuchColumnError(
- "Could not locate column in row for column '%s'"
- % util.string_or_unprintable(key)
- ),
- replace_context=err,
- )
+ raise exc.NoSuchColumnError(
+ "Could not locate column in row for column '%s'"
+ % util.string_or_unprintable(key)
+ ) from err
else:
return None
def _non_result(self, result, default, err=None):
if result.closed:
- util.raise_(
- exc.ResourceClosedError("This result object is closed."),
- replace_context=err,
- )
+ raise exc.ResourceClosedError(
+ "This result object is closed."
+ ) from err
else:
return default
returns_rows = False
def _we_dont_return_rows(self, err=None):
- util.raise_(
- exc.ResourceClosedError(
- "This result object does not return rows. "
- "It has been closed automatically."
- ),
- replace_context=err,
- )
+ raise exc.ResourceClosedError(
+ "This result object does not return rows. "
+ "It has been closed automatically."
+ ) from err
def _index_for_key(self, keys, raiseerr):
self._we_dont_return_rows()
def _key_fallback(self, key, err, raiseerr=True):
assert raiseerr
- util.raise_(KeyError(key), replace_context=err)
+ raise KeyError(key) from err
def _raise_for_nonint(self, key):
raise TypeError(
try:
obj.__dict__["dispatch"] = disp
except AttributeError as ae:
- util.raise_(
- TypeError(
- "target %r doesn't have __dict__, should it be "
- "defining _slots_dispatch?" % (obj,)
- ),
- replace_context=ae,
- )
+ raise TypeError(
+ "target %r doesn't have __dict__, should it be "
+ "defining _slots_dispatch?" % (obj,)
+ ) from ae
return disp
# this was never asserted before but this should be made clear.
if not isinstance(prop, orm.RelationshipProperty):
- util.raise_(
- NotImplementedError(
- "association proxy to a non-relationship "
- "intermediary is not supported"
- ),
- replace_context=None,
- )
+ raise NotImplementedError(
+ "association proxy to a non-relationship "
+ "intermediary is not supported"
+ ) from None
target_class = prop.mapper.class_
for k, v in seq_or_map:
self[k] = v
except ValueError as err:
- util.raise_(
- ValueError(
- "dictionary update sequence "
- "requires 2-element tuples"
- ),
- replace_context=err,
- )
+ raise ValueError(
+ "dictionary update sequence "
+ "requires 2-element tuples"
+ ) from err
for key, value in kw:
self[key] = value
"""
from .. import exc
-from .. import util
from ..sql import sqltypes
try:
return existing_dispatch(element, compiler, **kw)
except exc.UnsupportedCompilationError as uce:
- util.raise_(
- exc.UnsupportedCompilationError(
- compiler,
- type(element),
- message="%s construct has no default "
- "compilation handler." % type(element),
- ),
- from_=uce,
- )
+ raise exc.UnsupportedCompilationError(
+ compiler,
+ type(element),
+ message="%s construct has no default "
+ "compilation handler." % type(element),
+ ) from uce
existing.specs["default"] = _wrap_existing_dispatch
try:
fn = self.specs["default"]
except KeyError as ke:
- util.raise_(
- exc.UnsupportedCompilationError(
- compiler,
- type(element),
- message="%s construct has no default "
- "compilation handler." % type(element),
- ),
- replace_context=ke,
- )
+ raise exc.UnsupportedCompilationError(
+ compiler,
+ type(element),
+ message="%s construct has no default "
+ "compilation handler." % type(element),
+ ) from ke
# if compilation includes add_to_result_map, collect add_to_result_map
# arguments from the user-defined callable, which are probably none
""" # noqa
from .. import inspect
-from .. import util
from ..ext.hybrid import hybrid_property
from ..orm.attributes import flag_modified
def _fget_default(self, err=None):
if self.default == self._NO_DEFAULT_ARGUMENT:
- util.raise_(AttributeError(self.attr_name), replace_context=err)
+ raise AttributeError(self.attr_name) from err
else:
return self.default
try:
del column_value[self.index]
except KeyError as err:
- util.raise_(AttributeError(self.attr_name), replace_context=err)
+ raise AttributeError(self.attr_name) from err
else:
setattr(instance, attr_name, column_value)
flag_modified(instance, attr_name)
try:
anno = ce._annotate
except AttributeError as ae:
- util.raise_(
- exc.InvalidRequestError(
- 'When interpreting attribute "%s" as a SQL expression, '
- "expected __clause_element__() to return "
- "a ClauseElement object, got: %r" % (self, ce)
- ),
- from_=ae,
- )
+ raise exc.InvalidRequestError(
+ 'When interpreting attribute "%s" as a SQL expression, '
+ "expected __clause_element__() to return "
+ "a ClauseElement object, got: %r" % (self, ce)
+ ) from ae
else:
return anno(annotations)
try:
return getattr(self.comparator, key)
except AttributeError as err:
- util.raise_(
- AttributeError(
- "Neither %r object nor %r object associated with %s "
- "has an attribute %r"
- % (
- type(self).__name__,
- type(self.comparator).__name__,
- self,
- key,
- )
- ),
- replace_context=err,
- )
+ raise AttributeError(
+ "Neither %r object nor %r object associated with %s "
+ "has an attribute %r"
+ % (
+ type(self).__name__,
+ type(self.comparator).__name__,
+ self,
+ key,
+ )
+ ) from err
def __str__(self):
return "%s.%s" % (self.class_.__name__, self.key)
try:
state = instance_state(instance)
except AttributeError as err:
- util.raise_(
- orm_exc.UnmappedInstanceError(instance),
- replace_context=err,
- )
+ raise orm_exc.UnmappedInstanceError(instance) from err
return self.impl.get(state, dict_)
return getattr(descriptor, attribute)
except AttributeError as err:
if attribute == "comparator":
- util.raise_(
- AttributeError("comparator"), replace_context=err
- )
+ raise AttributeError("comparator") from err
try:
# comparator itself might be unreachable
comparator = self.comparator
except AttributeError as err2:
- util.raise_(
- AttributeError(
- "Neither %r object nor unconfigured comparator "
- "object associated with %s has an attribute %r"
- % (type(descriptor).__name__, self, attribute)
- ),
- replace_context=err2,
- )
+ raise AttributeError(
+ "Neither %r object nor unconfigured comparator "
+ "object associated with %s has an attribute %r"
+ % (type(descriptor).__name__, self, attribute)
+ ) from err2
else:
try:
return getattr(comparator, attribute)
except AttributeError as err3:
- util.raise_(
- AttributeError(
- "Neither %r object nor %r object "
- "associated with %s has an attribute %r"
- % (
- type(descriptor).__name__,
- type(comparator).__name__,
- self,
- attribute,
- )
- ),
- replace_context=err3,
- )
+ raise AttributeError(
+ "Neither %r object nor %r object "
+ "associated with %s has an attribute %r"
+ % (
+ type(descriptor).__name__,
+ type(comparator).__name__,
+ self,
+ attribute,
+ )
+ ) from err3
Proxy.__name__ = type(descriptor).__name__ + "Proxy"
return dict_[key]
except KeyError as err:
# TODO: no test coverage here.
- util.raise_(
- KeyError(
- "Deferred loader for attribute "
- "%r failed to populate "
- "correctly" % key
- ),
- replace_context=err,
- )
+ raise KeyError(
+ "Deferred loader for attribute "
+ "%r failed to populate "
+ "correctly" % key
+ ) from err
elif value is not ATTR_EMPTY:
return self.set_committed_value(state, dict_, value)
try:
return getattr(entity, key)
except AttributeError as err:
- util.raise_(
- sa_exc.InvalidRequestError(
- "Entity '%s' has no property '%s'" % (description, key)
- ),
- replace_context=err,
- )
+ raise sa_exc.InvalidRequestError(
+ "Entity '%s' has no property '%s'" % (description, key)
+ ) from err
_state_mapper = util.dottedgetter("manager.mapper")
return self.fallback[key]
def _raise_for_name(self, name, err):
- util.raise_(
- exc.InvalidRequestError(
- "When initializing mapper %s, expression %r failed to "
- "locate a name (%r). If this is a class name, consider "
- "adding this relationship() to the %r class after "
- "both dependent classes have been defined."
- % (self.prop.parent, self.arg, name, self.cls)
- ),
- from_=err,
- )
+ raise exc.InvalidRequestError(
+ "When initializing mapper %s, expression %r failed to "
+ "locate a name (%r). If this is a class name, consider "
+ "adding this relationship() to the %r class after "
+ "both dependent classes have been defined."
+ % (self.prop.parent, self.arg, name, self.cls)
+ ) from err
def _resolve_name(self):
name = self.arg
try:
right = right.entity
except AttributeError as err:
- util.raise_(
- sa_exc.ArgumentError(
- "Join target %s does not refer to a "
- "mapped entity" % right
- ),
- replace_context=err,
- )
+ raise sa_exc.ArgumentError(
+ "Join target %s does not refer to a "
+ "mapped entity" % right
+ ) from err
left = onclause._parententity
try:
right = right.entity
except AttributeError as err:
- util.raise_(
- sa_exc.ArgumentError(
- "Join target %s does not refer to a "
- "mapped entity" % right
- ),
- replace_context=err,
- )
+ raise sa_exc.ArgumentError(
+ "Join target %s does not refer to a "
+ "mapped entity" % right
+ ) from err
left = onclause._parententity
except sa_exc.NoForeignKeysError as nfe:
assert self.inherits.local_table is not None
assert self.local_table is not None
- util.raise_(
- sa_exc.NoForeignKeysError(
- "Can't determine the inherit condition "
- "between inherited table '%s' and "
- "inheriting "
- "table '%s'; tables have no "
- "foreign key relationships established. "
- "Please ensure the inheriting table has "
- "a foreign key relationship to the "
- "inherited "
- "table, or provide an "
- "'on clause' using "
- "the 'inherit_condition' mapper argument."
- % (
- self.inherits.local_table.description,
- self.local_table.description,
- )
- ),
- replace_context=nfe,
- )
+ raise sa_exc.NoForeignKeysError(
+ "Can't determine the inherit condition "
+ "between inherited table '%s' and "
+ "inheriting "
+ "table '%s'; tables have no "
+ "foreign key relationships established. "
+ "Please ensure the inheriting table has "
+ "a foreign key relationship to the "
+ "inherited "
+ "table, or provide an "
+ "'on clause' using "
+ "the 'inherit_condition' mapper argument."
+ % (
+ self.inherits.local_table.description,
+ self.local_table.description,
+ )
+ ) from nfe
except sa_exc.AmbiguousForeignKeysError as afe:
assert self.inherits.local_table is not None
assert self.local_table is not None
- util.raise_(
- sa_exc.AmbiguousForeignKeysError(
- "Can't determine the inherit condition "
- "between inherited table '%s' and "
- "inheriting "
- "table '%s'; tables have more than one "
- "foreign key relationship established. "
- "Please specify the 'on clause' using "
- "the 'inherit_condition' mapper argument."
- % (
- self.inherits.local_table.description,
- self.local_table.description,
- )
- ),
- replace_context=afe,
- )
+ raise sa_exc.AmbiguousForeignKeysError(
+ "Can't determine the inherit condition "
+ "between inherited table '%s' and "
+ "inheriting "
+ "table '%s'; tables have more than one "
+ "foreign key relationship established. "
+ "Please specify the 'on clause' using "
+ "the 'inherit_condition' mapper argument."
+ % (
+ self.inherits.local_table.description,
+ self.local_table.description,
+ )
+ ) from afe
self.persist_selectable = sql.join(
self.inherits.persist_selectable,
self.local_table,
try:
self.polymorphic_on = self._props[self.polymorphic_on]
except KeyError as err:
- util.raise_(
- sa_exc.ArgumentError(
- "Can't determine polymorphic_on "
- "value '%s' - no attribute is "
- "mapped to this name." % self.polymorphic_on
- ),
- replace_context=err,
- )
+ raise sa_exc.ArgumentError(
+ "Can't determine polymorphic_on "
+ "value '%s' - no attribute is "
+ "mapped to this name." % self.polymorphic_on
+ ) from err
if self.polymorphic_on in self._columntoproperty:
# polymorphic_on is a column that is already mapped
try:
return self._props[key]
except KeyError as err:
- util.raise_(
- sa_exc.InvalidRequestError(
- "Mapper '%s' has no property '%s'" % (self, key)
- ),
- replace_context=err,
- )
+ raise sa_exc.InvalidRequestError(
+ "Mapper '%s' has no property '%s'" % (self, key)
+ ) from err
def get_property_by_column(self, column):
"""Given a :class:`_schema.Column` object, return the
persistent, key=mapper._persistent_sortkey_fn
)
except TypeError as err:
- util.raise_(
- sa_exc.InvalidRequestError(
- "Could not sort objects by primary key; primary key "
- "values must be sortable in Python (was: %s)" % err
- ),
- replace_context=err,
- )
+ raise sa_exc.InvalidRequestError(
+ "Could not sort objects by primary key; primary key "
+ "values must be sortable in Python (was: %s)" % err
+ ) from err
return (
sorted(pending, key=operator.attrgetter("insert_order"))
+ persistent_sorted
return True
except evaluator.UnevaluatableError as err:
- util.raise_(
- sa_exc.InvalidRequestError(
- 'Could not evaluate current criteria in Python: "%s". '
- "Specify 'fetch' or False for the "
- "synchronize_session execution option." % err
- ),
- from_=err,
- )
+ raise sa_exc.InvalidRequestError(
+ 'Could not evaluate current criteria in Python: "%s". '
+ "Specify 'fetch' or False for the "
+ "synchronize_session execution option." % err
+ ) from err
if statement.__visit_name__ == "lambda_element":
# ._resolved is called on every LambdaElement in order to
)
except sa_exc.NoForeignKeysError as nfe:
if self.secondary is not None:
- util.raise_(
- sa_exc.NoForeignKeysError(
- "Could not determine join "
- "condition between parent/child tables on "
- "relationship %s - there are no foreign keys "
- "linking these tables via secondary table '%s'. "
- "Ensure that referencing columns are associated "
- "with a ForeignKey or ForeignKeyConstraint, or "
- "specify 'primaryjoin' and 'secondaryjoin' "
- "expressions." % (self.prop, self.secondary)
- ),
- from_=nfe,
- )
+ raise sa_exc.NoForeignKeysError(
+ "Could not determine join "
+ "condition between parent/child tables on "
+ "relationship %s - there are no foreign keys "
+ "linking these tables via secondary table '%s'. "
+ "Ensure that referencing columns are associated "
+ "with a ForeignKey or ForeignKeyConstraint, or "
+ "specify 'primaryjoin' and 'secondaryjoin' "
+ "expressions." % (self.prop, self.secondary)
+ ) from nfe
else:
- util.raise_(
- sa_exc.NoForeignKeysError(
- "Could not determine join "
- "condition between parent/child tables on "
- "relationship %s - there are no foreign keys "
- "linking these tables. "
- "Ensure that referencing columns are associated "
- "with a ForeignKey or ForeignKeyConstraint, or "
- "specify a 'primaryjoin' expression." % self.prop
- ),
- from_=nfe,
- )
+ raise sa_exc.NoForeignKeysError(
+ "Could not determine join "
+ "condition between parent/child tables on "
+ "relationship %s - there are no foreign keys "
+ "linking these tables. "
+ "Ensure that referencing columns are associated "
+ "with a ForeignKey or ForeignKeyConstraint, or "
+ "specify a 'primaryjoin' expression." % self.prop
+ ) from nfe
except sa_exc.AmbiguousForeignKeysError as afe:
if self.secondary is not None:
- util.raise_(
- sa_exc.AmbiguousForeignKeysError(
- "Could not determine join "
- "condition between parent/child tables on "
- "relationship %s - there are multiple foreign key "
- "paths linking the tables via secondary table '%s'. "
- "Specify the 'foreign_keys' "
- "argument, providing a list of those columns which "
- "should be counted as containing a foreign key "
- "reference from the secondary table to each of the "
- "parent and child tables."
- % (self.prop, self.secondary)
- ),
- from_=afe,
- )
+ raise sa_exc.AmbiguousForeignKeysError(
+ "Could not determine join "
+ "condition between parent/child tables on "
+ "relationship %s - there are multiple foreign key "
+ "paths linking the tables via secondary table '%s'. "
+ "Specify the 'foreign_keys' "
+ "argument, providing a list of those columns which "
+ "should be counted as containing a foreign key "
+ "reference from the secondary table to each of the "
+ "parent and child tables." % (self.prop, self.secondary)
+ ) from afe
else:
- util.raise_(
- sa_exc.AmbiguousForeignKeysError(
- "Could not determine join "
- "condition between parent/child tables on "
- "relationship %s - there are multiple foreign key "
- "paths linking the tables. Specify the "
- "'foreign_keys' argument, providing a list of those "
- "columns which should be counted as containing a "
- "foreign key reference to the parent table."
- % self.prop
- ),
- from_=afe,
- )
+ raise sa_exc.AmbiguousForeignKeysError(
+ "Could not determine join "
+ "condition between parent/child tables on "
+ "relationship %s - there are multiple foreign key "
+ "paths linking the tables. Specify the "
+ "'foreign_keys' argument, providing a list of those "
+ "columns which should be counted as containing a "
+ "foreign key reference to the parent table." % self.prop
+ ) from afe
@property
def primaryjoin_minus_local(self):
self._parent._rollback_exception = sys.exc_info()[1]
if rollback_err:
- util.raise_(rollback_err[1], with_traceback=rollback_err[2])
+ raise rollback_err[1].with_traceback(rollback_err[2])
sess.dispatch.after_soft_rollback(sess, self)
insp = inspect(key)
except sa_exc.NoInspectionAvailable as err:
if not isinstance(key, type):
- util.raise_(
- sa_exc.ArgumentError(
- "Not an acceptable bind target: %s" % key
- ),
- replace_context=err,
- )
+ raise sa_exc.ArgumentError(
+ "Not an acceptable bind target: %s" % key
+ ) from err
else:
self.__binds[key] = bind
else:
mapper = inspect(mapper)
except sa_exc.NoInspectionAvailable as err:
if isinstance(mapper, type):
- util.raise_(
- exc.UnmappedClassError(mapper),
- replace_context=err,
- )
+ raise exc.UnmappedClassError(mapper) from err
else:
raise
"consider using a session.no_autoflush block if this "
"flush is occurring prematurely"
)
- util.raise_(e, with_traceback=sys.exc_info()[2])
+ raise e.with_traceback(sys.exc_info()[2])
def refresh(self, instance, attribute_names=None, with_for_update=None):
"""Expire and refresh attributes on the given instance.
try:
state = attributes.instance_state(instance)
except exc.NO_STATE as err:
- util.raise_(
- exc.UnmappedInstanceError(instance),
- replace_context=err,
- )
+ raise exc.UnmappedInstanceError(instance) from err
self._expire_state(state, attribute_names)
try:
state = attributes.instance_state(instance)
except exc.NO_STATE as err:
- util.raise_(
- exc.UnmappedInstanceError(instance),
- replace_context=err,
- )
+ raise exc.UnmappedInstanceError(instance) from err
self._expire_state(state, attribute_names)
def _expire_state(self, state, attribute_names):
try:
state = attributes.instance_state(instance)
except exc.NO_STATE as err:
- util.raise_(
- exc.UnmappedInstanceError(instance),
- replace_context=err,
- )
+ raise exc.UnmappedInstanceError(instance) from err
if state.session_id is not self.hash_key:
raise sa_exc.InvalidRequestError(
"Instance %s is not present in this Session" % state_str(state)
try:
state = attributes.instance_state(instance)
except exc.NO_STATE as err:
- util.raise_(
- exc.UnmappedInstanceError(instance),
- replace_context=err,
- )
+ raise exc.UnmappedInstanceError(instance) from err
self._save_or_update_state(state)
try:
state = attributes.instance_state(instance)
except exc.NO_STATE as err:
- util.raise_(
- exc.UnmappedInstanceError(instance),
- replace_context=err,
- )
+ raise exc.UnmappedInstanceError(instance) from err
self._delete_impl(state, instance, head=True)
)
except KeyError as err:
- util.raise_(
- sa_exc.InvalidRequestError(
- "Incorrect names of values in identifier to formulate "
- "primary key for session.get(); primary key attribute "
- "names are %s"
- % ",".join(
- "'%s'" % prop.key
- for prop in mapper._identity_key_props
- )
- ),
- replace_context=err,
- )
+ raise sa_exc.InvalidRequestError(
+ "Incorrect names of values in identifier to formulate "
+ "primary key for session.get(); primary key attribute "
+ "names are %s"
+ % ",".join(
+ "'%s'" % prop.key
+ for prop in mapper._identity_key_props
+ )
+ ) from err
if (
not populate_existing
try:
state = attributes.instance_state(obj)
except exc.NO_STATE as err:
- util.raise_(
- exc.UnmappedInstanceError(obj),
- replace_context=err,
- )
+ raise exc.UnmappedInstanceError(obj) from err
to_attach = self._before_attach(state, obj)
state._load_pending = True
try:
state = attributes.instance_state(instance)
except exc.NO_STATE as err:
- util.raise_(
- exc.UnmappedInstanceError(instance),
- replace_context=err,
- )
+ raise exc.UnmappedInstanceError(instance) from err
return self._contains_state(state)
def __iter__(self):
state = attributes.instance_state(o)
except exc.NO_STATE as err:
- util.raise_(
- exc.UnmappedInstanceError(o),
- replace_context=err,
- )
+ raise exc.UnmappedInstanceError(o) from err
objset.add(state)
else:
objset = None
try:
state = attributes.instance_state(instance)
except exc.NO_STATE as err:
- util.raise_(
- exc.UnmappedInstanceError(instance),
- replace_context=err,
- )
+ raise exc.UnmappedInstanceError(instance) from err
else:
return _state_session(state)
try:
insp = inspect(attr)
except sa_exc.NoInspectionAvailable as err:
- util.raise_(
- sa_exc.ArgumentError(
- "expected ORM mapped attribute for loader strategy argument"
- ),
- from_=err,
- )
+ raise sa_exc.ArgumentError(
+ "expected ORM mapped attribute for loader strategy argument"
+ ) from err
if insp.is_property:
lead_entity = insp.parent
from . import attributes
from . import exc
from . import util as orm_util
-from .. import util
def populate(
isdest, source_mapper, source_column, dest_mapper, dest_column, err
):
if isdest:
- util.raise_(
- exc.UnmappedColumnError(
- "Can't execute sync rule for "
- "destination column '%s'; mapper '%s' does not map "
- "this column. Try using an explicit `foreign_keys` "
- "collection which does not include this column (or use "
- "a viewonly=True relation)." % (dest_column, dest_mapper)
- ),
- replace_context=err,
- )
+ raise exc.UnmappedColumnError(
+ "Can't execute sync rule for "
+ "destination column '%s'; mapper '%s' does not map "
+ "this column. Try using an explicit `foreign_keys` "
+ "collection which does not include this column (or use "
+ "a viewonly=True relation)." % (dest_column, dest_mapper)
+ ) from err
else:
- util.raise_(
- exc.UnmappedColumnError(
- "Can't execute sync rule for "
- "source column '%s'; mapper '%s' does not map this "
- "column. Try using an explicit `foreign_keys` "
- "collection which does not include destination column "
- "'%s' (or use a viewonly=True relation)."
- % (source_column, source_mapper, dest_column)
- ),
- replace_context=err,
- )
+ raise exc.UnmappedColumnError(
+ "Can't execute sync rule for "
+ "source column '%s'; mapper '%s' does not map this "
+ "column. Try using an explicit `foreign_keys` "
+ "collection which does not include destination column "
+ "'%s' (or use a viewonly=True relation)."
+ % (source_column, source_mapper, dest_column)
+ ) from err
try:
dialect, value_key = key.split("_", 1)
except ValueError as err:
- util.raise_(KeyError(key), replace_context=err)
+ raise KeyError(key) from err
else:
return dialect, value_key
try:
opt = self.obj.dialect_options[dialect]
except exc.NoSuchModuleError as err:
- util.raise_(KeyError(key), replace_context=err)
+ raise KeyError(key) from err
else:
return opt[value_key]
try:
dialect, value_key = self._key(key)
except KeyError as err:
- util.raise_(
- exc.ArgumentError(
- "Keys must be of the form <dialectname>_<argname>"
- ),
- replace_context=err,
- )
+ raise exc.ArgumentError(
+ "Keys must be of the form <dialectname>_<argname>"
+ ) from err
else:
self.obj.dialect_options[dialect][value_key] = value
return self._index[key]
except KeyError as err:
if isinstance(key, int):
- util.raise_(IndexError(key), replace_context=err)
+ raise IndexError(key) from err
else:
raise
try:
return self._index[key]
except KeyError as err:
- util.raise_(AttributeError(key), replace_context=err)
+ raise AttributeError(key) from err
def __contains__(self, key):
if key not in self._index:
else:
return getattr(ns, key)
except AttributeError as err:
- util.raise_(
- exc.InvalidRequestError(
- 'Entity namespace for "%s" has no property "%s"'
- % (entity, key)
- ),
- replace_context=err,
- )
+ raise exc.InvalidRequestError(
+ 'Entity namespace for "%s" has no property "%s"' % (entity, key)
+ ) from err
if advice:
msg += " " + advice
- util.raise_(exc.ArgumentError(msg, code=code), replace_context=err)
+ raise exc.ArgumentError(msg, code=code) from err
class _Deannotate:
def _no_text_coercion(
element, argname=None, exc_cls=exc.ArgumentError, extra=None, err=None
):
- util.raise_(
- exc_cls(
- "%(extra)sTextual SQL expression %(expr)r %(argname)sshould be "
- "explicitly declared as text(%(expr)r)"
- % {
- "expr": util.ellipses_string(element),
- "argname": "for argument %s" % (argname,) if argname else "",
- "extra": "%s " % extra if extra else "",
- }
- ),
- replace_context=err,
- )
+ raise exc_cls(
+ "%(extra)sTextual SQL expression %(expr)r %(argname)sshould be "
+ "explicitly declared as text(%(expr)r)"
+ % {
+ "expr": util.ellipses_string(element),
+ "argname": "for argument %s" % (argname,) if argname else "",
+ "extra": "%s " % extra if extra else "",
+ }
+ ) from err
class _NoTextCoercion:
raise exc.ObjectNotExecutableError(self.statement)
def visit_unsupported_compilation(self, element, err):
- util.raise_(
- exc.UnsupportedCompilationError(self, type(element)),
- replace_context=err,
- )
+ raise exc.UnsupportedCompilationError(self, type(element)) from err
@property
def sql_compiler(self):
return type_._compiler_dispatch(self, **kw)
def visit_unsupported_compilation(self, element, err, **kw):
- util.raise_(
- exc.UnsupportedCompilationError(self, element),
- replace_context=err,
- )
+ raise exc.UnsupportedCompilationError(self, element) from err
# this was a Visitable, but to allow accurate detection of
try:
return self.stack[-1]["selectable"]
except IndexError as ie:
- util.raise_(
- IndexError("Compiler does not have a stack entry"),
- replace_context=ie,
- )
+ raise IndexError("Compiler does not have a stack entry") from ie
@property
def prefetch(self):
try:
orig_extracted = self.cache_key[1]
except TypeError as err:
- util.raise_(
- exc.CompileError(
- "This compiled object has no original cache key; "
- "can't pass extracted_parameters to construct_params"
- ),
- replace_context=err,
- )
+ raise exc.CompileError(
+ "This compiled object has no original cache key; "
+ "can't pass extracted_parameters to construct_params"
+ ) from err
ckbm = self._cache_key_bind_match
resolved_extracted = {
try:
opstring = OPERATORS[operator_]
except KeyError as err:
- util.raise_(
- exc.UnsupportedCompilationError(self, operator_),
- replace_context=err,
- )
+ raise exc.UnsupportedCompilationError(self, operator_) from err
else:
return self._generate_generic_binary(
binary,
if column.primary_key:
first_pk = True
except exc.CompileError as ce:
- util.raise_(
- exc.CompileError(
- "(in table '%s', column '%s'): %s"
- % (table.description, column.name, ce.args[0])
- ),
- from_=ce,
- )
+ raise exc.CompileError(
+ "(in table '%s', column '%s'): %s"
+ % (table.description, column.name, ce.args[0])
+ ) from ce
const = self.create_table_constraints(
table,
)
collection = [(t, ()) for t in unsorted_tables]
else:
- util.raise_(
- exc.CircularDependencyError(
- err2.args[0],
- err2.cycles,
- err2.edges,
- msg="Can't sort tables for DROP; an "
- "unresolvable foreign key "
- "dependency exists between tables: %s. Please ensure "
- "that the ForeignKey and ForeignKeyConstraint objects "
- "involved in the cycle have "
- "names so that they can be dropped using "
- "DROP CONSTRAINT."
- % (
- ", ".join(
- sorted([t.fullname for t in err2.cycles])
- )
- ),
- ),
- from_=err2,
- )
+ raise exc.CircularDependencyError(
+ err2.args[0],
+ err2.cycles,
+ err2.edges,
+ msg="Can't sort tables for DROP; an "
+ "unresolvable foreign key "
+ "dependency exists between tables: %s. Please ensure "
+ "that the ForeignKey and ForeignKeyConstraint objects "
+ "involved in the cycle have "
+ "names so that they can be dropped using "
+ "DROP CONSTRAINT."
+ % (", ".join(sorted([t.fullname for t in err2.cycles]))),
+ ) from err2
seq_coll = [
s
try:
comparator_factory = self.type.comparator_factory
except AttributeError as err:
- util.raise_(
- TypeError(
- "Object %r associated with '.type' attribute "
- "is not a TypeEngine class or object" % self.type
- ),
- replace_context=err,
- )
+ raise TypeError(
+ "Object %r associated with '.type' attribute "
+ "is not a TypeEngine class or object" % self.type
+ ) from err
else:
return comparator_factory(self)
try:
return getattr(self.comparator, key)
except AttributeError as err:
- util.raise_(
- AttributeError(
- "Neither %r object nor %r object has an attribute %r"
- % (
- type(self).__name__,
- type(self.comparator).__name__,
- key,
- )
- ),
- replace_context=err,
- )
+ raise AttributeError(
+ "Neither %r object nor %r object has an attribute %r"
+ % (
+ type(self).__name__,
+ type(self.comparator).__name__,
+ key,
+ )
+ ) from err
def operate(self, op, *other, **kwargs):
return op(self.comparator, *other, **kwargs)
# so that a text() construct can support unique parameters
existing = new_params[bind._orig_key]
except KeyError as err:
- util.raise_(
- exc.ArgumentError(
- "This text() construct doesn't define a "
- "bound parameter named %r" % bind._orig_key
- ),
- replace_context=err,
- )
+ raise exc.ArgumentError(
+ "This text() construct doesn't define a "
+ "bound parameter named %r" % bind._orig_key
+ ) from err
else:
new_params[existing._orig_key] = bind
try:
existing = new_params[key]
except KeyError as err:
- util.raise_(
- exc.ArgumentError(
- "This text() construct doesn't define a "
- "bound parameter named %r" % key
- ),
- replace_context=err,
- )
+ raise exc.ArgumentError(
+ "This text() construct doesn't define a "
+ "bound parameter named %r" % key
+ ) from err
else:
new_params[key] = existing._with_value(value, required=False)
try:
lower = int(range_[0])
except ValueError as err:
- util.raise_(
- exc.ArgumentError(
- "Integer or None expected for range value"
- ),
- replace_context=err,
- )
+ raise exc.ArgumentError(
+ "Integer or None expected for range value"
+ ) from err
else:
if lower == 0:
lower = RANGE_CURRENT
try:
upper = int(range_[1])
except ValueError as err:
- util.raise_(
- exc.ArgumentError(
- "Integer or None expected for range value"
- ),
- replace_context=err,
- )
+ raise exc.ArgumentError(
+ "Integer or None expected for range value"
+ ) from err
else:
if upper == 0:
upper = RANGE_CURRENT
def _raise_for_uncacheable_closure_variable(
self, variable_name, fn, from_=None
):
- util.raise_(
- exc.InvalidRequestError(
- "Closure variable named '%s' inside of lambda callable %s "
- "does not refer to a cacheable SQL element, and also does not "
- "appear to be serving as a SQL literal bound value based on "
- "the default "
- "SQL expression returned by the function. This variable "
- "needs to remain outside the scope of a SQL-generating lambda "
- "so that a proper cache key may be generated from the "
- "lambda's state. Evaluate this variable outside of the "
- "lambda, set track_on=[<elements>] to explicitly select "
- "closure elements to track, or set "
- "track_closure_variables=False to exclude "
- "closure variables from being part of the cache key."
- % (variable_name, fn.__code__),
- ),
- from_=from_,
- )
+ raise exc.InvalidRequestError(
+ "Closure variable named '%s' inside of lambda callable %s "
+ "does not refer to a cacheable SQL element, and also does not "
+ "appear to be serving as a SQL literal bound value based on "
+ "the default "
+ "SQL expression returned by the function. This variable "
+ "needs to remain outside the scope of a SQL-generating lambda "
+ "so that a proper cache key may be generated from the "
+ "lambda's state. Evaluate this variable outside of the "
+ "lambda, set track_on=[<elements>] to explicitly select "
+ "closure elements to track, or set "
+ "track_closure_variables=False to exclude "
+ "closure variables from being part of the cache key."
+ % (variable_name, fn.__code__),
+ ) from from_
def _cache_key_getter_tracked_literal(self, fn, pytracker):
"""Return a getter that will extend a cache key with new entries
try:
spwd = item._set_parent_with_dispatch
except AttributeError as err:
- util.raise_(
- exc.ArgumentError(
- "'SchemaItem' object, such as a 'Column' or a "
- "'Constraint' expected, got %r" % item
- ),
- replace_context=err,
- )
+ raise exc.ArgumentError(
+ "'SchemaItem' object, such as a 'Column' or a "
+ "'Constraint' expected, got %r" % item
+ ) from err
else:
spwd(self, **kw)
*fk
)
except TypeError as err:
- util.raise_(
- TypeError(
- "Could not create a copy of this %r object. "
- "Ensure the class includes a _constructor() "
- "attribute or method which accepts the "
- "standard Column constructor arguments, or "
- "references the Column class itself." % self.__class__
- ),
- from_=err,
- )
+ raise TypeError(
+ "Could not create a copy of this %r object. "
+ "Ensure the class includes a _constructor() "
+ "attribute or method which accepts the "
+ "standard Column constructor arguments, or "
+ "references the Column class itself." % self.__class__
+ ) from err
c.table = selectable
c._propagate_attrs = selectable._propagate_attrs
try:
ColumnCollectionConstraint._set_parent(self, table)
except KeyError as ke:
- util.raise_(
- exc.ArgumentError(
- "Can't create ForeignKeyConstraint "
- "on table '%s': no column "
- "named '%s' is present." % (table.description, ke.args[0])
- ),
- from_=ke,
- )
+ raise exc.ArgumentError(
+ "Can't create ForeignKeyConstraint "
+ "on table '%s': no column "
+ "named '%s' is present." % (table.description, ke.args[0])
+ ) from ke
for col, fk in zip(self.columns, self.elements):
if not hasattr(fk, "parent") or fk.parent is not col:
try:
value = clause._limit_offset_value
except AttributeError as err:
- util.raise_(
- exc.CompileError(
- "This SELECT structure does not use a simple "
- "integer value for %s" % attrname
- ),
- replace_context=err,
- )
+ raise exc.CompileError(
+ "This SELECT structure does not use a simple "
+ "integer value for %s" % attrname
+ ) from err
else:
return util.asint(value)
try:
cols_present = bool(columns)
except TypeError as err:
- util.raise_(
- exc.ArgumentError(
- "select() construct created in legacy mode, i.e. with "
- "keyword arguments, must provide the columns argument as "
- "a Python list or other iterable.",
- code="c9ae",
- ),
- from_=err,
- )
+ raise exc.ArgumentError(
+ "select() construct created in legacy mode, i.e. with "
+ "keyword arguments, must provide the columns argument as "
+ "a Python list or other iterable.",
+ code="c9ae",
+ ) from err
if cols_present:
self._raw_columns = [
if not self.validate_strings and isinstance(elem, str):
return elem
else:
- util.raise_(
- LookupError(
- "'%s' is not among the defined enum values. "
- "Enum name: %s. Possible values: %s"
- % (
- elem,
- self.name,
- langhelpers.repr_tuple_names(self.enums),
- )
- ),
- replace_context=err,
- )
+ raise LookupError(
+ "'%s' is not among the defined enum values. "
+ "Enum name: %s. Possible values: %s"
+ % (
+ elem,
+ self.name,
+ langhelpers.repr_tuple_names(self.enums),
+ )
+ ) from err
class Comparator(String.Comparator):
def _adapt_expression(self, op, other_comparator):
try:
return self._object_lookup[elem]
except KeyError as err:
- util.raise_(
- LookupError(
- "'%s' is not among the defined enum values. "
- "Enum name: %s. Possible values: %s"
- % (
- elem,
- self.name,
- langhelpers.repr_tuple_names(self.enums),
- )
- ),
- replace_context=err,
- )
+ raise LookupError(
+ "'%s' is not among the defined enum values. "
+ "Enum name: %s. Possible values: %s"
+ % (
+ elem,
+ self.name,
+ langhelpers.repr_tuple_names(self.enums),
+ )
+ ) from err
def __repr__(self):
return util.generic_repr(
)
break
else:
- util.raise_(ex, with_traceback=sys.exc_info()[2])
+ raise ex.with_traceback(sys.exc_info()[2])
def _expect_success(self, config, name="block"):
if not self.fails:
from .compat import py38
from .compat import py39
from .compat import pypy
-from .compat import raise_
-from .compat import raise_from_cause
-from .compat import reraise
from .compat import threading
from .compat import win32
from .concurrency import asyncio
return (a > b) - (a < b)
-def raise_(exception, with_traceback=None, replace_context=None, from_=False):
- r"""implement "raise" with cause support.
-
- :param exception: exception to raise
- :param with_traceback: will call exception.with_traceback()
- :param replace_context: an as-yet-unsupported feature. This is
- an exception object which we are "replacing", e.g., it's our
- "cause" but we don't want it printed. Basically just what
- ``__suppress_context__`` does but we don't want to suppress
- the enclosing context, if any. So for now we make it the
- cause.
- :param from\_: the cause. this actually sets the cause and doesn't
- hope to hide it someday.
-
- """
- if with_traceback is not None:
- exception = exception.with_traceback(with_traceback)
-
- if from_ is not False:
- exception.__cause__ = from_
- elif replace_context is not None:
- # no good solution here, we would like to have the exception
- # have only the context of replace_context.__context__ so that the
- # intermediary exception does not change, but we can't figure
- # that out.
- exception.__cause__ = replace_context
-
- try:
- raise exception
- finally:
- # credit to
- # https://cosmicpercolator.com/2016/01/13/exception-leaks-in-python-2-and-3/
- # as the __traceback__ object creates a cycle
- del exception, replace_context, from_, with_traceback
-
-
def _formatannotation(annotation, base_module=None):
"""vendored from python 3.7"""
return [f for f in dataclasses.fields(cls) if f not in super_fields]
else:
return []
-
-
-def raise_from_cause(exception, exc_info=None):
- r"""legacy. use raise\_()"""
-
- if exc_info is None:
- exc_info = sys.exc_info()
- exc_type, exc_value, exc_tb = exc_info
- cause = exc_value if exc_value is not exception else None
- reraise(type(exception), exception, tb=exc_tb, cause=cause)
-
-
-def reraise(tp, value, tb=None, cause=None):
- r"""legacy. use raise\_()"""
-
- raise_(value, with_traceback=tb, from_=cause)
exc_type, exc_value, exc_tb = self._exc_info
self._exc_info = None # remove potential circular references
if not self.warn_only:
- compat.raise_(
- exc_value,
- with_traceback=exc_tb,
- )
+ raise exc_value.with_traceback(exc_tb)
else:
self._exc_info = None # remove potential circular references
- compat.raise_(value, with_traceback=traceback)
+ raise value.with_traceback(traceback)
def walk_subclasses(cls):
from collections import deque
from time import time as _time
-from . import compat
from .compat import threading
from .concurrency import asyncio
from .concurrency import await_fallback
try:
return self._queue.put_nowait(item)
except asyncio.QueueFull as err:
- compat.raise_(
- Full(),
- replace_context=err,
- )
+ raise Full() from err
def put(self, item, block=True, timeout=None):
if not block:
else:
return self.await_(self._queue.put(item))
except (asyncio.QueueFull, asyncio.TimeoutError) as err:
- compat.raise_(
- Full(),
- replace_context=err,
- )
+ raise Full() from err
def get_nowait(self):
try:
return self._queue.get_nowait()
except asyncio.QueueEmpty as err:
- compat.raise_(
- Empty(),
- replace_context=err,
- )
+ raise Empty() from err
def get(self, block=True, timeout=None):
if not block:
else:
return self.await_(self._queue.get())
except (asyncio.QueueEmpty, asyncio.TimeoutError) as err:
- compat.raise_(
- Empty(),
- replace_context=err,
- )
+ raise Empty() from err
class FallbackAsyncAdaptedQueue(AsyncAdaptedQueue):
go()
- def test_raise_from(self):
- @assert_cycles()
- def go():
- try:
- try:
- raise KeyError("foo")
- except KeyError as ke:
-
- util.raise_(Exception("oops"), from_=ke)
- except Exception as err: # noqa
- pass
-
- go()
-
def test_query_alias(self):
User, Address = self.classes("User", "Address")
configure_mappers()
eq_(set(util.class_hierarchy(B)), set((A, B, C, object)))
-class ReraiseTest(fixtures.TestBase):
- def test_raise_from_cause_same_cause(self):
- class MyException(Exception):
- pass
-
- def go():
- try:
- raise MyException("exc one")
- except Exception as err:
- util.raise_from_cause(err)
-
- try:
- go()
- assert False
- except MyException as err:
- is_(err.__cause__, None)
-
- def test_raise_from_cause_legacy(self):
- class MyException(Exception):
- pass
-
- class MyOtherException(Exception):
- pass
-
- me = MyException("exc on")
-
- def go():
- try:
- raise me
- except Exception:
- util.raise_from_cause(MyOtherException("exc two"))
-
- try:
- go()
- assert False
- except MyOtherException as moe:
- is_(moe.__cause__, me)
-
- def test_raise_from(self):
- class MyException(Exception):
- pass
-
- class MyOtherException(Exception):
- pass
-
- me = MyException("exc on")
-
- def go():
- try:
- raise me
- except Exception as err:
- util.raise_(MyOtherException("exc two"), from_=err)
-
- try:
- go()
- assert False
- except MyOtherException as moe:
- is_(moe.__cause__, me)
-
-
class TestClassProperty(fixtures.TestBase):
def test_simple(self):
class A:
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
