Examples: add replicate.use() demo script

Author: dgellow

examples/use_demo.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+"""
+Example of using the experimental replicate.use() interface
+"""
+
+import replicate
+
+print("Testing replicate.use() functionality...")
+
+# Test 1: Simple text model
+print("\n1. Testing simple text model...")
+try:
+    hello_world = replicate.use("replicate/hello-world")
+    result = hello_world(text="Alice")
+    print(f"Result: {result}")
+except Exception as e:
+    print(f"Error: {type(e).__name__}: {e}")
+
+# Test 2: Image generation model
+print("\n2. Testing image generation model...")
+try:
+    from replicate.lib._predictions_use import get_path_url
+
+    flux_dev = replicate.use("black-forest-labs/flux-dev")
+    outputs = flux_dev(
+        prompt="a cat wearing a wizard hat, digital art",
+        num_outputs=1,
+        aspect_ratio="1:1",
+        output_format="webp",
+        guidance=3.5,
+        num_inference_steps=28,
+    )
+    print(f"Generated output: {outputs}")
+    if isinstance(outputs, list):
+        print(f"Generated {len(outputs)} image(s)")
+        for i, output in enumerate(outputs):
+            print(f"  Image {i}: {output}")
+            # Get the URL without downloading
+            url = get_path_url(output)
+            if url:
+                print(f"  URL: {url}")
+    else:
+        print(f"Single output: {outputs}")
+        url = get_path_url(outputs)
+        if url:
+            print(f"  URL: {url}")
+except Exception as e:
+    print(f"Error: {type(e).__name__}: {e}")
+    import traceback
+
+    traceback.print_exc()
+
+# Test 3: Language model with streaming
+print("\n3. Testing language model with streaming...")
+try:
+    llama = replicate.use("meta/meta-llama-3-8b-instruct", streaming=True)
+    output = llama(prompt="Write a haiku about Python programming", max_tokens=50)
+    print("Streaming output:")
+    for chunk in output:
+        print(chunk, end="", flush=True)
+    print()
+except Exception as e:
+    print(f"Error: {type(e).__name__}: {e}")
+    import traceback
+
+    traceback.print_exc()
+
+# Test 4: Using async
+print("\n4. Testing async functionality...")
+import asyncio
+
+
+async def test_async():
+    try:
+        hello_world = replicate.use("replicate/hello-world", use_async=True)
+        result = await hello_world(text="Bob")
+        print(f"Async result: {result}")
+
+        print("\n4b. Testing async streaming...")
+        llama = replicate.use("meta/meta-llama-3-8b-instruct", streaming=True, use_async=True)
+        output = await llama(prompt="Write a short poem about async/await", max_tokens=50)
+        print("Async streaming output:")
+        async for chunk in output:
+            print(chunk, end="", flush=True)
+        print()
+    except Exception as e:
+        print(f"Error: {type(e).__name__}: {e}")
+        import traceback
+
+        traceback.print_exc()
+
+
+asyncio.run(test_async())
+
+print("\nDone!")

src/replicate/_module_client.py

@@ -87,8 +87,13 @@ def __load__(self) -> PredictionsResource:
     def _run(*args, **kwargs):
         return _load_client().run(*args, **kwargs)
 
-    def _use(*args, **kwargs):
-        return _load_client().use(*args, **kwargs)
+    def _use(ref, *, hint=None, streaming=False, use_async=False, **kwargs):
+        if use_async:
+            # For async, we need to use AsyncReplicate instead
+            from ._client import AsyncReplicate
+            client = AsyncReplicate()
+            return client.use(ref, hint=hint, streaming=streaming, **kwargs)
+        return _load_client().use(ref, hint=hint, streaming=streaming, **kwargs)
 
     run = _run
     use = _use

src/replicate/lib/_predictions_use.py

@@ -466,7 +466,10 @@ def create(self, *_: Input.args, **inputs: Input.kwargs) -> Run[Output]:
                 version_id = str(version)
             prediction = self._client.predictions.create(version=version_id, input=processed_inputs)
         else:
-            prediction = self._client.models.predictions.create(model=self._model, input=processed_inputs)
+            model = self._model
+            prediction = self._client.models.predictions.create(
+                model_owner=model.owner or "", model_name=model.name or "", input=processed_inputs
+            )
 
         return Run(
             client=self._client,
@@ -600,7 +603,7 @@ async def logs(self) -> Optional[str]:
         """
         Fetch and return the logs from the prediction asynchronously.
         """
-        self._prediction = await self._client.predictions.async_get(prediction_id=self._prediction.id)
+        self._prediction = await self._client.predictions.get(prediction_id=self._prediction.id)
 
         return self._prediction.logs
 
@@ -623,7 +626,7 @@ async def _async_output_iterator(self) -> AsyncIterator[Any]:
             import asyncio
 
             await asyncio.sleep(self._client.poll_interval)
-            self._prediction = await self._client.predictions.async_get(prediction_id=self._prediction.id)
+            self._prediction = await self._client.predictions.get(prediction_id=self._prediction.id)
 
         if self._prediction.status == "failed":
             raise ModelError(self._prediction)