feat: add get_path_url() function support for migration compatibility

Add support for get_path_url() function to maintain compatibility with old
replicate-python client. This function extracts remote URLs from file output
objects, enabling users to reuse URLs in model inputs.

Key changes:
- Export get_path_url from main module (__init__.py)
- Add module-level function proxy in _module_client.py
- Enhance FileOutput classes with __url__ attribute for compatibility
- Add comprehensive test coverage for all supported object types
- Maintain backward compatibility with same API as old client

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: zeke

src/replicate/__init__.py

@@ -89,6 +89,7 @@
     "Model",
     "Version",
     "ModelVersionIdentifier",
+    "get_path_url",
 ]
 
 if not _t.TYPE_CHECKING:
@@ -104,6 +105,9 @@
 for __name in __all__:
     if not __name.startswith("__"):
         try:
+            # Skip get_path_url as it's imported later
+            if __name == "get_path_url":
+                continue
             __locals[__name].__module__ = "replicate"
         except (TypeError, AttributeError):
             # Some of our exported symbols are builtins which we can't set attributes for.
@@ -253,4 +257,5 @@ def _reset_client() -> None:  # type: ignore[reportUnusedFunction]
     collections as collections,
     deployments as deployments,
     predictions as predictions,
+    get_path_url as get_path_url,
 )

src/replicate/_module_client.py

@@ -82,6 +82,9 @@ def __load__(self) -> PredictionsResource:
     __client: Replicate = cast(Replicate, {})
     run = __client.run
     use = __client.use
+
+    # Import get_path_url for type checking
+    from .lib._predictions_use import get_path_url
 else:
 
     def _run(*args, **kwargs):
@@ -100,8 +103,14 @@ def _use(ref, *, hint=None, streaming=False, use_async=False, **kwargs):
 
         return use(Replicate, ref, hint=hint, streaming=streaming, **kwargs)
 
+    def _get_path_url(path):
+        from .lib._predictions_use import get_path_url
+
+        return get_path_url(path)
+
     run = _run
     use = _use
+    get_path_url = _get_path_url
 
 files: FilesResource = FilesResourceProxy().__as_proxied__()
 models: ModelsResource = ModelsResourceProxy().__as_proxied__()

src/replicate/lib/_files.py

@@ -139,6 +139,8 @@ class FileOutput(httpx.SyncByteStream):
     def __init__(self, url: str, client: Replicate) -> None:
         self.url = url
         self._client = client
+        # Add __url__ attribute for compatibility with get_path_url()
+        self.__url__ = url
 
     def read(self) -> bytes:
         if self.url.startswith("data:"):
@@ -184,6 +186,8 @@ class AsyncFileOutput(httpx.AsyncByteStream):
     def __init__(self, url: str, client: AsyncReplicate) -> None:
         self.url = url
         self._client = client
+        # Add __url__ attribute for compatibility with get_path_url()
+        self.__url__ = url
 
     async def read(self) -> bytes:
         if self.url.startswith("data:"):

tests/lib/test_get_path_url.py

@@ -0,0 +1,103 @@
+from pathlib import Path
+
+import replicate
+from replicate.lib._files import FileOutput, AsyncFileOutput
+from replicate.lib._predictions_use import URLPath, get_path_url
+
+
+def test_get_path_url_with_urlpath():
+    """Test get_path_url returns the URL for URLPath instances."""
+    url = "https://example.com/test.jpg"
+    path_proxy = URLPath(url)
+
+    result = get_path_url(path_proxy)
+    assert result == url
+
+
+def test_get_path_url_with_fileoutput():
+    """Test get_path_url returns the URL for FileOutput instances."""
+    url = "https://example.com/test.jpg"
+    file_output = FileOutput(url, replicate.Replicate())
+
+    result = get_path_url(file_output)
+    assert result == url
+
+
+def test_get_path_url_with_async_fileoutput():
+    """Test get_path_url returns the URL for AsyncFileOutput instances."""
+    url = "https://example.com/test.jpg"
+    async_file_output = AsyncFileOutput(url, replicate.AsyncReplicate())
+
+    result = get_path_url(async_file_output)
+    assert result == url
+
+
+def test_get_path_url_with_regular_path():
+    """Test get_path_url returns None for regular Path instances."""
+    regular_path = Path("test.txt")
+
+    result = get_path_url(regular_path)
+    assert result is None
+
+
+def test_get_path_url_with_object_without_target():
+    """Test get_path_url returns None for objects without __url__."""
+
+    # Test with a string
+    result = get_path_url("not a path")
+    assert result is None
+
+    # Test with a dict
+    result = get_path_url({"key": "value"})
+    assert result is None
+
+    # Test with None
+    result = get_path_url(None)
+    assert result is None
+
+
+def test_get_path_url_module_level_import():
+    """Test that get_path_url can be imported at module level."""
+    from replicate import get_path_url as module_get_path_url
+
+    url = "https://example.com/test.jpg"
+    file_output = FileOutput(url, replicate.Replicate())
+
+    result = module_get_path_url(file_output)
+    assert result == url
+
+
+def test_get_path_url_direct_module_access():
+    """Test that get_path_url can be accessed directly from replicate module."""
+    url = "https://example.com/test.jpg"
+    file_output = FileOutput(url, replicate.Replicate())
+
+    result = replicate.get_path_url(file_output)
+    assert result == url
+
+
+def test_fileoutput_has_url_attribute():
+    """Test that FileOutput instances have __url__ attribute."""
+    url = "https://example.com/test.jpg"
+    file_output = FileOutput(url, replicate.Replicate())
+
+    assert hasattr(file_output, "__url__")
+    assert file_output.__url__ == url
+
+
+def test_async_fileoutput_has_url_attribute():
+    """Test that AsyncFileOutput instances have __url__ attribute."""
+    url = "https://example.com/test.jpg"
+    async_file_output = AsyncFileOutput(url, replicate.AsyncReplicate())
+
+    assert hasattr(async_file_output, "__url__")
+    assert async_file_output.__url__ == url
+
+
+def test_urlpath_has_url_attribute():
+    """Test that URLPath instances have __url__ attribute."""
+    url = "https://example.com/test.jpg"
+    url_path = URLPath(url)
+
+    assert hasattr(url_path, "__url__")
+    assert url_path.__url__ == url