feat: add legacy type compatibility aliases for v1.x migration

This PR addresses DP-659 by adding backward compatibility aliases for legacy v1.x type names to ease migration to v2.x.

## Changes
- Created `replicate/model.py` module with legacy import paths
- Aliased `Model`, `Version`, and `Prediction` types from their current locations
- Added `ModelResponse` and `VersionResponse` aliases for response types
- Added comprehensive tests for isinstance() checks and type annotations

## Impact
This allows existing code using v1.x type imports like `from replicate.model import Model` to continue working with v2.x, reducing breaking changes during migration.

Author: zeke

requirements-dev.lock

@@ -78,9 +78,10 @@ mypy-extensions==1.0.0
 nodeenv==1.8.0
     # via pyright
 nox==2023.4.22
-packaging==23.2
+packaging==25.0
     # via nox
     # via pytest
+    # via replicate
 platformdirs==3.11.0
     # via virtualenv
 pluggy==1.5.0

requirements.lock

@@ -52,6 +52,8 @@ idna==3.4
 multidict==6.4.4
     # via aiohttp
     # via yarl
+packaging==25.0
+    # via replicate
 propcache==0.3.1
     # via aiohttp
     # via yarl

src/replicate/model.py

@@ -0,0 +1,35 @@
+"""
+Legacy compatibility module for replicate-python v1.x type names.
+
+This module provides backward compatibility for code that imports types
+using the old v1.x import paths like:
+    from replicate.model import Model
+    from replicate.model import Version
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .types import Prediction as Prediction
+
+# Import the actual types from their new locations
+from .lib._models import Model as Model, Version as Version
+
+# Also provide aliases for the response types for type checking
+if TYPE_CHECKING:
+    from .types import ModelGetResponse as ModelResponse
+    from .types.models.version_get_response import VersionGetResponse as VersionResponse
+else:
+    # At runtime, make the response types available under legacy names
+    from .types import ModelGetResponse as ModelResponse
+    from .types.models.version_get_response import VersionGetResponse as VersionResponse
+
+__all__ = [
+    "Model",
+    "Version",
+    "Prediction",
+    "ModelResponse",
+    "VersionResponse",
+]
+

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_legacy_compatibility.py

@@ -0,0 +1,159 @@
+"""Tests for legacy v1.x type compatibility."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from replicate.types import Prediction, ModelGetResponse
+from replicate.types.models.version_get_response import VersionGetResponse
+
+
+def test_legacy_model_imports():
+    """Test that legacy import paths work."""
+    # Test importing Model from legacy path
+    from replicate.model import Model
+    from replicate.lib._models import Model as LibModel
+
+    # Verify they are the same class
+    assert Model is LibModel
+
+
+def test_legacy_version_imports():
+    """Test that legacy Version import paths work."""
+    # Test importing Version from legacy path
+    from replicate.model import Version
+    from replicate.lib._models import Version as LibVersion
+
+    # Verify they are the same class
+    assert Version is LibVersion
+
+
+def test_legacy_prediction_imports():
+    """Test that legacy Prediction import paths work."""
+    # Test importing Prediction from legacy path
+    from replicate.model import Prediction as LegacyPrediction
+    from replicate.types import Prediction as TypesPrediction
+
+    # Verify they are the same class
+    assert LegacyPrediction is TypesPrediction
+
+
+def test_legacy_response_type_imports():
+    """Test that legacy response type aliases work."""
+    # Test importing response types from legacy path
+    from replicate.model import ModelResponse, VersionResponse
+
+    # Verify they are the correct types
+    assert ModelResponse is ModelGetResponse
+    assert VersionResponse is VersionGetResponse
+
+
+def test_legacy_isinstance_checks_with_model():
+    """Test that isinstance checks work with legacy Model type."""
+    from replicate.model import Model
+
+    # Create an instance
+    model = Model(owner="test", name="model")
+
+    # Test isinstance check
+    assert isinstance(model, Model)
+
+
+def test_legacy_isinstance_checks_with_version():
+    """Test that isinstance checks work with legacy Version type."""
+    import datetime
+
+    from replicate.model import Version
+
+    # Create a Version instance
+    version = Version(id="test-version-id", created_at=datetime.datetime.now(), cog_version="0.8.0", openapi_schema={})
+
+    # Test isinstance check
+    assert isinstance(version, Version)
+
+
+def test_legacy_isinstance_checks_with_prediction():
+    """Test that isinstance checks work with legacy Prediction type."""
+    import datetime
+
+    from replicate.model import Prediction
+
+    # Create a Prediction instance using construct to bypass validation
+    prediction = Prediction.construct(
+        id="test-prediction-id",
+        created_at=datetime.datetime.now(),
+        data_removed=False,
+        input={},
+        model="test/model",
+        output=None,
+        status="succeeded",
+        urls={
+            "cancel": "https://example.com/cancel",
+            "get": "https://example.com/get",
+            "web": "https://example.com/web",
+        },
+        version="test-version",
+    )
+
+    # Test isinstance check
+    assert isinstance(prediction, Prediction)
+
+
+def test_legacy_isinstance_checks_with_model_response():
+    """Test that isinstance checks work with ModelResponse alias."""
+    from replicate.model import ModelResponse
+
+    # Create a ModelGetResponse instance
+    model = ModelGetResponse.construct(name="test-model", owner="test-owner")
+
+    # Test isinstance check with both the alias and the actual type
+    assert isinstance(model, ModelResponse)
+    assert isinstance(model, ModelGetResponse)
+
+
+def test_legacy_isinstance_checks_with_version_response():
+    """Test that isinstance checks work with VersionResponse alias."""
+    import datetime
+
+    from replicate.model import VersionResponse
+
+    # Create a VersionGetResponse instance
+    version = VersionGetResponse.construct(
+        id="test-version-id", created_at=datetime.datetime.now(), cog_version="0.8.0", openapi_schema={}
+    )
+
+    # Test isinstance check with both the alias and the actual type
+    assert isinstance(version, VersionResponse)
+    assert isinstance(version, VersionGetResponse)
+
+
+def test_all_exports():
+    """Test that __all__ exports the expected items."""
+    from replicate import model
+
+    expected_exports = {
+        "Model",
+        "Version",
+        "Prediction",
+        "ModelResponse",
+        "VersionResponse",
+    }
+
+    assert set(model.__all__) == expected_exports
+
+    # Verify all exported items are importable
+    for name in model.__all__:
+        assert hasattr(model, name)
+
+
+if TYPE_CHECKING:
+    # Type checking test - ensure type annotations work correctly
+    def type_annotation_test():
+        from replicate.model import Model, Version, ModelResponse, VersionResponse
+
+        model: Model = Model("owner", "name")  # pyright: ignore[reportUnusedVariable]
+        version: Version  # pyright: ignore[reportUnusedVariable]
+        prediction: Prediction  # pyright: ignore[reportUnusedVariable]
+        model_response: ModelResponse  # pyright: ignore[reportUnusedVariable]
+        version_response: VersionResponse  # pyright: ignore[reportUnusedVariable]
+