refactor + reformat

Author: slampy97

tests/coordination/test_coordination_client.py

@@ -191,7 +191,6 @@ def test_coordination_lock_full_lifecycle_sync(self, driver_sync):
         client = CoordinationClient(driver_sync)
         node_path = "/local/test_lock_full_lifecycle"
 
-        # --- cleanup ---
         try:
             client.delete_node(node_path)
         except ydb.SchemeError:
@@ -210,7 +209,6 @@ def test_coordination_lock_full_lifecycle_sync(self, driver_sync):
 
         lock = client.lock("test_lock", node_path)
 
-        # --- create/update/describe ---
         create_resp: CreateSemaphoreResult = lock.create(init_limit=1, init_data=b"init-data")
         assert create_resp.status == StatusCode.SUCCESS
 
@@ -222,61 +220,49 @@ def test_coordination_lock_full_lifecycle_sync(self, driver_sync):
         assert update_resp.status == StatusCode.SUCCESS
         assert lock.describe().data == b"updated-data"
 
-        # --- threading coordination ---
         lock2_ready = threading.Event()
         lock2_acquired = threading.Event()
         thread_exc = {"err": None}
 
         def second_lock_task():
             try:
-                lock2_ready.set()  # сигнал, что поток готов
+                lock2_ready.set()
                 with client.lock("test_lock", node_path):
-                    lock2_acquired.set()  # сигнал, что захватил lock
+                    lock2_acquired.set()
                     logger.info("Second thread acquired lock")
             except Exception as e:
                 logger.exception("second_lock_task failed")
                 thread_exc["err"] = e
 
         t2 = threading.Thread(target=second_lock_task)
 
-        # --- main thread acquires first lock ---
         with client.lock("test_lock", node_path) as lock1:
             resp = lock1.describe()
             assert resp.status == StatusCode.SUCCESS
             assert resp.count == 1
 
-            # запускаем второй поток
             t2.start()
             started = lock2_ready.wait(timeout=2.0)
             assert started, "Second thread did not signal readiness to acquire lock"
 
-        # --- main thread released lock, второй поток должен захватить ---
-        acquired = lock2_acquired.wait(timeout=10.0)  # увеличенный таймаут
+        acquired = lock2_acquired.wait(timeout=10.0)
         t2.join(timeout=5.0)
 
         if not acquired:
             if thread_exc["err"]:
                 raise AssertionError(f"Second thread raised exception: {thread_exc['err']!r}") from thread_exc["err"]
             else:
-                raise AssertionError(
-                    "Second thread did not acquire the lock in time. Check logs for details."
-                )
+                raise AssertionError("Second thread did not acquire the lock in time. Check logs for details.")
 
         assert not t2.is_alive(), "Second thread did not finish after acquiring lock"
 
-        # --- проверяем, что lock можно снова взять в главном потоке ---
         with client.lock("test_lock", node_path) as lock3:
             resp3: DescribeLockResult = lock3.describe()
             assert resp3.status == StatusCode.SUCCESS
             assert resp3.count == 1
 
-        # --- cleanup ---
         delete_resp = lock.delete()
         assert delete_resp.status == StatusCode.SUCCESS
-        # небольшая пауза для удаления на сервере
         time.sleep(0.1)
         describe_after_delete: DescribeLockResult = lock.describe()
         assert describe_after_delete.status == StatusCode.NOT_FOUND
-
-
-

ydb/_grpc/grpcwrapper/ydb_coordination.py

@@ -10,6 +10,7 @@
 
 # ---------- CRUD для узлов ----------
 
+
 @dataclass
 class CreateNodeRequest(IToProto):
     path: str
@@ -55,8 +56,10 @@ def to_proto(self) -> "ydb_coordination_pb2.DropNodeRequest":
             path=self.path,
         )
 
+
 # ---------- Сессии и семафоры ----------
 
+
 @dataclass
 class SessionStart(IToProto):
     path: str
@@ -82,9 +85,7 @@ def to_proto(self) -> "ydb_coordination_pb2.SessionRequest":
 @dataclass
 class SessionStop(IToProto):
     def to_proto(self) -> "ydb_coordination_pb2.SessionRequest":
-        return ydb_coordination_pb2.SessionRequest(
-            session_stop=ydb_coordination_pb2.SessionRequest.SessionStop()
-        )
+        return ydb_coordination_pb2.SessionRequest(session_stop=ydb_coordination_pb2.SessionRequest.SessionStop())
 
 
 @dataclass
@@ -141,9 +142,7 @@ class ReleaseSemaphore(IToProto):
 
     def to_proto(self) -> "ydb_coordination_pb2.SessionRequest":
         return ydb_coordination_pb2.SessionRequest(
-            release_semaphore=ydb_coordination_pb2.SessionRequest.ReleaseSemaphore(
-                req_id=self.req_id, name=self.name
-            )
+            release_semaphore=ydb_coordination_pb2.SessionRequest.ReleaseSemaphore(req_id=self.req_id, name=self.name)
         )
 
 
@@ -168,6 +167,7 @@ def to_proto(self) -> "ydb_coordination_pb2.SessionRequest":
             )
         )
 
+
 @dataclass
 class UpdateSemaphore(IToProto):
     name: str

ydb/coordination/lock_sync.py

@@ -27,7 +27,6 @@ def __init__(
         self._count = count
         self._timeout_millis = timeout_millis
 
-
         async def _make_lock():
             return CoordinationLock(
                 client=self._client,
@@ -37,9 +36,7 @@ async def _make_lock():
                 timeout_millis=self._timeout_millis,
             )
 
-        self._async_lock: CoordinationLock = self._caller.safe_call_with_result(
-            _make_lock(), self._timeout_sec
-        )
+        self._async_lock: CoordinationLock = self._caller.safe_call_with_result(_make_lock(), self._timeout_sec)
 
     def _check_closed(self):
         if self._closed:
@@ -69,14 +66,12 @@ def release(self, timeout: Optional[float] = None):
     def create(self, init_limit: int, init_data: bytes, timeout: Optional[float] = None):
         self._check_closed()
         t = timeout or self._timeout_sec
-        return self._caller.safe_call_with_result(
-            self._async_lock.create(init_limit, init_data), t
-        )
+        return self._caller.safe_call_with_result(self._async_lock.create(init_limit, init_data), t)
 
     def delete(self, timeout: Optional[float] = None):
         self._check_closed()
         t = timeout or self._timeout_sec
-        return self._caller.safe_call_with_result( self._async_lock.delete(), t)
+        return self._caller.safe_call_with_result(self._async_lock.delete(), t)
 
     def describe(self, timeout: Optional[float] = None):
         self._check_closed()