chore: upd

Author: maxprilutskiy

src/lingodotdev/engine.py

@@ -134,7 +134,9 @@ async def _localize_raw(
                 )
 
                 if progress_callback:
-                    progress_callback(percentage_completed, chunk, processed_payload_chunk)
+                    progress_callback(
+                        percentage_completed, chunk, processed_payload_chunk
+                    )
 
                 processed_payload_chunks.append(processed_payload_chunk)
 
@@ -280,7 +282,9 @@ async def localize_object(
             A new object with the same structure but localized string values
         """
         localization_params = LocalizationParams(**params)
-        return await self._localize_raw(obj, localization_params, progress_callback, concurrent)
+        return await self._localize_raw(
+            obj, localization_params, progress_callback, concurrent
+        )
 
     async def localize_text(
         self,
@@ -425,7 +429,9 @@ async def recognize_locale(self, text: str) -> str:
                         f"Server error ({response.status_code}): {response.reason_phrase}. "
                         "This may be due to temporary service issues."
                     )
-                raise RuntimeError(f"Error recognizing locale: {response.reason_phrase}")
+                raise RuntimeError(
+                    f"Error recognizing locale: {response.reason_phrase}"
+                )
 
             json_response = response.json()
             return json_response.get("locale") or ""
@@ -466,9 +472,7 @@ async def whoami(self) -> Optional[Dict[str, str]]:
             return None
 
     async def batch_localize_objects(
-        self,
-        objects: List[Dict[str, Any]],
-        params: Dict[str, Any]
+        self, objects: List[Dict[str, Any]], params: Dict[str, Any]
     ) -> List[Dict[str, Any]]:
         """
         Localize multiple objects concurrently
@@ -515,15 +519,15 @@ async def quick_translate(
         Example:
             # Translate text
             result = await LingoDotDevEngine.quick_translate(
-                "Hello world", 
-                "your-api-key", 
+                "Hello world",
+                "your-api-key",
                 "es"
             )
-            
+
             # Translate object
             result = await LingoDotDevEngine.quick_translate(
                 {"greeting": "Hello", "farewell": "Goodbye"},
-                "your-api-key", 
+                "your-api-key",
                 "es"
             )
         """
@@ -573,8 +577,8 @@ async def quick_batch_translate(
 
         Example:
             results = await LingoDotDevEngine.quick_batch_translate(
-                "Hello world", 
-                "your-api-key", 
+                "Hello world",
+                "your-api-key",
                 ["es", "fr", "de"]
             )
             # Results: ["Hola mundo", "Bonjour le monde", "Hallo Welt"]

tests/test_engine.py

@@ -345,10 +345,9 @@ async def test_whoami_no_email(self, mock_post):
     @patch("lingodotdev.engine.LingoDotDevEngine.localize_object")
     async def test_batch_localize_objects(self, mock_localize_object):
         """Test batch object localization"""
-        mock_localize_object.side_effect = AsyncMock(side_effect=[
-            {"greeting": "hola"}, 
-            {"farewell": "adiós"}
-        ])
+        mock_localize_object.side_effect = AsyncMock(
+            side_effect=[{"greeting": "hola"}, {"farewell": "adiós"}]
+        )
 
         objects = [{"greeting": "hello"}, {"farewell": "goodbye"}]
         params = {"source_locale": "en", "target_locale": "es"}
@@ -360,21 +359,29 @@ async def test_batch_localize_objects(self, mock_localize_object):
 
     async def test_concurrent_processing(self):
         """Test concurrent processing functionality"""
-        with patch("lingodotdev.engine.LingoDotDevEngine._localize_chunk") as mock_chunk:
+        with patch(
+            "lingodotdev.engine.LingoDotDevEngine._localize_chunk"
+        ) as mock_chunk:
             mock_chunk.return_value = {"key": "value"}
 
             large_payload = {f"key{i}": f"value{i}" for i in range(5)}
-            
+
             # Test concurrent mode
             await self.engine._localize_raw(
                 large_payload,
-                await asyncio.to_thread(lambda: type('MockParams', (), {
-                    'source_locale': 'en',
-                    'target_locale': 'es', 
-                    'fast': False,
-                    'reference': None
-                })()),
-                concurrent=True
+                await asyncio.to_thread(
+                    lambda: type(
+                        "MockParams",
+                        (),
+                        {
+                            "source_locale": "en",
+                            "target_locale": "es",
+                            "fast": False,
+                            "reference": None,
+                        },
+                    )()
+                ),
+                concurrent=True,
             )
 
             # Should have called _localize_chunk multiple times concurrently

tests/test_integration.py

@@ -74,7 +74,11 @@ async def test_batch_localize_text_real_api(self):
         async with self.engine:
             result = await self.engine.batch_localize_text(
                 "Welcome to our application",
-                {"source_locale": "en", "target_locales": ["es", "fr", "de"], "fast": True},
+                {
+                    "source_locale": "en",
+                    "target_locales": ["es", "fr", "de"],
+                    "fast": True,
+                },
             )
 
             assert isinstance(result, list)
@@ -208,16 +212,19 @@ async def test_fast_mode(self):
     async def test_concurrent_processing_performance(self):
         """Test concurrent processing performance improvement"""
         import time
-        
-        large_object = {f"key_{i}": f"Test content number {i} for performance testing" for i in range(10)}
+
+        large_object = {
+            f"key_{i}": f"Test content number {i} for performance testing"
+            for i in range(10)
+        }
 
         async with self.engine:
             # Test sequential processing
             start_time = time.time()
             await self.engine.localize_object(
                 large_object,
                 {"source_locale": "en", "target_locale": "es"},
-                concurrent=False
+                concurrent=False,
             )
             sequential_time = time.time() - start_time
 
@@ -226,7 +233,7 @@ async def test_concurrent_processing_performance(self):
             await self.engine.localize_object(
                 large_object,
                 {"source_locale": "en", "target_locale": "es"},
-                concurrent=True
+                concurrent=True,
             )
             concurrent_time = time.time() - start_time
 
@@ -238,13 +245,12 @@ async def test_batch_localize_objects(self):
         objects = [
             {"greeting": "Hello", "question": "How are you?"},
             {"farewell": "Goodbye", "thanks": "Thank you"},
-            {"welcome": "Welcome", "help": "Can I help you?"}
+            {"welcome": "Welcome", "help": "Can I help you?"},
         ]
 
         async with self.engine:
             results = await self.engine.batch_localize_objects(
-                objects,
-                {"source_locale": "en", "target_locale": "es"}
+                objects, {"source_locale": "en", "target_locale": "es"}
             )
 
             assert len(results) == 3
@@ -337,15 +343,15 @@ async def test_workflow_id_consistency(self, mock_post):
     async def test_concurrent_chunk_processing(self, mock_post):
         """Test concurrent chunk processing"""
         import asyncio
-        
+
         # Mock API response with delay to test concurrency
         async def mock_response_with_delay(*args, **kwargs):
             await asyncio.sleep(0.1)  # Small delay
-            mock_resp = type('MockResponse', (), {})()
+            mock_resp = type("MockResponse", (), {})()
             mock_resp.is_success = True
             mock_resp.json = lambda: {"data": {"key": "value"}}
             return mock_resp
-        
+
         mock_post.side_effect = mock_response_with_delay
 
         # Create a payload that will be chunked
@@ -356,7 +362,7 @@ async def mock_response_with_delay(*args, **kwargs):
         await self.engine.localize_object(
             large_payload,
             {"source_locale": "en", "target_locale": "es"},
-            concurrent=True
+            concurrent=True,
         )
         concurrent_time = asyncio.get_event_loop().time() - start_time