- id: zimports
- repo: https://github.com/pycqa/flake8
- rev: 4.0.1
+ rev: 5.0.0
hooks:
- id: flake8
additional_dependencies:
# in case it requires a version pin
- pydocstyle
- pygments
-
-
-
-
@property
def inserted(self):
- """Provide the "inserted" namespace for an ON DUPLICATE KEY UPDATE statement
+ """Provide the "inserted" namespace for an ON DUPLICATE KEY UPDATE
+ statement
MySQL's ON DUPLICATE KEY UPDATE clause allows reference to the row
that would be inserted, via a special function called ``VALUES()``.
@property
def inserted_primary_key_rows(self):
- """Return the value of :attr:`_engine.CursorResult.inserted_primary_key`
+ """Return the value of
+ :attr:`_engine.CursorResult.inserted_primary_key`
as a row contained within a list; some dialects may support a
multiple row form as well.
@property
def returns_rows(self):
- """True if this :class:`_engine.CursorResult` returns zero or more rows.
+ """True if this :class:`_engine.CursorResult` returns zero or more
+ rows.
I.e. if it is legal to call the methods
:meth:`_engine.CursorResult.fetchone`,
scope: ObjectScope = ObjectScope.DEFAULT,
**kw: Any,
) -> Dict[TableKey, List[ReflectedColumn]]:
- r"""Return information about columns in all objects in the given schema.
+ r"""Return information about columns in all objects in the given
+ schema.
The objects can be filtered by passing the names to use to
``filter_names``.
...
def scalar(self) -> Any:
- """Fetch the first column of the first row, and close the result set.
+ """Fetch the first column of the first row, and close the result
+ set.
Returns None if there are no rows to fetch.
class ChunkedIteratorResult(IteratorResult[_TP]):
- """An :class:`.IteratorResult` that works from an iterator-producing callable.
+ """An :class:`.IteratorResult` that works from an iterator-producing
+ callable.
The given ``chunks`` argument is a function that is given a number of rows
to return in each chunk, or ``None`` for all rows. The function should
class RowMapping(BaseRow, typing.Mapping[str, Any]):
- """A ``Mapping`` that maps column names and objects to :class:`.Row` values.
+ """A ``Mapping`` that maps column names and objects to :class:`.Row`
+ values.
The :class:`.RowMapping` is available from a :class:`.Row` via the
:attr:`.Row._mapping` attribute, as well as from the iterable interface
return await greenlet_spawn(FrozenResult, self)
def merge(self, *others: AsyncResult[_TP]) -> MergedResult[_TP]:
- """Merge this :class:`_asyncio.AsyncResult` with other compatible result
- objects.
+ """Merge this :class:`_asyncio.AsyncResult` with other compatible
+ result objects.
The object returned is an instance of :class:`_engine.MergedResult`,
which will be composed of iterators from the given result
class AsyncMappingResult(AsyncCommon[RowMapping]):
- """A wrapper for a :class:`_asyncio.AsyncResult` that returns dictionary values
- rather than :class:`_engine.Row` values.
+ """A wrapper for a :class:`_asyncio.AsyncResult` that returns dictionary
+ values rather than :class:`_engine.Row` values.
The :class:`_asyncio.AsyncMappingResult` object is acquired by calling the
:meth:`_asyncio.AsyncResult.mappings` method.
...
async def scalar(self) -> Any:
- """Fetch the first column of the first row, and close the result set.
+ """Fetch the first column of the first row, and close the result
+ set.
Returns None if there are no rows to fetch.
}
def expand_typevar_from_subtype(self, sub_type: TypeInfo) -> None:
- """Expands type vars in the context of a subtype when an attribute is inherited
- from a generic super type."""
+ """Expands type vars in the context of a subtype when an attribute is
+ inherited from a generic super type.
+ """
if not isinstance(self.type, TypeVarType):
return
@_lifecycle_event
def transient_to_pending(self, session, instance):
- """Intercept the "transient to pending" transition for a specific object.
+ """Intercept the "transient to pending" transition for a specific
+ object.
This event is a specialization of the
:meth:`.SessionEvents.after_attach` event which is only invoked
@_lifecycle_event
def pending_to_transient(self, session, instance):
- """Intercept the "pending to transient" transition for a specific object.
+ """Intercept the "pending to transient" transition for a specific
+ object.
This less common transition occurs when an pending object that has
not been flushed is evicted from the session; this can occur
@_lifecycle_event
def persistent_to_transient(self, session, instance):
- """Intercept the "persistent to transient" transition for a specific object.
+ """Intercept the "persistent to transient" transition for a specific
+ object.
This less common transition occurs when an pending object that has
has been flushed is evicted from the session; this can occur
@_lifecycle_event
def pending_to_persistent(self, session, instance):
- """Intercept the "pending to persistent"" transition for a specific object.
+ """Intercept the "pending to persistent"" transition for a specific
+ object.
This event is invoked within the flush process, and is
similar to scanning the :attr:`.Session.new` collection within
@_lifecycle_event
def detached_to_persistent(self, session, instance):
- """Intercept the "detached to persistent" transition for a specific object.
+ """Intercept the "detached to persistent" transition for a specific
+ object.
This event is a specialization of the
:meth:`.SessionEvents.after_attach` event which is only invoked
@_lifecycle_event
def loaded_as_persistent(self, session, instance):
- """Intercept the "loaded as persistent" transition for a specific object.
+ """Intercept the "loaded as persistent" transition for a specific
+ object.
This event is invoked within the ORM loading process, and is invoked
very similarly to the :meth:`.InstanceEvents.load` event. However,
@_lifecycle_event
def persistent_to_deleted(self, session, instance):
- """Intercept the "persistent to deleted" transition for a specific object.
+ """Intercept the "persistent to deleted" transition for a specific
+ object.
This event is invoked when a persistent object's identity
is deleted from the database within a flush, however the object
@_lifecycle_event
def deleted_to_persistent(self, session, instance):
- """Intercept the "deleted to persistent" transition for a specific object.
+ """Intercept the "deleted to persistent" transition for a specific
+ object.
This transition occurs only when an object that's been deleted
successfully in a flush is restored due to a call to
@_lifecycle_event
def deleted_to_detached(self, session, instance):
- """Intercept the "deleted to detached" transition for a specific object.
+ """Intercept the "deleted to detached" transition for a specific
+ object.
This event is invoked when a deleted object is evicted
from the session. The typical case when this occurs is when
@_lifecycle_event
def persistent_to_detached(self, session, instance):
- """Intercept the "persistent to detached" transition for a specific object.
+ """Intercept the "persistent to detached" transition for a specific
+ object.
This event is invoked when a persistent object is evicted
from the session. There are many conditions that cause this
@property
def entity_description(self) -> Dict[str, Any]:
- """Return a :term:`plugin-enabled` description of the table and/or entity
- which this DML construct is operating against.
+ """Return a :term:`plugin-enabled` description of the table and/or
+ entity which this DML construct is operating against.
This attribute is generally useful when using the ORM, as an
extended structure which includes information about mapped
return FunctionFilter(self, *criterion)
def as_comparison(self, left_index, right_index):
- """Interpret this expression as a boolean comparison between two values.
+ """Interpret this expression as a boolean comparison between two
+ values.
This method is used for an ORM use case described at
:ref:`relationship_custom_operator_sql_function`.
return tva
def lateral(self, name: Optional[str] = None) -> LateralFromClause:
- """Return a new :class:`_sql.TableValuedAlias` with the lateral flag set,
- so that it renders as LATERAL.
+ """Return a new :class:`_sql.TableValuedAlias` with the lateral flag
+ set, so that it renders as LATERAL.
.. seealso::
*,
full: bool = False,
) -> SelfSelect:
- r"""Create a SQL LEFT OUTER JOIN against this :class:`_expression.Select`
- object's criterion
- and apply generatively, returning the newly resulting
- :class:`_expression.Select`.
+ r"""Create a SQL LEFT OUTER JOIN against this
+ :class:`_expression.Select` object's criterion and apply generatively,
+ returning the newly resulting :class:`_expression.Select`.
Usage is the same as that of :meth:`_selectable.Select.join_from`.
self: SelfExists,
*fromclauses: Union[Literal[None, False], _FromClauseArgument],
) -> SelfExists:
- """Apply correlation to the subquery noted by this :class:`_sql.Exists`.
+ """Apply correlation to the subquery noted by this
+ :class:`_sql.Exists`.
.. seealso::
self: SelfExists,
*fromclauses: Union[Literal[None, False], _FromClauseArgument],
) -> SelfExists:
- """Apply correlation to the subquery noted by this :class:`_sql.Exists`.
+ """Apply correlation to the subquery noted by this
+ :class:`_sql.Exists`.
.. seealso::
] = util.EMPTY_DICT
def evaluates_none(self: SelfTypeEngine) -> SelfTypeEngine:
- """Return a copy of this type which has the :attr:`.should_evaluate_none`
- flag set to True.
+ """Return a copy of this type which has the
+ :attr:`.should_evaluate_none` flag set to True.
E.g.::
impltype: Type[Union[TypeEngine[Any], TypeEngineMixin]],
**kw: Any,
) -> TypeEngine[Any]:
- """Given an impl class, adapt this type to the impl assuming "emulated".
+ """Given an impl class, adapt this type to the impl assuming
+ "emulated".
The impl should also be an "emulated" version of this type,
most likely the same class as this type itself.
**kw: Any,
) -> TypeEngine[Any]:
- """Given an impl, adapt this type's class to the impl assuming "native".
+ """Given an impl, adapt this type's class to the impl assuming
+ "native".
The impl will be an :class:`.Emulated` class but not a
:class:`.NativeForEmulated`.
@property
def standalone_binds(self):
- """target database/driver supports bound parameters as column expressions
- without being in the context of a typed column.
-
+ """target database/driver supports bound parameters as column
+ expressions without being in the context of a typed column.
"""
return exclusions.open()
class DistinctPKTest(fixtures.MappedTest):
- """test the construction of mapper.primary_key when an inheriting relationship
- joins on a column other than primary key column."""
+ """test the construction of mapper.primary_key when an inheriting
+ relationship joins on a column other than primary key column."""
run_inserts = "once"
run_deletes = None
class JoinAcrossJoinedInhMultiPath(
fixtures.DeclarativeMappedTest, testing.AssertsCompiledSQL
):
- """test long join paths with a joined-inh in the middle, where we go multiple
- times across the same joined-inh to the same target but with other classes
- in the middle. E.g. test [ticket:2908]
+ """test long join paths with a joined-inh in the middle, where we go
+ multiple times across the same joined-inh to the same target but with
+ other classes in the middle. E.g. test [ticket:2908]
"""
run_setup_mappers = "once"
),
def test_eager_terminate(self):
- """Eager query generation does not include the same mapper's table twice.
+ """Eager query generation does not include the same mapper's table
+ twice.
Or, that bi-directional eager loads don't include each other in eager
query generation.
assert p2 in p1.parent_places
def test_joinedload_on_double(self):
- """test that a mapper can have two eager relationships to the same table, via
- two different association tables. aliases are required."""
+ """test that a mapper can have two eager relationships to the same
+ table, via two different association tables. aliases are required.
+ """
(
place_input,
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
