Update to flake8 5.

Change-Id: I5a241a70efba68bcea9819ddce6aebc25703e68d

13 files changed, 64 insertions, 42 deletions

diff --git a/lib/sqlalchemy/dialects/mysql/dml.py b/lib/sqlalchemy/dialects/mysql/dml.py
index b93116c38..4ee40b909 100644
--- a/lib/sqlalchemy/dialects/mysql/dml.py
+++ b/lib/sqlalchemy/dialects/mysql/dml.py
@@ -60,7 +60,8 @@ class Insert(StandardInsert):
 
     @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()``.
diff --git a/lib/sqlalchemy/engine/cursor.py b/lib/sqlalchemy/engine/cursor.py
index 3ff815f70..0204fbbbb 100644
--- a/lib/sqlalchemy/engine/cursor.py
+++ b/lib/sqlalchemy/engine/cursor.py
@@ -1413,7 +1413,8 @@ class CursorResult(Result[_T]):
 
     @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.
 
@@ -1754,7 +1755,8 @@ class CursorResult(Result[_T]):
 
     @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`,
diff --git a/lib/sqlalchemy/engine/reflection.py b/lib/sqlalchemy/engine/reflection.py
index c3c5ff5a8..f744d53ad 100644
--- a/lib/sqlalchemy/engine/reflection.py
+++ b/lib/sqlalchemy/engine/reflection.py
@@ -881,7 +881,8 @@ class Inspector(inspection.Inspectable["Inspector"]):
         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``.
diff --git a/lib/sqlalchemy/engine/result.py b/lib/sqlalchemy/engine/result.py
index a4e373ec3..df5a8199c 100644
--- a/lib/sqlalchemy/engine/result.py
+++ b/lib/sqlalchemy/engine/result.py
@@ -1893,7 +1893,8 @@ class TupleResult(FilterResult[_R], util.TypingOnly):
             ...
 
         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.
 
@@ -2219,7 +2220,8 @@ SelfChunkedIteratorResult = TypeVar(
 
 
 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
diff --git a/lib/sqlalchemy/engine/row.py b/lib/sqlalchemy/engine/row.py
index 06976dd4b..045b32ac5 100644
--- a/lib/sqlalchemy/engine/row.py
+++ b/lib/sqlalchemy/engine/row.py
@@ -307,7 +307,8 @@ class ROMappingItemsView(ROMappingView, typing.ItemsView[str, Any]):
 
 
 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
diff --git a/lib/sqlalchemy/ext/asyncio/result.py b/lib/sqlalchemy/ext/asyncio/result.py
index 43f5fae81..8f1c07fd8 100644
--- a/lib/sqlalchemy/ext/asyncio/result.py
+++ b/lib/sqlalchemy/ext/asyncio/result.py
@@ -442,8 +442,8 @@ class AsyncResult(AsyncCommon[Row[_TP]]):
         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
@@ -648,8 +648,8 @@ SelfAsyncMappingResult = TypeVar(
 
 
 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.
@@ -974,7 +974,8 @@ class AsyncTupleResult(AsyncCommon[_R], util.TypingOnly):
             ...
 
         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.
 
diff --git a/lib/sqlalchemy/ext/mypy/util.py b/lib/sqlalchemy/ext/mypy/util.py
index 49fe5140f..44a1768a8 100644
--- a/lib/sqlalchemy/ext/mypy/util.py
+++ b/lib/sqlalchemy/ext/mypy/util.py
@@ -76,8 +76,9 @@ class SQLAlchemyAttribute:
         }
 
     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
 
diff --git a/lib/sqlalchemy/orm/events.py b/lib/sqlalchemy/orm/events.py
index 7cc0aa9c9..680e49981 100644
--- a/lib/sqlalchemy/orm/events.py
+++ b/lib/sqlalchemy/orm/events.py
@@ -1927,7 +1927,8 @@ class SessionEvents(event.Events[Session]):
 
     @_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
@@ -1948,7 +1949,8 @@ class SessionEvents(event.Events[Session]):
 
     @_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
@@ -1969,7 +1971,8 @@ class SessionEvents(event.Events[Session]):
 
     @_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
@@ -1989,7 +1992,8 @@ class SessionEvents(event.Events[Session]):
 
     @_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
@@ -2011,7 +2015,8 @@ class SessionEvents(event.Events[Session]):
 
     @_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
@@ -2047,7 +2052,8 @@ class SessionEvents(event.Events[Session]):
 
     @_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,
@@ -2082,7 +2088,8 @@ class SessionEvents(event.Events[Session]):
 
     @_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
@@ -2114,7 +2121,8 @@ class SessionEvents(event.Events[Session]):
 
     @_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
@@ -2131,7 +2139,8 @@ class SessionEvents(event.Events[Session]):
 
     @_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
@@ -2154,7 +2163,8 @@ class SessionEvents(event.Events[Session]):
 
     @_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
diff --git a/lib/sqlalchemy/sql/dml.py b/lib/sqlalchemy/sql/dml.py
index e99f35418..76a16eb1c 100644
--- a/lib/sqlalchemy/sql/dml.py
+++ b/lib/sqlalchemy/sql/dml.py
@@ -590,8 +590,8 @@ class UpdateBase(
 
     @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
diff --git a/lib/sqlalchemy/sql/functions.py b/lib/sqlalchemy/sql/functions.py
index befd262ec..77c93aed6 100644
--- a/lib/sqlalchemy/sql/functions.py
+++ b/lib/sqlalchemy/sql/functions.py
@@ -462,7 +462,8 @@ class FunctionElement(Executable, ColumnElement[_T], FromClause, Generative):
         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`.
diff --git a/lib/sqlalchemy/sql/selectable.py b/lib/sqlalchemy/sql/selectable.py
index ce561697b..a6047bec1 100644
--- a/lib/sqlalchemy/sql/selectable.py
+++ b/lib/sqlalchemy/sql/selectable.py
@@ -1807,8 +1807,8 @@ class TableValuedAlias(LateralFromClause, Alias):
         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::
 
@@ -5280,10 +5280,9 @@ class Select(
         *,
         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`.
 
@@ -6559,7 +6558,8 @@ class Exists(UnaryExpression[bool]):
         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::
 
@@ -6576,7 +6576,8 @@ class Exists(UnaryExpression[bool]):
         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::
 
diff --git a/lib/sqlalchemy/sql/type_api.py b/lib/sqlalchemy/sql/type_api.py
index 6c1a99daa..90320701e 100644
--- a/lib/sqlalchemy/sql/type_api.py
+++ b/lib/sqlalchemy/sql/type_api.py
@@ -290,8 +290,8 @@ class TypeEngine(Visitable, Generic[_T]):
     ] = 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.::
 
@@ -1356,7 +1356,8 @@ class Emulated(TypeEngineMixin):
         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.
@@ -1428,7 +1429,8 @@ class NativeForEmulated(TypeEngineMixin):
         **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`.
diff --git a/lib/sqlalchemy/testing/requirements.py b/lib/sqlalchemy/testing/requirements.py
index 55b10bdd5..874383394 100644
--- a/lib/sqlalchemy/testing/requirements.py
+++ b/lib/sqlalchemy/testing/requirements.py
@@ -252,9 +252,8 @@ class SuiteRequirements(Requirements):
 
     @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()