fix by linters

Author: rekby

ydb/_errors.py

@@ -21,27 +21,37 @@
 def check_retriable_error(err, retry_settings, attempt):
     if isinstance(err, issues.NotFound):
         if retry_settings.retry_not_found:
-            return ErrorRetryInfo(True, retry_settings.fast_backoff.calc_timeout(attempt))
+            return ErrorRetryInfo(
+                True, retry_settings.fast_backoff.calc_timeout(attempt)
+            )
         else:
             return ErrorRetryInfo(False, None)
 
     if isinstance(err, issues.InternalError):
         if retry_settings.retry_internal_error:
-            return ErrorRetryInfo(True, retry_settings.slow_backoff.calc_timeout(attempt))
+            return ErrorRetryInfo(
+                True, retry_settings.slow_backoff.calc_timeout(attempt)
+            )
         else:
             return ErrorRetryInfo(False, None)
 
     for t in _errors_retriable_fast_backoff_types:
         if isinstance(err, t):
-            return ErrorRetryInfo(True, retry_settings.fast_backoff.calc_timeout(attempt))
+            return ErrorRetryInfo(
+                True, retry_settings.fast_backoff.calc_timeout(attempt)
+            )
 
     for t in _errors_retriable_slow_backoff_types:
         if isinstance(err, t):
-            return ErrorRetryInfo(True, retry_settings.slow_backoff.calc_timeout(attempt))
+            return ErrorRetryInfo(
+                True, retry_settings.slow_backoff.calc_timeout(attempt)
+            )
 
     if retry_settings.idempotent:
         for t in _errors_retriable_slow_backoff_idempotent_types:
-            return ErrorRetryInfo(True, retry_settings.slow_backoff.calc_timeout(attempt))
+            return ErrorRetryInfo(
+                True, retry_settings.slow_backoff.calc_timeout(attempt)
+            )
 
     return ErrorRetryInfo(False, None)
 

ydb/table.py

@@ -930,7 +930,11 @@ def __init__(self, result):
         self.exc = None
 
     def __eq__(self, other):
-        return type(self) == type(other) and self.result == other.result and self.exc == other.exc
+        return (
+            type(self) == type(other)
+            and self.result == other.result
+            and self.exc == other.exc
+        )
 
     def __repr__(self):
         return "YdbRetryOperationFinalResult(%s, exc=%s)" % (self.result, self.exc)

ydb/table_test.py

@@ -1,13 +1,20 @@
-import random
 from unittest import mock
-from ydb import retry_operation_impl, YdbRetryOperationFinalResult, issues, YdbRetryOperationSleepOpt, RetrySettings
+from ydb import (
+    retry_operation_impl,
+    YdbRetryOperationFinalResult,
+    issues,
+    YdbRetryOperationSleepOpt,
+    RetrySettings,
+)
 
 
 def test_retry_operation_impl(monkeypatch):
     monkeypatch.setattr("random.random", lambda: 0.5)
-    monkeypatch.setattr(issues.Error, "__eq__",
-                        lambda self, other: type(self) == type(other) and self.message == other.message
-                        )
+    monkeypatch.setattr(
+        issues.Error,
+        "__eq__",
+        lambda self, other: type(self) == type(other) and self.message == other.message,
+    )
 
     retry_once_settings = RetrySettings(
         max_retries=1,
@@ -41,7 +48,9 @@ def check_unretriable_error(err_type, call_ydb_handler):
         retry_once_settings.on_ydb_error_callback.reset_mock()
         retry_once_settings.unknown_error_handler.reset_mock()
 
-        results = get_results(mock.Mock(side_effect=[err_type("test1"), err_type("test2")]))
+        results = get_results(
+            mock.Mock(side_effect=[err_type("test1"), err_type("test2")])
+        )
         yields = results[0]
         exc = results[1]
 
@@ -50,25 +59,33 @@ def check_unretriable_error(err_type, call_ydb_handler):
 
         if call_ydb_handler:
             assert retry_once_settings.on_ydb_error_callback.call_count == 1
-            retry_once_settings.on_ydb_error_callback.assert_called_with(err_type("test1"))
+            retry_once_settings.on_ydb_error_callback.assert_called_with(
+                err_type("test1")
+            )
 
             assert retry_once_settings.unknown_error_handler.call_count == 0
         else:
             assert retry_once_settings.on_ydb_error_callback.call_count == 0
 
             assert retry_once_settings.unknown_error_handler.call_count == 1
-            retry_once_settings.unknown_error_handler.assert_called_with(err_type("test1"))
-
+            retry_once_settings.unknown_error_handler.assert_called_with(
+                err_type("test1")
+            )
 
     def check_retriable_error(err_type, backoff):
         retry_once_settings.on_ydb_error_callback.reset_mock()
 
-        results = get_results(mock.Mock(side_effect=[err_type("test1"), err_type("test2")]))
+        results = get_results(
+            mock.Mock(side_effect=[err_type("test1"), err_type("test2")])
+        )
         yields = results[0]
         exc = results[1]
 
         if backoff:
-            assert [YdbRetryOperationSleepOpt(backoff.calc_timeout(0)), YdbRetryOperationSleepOpt(backoff.calc_timeout(1))] == yields
+            assert [
+                YdbRetryOperationSleepOpt(backoff.calc_timeout(0)),
+                YdbRetryOperationSleepOpt(backoff.calc_timeout(1)),
+            ] == yields
         else:
             assert [] == yields
 
@@ -84,10 +101,13 @@ def check_retriable_error(err_type, backoff):
     assert get_results(lambda: True) == ([YdbRetryOperationFinalResult(True)], None)
 
     # check retry error and return result
-    assert get_results(mock.Mock(side_effect=[issues.Overloaded("test"), True])) == ([
-        YdbRetryOperationSleepOpt(retry_once_settings.slow_backoff.calc_timeout(0)),
-        YdbRetryOperationFinalResult(True),
-    ], None)
+    assert get_results(mock.Mock(side_effect=[issues.Overloaded("test"), True])) == (
+        [
+            YdbRetryOperationSleepOpt(retry_once_settings.slow_backoff.calc_timeout(0)),
+            YdbRetryOperationFinalResult(True),
+        ],
+        None,
+    )
 
     # check errors
     check_retriable_error(issues.Aborted, None)
@@ -113,4 +133,3 @@ def check_retriable_error(err_type, backoff):
 
     check_unretriable_error(issues.Error, True)
     check_unretriable_error(TestException, False)
-