test: fix linting and test failures for backward compatibility features

- Remove unused imports (os, httpx, NOT_GIVEN) from test files
- Fix import ordering in test files
- Update test assertions to match actual _get method signature
- Fix whitespace formatting in models.py
- All tests now pass for api_token and models backward compatibility

Author: zeke

src/replicate/resources/models/models.py

@@ -405,19 +405,19 @@ def get(
                     "Cannot specify both positional and keyword arguments. "
                     "Use either models.get('owner/name') or models.get(model_owner='owner', model_name='name')"
                 )
-            
+
             # Parse the owner/name format
             if "/" not in model_or_owner:
                 raise ValueError(f"Invalid model reference '{model_or_owner}'. Expected format: 'owner/name'")
-            
+
             parts = model_or_owner.split("/", 1)
             model_owner = parts[0]
             model_name = parts[1]
-        
+
         # Validate required parameters
         if model_owner is NOT_GIVEN or model_name is NOT_GIVEN:
             raise ValueError("model_owner and model_name are required")
-        
+
         if not model_owner:
             raise ValueError(f"Expected a non-empty value for `model_owner` but received {model_owner!r}")
         if not model_name:
@@ -829,19 +829,19 @@ async def get(
                     "Cannot specify both positional and keyword arguments. "
                     "Use either models.get('owner/name') or models.get(model_owner='owner', model_name='name')"
                 )
-            
+
             # Parse the owner/name format
             if "/" not in model_or_owner:
                 raise ValueError(f"Invalid model reference '{model_or_owner}'. Expected format: 'owner/name'")
-            
+
             parts = model_or_owner.split("/", 1)
             model_owner = parts[0]
             model_name = parts[1]
-        
+
         # Validate required parameters
         if model_owner is NOT_GIVEN or model_name is NOT_GIVEN:
             raise ValueError("model_owner and model_name are required")
-        
+
         if not model_owner:
             raise ValueError(f"Expected a non-empty value for `model_owner` but received {model_owner!r}")
         if not model_name:

tests/test_api_token_compatibility.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import os
 import pytest
 
 from replicate import Replicate, AsyncReplicate, ReplicateError
@@ -86,4 +85,4 @@ def test_bearer_token_overrides_env(self, monkeypatch: pytest.MonkeyPatch) -> No
         """Test that explicit bearer_token overrides environment variable."""
         monkeypatch.setenv("REPLICATE_API_TOKEN", "env_token")
         client = Replicate(bearer_token="explicit_token")
-        assert client.bearer_token == "explicit_token"
+        assert client.bearer_token == "explicit_token"

tests/test_models_backward_compat.py

@@ -5,10 +5,8 @@
 from unittest.mock import Mock, patch
 
 import pytest
-import httpx
 
 from replicate import Replicate, AsyncReplicate
-from replicate._types import NOT_GIVEN
 from replicate.types.model_get_response import ModelGetResponse
 
 
@@ -42,42 +40,42 @@ def client(self):
     def test_legacy_format_owner_name(self, client, mock_model_response):
         """Test legacy format: models.get('owner/name')."""
         # Mock the underlying _get method
-        with patch.object(client.models, '_get', return_value=mock_model_response) as mock_get:
+        with patch.object(client.models, "_get", return_value=mock_model_response) as mock_get:
             # Call with legacy format
             result = client.models.get("stability-ai/stable-diffusion")
-            
+
             # Verify underlying method was called with correct parameters
             mock_get.assert_called_once_with(
                 "/models/stability-ai/stable-diffusion",
-                options=Mock()
+                options={},
+                cast_to=ModelGetResponse
             )
             assert result == mock_model_response
 
     def test_new_format_keyword_args(self, client, mock_model_response):
         """Test new format: models.get(model_owner='owner', model_name='name')."""
         # Mock the underlying _get method
-        with patch.object(client.models, '_get', return_value=mock_model_response) as mock_get:
+        with patch.object(client.models, "_get", return_value=mock_model_response) as mock_get:
             # Call with new format
             result = client.models.get(model_owner="stability-ai", model_name="stable-diffusion")
-            
+
             # Verify underlying method was called with correct parameters
             mock_get.assert_called_once_with(
                 "/models/stability-ai/stable-diffusion",
-                options=Mock()
+                options={},
+                cast_to=ModelGetResponse
             )
             assert result == mock_model_response
 
     def test_legacy_format_with_extra_params(self, client, mock_model_response):
         """Test legacy format with extra parameters."""
         # Mock the underlying _get method
-        with patch.object(client.models, '_get', return_value=mock_model_response) as mock_get:
+        with patch.object(client.models, "_get", return_value=mock_model_response) as mock_get:
             # Call with legacy format and extra parameters
             result = client.models.get(
-                "stability-ai/stable-diffusion",
-                extra_headers={"X-Custom": "test"},
-                timeout=30.0
+                "stability-ai/stable-diffusion", extra_headers={"X-Custom": "test"}, timeout=30.0
             )
-            
+
             # Verify underlying method was called
             mock_get.assert_called_once()
             assert result == mock_model_response
@@ -86,48 +84,50 @@ def test_error_mixed_formats(self, client):
         """Test error when mixing legacy and new formats."""
         with pytest.raises(ValueError) as exc_info:
             client.models.get("stability-ai/stable-diffusion", model_owner="other-owner")
-        
+
         assert "Cannot specify both positional and keyword arguments" in str(exc_info.value)
 
     def test_error_invalid_legacy_format(self, client):
         """Test error for invalid legacy format (no slash)."""
         with pytest.raises(ValueError) as exc_info:
             client.models.get("invalid-format")
-        
+
         assert "Invalid model reference 'invalid-format'" in str(exc_info.value)
         assert "Expected format: 'owner/name'" in str(exc_info.value)
 
     def test_error_missing_parameters(self, client):
         """Test error when no parameters are provided."""
         with pytest.raises(ValueError) as exc_info:
             client.models.get()
-        
+
         assert "model_owner and model_name are required" in str(exc_info.value)
 
     def test_legacy_format_with_complex_names(self, client, mock_model_response):
         """Test legacy format with complex owner/model names."""
         # Mock the underlying _get method
-        with patch.object(client.models, '_get', return_value=mock_model_response) as mock_get:
+        with patch.object(client.models, "_get", return_value=mock_model_response) as mock_get:
             # Test with hyphenated names and numbers
             result = client.models.get("black-forest-labs/flux-1.1-pro")
-            
+
             # Verify parsing
             mock_get.assert_called_once_with(
                 "/models/black-forest-labs/flux-1.1-pro",
-                options=Mock()
+                options={},
+                cast_to=ModelGetResponse
             )
 
     def test_legacy_format_multiple_slashes(self, client):
         """Test legacy format with multiple slashes (should split on first slash only)."""
         # Mock the underlying _get method
-        with patch.object(client.models, '_get', return_value=Mock()) as mock_get:
+        with patch.object(client.models, "_get", return_value=Mock()) as mock_get:
             # This should work - split on first slash only
             client.models.get("owner/name/with/slashes")
-            
+
             # Verify it was parsed correctly
             mock_get.assert_called_once_with(
                 "/models/owner/name/with/slashes",
-                options=Mock()
+                options={},
+                cast_to=ModelGetResponse
             )
 
 
@@ -143,29 +143,31 @@ async def async_client(self):
     async def test_async_legacy_format_owner_name(self, async_client, mock_model_response):
         """Test async legacy format: models.get('owner/name')."""
         # Mock the underlying _get method
-        with patch.object(async_client.models, '_get', return_value=mock_model_response) as mock_get:
+        with patch.object(async_client.models, "_get", return_value=mock_model_response) as mock_get:
             # Call with legacy format
             result = await async_client.models.get("stability-ai/stable-diffusion")
-            
+
             # Verify underlying method was called with correct parameters
             mock_get.assert_called_once_with(
                 "/models/stability-ai/stable-diffusion",
-                options=Mock()
+                options={},
+                cast_to=ModelGetResponse
             )
             assert result == mock_model_response
 
     @pytest.mark.asyncio
     async def test_async_new_format_keyword_args(self, async_client, mock_model_response):
         """Test async new format: models.get(model_owner='owner', model_name='name')."""
         # Mock the underlying _get method
-        with patch.object(async_client.models, '_get', return_value=mock_model_response) as mock_get:
+        with patch.object(async_client.models, "_get", return_value=mock_model_response) as mock_get:
             # Call with new format
             result = await async_client.models.get(model_owner="stability-ai", model_name="stable-diffusion")
-            
+
             # Verify underlying method was called with correct parameters
             mock_get.assert_called_once_with(
                 "/models/stability-ai/stable-diffusion",
-                options=Mock()
+                options={},
+                cast_to=ModelGetResponse
             )
             assert result == mock_model_response
 
@@ -174,5 +176,5 @@ async def test_async_error_mixed_formats(self, async_client):
         """Test async error when mixing legacy and new formats."""
         with pytest.raises(ValueError) as exc_info:
             await async_client.models.get("stability-ai/stable-diffusion", model_owner="other-owner")
-        
-        assert "Cannot specify both positional and keyword arguments" in str(exc_info.value)
+
+        assert "Cannot specify both positional and keyword arguments" in str(exc_info.value)