formatting

setup.py

@@ -13,7 +13,7 @@ def is_mac():  # pragma: no cover
     return platform.system().lower() == "darwin"
 
 
-COMPILE_FLAGS = ["-O2"] if is_mac() else   ["-O2", "-march=native"]
+COMPILE_FLAGS = ["-O2"] if is_mac() else ["-O2", "-march=native"]
 
 __version__ = "notset"
 with open(f"{LIBRARY}/version.py", mode="r") as v:

tests/test_schema.py

@@ -261,6 +261,7 @@ def test_minimum_definition():
     with pytest.raises(ExcessColumnsInDataError):
         rs.validate({"apples": "green", "oranges": "orange"})
 
+
 def test_parsers():
     import datetime
     import decimal
@@ -279,7 +280,7 @@ def test_parsers():
     field = OrsoTypes.DATE
     with pytest.raises(Exception):
         parsed = field.parse("apples")
-    
+
     field = OrsoTypes.DECIMAL
     parsed = field.parse("8.7")
     assert isinstance(parsed, decimal.Decimal), type(parsed)
@@ -320,6 +321,7 @@ def test_parsers():
     assert isinstance(parsed, str), type(parsed)
     assert parsed == "1718530754", parsed
 
+
 if __name__ == "__main__":  # prgama: nocover
     from tests import run_tests
 

tests/test_schema_columns.py

@@ -90,17 +90,20 @@ def test_columns_with_unknown_parameters():
     FlatColumn(name="athena", type=OrsoTypes.INTEGER, alpha="betty")
     FunctionColumn(name="aries", type=OrsoTypes.DATE, binding=datetime.date.today, sketty="yum")
 
+
 def test_column_with_valid_default():
     col = FlatColumn(name="valid", type=OrsoTypes.INTEGER, default="1")
     assert col.default == 1
 
     col = FlatColumn(name="valid", type=OrsoTypes.INTEGER, default=1)
     assert col.default == 1
 
+
 def test_column_with_invalid_default():
     with pytest.raises(ValueError):
         FlatColumn(name="invalid", type=OrsoTypes.INTEGER, default="green")
 
+
 def test_flat_column_from_arrow():
     field_name = "test_field"
     arrow_type = pyarrow.string()
@@ -143,8 +146,6 @@ def test_missing_column_missing_name():
         FlatColumn()
 
 
-
-
 def test_type_checks():
     from decimal import Decimal
     from orso.schema import RelationSchema

tests/test_tools_dates.py

@@ -6,7 +6,7 @@
 
 import datetime
 import numpy
-import pandas 
+import pandas
 
 from orso.tools import parse_iso
 

tests/test_tools_retry.py

@@ -16,81 +16,90 @@ def test_retry_success_on_first_try():
     def decorated_func():
         return mock_func()
 
-    with patch('time.sleep', return_value=None) as mock_sleep:
+    with patch("time.sleep", return_value=None) as mock_sleep:
         result = decorated_func()
         assert result == "success"
         mock_func.assert_called_once()
         mock_sleep.assert_not_called()
 
+
 def test_retry_success_after_retries():
     mock_func = Mock(side_effect=[Exception("fail"), Exception("fail"), "success"])
 
     @retry(max_tries=3, backoff_seconds=1)
     def decorated_func():
         return mock_func()
 
-    with patch('time.sleep', return_value=None) as mock_sleep:
+    with patch("time.sleep", return_value=None) as mock_sleep:
         result = decorated_func()
         assert result == "success"
         assert mock_func.call_count == 3
         assert mock_sleep.call_count == 2
 
+
 def test_retry_failure_after_max_retries():
     mock_func = Mock(side_effect=Exception("fail"))
 
     @retry(max_tries=3, backoff_seconds=1)
     def decorated_func():
         return mock_func()
 
-    with patch('time.sleep', return_value=None) as mock_sleep:
+    with patch("time.sleep", return_value=None) as mock_sleep:
         with pytest.raises(Exception):
             decorated_func()
 
         assert mock_func.call_count == 3
         assert mock_sleep.call_count == 2
 
+
 def test_retry_with_exponential_backoff():
     mock_func = Mock(side_effect=[Exception("fail"), Exception("fail"), "success"])
 
     @retry(max_tries=3, backoff_seconds=1, exponential_backoff=True, max_backoff=4)
     def decorated_func():
         return mock_func()
 
-    with patch('time.sleep', return_value=None) as mock_sleep:
+    with patch("time.sleep", return_value=None) as mock_sleep:
         result = decorated_func()
         assert result == "success"
         assert mock_func.call_count == 3
         assert mock_sleep.call_count == 2
         mock_sleep.assert_any_call(1)
         mock_sleep.assert_any_call(2)
 
+
 def test_retry_with_jitter():
     mock_func = Mock(side_effect=[Exception("fail"), Exception("fail"), "success"])
 
     @retry(max_tries=3, backoff_seconds=1, jitter=True)
     def decorated_func():
         return mock_func()
 
-    with patch('time.sleep', return_value=None) as mock_sleep, patch('random.uniform', return_value=0.5) as mock_random:
+    with (
+        patch("time.sleep", return_value=None) as mock_sleep,
+        patch("random.uniform", return_value=0.5) as mock_random,
+    ):
         result = decorated_func()
         assert result == "success"
         assert mock_func.call_count == 3
         assert mock_sleep.call_count == 2
         mock_random.assert_called()
 
+
 def test_retry_with_specific_exceptions():
     mock_func = Mock(side_effect=[ValueError("fail"), ValueError("fail"), "success"])
 
     @retry(max_tries=3, backoff_seconds=1, retry_exceptions=(ValueError,))
     def decorated_func():
         return mock_func()
 
-    with patch('time.sleep', return_value=None) as mock_sleep:
+    with patch("time.sleep", return_value=None) as mock_sleep:
         result = decorated_func()
         assert result == "success"
         assert mock_func.call_count == 3
         assert mock_sleep.call_count == 2
 
+
 def test_retry_with_callback():
     mock_func = Mock(side_effect=[Exception("fail"), "success"])
     callback_func = Mock()
@@ -99,19 +108,19 @@ def test_retry_with_callback():
     def decorated_func():
         return mock_func()
 
-    with patch('time.sleep', return_value=None) as mock_sleep:
+    with patch("time.sleep", return_value=None) as mock_sleep:
         result = decorated_func()
         assert result == "success"
         assert mock_func.call_count == 2
         assert mock_sleep.call_count == 1
-        
+
         # Ensure callback was called once with correct arguments
         assert callback_func.call_count == 1
         called_exception, called_attempt = callback_func.call_args[0]
         assert isinstance(called_exception, Exception)
         assert called_exception.args == ("fail",)
         assert called_attempt == 1
-        
+
 
 def test_retry_no_retries_needed():
     mock_func = Mock(return_value="success")
@@ -120,27 +129,31 @@ def test_retry_no_retries_needed():
     def decorated_func():
         return mock_func()
 
-    with patch('time.sleep', return_value=None) as mock_sleep:
+    with patch("time.sleep", return_value=None) as mock_sleep:
         result = decorated_func()
         assert result == "success"
         assert mock_func.call_count == 1
         mock_sleep.assert_not_called()
 
+
 def test_retry_with_multiple_exceptions():
     mock_func = Mock(side_effect=[ValueError("fail"), KeyError("fail"), "success"])
 
     @retry(max_tries=3, backoff_seconds=1, retry_exceptions=(ValueError, KeyError))
     def decorated_func():
         return mock_func()
 
-    with patch('time.sleep', return_value=None) as mock_sleep:
+    with patch("time.sleep", return_value=None) as mock_sleep:
         result = decorated_func()
         assert result == "success"
         assert mock_func.call_count == 3
         assert mock_sleep.call_count == 2
 
+
 def test_retry_with_partial_success():
-    mock_func = Mock(side_effect=[Exception("fail"), "partial_success", Exception("fail_again"), "success"])
+    mock_func = Mock(
+        side_effect=[Exception("fail"), "partial_success", Exception("fail_again"), "success"]
+    )
 
     @retry(max_tries=4, backoff_seconds=1)
     def decorated_func():
@@ -149,20 +162,21 @@ def decorated_func():
             raise Exception("retrying due to partial success")
         return result
 
-    with patch('time.sleep', return_value=None) as mock_sleep:
+    with patch("time.sleep", return_value=None) as mock_sleep:
         result = decorated_func()
         assert result == "success"
         assert mock_func.call_count == 4
         assert mock_sleep.call_count == 3
 
+
 def test_retry_with_max_backoff():
     mock_func = Mock(side_effect=[Exception("fail"), Exception("fail"), "success"])
 
     @retry(max_tries=3, backoff_seconds=1, exponential_backoff=True, max_backoff=2)
     def decorated_func():
         return mock_func()
 
-    with patch('time.sleep', return_value=None) as mock_sleep:
+    with patch("time.sleep", return_value=None) as mock_sleep:
         result = decorated_func()
         assert result == "success"
         assert mock_func.call_count == 3
@@ -174,4 +188,4 @@ def decorated_func():
 if __name__ == "__main__":  # pragma: nocover
     from tests import run_tests
 
-    run_tests()
+    run_tests()