➜  opper usage list --fields=total_tokens
Usage Events:

Time Bucket: 2024-12-03T00:00:00Z
Cost: 0.029731
Count: 25
total_tokens: 4806

Time Bucket: 2024-12-04T00:00:00Z
Cost: 0.025908
Count: 13
total_tokens: 4155

Time Bucket: 2024-12-06T00:00:00Z
Cost: 0.017290
Count: 7
total_tokens: 2689

➜  opper usage                           
Manage usage information

Usage:
  opper usage [command]

Examples:
  # List usage information
  opper usage list

  # List usage with time range and granularity
  opper usage list --from-date=2024-01-01T00:00:00Z --to-date=2024-12-31T23:59:59Z --granularity=day

  # List usage with specific fields and grouping
  opper usage list --fields=completion_tokens,total_tokens --group-by=model,project.name

  # Show count over time as ASCII graph (default)
  opper usage list --graph

  # Show cost over time as ASCII graph
  opper usage list --graph=cost

  # Show count over time by model
  opper usage list --group-by model --graph

  # Export usage as CSV
  opper usage list --out csv

opper.call(
    name="my-function",
    input="Hello, world!",
    tags={"customer": "mycustomer"},
)

➜  opper usage list --fields=total_tokens --group-by=customer 
Usage Events:

Time Bucket: 2024-12-06T00:00:00Z
Cost: 0.025908
Count: 13
customer: <nil>
total_tokens: 4155

Time Bucket: 2024-12-06T00:00:00Z
Cost: 0.000007
Count: 1
customer: mycustomer
total_tokens: 23

opper models create example/my-gpt4 azure/gpt4-production my-api-key-here '{"api_base": "https://my-gpt4-deployment.openai.azure.com/", "api_version": "2024-06-01"}'

from opperai import Opper
opper = Opper()
response, _ = opper.call(
    name="GetFirstWeekday",
    input="Today is Tuesday, yesterday was Monday",
    instructions="Extract the first weekday mentioned in the text",
    model="azure/gpt-4o-eu",
    fallback_models=["openai/gpt-4o"],
)
print(response)

from opperai import AsyncOpper
import asyncio
opper = AsyncOpper()
async def main():
    response, _ = await opper.call(
        name="GetFirstWeekday",
        input="Today is Tuesday, yesterday was Monday",
        instructions="Extract the first weekday mentioned in the text",
        model="azure/gpt-4o-eu",
        fallback_models=["openai/gpt-4o"],
    )
    print(response)
if __name__ == "__main__":
    asyncio.run(main())

import OpperAI from 'opperai';
import fs from "fs";
import path from "path";
import os from "os";

async function testCallFallback() {
    // Replace 'your-api-key' with your actual OpperAI API key
    const client = new OpperAI({ apiKey: 'your-api-key' });

    const { message, span_id } = await client.call({
        name: "GetFirstWeekday",
        input: "Today is Tuesday, yesterday was Monday",
        instructions: "Extract the first weekday mentioned in the text",
        model: "azure/gpt-4o-eu",
        fallback_models: ["openai/gpt-4o"],
    });

    console.log(message);
}

testCallFallback();

import asyncio
from opperai import AsyncOpper

async def haiku():
    aopper = AsyncOpper()
    res, _ = await aopper.call(
        model="anthropic/claude-3.5-haiku",
        name="new-haiku-3-5",
        instructions="answer the following question",
        input="what are some uses of 42",
    )
    print(res)


asyncio.run(haiku())

import asyncio
from opperai import AsyncOpper

async def stream():
    aopper = AsyncOpper()
    res = await aopper.call(
        model="anthropic/claude-3.5-sonnet",
        input="what are some uses of 42",
        stream=True,
    )
    async for chunk in res.deltas:
        print(chunk)

asyncio.run(stream())

import asyncio
from opperai import AsyncOpper

async def sonnet():
    aopper = AsyncOpper()
    res, _ = await aopper.call(
        model="anthropic/claude-3.5-sonnet-20241022",
        name="new-sonnet-3-5",
        instructions="answer the following question",
        input="what are some uses of 42",
    )
    print(res)


asyncio.run(sonnet())

def generate_image(description: str) -> ImageOutput:
    image, _ = opper.call(
        name="generate_image",
        output_type=ImageOutput,
        input=description,
        model="gcp/imagen-3.0-generate-001-eu",
        configuration=CallConfiguration(
            model_parameters={
                "aspectRatio": "9:16",
            }
        ),
    ) 
    return image


description = "portrait of a person standing in front of a park. vibrant, autumn colors"

path = save_file(generate_image(description).bytes)
print(path)

async function testImageGeneration() {
    const image = await client.generateImage({
        model: "gcp/imagen-3.0-generate-001-eu",
        prompt: "portrait of a person standing in front of a park. vibrant, autumn colors",
        configuration: {
            model_parameters: {
                aspectRatio: "9:16",
            }
        }
    });

    const tempFilePath = path.join(os.tmpdir(), "image.png");
    fs.writeFileSync(tempFilePath, image.bytes);
    console.log(`image written to temporary file: ${tempFilePath}`);
}

testImageGeneration();

# special type for images, this is to capture the need for encoding the image in the right format
from opperai import ImageInput 

description, response = await aopper.call(
    name="async_describe_image",
    instructions="Create a short description of the image",
    output_type=Description,
    input=Image(
        image=ImageInput.from_path("examples/cat.png"),
    ),
    model="openai/gpt-4o",
)

// special function to read images, this is to capture the need for encoding the image in the right format
import { opperImage } from "opperai"; 

const { message } = await client.call({
    parent_span_uuid: trace.uuid,
    name: "node-sdk/call/multimodal/image-input",
    instructions: "Create a short description of the image",
    input: {image: image("examples/cat.png")},
    model: "openai/gpt-4o",
});

from opperai import ImageOutput

cat, _ = await aopper.call(
    name="generate_cat",
    output_type=ImageOutput,
    input="Create an image of a cat",
)

const cat = await client.generateImage({
    parent_span_uuid: trace.uuid,
    prompt: "Create an image of a cat",
});

output, _ = opper.call(
    name="changelog/python/call-with-examples",
    instructions="extract the weekday from a text",
    examples=[
        Example(input="Today is Monday", output="Monday"),
        Example(input="Friday is the best day of the week", output="Friday"),
        Example(
            input="Saturday is the second best day of the week", output="Saturday"
        ),
    ],
    input="Wonder what day it is on Sunday",
)

span = opper.traces.start_trace(name="my_function", input="Hello, world!")
# business logic here
span.end()

with opper.traces.start(name="my_function", input="Hello, world!") as span:
    # business logic here

@trace
def my_function(input: str) -> str:
    # business logic here

opper.call(name="anthropic/claude-3-haiku", input="Hello, world!")

// Start parent trace
const trace = await client.traces.start({
    name: "node-sdk/tracing-manual",
    input: "Trace initialization",
});

// You can optionally start a child span and provide the input
const span = await trace.startSpan({
    name: "node-sdk/tracing-manual/span",
    input: "Some input given to the span",
});

// A metric and/or comment can be saved to the span
// A span generation can also be saved using .saveGeneration()
await span.saveMetric({
    dimension: "accuracy",
    score: 1,
    comment: "This is a comment",
});

// End the span and provide the output
await span.end({
    output: JSON.stringify({ foo: "bar" }),
});

// End the parent trace
await trace.end({ output: JSON.stringify({ foo: "bar" }) });

const { message } = await client.call({
    name: "node-sdk/call/basic",
    input: "what is the capital of sweden",
});

def run():
    opper = Opper()
    spans = opper.spans

    with spans.start("transform", input="Hello, world!") as span:
        t0 = datetime.now(timezone.utc)
        manually_call_llm()
        t1 = datetime.now(timezone.utc)
        span.save_generation(
            called_at=t0,
            duration_ms=int((t1 - t0).total_seconds() * 1000),
            response="I'm happy because I'm happy",
            model="anthropic/claude-3-haiku",
            messages=[
                {
                    "role": "user",
                    "content": "Hello, world!",
                }
            ],
            cost=3.1,
            prompt_tokens=10,
            completion_tokens=10,
            total_tokens=20,
        )