genblaze-replicate 0.2.0__py3-none-any.whl

genblaze_replicate/__init__.py

@@ -0,0 +1,5 @@
+"""Replicate provider adapter for genblaze."""
+
+from genblaze_replicate.provider import ReplicateProvider
+
+__all__ = ["ReplicateProvider"]

genblaze_replicate/_errors.py

@@ -0,0 +1,21 @@
+"""Shared Replicate error mapping — used by provider.py."""
+
+from genblaze_core.models.enums import ProviderErrorCode
+
+
+def map_replicate_error(exc_or_msg: Exception | str) -> ProviderErrorCode:
+    """Map a Replicate API exception (or error string) to a ProviderErrorCode."""
+    msg = (str(exc_or_msg)).lower()
+    if "rate" in msg or "429" in msg:
+        return ProviderErrorCode.RATE_LIMIT
+    if "auth" in msg or "401" in msg or "403" in msg or "token" in msg:
+        return ProviderErrorCode.AUTH_FAILURE
+    if "invalid" in msg or "400" in msg or "validation" in msg:
+        return ProviderErrorCode.INVALID_INPUT
+    if "timeout" in msg or "timed out" in msg:
+        return ProviderErrorCode.TIMEOUT
+    if "model" in msg and ("not found" in msg or "error" in msg or "does not exist" in msg):
+        return ProviderErrorCode.MODEL_ERROR
+    if "500" in msg or "502" in msg or "503" in msg:
+        return ProviderErrorCode.SERVER_ERROR
+    return ProviderErrorCode.UNKNOWN

genblaze_replicate/provider.py

@@ -0,0 +1,202 @@
+"""ReplicateProvider — adapter for the Replicate API.
+
+Models are free-form strings (any Replicate model slug). Default pricing is
+compute-time-based (``predict_time`` × rate). Override per-model or wildcard::
+
+    from genblaze_replicate import ReplicateProvider
+    reg = ReplicateProvider.models_default().fork()
+    reg.register_pricing("owner/my-model", per_response_metric(...))
+    provider = ReplicateProvider(models=reg)
+"""
+
+from __future__ import annotations
+
+import mimetypes
+from typing import Any
+from urllib.parse import urlparse
+
+from genblaze_core.exceptions import ProviderError
+from genblaze_core.models.asset import Asset
+from genblaze_core.models.enums import Modality, ProviderErrorCode
+from genblaze_core.models.step import Step
+from genblaze_core.providers import (
+    BaseProvider,
+    ModelRegistry,
+    ModelSpec,
+    PricingContext,
+    ProviderCapabilities,
+    per_response_metric,
+    route_by_media_type,
+    validate_asset_url,
+)
+from genblaze_core.runnable.config import RunnableConfig
+
+from ._errors import map_replicate_error
+
+# Default per-second GPU-compute rate (Nvidia A40/T4 tier).
+_COST_PER_SEC = 0.000225
+
+
+def _compute_time_cost(ctx: PricingContext) -> float | None:
+    payload = ctx.provider_payload.get("replicate") if ctx.provider_payload else None
+    if not isinstance(payload, dict):
+        return None
+    predict_time = payload.get("predict_time")
+    if predict_time is None:
+        return None
+    try:
+        return float(predict_time) * _COST_PER_SEC
+    except (TypeError, ValueError):
+        return None
+
+
+# Replicate has no enumerable model list; fallback spec applies to every model.
+_FALLBACK_SPEC = ModelSpec(
+    model_id="*",
+    pricing=per_response_metric(_compute_time_cost),
+    input_mapping=route_by_media_type({"image": "image", "video": "video", "audio": "audio"}),
+)
+
+
+class ReplicateProvider(BaseProvider):
+    """Provider adapter for Replicate (replicate.com)."""
+
+    name = "replicate"
+
+    @classmethod
+    def create_registry(cls) -> ModelRegistry:
+        # No enumerable defaults — every model uses the fallback spec.
+        return ModelRegistry(defaults={}, fallback=_FALLBACK_SPEC)
+
+    def get_capabilities(self) -> ProviderCapabilities:
+        """Replicate: multi-modal generation depending on selected model."""
+        return ProviderCapabilities(
+            supported_modalities=[Modality.IMAGE, Modality.VIDEO, Modality.AUDIO],
+            supported_inputs=["text", "image", "video", "audio"],
+            accepts_chain_input=True,
+        )
+
+    def __init__(
+        self,
+        api_token: str | None = None,
+        poll_interval: float = 1.0,
+        http_timeout: float = 30.0,
+        *,
+        models: ModelRegistry | None = None,
+    ):
+        super().__init__(models=models)
+        self.poll_interval = poll_interval
+        self._client: Any = None
+        self._api_token = api_token
+        self._http_timeout = http_timeout
+
+    def _get_client(self):
+        if self._client is None:
+            try:
+                import httpx
+                import replicate
+
+                timeout = httpx.Timeout(self._http_timeout, connect=10.0)
+                if self._api_token:
+                    self._client = replicate.Client(
+                        api_token=self._api_token,  # noqa: S106
+                        timeout=timeout,
+                    )
+                else:
+                    self._client = replicate.Client(timeout=timeout)
+            except ImportError as exc:
+                raise ProviderError(
+                    "replicate package not installed. Run: pip install replicate"
+                ) from exc
+        return self._client
+
+    def submit(self, step: Step, config: RunnableConfig | None = None) -> Any:
+        client = self._get_client()
+        try:
+            input_params = self.prepare_payload(step)
+            prediction = client.predictions.create(
+                model=step.model,
+                input=input_params,
+            )
+            return prediction.id
+        except Exception as exc:
+            raise ProviderError(
+                f"Replicate submit failed: {exc}",
+                error_code=map_replicate_error(exc),
+            ) from exc
+
+    def poll(self, prediction_id: Any, config: RunnableConfig | None = None) -> bool:
+        client = self._get_client()
+        try:
+            prediction = client.predictions.get(prediction_id)
+            if prediction.status in ("succeeded", "failed", "canceled"):
+                self._cache_poll_result(prediction_id, prediction)
+                return True
+            return False
+        except Exception as exc:
+            raise ProviderError(
+                f"Replicate poll failed: {exc}",
+                error_code=map_replicate_error(exc),
+            ) from exc
+
+    def fetch_output(self, prediction_id: Any, step: Step) -> Step:
+        client = self._get_client()
+        try:
+            prediction = self._get_cached_poll_result(prediction_id)
+            if prediction is None:
+                prediction = client.predictions.get(prediction_id)
+
+            # Capture predict_time so registry pricing can read it.
+            metrics = getattr(prediction, "metrics", None)
+            predict_time = getattr(metrics, "predict_time", None) if metrics else None
+
+            step.provider_payload = {
+                "replicate": {
+                    "prediction_id": prediction.id,
+                    "model": prediction.model if hasattr(prediction, "model") else None,
+                    "version": prediction.version if hasattr(prediction, "version") else None,
+                    "status": prediction.status,
+                    "created_at": str(prediction.created_at)
+                    if hasattr(prediction, "created_at")
+                    else None,
+                    "predict_time": predict_time,
+                }
+            }
+
+            if prediction.status == "failed":
+                error_msg = prediction.error or "Unknown error"
+                raise ProviderError(
+                    error_msg,
+                    error_code=map_replicate_error(error_msg),
+                )
+
+            if prediction.status == "canceled":
+                raise ProviderError(
+                    "Prediction was canceled",
+                    error_code=ProviderErrorCode.UNKNOWN,
+                )
+
+            output = prediction.output
+            if isinstance(output, str):
+                output = [output]
+            elif output is None:
+                output = []
+
+            for url in output:
+                url_str = str(url)
+                validate_asset_url(url_str)
+                path = urlparse(url_str).path
+                mime, _ = mimetypes.guess_type(path)
+                if mime is None:
+                    mime = f"{step.modality.value}/octet-stream"
+                step.assets.append(Asset(url=url_str, media_type=mime))
+
+            self._apply_registry_pricing(step)
+            return step
+        except ProviderError:
+            raise
+        except Exception as exc:
+            raise ProviderError(
+                f"Replicate fetch_output failed: {exc}",
+                error_code=map_replicate_error(exc),
+            ) from exc

genblaze_replicate-0.2.0.dist-info/METADATA

@@ -0,0 +1,128 @@
+Metadata-Version: 2.4
+Name: genblaze-replicate
+Version: 0.2.0
+Summary: Replicate provider adapter for genblaze
+Project-URL: Documentation, https://github.com/backblaze-labs/genblaze
+Project-URL: Repository, https://github.com/backblaze-labs/genblaze
+Project-URL: Issues, https://github.com/backblaze-labs/genblaze/issues
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: genblaze-core<0.3,>=0.2.0
+Requires-Dist: replicate>=0.25
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+<!-- last_verified: 2026-04-22 -->
+# genblaze-replicate
+
+**[Replicate](https://replicate.com) provider adapter for [genblaze](https://github.com/backblaze-labs/genblaze) — run any Replicate-hosted image, video, or audio model through a unified AI pipeline with SHA-256 provenance.**
+
+`genblaze-replicate` wraps Replicate's hosted model catalog (FLUX, SDXL, Stable Diffusion, video models, music models — anything on Replicate) as a genblaze provider. Compose Replicate calls into multi-step pipelines, persist outputs to [Backblaze B2](https://www.backblaze.com/cloud-storage?utm_source=github&utm_medium=referral&utm_campaign=ai_artifacts&utm_content=genblaze) or any S3-compatible store, and emit a tamper-evident provenance manifest for every run.
+
+## Why genblaze-replicate
+
+- **Any Replicate model, one API** — Pass the `owner/model` slug; genblaze handles submission, polling, asset download, and manifest capture.
+- **Provenance by default** — SHA-256 hash of every output, canonical manifest with prompt + params + timestamps.
+- **Composable** — Chain Replicate outputs into downstream steps (image → video, upscale, transcode).
+- **Production-ready** — Timeouts, retries, moderation hooks, step caching, OpenTelemetry tracing.
+- **Durable storage** — Drop the `genblaze-s3` sink in for B2/S3/R2/MinIO persistence of assets + manifests.
+
+## Models
+
+Supports any model hosted on Replicate — including:
+
+- **Image** — `black-forest-labs/flux-schnell`, `black-forest-labs/flux-dev`, `stability-ai/sdxl`, `stability-ai/stable-diffusion-3`
+- **Video** — text-to-video and image-to-video models on Replicate
+- **Audio** — music and speech models on Replicate
+
+Use the full `owner/model` slug from https://replicate.com/explore.
+
+## Install
+
+```bash
+pip install genblaze-replicate
+```
+
+Registers the `replicate` provider via entry points; [`genblaze-core`](https://pypi.org/project/genblaze-core/) discovers it automatically.
+
+## Quickstart — FLUX Schnell (text-to-image)
+
+```bash
+pip install genblaze-core genblaze-replicate
+export REPLICATE_API_TOKEN="r8_..."
+```
+
+```python
+from genblaze_core import Modality, Pipeline
+from genblaze_replicate import ReplicateProvider
+
+run, manifest = (
+    Pipeline("flux-demo")
+    .step(
+        ReplicateProvider(),
+        model="black-forest-labs/flux-schnell",
+        prompt="a photorealistic golden retriever puppy in a field of wildflowers, "
+               "golden hour, shallow depth of field",
+        modality=Modality.IMAGE,
+        num_outputs=1,
+        aspect_ratio="1:1",
+    )
+    .run()
+)
+
+print(run.steps[0].assets[0].url)
+print(manifest.canonical_hash)
+assert manifest.verify()
+```
+
+## Quickstart — persist to Backblaze B2
+
+```bash
+pip install genblaze-core genblaze-replicate genblaze-s3
+export REPLICATE_API_TOKEN="r8_..."
+export B2_KEY_ID="..."  B2_APP_KEY="..."
+```
+
+```python
+from genblaze_core import KeyStrategy, ObjectStorageSink, Pipeline
+from genblaze_replicate import ReplicateProvider
+from genblaze_s3 import S3StorageBackend
+
+storage = ObjectStorageSink(
+    S3StorageBackend.for_backblaze("my-bucket"),
+    key_strategy=KeyStrategy.CONTENT_ADDRESSABLE,
+)
+
+result = (
+    Pipeline("flux-b2")
+    .step(ReplicateProvider(), model="black-forest-labs/flux-schnell",
+          prompt="cyberpunk tokyo street at night, neon reflections on wet pavement")
+    .run(sink=storage, timeout=120)
+)
+
+print(result.run.steps[0].assets[0].url)   # durable B2 URL
+```
+
+## Credentials
+
+| Env var | Where to get it |
+|---|---|
+| `REPLICATE_API_TOKEN` | https://replicate.com/account/api-tokens |
+
+## Documentation
+
+- **Main repo**: https://github.com/backblaze-labs/genblaze
+- **Runnable example**: [`replicate_flux_pipeline.py`](https://github.com/backblaze-labs/genblaze/blob/main/examples/replicate_flux_pipeline.py)
+
+## Related packages
+
+- [`genblaze-core`](https://pypi.org/project/genblaze-core/) — the pipeline SDK
+- [`genblaze-s3`](https://pypi.org/project/genblaze-s3/) — durable storage on [Backblaze B2](https://www.backblaze.com/cloud-storage?utm_source=github&utm_medium=referral&utm_campaign=ai_artifacts&utm_content=genblaze) and other S3-compatible backends
+
+## License
+
+MIT

genblaze_replicate-0.2.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+genblaze_replicate/__init__.py,sha256=Z_DPw0bY5RwVIM-dQotVAqYBjsDZ4hTK0NxPR4RXjoE,139
+genblaze_replicate/_errors.py,sha256=FIzMWCKlFVGW1xZ8wwEpqKbtKxyQC-mnka_dV3kqq2g,988
+genblaze_replicate/provider.py,sha256=IRfhiO99O9SI-m7odbY0beiiqFfEcaShPyaXPfFdXx4,7242
+genblaze_replicate/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+genblaze_replicate-0.2.0.dist-info/METADATA,sha256=mQFaJhdwu4UNEcA_LygBKddQntSY3eUTrfvefqGkMpw,4846
+genblaze_replicate-0.2.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+genblaze_replicate-0.2.0.dist-info/entry_points.txt,sha256=_7zgMbb_050SVJbdqCV0ApUVpqMDIWEtJ_074uYvC9g,70
+genblaze_replicate-0.2.0.dist-info/RECORD,,

genblaze_replicate-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

genblaze_replicate-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[genblaze.providers]
+replicate = genblaze_replicate:ReplicateProvider