sdk/python: ruff format

Author: kvinwang

sdk/python/src/dstack_sdk/dstack_client.py

@@ -197,7 +197,6 @@ class BaseClient:
 
 
 class AsyncDstackClient(BaseClient):
-
     PATH_PREFIX = "/"
 
     def __init__(self, endpoint: str | None = None, use_sync_http: bool = False):
@@ -363,7 +362,6 @@ async def is_reachable(self) -> bool:
 
 
 class DstackClient(BaseClient):
-
     PATH_PREFIX = "/"
 
     def __init__(self, endpoint: str | None = None):

sdk/python/src/dstack_sdk/ethereum.py

@@ -7,6 +7,7 @@
 Use with ``dstack_sdk.DstackClient`` responses to create ``eth_account``
 objects for signing and transacting.
 """
+
 import hashlib
 import warnings
 

sdk/python/src/dstack_sdk/solana.py

@@ -7,6 +7,7 @@
 Use with ``dstack_sdk.DstackClient`` responses to create ``solders.Keypair``
 objects for signing transactions on Solana.
 """
+
 import hashlib
 import warnings
 

sdk/python/test_outputs.py

@@ -5,82 +5,103 @@
 import asyncio
 import sys
 
-from dstack_sdk import DstackClient, AsyncDstackClient, TappdClient, AsyncTappdClient, get_compose_hash, verify_env_encrypt_public_key
+from dstack_sdk import (
+    DstackClient,
+    AsyncDstackClient,
+    TappdClient,
+    AsyncTappdClient,
+    get_compose_hash,
+    verify_env_encrypt_public_key,
+)
 
 
 async def main():
     print("=== Python SDK Output Test ===")
-    
+
     try:
         # Test client get_key
         client = DstackClient()
         print("\n1. Testing DstackClient.get_key()")
-        
+
         test_paths = [
             {"path": "test/wallet", "purpose": "ethereum"},
             {"path": "test/signing", "purpose": "solana"},
-            {"path": "user/alice", "purpose": "mainnet"}
+            {"path": "user/alice", "purpose": "mainnet"},
         ]
-        
+
         for test_case in test_paths:
             path, purpose = test_case["path"], test_case["purpose"]
             key_result = client.get_key(path, purpose)
             print(f"get_key('{path}', '{purpose}'):")
             print(f"  key: {key_result.decode_key().hex()}")
             print(f"  signature_chain length: {len(key_result.signature_chain)}")
-            print(f"  signature_chain[0]: {key_result.decode_signature_chain()[0].hex()}")
+            print(
+                f"  signature_chain[0]: {key_result.decode_signature_chain()[0].hex()}"
+            )
 
         # Test viem integration (if available)
         print("\n2. Testing Viem Integration")
         eth_key = client.get_key("eth/test", "wallet")
-        
+
         print("\n2.1 to_account (legacy):")
         try:
             from dstack_sdk.ethereum import to_account
+
             account = to_account(eth_key)
             print(f"  address: {account.address}")
             print(f"  type: ethereum account")
         except ImportError:
-            print("  error: Ethereum integration not available (install with pip install 'dstack-sdk[eth]')")
+            print(
+                "  error: Ethereum integration not available (install with pip install 'dstack-sdk[eth]')"
+            )
         except Exception as error:
             print(f"  error: {error}")
-        
+
         print("\n2.2 to_account_secure:")
         try:
             from dstack_sdk.ethereum import to_account_secure
+
             account_secure = to_account_secure(eth_key)
             print(f"  address: {account_secure.address}")
             print(f"  type: ethereum account")
         except ImportError:
-            print("  error: Ethereum integration not available (install with pip install 'dstack-sdk[eth]')")
+            print(
+                "  error: Ethereum integration not available (install with pip install 'dstack-sdk[eth]')"
+            )
         except Exception as error:
             print(f"  error: {error}")
 
         # Test solana integration (if available)
         print("\n3. Testing Solana Integration")
         sol_key = client.get_key("sol/test", "wallet")
-        
+
         print("\n3.1 to_keypair (legacy):")
         try:
             from dstack_sdk.solana import to_keypair
+
             keypair = to_keypair(sol_key)
             print(f"  publicKey: {keypair.pubkey()}")
             print(f"  secretKey length: {len(bytes(keypair))}")
             print(f"  secretKey (first 32 bytes): {bytes(keypair)[:32].hex()}")
         except ImportError:
-            print("  error: Solana integration not available (install with pip install 'dstack-sdk[sol]')")
+            print(
+                "  error: Solana integration not available (install with pip install 'dstack-sdk[sol]')"
+            )
         except Exception as error:
             print(f"  error: {error}")
-        
+
         print("\n3.2 to_keypair_secure:")
         try:
             from dstack_sdk.solana import to_keypair_secure
+
             keypair_secure = to_keypair_secure(sol_key)
             print(f"  publicKey: {keypair_secure.pubkey()}")
             print(f"  secretKey length: {len(bytes(keypair_secure))}")
             print(f"  secretKey (first 32 bytes): {bytes(keypair_secure)[:32].hex()}")
         except ImportError:
-            print("  error: Solana integration not available (install with pip install 'dstack-sdk[sol]')")
+            print(
+                "  error: Solana integration not available (install with pip install 'dstack-sdk[sol]')"
+            )
         except Exception as error:
             print(f"  error: {error}")
 
@@ -106,7 +127,9 @@ async def main():
         try:
             async_tappd_client = AsyncTappdClient()
             print("\n4.3.1 AsyncTappdClient.get_key():")
-            async_tappd_key = await async_tappd_client.get_key("test/wallet", "ethereum")
+            async_tappd_key = await async_tappd_client.get_key(
+                "test/wallet", "ethereum"
+            )
             print(f"  key: {async_tappd_key.decode_key().hex()}")
             print(f"  signature_chain length: {len(async_tappd_key.signature_chain)}")
 
@@ -140,16 +163,16 @@ async def main():
                 "manifest_version": 1,
                 "name": "test-app",
                 "runner": "docker-compose",
-                "docker_compose_file": "services:\\n  app:\\n    image: test\\n    ports:\\n      - 8080:8080"
+                "docker_compose_file": "services:\\n  app:\\n    image: test\\n    ports:\\n      - 8080:8080",
             },
             {
                 "manifest_version": 1,
-                "name": "another-app", 
+                "name": "another-app",
                 "runner": "docker-compose",
-                "docker_compose_file": "services:\\n  web:\\n    build: .\\n    environment:\\n      - NODE_ENV=production"
-            }
+                "docker_compose_file": "services:\\n  web:\\n    build: .\\n    environment:\\n      - NODE_ENV=production",
+            },
         ]
-        
+
         for index, compose in enumerate(test_composes):
             hash_value = get_compose_hash(compose)
             print(f"compose {index + 1}: {hash_value}")
@@ -160,23 +183,29 @@ async def main():
         print("\n7. Testing verify_env_encrypt_public_key")
         test_cases = [
             {
-                "public_key": bytes.fromhex('e33a1832c6562067ff8f844a61e51ad051f1180b66ec2551fb0251735f3ee90a'),
-                "signature": bytes.fromhex('8542c49081fbf4e03f62034f13fbf70630bdf256a53032e38465a27c36fd6bed7a5e7111652004aef37f7fd92fbfc1285212c4ae6a6154203a48f5e16cad2cef00'),
-                "app_id": '0000000000000000000000000000000000000000'
+                "public_key": bytes.fromhex(
+                    "e33a1832c6562067ff8f844a61e51ad051f1180b66ec2551fb0251735f3ee90a"
+                ),
+                "signature": bytes.fromhex(
+                    "8542c49081fbf4e03f62034f13fbf70630bdf256a53032e38465a27c36fd6bed7a5e7111652004aef37f7fd92fbfc1285212c4ae6a6154203a48f5e16cad2cef00"
+                ),
+                "app_id": "0000000000000000000000000000000000000000",
             },
             {
-                "public_key": bytes.fromhex('deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef'),
-                "signature": bytes.fromhex('0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000'),
-                "app_id": 'invalid-app-id'
-            }
+                "public_key": bytes.fromhex(
+                    "deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef"
+                ),
+                "signature": bytes.fromhex(
+                    "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"
+                ),
+                "app_id": "invalid-app-id",
+            },
         ]
 
         for index, test_case in enumerate(test_cases):
             try:
                 result = verify_env_encrypt_public_key(
-                    test_case["public_key"],
-                    test_case["signature"],
-                    test_case["app_id"]
+                    test_case["public_key"], test_case["signature"], test_case["app_id"]
                 )
                 print(f"test case {index + 1}: {result.hex() if result else 'null'}")
             except Exception as error:
@@ -186,5 +215,6 @@ async def main():
         print(f"Error: {error}")
         sys.exit(1)
 
+
 if __name__ == "__main__":
-    asyncio.run(main())
+    asyncio.run(main())

sdk/python/tests/test_client.py

@@ -263,14 +263,15 @@ def test_tappd_client_deprecated():
     with warnings.catch_warnings(record=True) as w:
         warnings.simplefilter("always")
         TappdClient()
-        
+
         # Filter for TappdClient deprecation warnings specifically
         tappd_warnings = [
-            warning for warning in w 
-            if issubclass(warning.category, DeprecationWarning) 
+            warning
+            for warning in w
+            if issubclass(warning.category, DeprecationWarning)
             and "TappdClient is deprecated" in str(warning.message)
         ]
-        
+
         assert len(tappd_warnings) == 1
         assert "TappdClient is deprecated" in str(tappd_warnings[0].message)
 
@@ -307,14 +308,15 @@ def test_async_tappd_client_deprecated():
     with warnings.catch_warnings(record=True) as w:
         warnings.simplefilter("always")
         AsyncTappdClient()
-        
+
         # Filter for AsyncTappdClient deprecation warnings specifically
         tappd_warnings = [
-            warning for warning in w 
-            if issubclass(warning.category, DeprecationWarning) 
+            warning
+            for warning in w
+            if issubclass(warning.category, DeprecationWarning)
             and "AsyncTappdClient is deprecated" in str(warning.message)
         ]
-        
+
         assert len(tappd_warnings) == 1
         assert "AsyncTappdClient is deprecated" in str(tappd_warnings[0].message)
 
@@ -329,9 +331,7 @@ async def test_async_tappd_client_derive_key_deprecated():
         await client.derive_key("/", "test")
         # Should have warnings for both constructor and derive_key
         warning_messages = [str(warning.message) for warning in w]
-        assert any(
-            "AsyncTappdClient is deprecated" in msg for msg in warning_messages
-        )
+        assert any("AsyncTappdClient is deprecated" in msg for msg in warning_messages)
         assert any("derive_key is deprecated" in msg for msg in warning_messages)
 
 
@@ -345,9 +345,7 @@ async def test_async_tappd_client_tdx_quote_deprecated():
         await client.tdx_quote("test data", "raw")
         # Should have warnings for both constructor and tdx_quote
         warning_messages = [str(warning.message) for warning in w]
-        assert any(
-            "AsyncTappdClient is deprecated" in msg for msg in warning_messages
-        )
+        assert any("AsyncTappdClient is deprecated" in msg for msg in warning_messages)
         assert any("tdx_quote is deprecated" in msg for msg in warning_messages)
 
 

sdk/python/tests/test_typing.py

@@ -41,9 +41,9 @@ def test_sync_method_type_annotations():
     except Exception as e:
         print(f"Error getting type hints for get_tls_key: {e}")
         # If we can't get type hints, at least check it's not a coroutine function
-        assert not inspect.iscoroutinefunction(
-            get_tls_key_method
-        ), "Sync method should not be a coroutine function"
+        assert not inspect.iscoroutinefunction(get_tls_key_method), (
+            "Sync method should not be a coroutine function"
+        )
 
 
 def test_all_sync_method_types():
@@ -64,9 +64,9 @@ def test_all_sync_method_types():
         assert callable(method), f"{method_name} should be callable"
 
         # Should not be coroutine function for sync client
-        assert not inspect.iscoroutinefunction(
-            method
-        ), f"Sync {method_name} should not be coroutine function"
+        assert not inspect.iscoroutinefunction(method), (
+            f"Sync {method_name} should not be coroutine function"
+        )
 
         try:
             type_hints = get_type_hints(method)
@@ -80,7 +80,9 @@ def test_all_sync_method_types():
                 assert (
                     return_type == expected_return_type
                     or return_type is expected_return_type
-                ), f"{method_name} should return {expected_return_type}, got {return_type}"
+                ), (
+                    f"{method_name} should return {expected_return_type}, got {return_type}"
+                )
 
         except Exception as e:
             print(f"Warning: Could not get type hints for {method_name}: {e}")
@@ -104,9 +106,9 @@ def test_async_method_types():
         assert callable(method), f"{method_name} should be callable"
 
         # Should be coroutine function for async client
-        assert inspect.iscoroutinefunction(
-            method
-        ), f"Async {method_name} should be coroutine function"
+        assert inspect.iscoroutinefunction(method), (
+            f"Async {method_name} should be coroutine function"
+        )
 
         try:
             type_hints = get_type_hints(method)
@@ -153,9 +155,9 @@ def test_method_signature_comparison():
         if "self" in async_params:
             async_params.remove("self")
 
-        assert (
-            sync_params == async_params
-        ), f"Parameter mismatch for {method_name}: sync={sync_params}, async={async_params}"
+        assert sync_params == async_params, (
+            f"Parameter mismatch for {method_name}: sync={sync_params}, async={async_params}"
+        )
 
 
 if __name__ == "__main__":

sdk/run-tests.sh

@@ -35,8 +35,9 @@ if [ ! -d .venv ]; then
 fi
 source .venv/bin/activate
 pip install -e .
-pip install pytest pytest-asyncio evidence-api web3 solders
+pip install pytest pytest-asyncio evidence-api web3 solders ruff
 pytest
+ruff format --check --diff .
 popd
 
 pushd js/