style: use new ruff rules

Author: emptybutton

pyproject.toml

@@ -24,17 +24,16 @@ Repository = "https://github.com/emptybutton/tgdb"
 
 [project.optional-dependencies]
 dev = [
-    "mypy[faster-cache]==1.15.0",
+    "mypy[faster-cache]==1.16.0",
     "types-pyyaml==6.0.12.20250516",
-    "ruff==0.9.7",
-    "pytest==8.3.4",
-    "pytest-cov==6.0.0",
-    "pytest-asyncio==0.25.3",
+    "ruff==0.11.13",
+    "pytest==8.4.0",
+    "pytest-cov==6.1.1",
+    "pytest-asyncio==1.0.0",
     "pytest-timeout==2.4.0",
-    "dirty-equals==0.8.0",
-    "httpx==0.27.2",
+    "dirty-equals==0.9.0",
+    "httpx==0.28.1",
     "httpx-ws==0.7.2",
-    "plotext==5.2.8",
 ]
 
 [build-system]
@@ -65,25 +64,41 @@ line-length = 80
 indent-width = 4
 
 [tool.ruff.lint]
-select = [
-    "ANN", "F", "W", "E", "B", "C90", "N", "UP", "YTT", "ASYNC", "PL", "RUF",
-    "Q", "RET", "SLF", "SLOT", "SIM", "TID252", "TCH", "ARG", "PTH", "ERA",
-    "TRY", "PERF", "INP", "I", "S", "FAST", "TID", "TCH", "INT"
-]
+select = ["ALL"]
 ignore = [
-    "N818", "RUF009", "UP018", "PLR6301", "PLR0913", "PLW0108", "TC006",
-    "S101", "TC003", "TC002"
+    "EXE002",
+    "CPY001",
+    "C401",
+    "C408",
+    "D100",
+    "D101",
+    "D102",
+    "D103",
+    "D104",
+    "D105",
+    "D106",
+    "D107",
+    "D200",
+    "D201",
+    "D202",
+    "D203",
+    "D205",
+    "D401",
+    "D212",
+    "DOC201",
+    "DOC501",
+    "PLR6301",
+    "TC002",
+    "TC003",
+    "TC006",
 ]
 
 [tool.ruff.lint.isort]
 lines-after-imports = 2
 
 [tool.ruff.lint.per-file-ignores]
-"src/tgdb/entities/*" = ["PLR2004"]
-"src/tgdb/application/*" = ["PLR0917"]
-"src/tgdb/infrastructure/adapters/*" = ["RUF029"]
-"tests/*" = ["PLR0124", "PLR0917", "S106", "C901", "PLR2004"]
-"__init__.py" = ["PLC0414"]
+"tests/*" = ["S101", "PT013", "PLR2004", "D400", "D415"]
+"tests/test_tgdb/test_entities/test_horizon.py" = ["D400", "D415"]
 
 [tool.pytest.ini_options]
 pythonpath = ["src"]

src/tgdb/application/horizon/commit_transaction.py

@@ -58,7 +58,7 @@ async def __call__(self, xid: XID, operators: Sequence[Operator]) -> None:
             raise notification from notification
 
     async def _effect(
-        self, operator: Operator
+        self, operator: Operator,
     ) -> NewTuple | MutatedTuple | DeletedTuple | Claim:
         """
         :raises tgdb.application.relation.ports.relations.NoRelationError:

src/tgdb/application/relation/create_relation.py

@@ -13,7 +13,7 @@ class CreateRelation:
     tuples: Tuples
 
     async def __call__(
-        self, relation_number: Number, relation_schema: Schema
+        self, relation_number: Number, relation_schema: Schema,
     ) -> None:
         """
         :raises tgdb.application.relation.ports.relations.OversizedRelationSchemaError:

src/tgdb/application/relation/ports/relation_views.py

@@ -9,5 +9,5 @@ async def view_of_all_relations(self) -> ViewOfAllRelationsT: ...
 
     @abstractmethod
     async def view_of_one_relation(
-        self, relation_number: Number
+        self, relation_number: Number,
     ) -> ViewOfOneRelationT: ...

src/tgdb/application/relation/ports/tuples.py

@@ -30,7 +30,7 @@ async def map(self, effects: Sequence[TransactionEffect], /) -> None: ...
 
     @abstractmethod
     async def map_idempotently(
-        self, effects: Sequence[TransactionEffect], /
+        self, effects: Sequence[TransactionEffect], /,
     ) -> None: ...
 
     @abstractmethod

src/tgdb/application/relation/view_tuples.py

@@ -34,7 +34,7 @@ async def __call__(
         """
 
         tuples = await self.tuples.tuples_with_attribute(
-            relation_number, attribute_number, attribute_scalar
+            relation_number, attribute_number, attribute_scalar,
         )
         versioned_tuples = map(versioned_tuple, tuples)
         relation = await self.relartions.relation(relation_number)

src/tgdb/entities/horizon/horizon.py

@@ -59,7 +59,7 @@ class Horizon:
     _max_transaction_age: LogicTime
     _serializable_transaction_map: OrderedDict[XID, SerializableTransaction]
     _read_uncommited_transaction_map: OrderedDict[
-        XID, ReadUncommitedTransaction
+        XID, ReadUncommitedTransaction,
     ]
 
     def __post_init__(self) -> None:
@@ -86,7 +86,7 @@ def start_transaction(
         """
 
         assert_(
-            all(xid not in map for map in self._transaction_maps()),
+            all(xid not in map_ for map_ in self._transaction_maps()),
             else_=DoubleStartTransactionError,
         )
 
@@ -97,8 +97,8 @@ def start_transaction(
             self._serializable_transaction_map.values(),
         )
 
-        map = self._transaction_map(started_transaction)
-        map[started_transaction.xid()] = started_transaction
+        map_ = self._transaction_map(started_transaction)
+        map_[started_transaction.xid()] = started_transaction
         self._limit_len()
         self.move_to_future(time)
 
@@ -131,7 +131,6 @@ def rollback_transaction(self, time: LogicTime, xid: XID) -> None:
         :raises tgdb.entities.horizon.horizon.NoTransactionError:
         :raises tgdb.entities.horizon.horizon.TransactionCommittingError:
         """
-
         self.move_to_future(time)
 
         transaction = self._transaction(
@@ -154,7 +153,6 @@ def commit_transaction(
         :raises tgdb.entities.horizon.horizon.TransactionCommittingError:
         :raises tgdb.entities.horizon.transaction.ConflictError:
         """
-
         self.move_to_future(time)
 
         transaction = self._transaction(
@@ -240,7 +238,7 @@ def _limit_len(self) -> None:
             ]
 
     def _is_transaction_autorollbackable(
-        self, transaction: Transaction
+        self, transaction: Transaction,
     ) -> bool:
         return (
             not isinstance(transaction, SerializableTransaction)
@@ -249,7 +247,7 @@ def _is_transaction_autorollbackable(
 
     def _oldest_transaction(self) -> Transaction | None:
         first_map_tranactions = (
-            first_map_value(map) for map in self._transaction_maps()
+            first_map_value(map_) for map_ in self._transaction_maps()
         )
         oldest_transactions = tuple(
             first_map_tranaction
@@ -288,7 +286,7 @@ def _serializable_transaction(
         return transaction
 
     def _non_serializable_read_transaction(
-        self, xid: XID
+        self, xid: XID,
     ) -> ReadUncommitedTransaction:
         """
         :raises tgdb.entities.horizon.horizon.NoTransactionError:
@@ -312,7 +310,6 @@ def _transaction(
         :raises tgdb.entities.horizon.horizon.NoTransactionError:
         :raises else_:
         """
-
         with suppress(NoTransactionError):
             return self._non_serializable_read_transaction(xid)
 
@@ -323,7 +320,7 @@ def _transaction_maps(self) -> Iterable[Mapping[XID, Transaction]]:
         yield self._read_uncommited_transaction_map
 
     def _transaction_map[TransactionT: Transaction](
-        self, transaction: TransactionT
+        self, transaction: TransactionT,
     ) -> OrderedDict[XID, TransactionT]:
         match transaction:
             case ReadUncommitedTransaction():
@@ -333,12 +330,11 @@ def _transaction_map[TransactionT: Transaction](
 
 
 def horizon(
-    time: LogicTime, max_len: int, max_transaction_age: LogicTime
+    time: LogicTime, max_len: int, max_transaction_age: LogicTime,
 ) -> Horizon:
     """
     :raises tgdb.entities.horizon.horizon.HorizonAlwaysWithoutTransactionsError:
     """
-
     return Horizon(
         _time=time,
         _max_len=max_len,

src/tgdb/entities/horizon/transaction.py

@@ -1,4 +1,5 @@
-from collections.abc import Iterable, Sequence, Set
+from collections.abc import Iterable, Sequence
+from collections.abc import Set as AbstractSet
 from dataclasses import dataclass
 from enum import Enum, auto
 from uuid import UUID
@@ -26,7 +27,7 @@
 type TransactionScalarEffect = (
     NewTuple | MutatedTuple | MigratedTuple | DeletedTuple
 )
-type TransactionEffect = Set[TransactionScalarEffect]
+type TransactionEffect = AbstractSet[TransactionScalarEffect]
 
 
 @dataclass(frozen=True)
@@ -119,10 +120,7 @@ def rollback(self) -> None:
         self._complete()
 
     def prepare_commit(self) -> PreparedCommit:
-        """
-        :raises tgdb.entities.horizon.transaction.ConflictError:
-        """
-
+        """:raises tgdb.entities.horizon.transaction.ConflictError:"""
         conflict = self._conflict()
 
         if conflict is not None:
@@ -144,36 +142,36 @@ def commit(self) -> Commit:
         return Commit(self._xid, self._effect())
 
     def track_concurrent_transaction(
-        self, transaction: "SerializableTransaction"
+        self, transaction: "SerializableTransaction",
     ) -> None:
         self._concurrent_transactions.add(transaction)
 
         if transaction.state() is SerializableTransactionState.prepared:
             self._transactions_with_possible_conflict.add(transaction)
 
     def track_started_transaction(
-        self, started_transaction: "SerializableTransaction"
+        self, started_transaction: "SerializableTransaction",
     ) -> None:
         self._concurrent_transactions.add(started_transaction)
 
     def track_prepared_transaction(
-        self, prepared_transaction: "SerializableTransaction"
+        self, prepared_transaction: "SerializableTransaction",
     ) -> None:
         self._transactions_with_possible_conflict.add(prepared_transaction)
 
     def track_rollbacked_prepared_transaction(
-        self, rollbacked_prepared_transaction: "SerializableTransaction"
+        self, rollbacked_prepared_transaction: "SerializableTransaction",
     ) -> None:
         if self._state is SerializableTransactionState.active:
             self._transactions_with_possible_conflict.remove(
-                rollbacked_prepared_transaction
+                rollbacked_prepared_transaction,
             )
             self._concurrent_transactions.remove(
-                rollbacked_prepared_transaction
+                rollbacked_prepared_transaction,
             )
 
     def track_rollbacked_active_transaction(
-        self, rollbacked_active_transaction: "SerializableTransaction"
+        self, rollbacked_active_transaction: "SerializableTransaction",
     ) -> None:
         if self._state is SerializableTransactionState.active:
             self._concurrent_transactions.remove(rollbacked_active_transaction)
@@ -197,10 +195,10 @@ def start(
 
         for concurrent_transaction in concurrent_transactions:
             concurrent_transaction.track_started_transaction(
-                started_transaction
+                started_transaction,
             )
             started_transaction.track_concurrent_transaction(
-                concurrent_transaction
+                concurrent_transaction,
             )
 
         return started_transaction
@@ -291,7 +289,7 @@ def start_transaction(
     match isolation:
         case IsolationLevel.serializable:
             return SerializableTransaction.start(
-                xid, time, serializable_transactions
+                xid, time, serializable_transactions,
             )
 
         case IsolationLevel.read_uncommited:

src/tgdb/entities/relation/relation.py

@@ -76,7 +76,7 @@ def last_version_schema_id(self) -> RelationSchemaID:
         return RelationSchemaID(self._number, self.last_version().number)
 
     def recent_versions(
-        self, current_version_number: Number
+        self, current_version_number: Number,
     ) -> Sequence[DerivativeRelationVersion]:
         if current_version_number < self._initial_version.number:
             return tuple()
@@ -91,7 +91,7 @@ def recent_versions(
             return tuple()
 
         current_version_index = int(
-            self._intermediate_versions[0].number
+            self._intermediate_versions[0].number,
         ) - int(current_version_number)
 
         return self._intermediate_versions[current_version_index + 1 :]
@@ -111,7 +111,7 @@ def migrate(
     def remove_old_versions(self, count: int) -> None:
         count_to_remove_intermediate_versions = count - 1
         count_to_remove_intermediate_versions = min(
-            count_to_remove_intermediate_versions, len(self) - 1
+            count_to_remove_intermediate_versions, len(self) - 1,
         )
         del self._intermediate_versions[:count_to_remove_intermediate_versions]
 
@@ -124,9 +124,9 @@ def remove_old_versions(self, count: int) -> None:
         del self._intermediate_versions[0]
 
     @classmethod
-    def new(cls, id: Number, schema: Schema) -> "Relation":
+    def new(cls, id_: Number, schema: Schema) -> "Relation":
         return Relation(
-            id,
+            id_,
             InitialRelationVersion(Number(0), schema),
             list(),
         )

src/tgdb/entities/relation/tuple.py

@@ -38,11 +38,11 @@ def __getitem__(self, index: int, /) -> Scalar: ...
 
     @overload
     def __getitem__(
-        self, sclice: "slice[Any, Any, Any]", /
+        self, sclice: "slice[Any, Any, Any]", /,
     ) -> Sequence[Scalar]: ...
 
     def __getitem__(
-        self, key: "int | slice[Any, Any, Any]", /
+        self, key: "int | slice[Any, Any, Any]", /,
     ) -> Scalar | Sequence[Scalar]:
         return self.scalars[key]