Skip to main content

Rendobar

Rendobar Python SDK

The official Python client for Rendobar's media processing and AI generation API.
pip install rendobar

Docs  ·  Guide  ·  API reference  ·  PyPI  ·  Get an API key  ·  Discord

PyPI version Python versions License

The official Python client for Rendobar's media processing and AI generation API. With the rendobar package you submit a job, wait for it, and get back a hosted file URL. It has sync and asyncio clients with full types, retries rate limits, server errors and failed connections on its own, and never turns a retried submit into a second job.

It covers the same resources as @rendobar/sdk: jobs, uploads and assets, webhook endpoints, connected storage, API keys, organizations, billing, compose, notifications, the account and realtime events. See What the client covers.

Install

pip install rendobar

Python 3.10 or newer. For realtime events, install the realtime extra: pip install "rendobar[realtime]".

Quickstart

from rendobar import Rendobar

with Rendobar() as rb:  # reads RENDOBAR_API_KEY, or pass Rendobar("rb_...")
    job = rb.jobs.run({
        "type": "ffmpeg",
        "params": {"command": "ffmpeg -i https://cdn.rendobar.com/assets/examples/sample.mp4 -vf scale=1280:-2 out.mp4"},
    })
print(job.output.files[0].url)

jobs.run() submits the job and waits for it. Use jobs.create() and jobs.wait() to do the two steps yourself, and rb.jobs.types() to list every live job type.

The job is a dict typed per job type. Pyright, mypy and your editor know each type's params, so a misspelt or missing param, a wrong value type or an unknown job type fails the type check before anything runs.

The with block closes the client's connections when it ends. A long-lived client (one per app) can skip it and call rb.close() at shutdown.

asyncio

import asyncio

from rendobar import AsyncRendobar


async def main() -> None:
    async with AsyncRendobar() as rb:
        job = await rb.jobs.run({"type": "ffprobe", "params": {"command": "https://cdn.rendobar.com/assets/examples/sample.mp4"}})
        print(job.output.data)


asyncio.run(main())

AsyncRendobar takes the same arguments and has the same methods as Rendobar, awaited. await rb.aclose() does the same as the async with block for a client you keep open. A call on a closed client raises RendobarError with code CLIENT_CLOSED.

Let your AI assistant do it

Paste this one line into Claude, ChatGPT, or Cursor and the assistant reads the integration playbook and wires Rendobar into your codebase. Your API key stays in your env file, never in the chat.

Add Rendobar to my app: read and follow https://rendobar.com/prompts/integrate.md

Submitting a job

The first argument of jobs.create() and jobs.run() says what to run: type, params and, for job types that read files, inputs. Everything about how to run it is a keyword argument, listed under Job options. A submit option inside the job dict is a type error. Enum params are closed sets, so a value the job type does not take ("compute": "tpu") fails the check too.

Each input is a URL, {"url": ...}, {"content": ...} for inline text such as subtitles, {"job": "job_..."} for another job's output, or a list of those for an input that takes several, such as the images of image.edit (JobInput).

A job dict written inline is checked where you pass it. One built in a variable first needs the annotation, or the checker infers a plain dict: job: SubmitJob = {"type": "ffprobe", "params": {"command": url}}.

from rendobar import Rendobar, UntypedJob

rb = Rendobar()
rb.jobs.create({"type": "ffprobe", "params": {"command": "https://cdn.rendobar.com/assets/examples/sample.mp4"}}, label="probe")

# A job type newer than your SDK version: UntypedJob is the one way to submit it.
# It skips the type check, so the API is the first to see a mistake.
rb.jobs.create(UntypedJob("your.new_job_type", {"option": "value"}))

"your.new_job_type" is a placeholder. It stands for a job type newer than your SDK version, one that rb.jobs.types() lists and the SDK has no typed dict for yet.

UntypedJob covers two cases: a job type newer than your installed SDK, and compose. Compose params nest timelines, tracks and effects that the spec does not name one by one, so the SDK leaves them untyped rather than ship generated names that change with every spec revision. rb.jobs.schema("compose") describes them, and the API validates every compose submit.

rb.jobs.schema(type) describes any job type's params at run time. The typed dicts come from the API spec, so a new job type gets its own type in the next release of this SDK.

Job options

jobs.run() takes every option of jobs.create() and jobs.wait(). All of them are keyword arguments except job.

Option Method What it does
job create, run What to run: a job dict typed per job type, or an UntypedJob. See Submitting a job.
idempotency_key create, run Makes the submit safe to repeat. See Retries and idempotency.
label create, run A short name for the job, shown in the dashboard and returned as job.label.
destinations create, run Where to deliver the output, as a list of storage://<id>[/<folder or path>].
callback create, run A URL Rendobar POSTs the job to when it ends: {"url": ..., "headers": {...}, "verify": True}.
force_async create, run Queue the job even when its type can finish during the request.
timeout wait, run Seconds to wait before WaitTimeoutError. Default described below.
interval wait, run Seconds before the second poll (default 2). Each later pause is 1.5 times longer.
max_interval wait, run The longest pause between polls, in seconds (default 10).
on_progress wait, run Called with the job after every poll.
throw_on_failure wait, run Raise JobFailedError when the job fails or is cancelled. Default True for run(), False for wait(), which then returns the failed job.

jobs.wait() with no timeout allows five minutes. Once the job reports its own execution budget (your plan's per-job limit), the wait extends to that budget plus two minutes, counted from the poll that saw it, so a long job is not cut off while it runs. Pass timeout= for a fixed bound.

Results

Every method returns a typed result, so your editor completes fields and your type checker flags a misspelled one.

Call Returns
jobs.run() JobComplete (with throw_on_failure=False: JobComplete, JobFailed or JobCancelled)
jobs.wait() JobComplete, JobFailed, JobCancelled, or an UnknownJob that ended with a status newer than the SDK (with throw_on_failure=True: JobComplete)
jobs.create() JobCreated, JobCompletedOnSubmit for a job that finished during the request, or JobReplayed when the idempotency key was used before
jobs.get(), jobs.list(), jobs.list_all() Job: one of JobWaiting, JobDispatched, JobRunning, JobComplete, JobFailed, JobCancelled, or an UnknownJob for a status newer than the SDK
jobs.cancel() JobCancellation (id and status)
jobs.types(), jobs.schema() a list of JobType, a JobTypeSchema
jobs.logs(), jobs.get_timings(), jobs.stats() a list of JobLogEntry, JobTimings, JobStats
account.capabilities() AccountCapabilities (plan, limits, features)
any other resource the model its method names, such as Asset, WebhookEndpoint, StorageConnection, OrgSettings or BillingState. One resource is one class, whichever method returned it

A response field the SDK does not know is kept in model_extra, and an enum value newer than your SDK (a new delivery status, a new storage check) arrives as a plain string, so a newer API never breaks a parse. Enums you pass are closed sets: a value the API does not take fails the type check.

Only a JobComplete has output, and only a JobFailed has error. Check which one you have with isinstance:

from rendobar import JobComplete, JobFailed, Rendobar

rb = Rendobar()
job = rb.jobs.get("job_abc123")
if isinstance(job, JobComplete):
    print(job.output.files[0].url)
elif isinstance(job, JobFailed):
    print(job.error.code, job.error.message)

The models are generated from the API spec. Most are named components there, such as JobCreated, JobCost, JobOutput, OutputFile, JobStep, JobDelivery, JobError and FfprobeResult, and your editor shows those names. The six job variants are the exception: the generator inlines them into the Job union. isinstance(), annotations, type(job).__name__ and repr(job) use their public names, but hovers and pyright's messages show the generated one, such as Job_Complete for JobComplete.

Counts, bytes, nanodollars and Unix-millisecond timestamps are int.

A job type with a typed result reads it with output_data(). Today that is ffprobe, with FfprobeResult:

from rendobar import FfprobeResult, Rendobar, output_data

rb = Rendobar()
probe = rb.jobs.run({"type": "ffprobe", "params": {"command": "https://cdn.rendobar.com/assets/examples/sample.mp4"}})
result = output_data(probe, FfprobeResult)
if result.summary is not None:
    print(result.summary)

result.summary is one of FfprobeVideoSummary, FfprobeAudioSummary, FfprobeImageSummary or FfprobeOtherSummary, by its kind. A kind newer than your SDK leaves summary as None and keeps the value in result.model_extra["unknown_summary"], so the rest of the result stays typed. output_data() raises ResponseValidationError only when the data is not that shape at all. Each job type the spec gives a result type gets one the same way.

Free-form values the API does not describe, such as job.params and job.output.data, are typed object, so your type checker asks you to narrow them before use.

jobs.list() takes status as one of the six job statuses (JobStatus), type, limit (1 or more), offset (0 or more), sort ("created", "duration", "cost"), order, client (such as "python") and from_/to (Unix milliseconds). jobs.list_all() takes the same filters.

job.cost is None until billing settles, which can be a moment after the job completes. Its amount is in nanodollars (1 USD = 1,000,000,000), and formatted has the same amount as dollars, such as "$0.0021":

from rendobar import JobComplete, Rendobar

rb = Rendobar()
job = rb.jobs.get("job_abc123")
if isinstance(job, JobComplete) and job.cost is not None:
    print(job.cost.formatted)

jobs.download(job_id, to) streams a completed job's output file to a path or to a binary file you opened, and returns the bytes written. It never holds the file in memory. A connection that breaks mid-file raises at once rather than retrying, and a file the call created is removed.

A job whose status is newer than your installed SDK comes back as UnknownJob with id, status and raw, rather than raising. That holds for every call that returns jobs (get, list, list_all, create, cancel, wait): in a list, only the job with the new status is an UnknownJob, the rest of the page is typed as usual. Every job says whether it has ended (terminal), so jobs.wait() also stops on a status it does not know when that job is terminal, and returns it as an UnknownJob. jobs.run() raises JobFailedError (code JOB_ENDED) for it, since only JobComplete counts as success. A status that is not terminal is polled until the timeout.

What the client covers

Each resource is an attribute of the client, with the same names as @rendobar/sdk in snake case. AsyncRendobar has the same resources and methods, awaited.

Resource Methods
jobs create, run, wait, get, list, list_all, cancel, download, logs, get_timings, stats, retry_deliveries, types, schema
uploads create
assets list, get, delete, download, templates
webhooks create, list, get, update, delete, rotate_secret, test, list_deliveries, retry_delivery
storage create, list, get, update, delete, test, stats, list_objects, prepare_aws, list_account_buckets, look_up_s3_bucket, start_supabase, list_supabase_projects, list_supabase_buckets, finish_supabase
api_keys create, list, revoke, update
orgs list, current, create, update, delete, get_settings, update_settings, members.invite, members.change_role, members.remove, invitations.revoke
billing state, usage, usage_by_client, transactions, history, checkout_credits, checkout_plan, cancel_subscription, reactivate_subscription, cancel_credit_schedule, payment_methods, delete_payment_method, set_default_payment_method, portal_url
compose effects, engine_effects, validate
notifications list, mark_read
account capabilities
realtime connect, subscribe_job (the realtime extra, see Realtime events)

The first argument of a method is the id it acts on, when it has one. Everything else is a keyword argument, so a new option never breaks a call you wrote. An argument left out, or passed as None, is not sent.

A list comes back as a Page: iterate it, or read data (the items) and meta (the totals the API reports, such as total). A list the API does not page, such as api_keys.list(), is a plain list.

from rendobar import Rendobar

rb = Rendobar()
page = rb.webhooks.list_deliveries(status="failed", limit=20)
print(page.meta.total, [delivery.event for delivery in page])
for key in rb.api_keys.list():
    print(key.prefix, key.scopes)

Billing amounts (billing.state().balance.amount, transactions, invoices) are US dollars, as the API sends them. Job costs are integer nanodollars (see Results).

Uploads and assets

uploads.create() sends a local file (a path, or bytes with a filename) straight to storage on presigned URLs and returns the ready Asset. A large file goes up in parts, in parallel, and a file on disk is streamed, never read into memory whole. A job reads the asset as asset://<id>:

from rendobar import Rendobar


def trim(rb: Rendobar, path: str) -> str:
    asset = rb.uploads.create(path, content_type="video/mp4", on_progress=lambda p: print(p.loaded, "of", p.total))
    job = rb.jobs.run({
        "type": "ffmpeg",
        "inputs": {"clip.mp4": f"asset://{asset.id}"},
        "params": {"command": "ffmpeg -i clip.mp4 -t 5 out.mp4"},
    })
    rb.assets.delete(asset.id)
    return job.output.files[0].url

An upload is ephemeral unless you pass persist=True: it expires on its own after 24 hours. A PUT to storage that fails is tried three times, then raises RendobarError with code UPLOAD_FAILED.

Webhook endpoints

webhooks.create() returns a WebhookEndpointWithSecret. Its signing_secret is in plaintext only there and in rotate_secret(), so store it then. webhooks.test() sends a test event and reports whether your URL answered with a 2xx. To read a delivery your server receives, use rendobar.webhooks.parse() (Webhooks).

from rendobar import Rendobar

rb = Rendobar()
endpoint = rb.webhooks.create(name="prod", url="https://example.com/rendobar-webhook", subscribed_events=["job.completed", "job.failed"])
print(endpoint.signing_secret)  # put it in your server's RENDOBAR_WEBHOOK_SECRET
print(rb.webhooks.test(endpoint.id).delivered)
rb.webhooks.delete(endpoint.id)

Creating an API key needs the keys:write scope, which no API key holds. With an API key, api_keys.create() raises PermissionDeniedError with code INSUFFICIENT_SCOPE. An OAuth access token or a dashboard session can create one.

Errors

from rendobar import NotFoundError, Rendobar, RendobarError

rb = Rendobar()
try:
    rb.jobs.get("job_missing")
except NotFoundError as err:
    print(err.code)        # "NOT_FOUND"
except RendobarError as err:
    print(err.status_code, err.code, err.request_id)  # quote request_id to support

Everything the SDK raises is a RendobarError with a code:

Error When
BadRequestError, AuthenticationError, InsufficientCreditsError, PermissionDeniedError, NotFoundError, ConflictError, RateLimitError, InternalServerError the API answered 400, 401, 402, 403, 404, 409, 429 or 5xx. status_code and request_id are set
AuthenticationError with code MISSING_API_KEY or INVALID_API_KEY the client has no API key, or one that does not start with rb_. Raised before any request, so status_code is None
InvalidArgumentError (also a ValueError) an argument the SDK refuses before any request: a job id that is not one path segment ("../x"), limit below 1, a negative offset, an invalid app name
APIConnectionError no response: the connection failed or dropped
APITimeoutError (an APIConnectionError) the request took longer than the client's timeout
ResponseValidationError a response this SDK version cannot read, such as a success body that is not JSON (body holds it)
RendobarError with code CLIENT_CLOSED a call on a client after close() or aclose()
JobFailedError jobs.run(), or jobs.wait(throw_on_failure=True), saw the job fail or be cancelled. code is the job's own error code and job the job
WaitTimeoutError jobs.wait() gave up. The job may still finish. job_id, last_status and job (the last job read) are set
WebhookSignatureError rendobar.webhooks.parse() got a delivery that is not signed with your secret, or is stale

code is one of the codes in ErrorCode or, from a newer API, any other string, so compare it with strings rather than matching every case.

A refusal that lists what is wrong has problems: each one's path (such as ("command",)), message and, on a plan refusal, upgrade_to (the plan that allows it). details holds the same list, or a mapping of other facts such as the jobId of a conflict.

from rendobar import BadRequestError, Rendobar

rb = Rendobar()
try:
    rb.jobs.create({"type": "ffmpeg", "params": {"command": "ffmpeg -i https://example.com/missing.mp4 out.mp4"}})
except BadRequestError as err:
    for problem in err.problems:
        print(".".join(map(str, problem.path)), problem.message)

Retries and idempotency

Only 429, 500, 502, 503, 504 and a connection that could not be made are retried, twice by default (max_retries). A 5xx is retried only for a request that is safe to repeat: a read, a keyed job submit, a cancel. A write such as webhooks.create() or billing.checkout_credits() may have taken effect before the 5xx, so it raises at once rather than run twice. The client honours Retry-After (seconds or an HTTP date) up to 60 seconds, and a longer one raises the error with retry_after set. Without one, it backs off exponentially from half a second, with jitter. A retry that would sleep past the end of a jobs.wait() raises instead. Everything else raises at once: a 409 conflict, a 501, any other 4xx, and a request that timed out after reaching the API.

Retrying a submit never creates a second job. With no idempotency_key, jobs.create() generates one for that call and sends it on every retry, so the API returns the job the first attempt created. Pass your own key, such as an order id, to make separate calls safe to repeat. A repeat with the same key and the same params returns the first job as a JobReplayed. A repeat with the same key and different params raises ConflictError (409, code CONFLICT). Keys never expire.

When a submit fails in a way that may still have created the job (no answer, a timeout, or a 429 or 5xx after the last retry), the error's idempotency_key holds the key that was sent. Submit again with it to get that job, not a second one. generate_idempotency_key() makes keys of the same kind for your own use.

Webhooks

import os
from typing import Mapping

from rendobar import WebhookSignatureError
from rendobar.webhooks import JobCompletedWebhookEvent, JobFailedWebhookEvent, parse


def handle_rendobar_webhook(raw_body: bytes, headers: Mapping[str, str]) -> int:
    try:
        event = parse(raw_body, headers, os.environ["RENDOBAR_WEBHOOK_SECRET"])
    except WebhookSignatureError:
        return 401
    if isinstance(event, JobCompletedWebhookEvent):
        print(event.data.job_id, [file.url for file in event.data.output.files])
    elif isinstance(event, JobFailedWebhookEvent):
        print(event.data.job_id, event.data.error.code)
    return 200  # acknowledge every genuine delivery, including events you do not handle

parse() checks the signature, then returns the event typed by its name: JobCreatedWebhookEvent, JobStartedWebhookEvent, JobCompletedWebhookEvent, JobFailedWebhookEvent, JobCancelledWebhookEvent, JobDeliverySucceededWebhookEvent, JobDeliveryFailedWebhookEvent, JobDeliveriesSettledWebhookEvent, BalanceLowWebhookEvent, BalanceDepletedWebhookEvent or TestWebhookEvent. An event, or an envelope version, that your SDK does not know comes back as UnknownWebhookEvent with the body in raw and a reason (unknown_event, unknown_version or invalid_payload), never as an exception, so a new event cannot break your handler. verify() is the signature check alone, as a bool, if you read the body yourself.

Pass the raw body exactly as received. Parsing and re-serialising the JSON first changes the bytes, and the signature no longer matches. An empty secret never verifies, so read it with os.environ["RENDOBAR_WEBHOOK_SECRET"] and let a missing one fail at startup.

Rendobar signs each delivery with these headers:

Header Value
X-Rendobar-Timestamp when Rendobar sent it, in Unix seconds
X-Rendobar-Signature sha256= and the hex HMAC-SHA256 of "<timestamp>.<raw body>", keyed with your webhook secret. A signature without the sha256= prefix does not verify
X-Rendobar-Signature-Previous during a secret rotation, the same signature made with the previous secret

verify() recomputes the signature and compares it in constant time. It accepts either signature header, so a receiver holding the old or the new secret verifies during a rotation. It rejects a timestamp more than 300 seconds from now (tolerance_seconds) and a blank secret. A per-job callback sent with "verify": True carries the same headers, signed with your callback signing secret.

Realtime events

rb.realtime streams a workspace's events over a WebSocket as they happen. It needs the realtime extra:

pip install "rendobar[realtime]"

subscribe_job() follows one job and stops after its final status:

from rendobar import Rendobar, realtime


def follow(rb: Rendobar, job_id: str) -> None:
    for event in rb.realtime.subscribe_job(job_id, timeout=600):
        if isinstance(event, realtime.JobProgress):
            print(event.phase, event.progress)  # progress is 0 to 1, or None when it cannot be told
        elif isinstance(event, realtime.JobLog):
            print(event.level, event.message)
        elif isinstance(event, realtime.JobStatusChanged):
            print("status", event.status, event.final)
        # anything else: another event, or realtime.UnknownRealtimeEvent for one newer than this SDK

It yields realtime.Connected, then the job's progress, steps, logs, resources, previews, status and result, replayed ones first. A job that already ended stops after its replayed status. A job the workspace does not have raises NotFoundError. With timeout (seconds), a job that has not ended by then raises RendobarError with code WAIT_TIMEOUT.

connect() streams every event of the workspace, such as realtime.BalanceUpdated and realtime.Notification, until you stop iterating. It yields realtime.Connected on each connection, the events the workspace kept, realtime.ReplayDone, then live events.

Both reconnect with backoff (1 second, growing to 30) and resume after the last event they yielded, so you never see one twice. To resume in a later process, store the event_id of the last event you handled and pass it as connect(last_event_id=...). realtime.Resync says events were lost: read your state again. A message this SDK cannot read, a type newer than it or a known type whose fields changed shape, comes back as realtime.UnknownRealtimeEvent with the message in raw, never as an exception. A refusal no reconnect fixes, such as a revoked key (401) or one without the jobs:read scope (403), raises its error. The key travels in the Authorization header, never in the URL.

On AsyncRendobar the same methods return async generators: async for event in rb.realtime.subscribe_job(job_id). To close a stream before it ends, break out of the loop and drop it, or wrap it in contextlib.closing (contextlib.aclosing for async) to close it at a known point.

Without the extra, both methods raise ImportError naming it. The rest of the SDK, and the event types in rendobar.realtime, work without it.

AI agents

Give an agent Rendobar's four tools: list_job_types, run_job, get_job and probe_media. They match the Rendobar MCP server's tools, and run_job is the MCP server's submit_job followed by a wait. Failures come back to the model as data ({"error": {"code", "message", "request_id"}}), so one bad call does not end the run. Once a job exists, a failure while waiting returns its id and tells the model to call get_job, so a dropped connection never leads to a second billed job.

pip install "rendobar[langchain]"
from langchain.agents import create_agent
from langchain_core.language_models import BaseChatModel
from rendobar.agents.langchain import rendobar_tools


def build_agent(model: BaseChatModel):  # model: any LangChain chat model
    return create_agent(model, tools=rendobar_tools())
pip install "rendobar[crewai]"
from crewai import Agent
from rendobar.agents.crewai import rendobar_tools


def video_editor() -> Agent:
    return Agent(role="Video editor", goal="Cut and caption clips", backstory="Edits for social", tools=rendobar_tools())

With no argument, rendobar_tools() builds a client that reads RENDOBAR_API_KEY and talks to https://api.rendobar.com. Pass your own client to choose the key, the server or any other client option:

from rendobar import Rendobar
from rendobar.agents.langchain import rendobar_tools

tools = rendobar_tools(Rendobar(api_key="rb_...", base_url="https://api.staging.example.com"))

The crewai extra installs CrewAI itself, which brings about 120 packages and takes a few minutes. The langchain extra installs LangChain and LangGraph.

Frameworks that speak MCP (the OpenAI Agents SDK, the Claude Agent SDK) can connect to https://api.rendobar.com/mcp with no package.

Client options

from rendobar import Rendobar

rb = Rendobar(
    api_key="rb_...",                  # default: the RENDOBAR_API_KEY environment variable
    base_url="https://api.rendobar.com",
    timeout=30.0,                      # seconds per HTTP request
    max_retries=2,                     # retries of a 429, a 5xx or a failed connection
    app="my-app",                      # sent in X-Rendobar-Client, so your jobs show where they came from
    on_deprecation=print,              # called once per deprecated endpoint, see Versioning and support
)

base_url points the client at another server, such as a staging deployment or a local mock: Rendobar(base_url="https://api.staging.example.com").

With no key passed and no RENDOBAR_API_KEY set (or an empty one), the client still works for jobs.types() and jobs.schema(), which need no key. Every other call raises AuthenticationError with code MISSING_API_KEY before it sends anything. A key that does not start with rb_ gets code INVALID_API_KEY the same way, and the client never sends it.

Examples

examples/ has small projects that use the SDK end to end. CI runs all of them against the conformance mock.

  • quickstart: probe a public video and print its duration, resolution and codecs.
  • upload-process-download: upload a clip, trim it with ffmpeg and stream the output back to disk.
  • batch-worker: submit with idempotency keys, read logs, page through jobs and handle each error.
  • webhook-receiver: manage a real webhook endpoint and verify the deliveries it receives.
  • account-admin: read billing, usage, API keys, org settings and notifications.
  • realtime-progress: follow a job live over the event stream.
  • fastapi_app.py: a FastAPI app that submits a job and verifies Rendobar's webhook.
  • django_views.py: the same submit and webhook as Django views.

Other Rendobar SDKs

Versioning and support

  • Semantic versioning. Before 1.0, a minor release may tighten types, so code that type-checked before can fail the check after it. The changelog says so when one does.
  • A deprecation is announced before anything is removed. See rendobar.com/docs/support/versioning and the changelog.
  • Python 3.10 to 3.13, tested on each. A Python version is dropped only after its end of life.
  • A deprecated endpoint is reported once per endpoint through on_deprecation or a RendobarDeprecationWarning (a FutureWarning, so Python shows it by default), with the day it was deprecated.

License

MIT. See LICENSE. Rendobar is a product of Craftobar LLC.

Metadata

Release files for rendobar 0.1.0

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for rendobar 0.1.0
File Size Uploaded Provenance Actions
rendobar-0.1.0.tar.gz 891.1 kB With provenance Details for rendobar-0.1.0.tar.gz

Built distribution (wheel)

Table of built distributions (wheels) for rendobar 0.1.0
File Interpreter ABI Platform Actions
rendobar-0.1.0-py3-none-any.whl Python 3 none any Details for rendobar-0.1.0-py3-none-any.whl

Total release size: 1.9 MB

Release files / rendobar-0.1.0.tar.gz

Download URL rendobar-0.1.0.tar.gz
Size 891.1 kB
Tags Source
SHA-256 checksum
How to use checksums
1fb3a20c5efdf2a6ac336add359a47f20f42dcd766a7676a39a7c1676a4b91b5
BLAKE2b-256 checksum
How to use checksums
d7bd65e5bea3acbae386b1722961b8c6eca833f8ce5038ccc98e5dda8c167b1f
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 22, 2026.

Transparency log

Release files / rendobar-0.1.0-py3-none-any.whl

Download URL rendobar-0.1.0-py3-none-any.whl
Size 1.0 MB
Tags Python 3
SHA-256 checksum
How to use checksums
c973df0115e72df772824f05ab7f35a93ec795a23aad91cc8809f0b1dd4ab57b
BLAKE2b-256 checksum
How to use checksums
b8ab6171b455091bd9bbb444b579cd8258abbdd151ba6cc08f33595fb89b2c11
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 22, 2026.

Transparency log

Security for rendobar 0.1.0

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

Full provenance

Both files in this release have been uploaded with provenance metadata.

Select from 2 files

Attestation for rendobar-0.1.0.tar.gz

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 22, 2026.

Transparency log

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Release history Release notifications | RSS feed

This release

0.1.0 This release

2 release files Full provenance

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page