import asyncio
from Ryzenth import RyzenthApiClient

GEMINI_API_KEY = ""

async def gemini_openai(prompt: str):
    if not GEMINI_API_KEY:
        return

    clients = RyzenthApiClient(
        tools_name=["gemini-openai"],
        api_key={"gemini-openai": [{"Authorization": f"Bearer {GEMINI_API_KEY}"}]},
        rate_limit=100,
        use_default_headers=True
    )

    return await clients.post(
        tool="gemini-openai",
        path="/chat/completions",
        json={
            "model": "gemini-2.5-flash",
            "reasoning_effort": "low",
            "messages": [
                {"role": "user", "content": prompt}
            ]
        }
    )

async def main():
    response = await gemini_openai("Testing hello")
    print(response)

asyncio.run(main())

  "model": "imagen-3.0-generate-002"

from Ryzenth import RyzenthApiClient

DASHSCOPE_API_KEY = ""

async def qwen_imagen(prompt: str):
    clients = RyzenthApiClient(
        tools_name=["alibaba"],
        api_key={"alibaba": [
            {
                "Authorization": f"Bearer {DASHSCOPE_API_KEY}",
                "Content-Type": "application/json",
                "X-DashScope-Async": "enable"
            }
        ]},
        rate_limit=100,
        use_default_headers=True
    )
    response_status_json = await clients.post(
        tool="alibaba",
        path="/api/v1/services/aigc/text2image/image-synthesis",
        json={
            "model": "wan2.2-t2i-flash",
            "input": {
                "prompt": prompt
            },
            "parameters": {
                "size": "1024*1024",
                "n": 1
            }
        },
        timeout=100
    )
    while True:
        if response_status_json["output"]["task_status"] == "SUCCEEDED":
            task_id = response_status_json["output"]["task_id"]
            response_status = await clients.get(
                tool="alibaba",
                path=f"/api/v1/tasks/{task_id}",
                timeout=100
            )
            if response_status["output"]["task_status"] == "SUCCEEDED":
                return response_status["output"]["results"][0]["url"]
            if response_status["output"]["task_status"] == "FAILED":
                return "Ok Failed"

        if response_status_json["output"]["task_status"] == "FAILED":
            raise Exception("down gay")
            break

result_url = await qwen_imagen("A flower shop with exquisite windows")
print(result_url)

from Ryzenth import RyzenthTools

new_client = RyzenthTools()
file_path = await new_client.aio_client.images.create("make a generate cat blue")
print(file_path)

file_path_multiple = await new_client.aio_client.images.create_multiple(
    prompts=["make a generate cat blue", "make a generate cat yellow"],
    concurrent_limit=3
)
print(file_path_multiple)

from Ryzenth import RyzenthTools

new_client = RyzenthTools()

response = await new_client.aio_client.chat.ask("what is telegram?")

print(response)

response_2 = await new_client.aio_client.chat.ask_ultimate("what is GTA 5?", model="grok")

print(response_2)

response_3 = await new_client.aio_client.images.upload_ask("Describe this image:", "/path/to/example.jpg")

print(response_3)

response = await new_client.aio_client.images.upload_ask("Describe this image:", "/path/to/example.jpg")
print(response)

response_content = await new.aio_client.images.create("make a generate cat blue")
await response_content.to_save()

response = await new.aio_client.images.create_upload_ask("Describe this image:", "/path/to/example.jpg")
await response.to_result()

response = await new.aio_client.chat.ask("What's the capital of Japan?")
print(await response.to_result())

from Ryzenth import RyzenthTools

gemini_magic = RyzenthTools()

response = await gemini_magic.aio_client.images.create_gemini_and_captions(
    "Bikin gambar 3D babi pake sayap jet + kacamata hitam"
    "lagi terbang di atas kota cyberpunk yang ujan neon"
)

img, caption = await response.to_buffer_and_list()

await message.reply_photo(
    photo=img,
    caption=caption
)

Ga pake lama proses cepet ga nunggu loading kayak nunggu gorengan. ⏳

No ribet token ga perlu setel config bertele tele.

Dijamin stabil backend pake TypeScript jadi jarang error.

await new.aio_client.images.create()
await new.aio_client.images.create_gemini_and_captions()
await new.aio_client.images.create_gemini_to_edit("add background Lamborghini", "/path/to/example.jpg") # use response.to_buffer_and_list()
await new.aio_client.images.create_upload_to_ask()
await new.aio_client.images.create_multiple()
await new.aio_client.chat.ask()
await new.aio_client.chat.ask_ultimate()

from Ryzenth import RyzenthApiClient

class CustomName:
    def __init__(self):
        self.client = RyzenthApiClient()

    async def sapa(self):
        pass

qwen_response = await aio.client.images.create_qwen_flash()

url = await qwen_response.create_task_and_wait(return_url=True)

from Ryzenth import RyzenthTools

_ = RyzenthTools("your-api-key-from-qwen")

response = await _.aio_client.qwen_images.create_qwen_flash("make a generate cat blue")

url = await response.create_task_and_wait(
    max_retries=120,
    poll_interval=1.0,
    return_url=True
)
print(url)

from Ryzenth import RyzenthTools

rt = RyzenthTools("your-api-key-from-qwen")

# ---------------------------
# 1. Generate Image
# ---------------------------
response = await rt.aio.qwen_images.create("make a generate cat blue")
output = await response.create_task_and_wait(max_retries=120, poll_interval=1.0)

print("Image URL:", output.results[0].url)

# ---------------------------
# 2. Generate Video
# ---------------------------
response_two = await rt.aio.qwen_videos.create("make a generate cat blue run")
output_two = await response_two.create_task_and_wait(max_retries=120, poll_interval=1.0)

print("Video URL:", output_two.video_url)

response = await rt.aio.qwen_images.create("make a generate meme random")
output = await response.run()

response_chats = await rt.aio.qwen_chat.ask(
    "Hey, what’s your name?",
    stream=False,
    include_usage=False,
    enable_thinking=True
)
obj = await response_chats.to_obj()

from Ryzenth import RyzenthTools

rt = RyzenthTools("api-key-from-qwen")

response = await rt.aio.qwen_images.to_edit(
    prompt="Convert face to anime",
    base_image_url="",
    function_call="stylization_all"
)
f = await response.run()
print(f)

from Ryzenth import RyzenthTools

openai_st = RyzenthTools("sk-proj-*")
qwen_st = RyzenthTools("sk-*")
default_st = RyzenthTools()

await openai_st.aio.openai_responses.create()
await qwen_st.aio.qwen_chat.ask()
await default_st.aio.chat.ask()

from Ryzenth import RyzenthTools

rt = RyzenthTools("api-key-from-qwen")

response = await rt.aio.qwen_images.create("make a generate cat blue and background car Lamborghini gold")

output = await response.run()

img = await response.to_buffer_request(output.results[0].url)

await message.reply_photo(img)

from Ryzenth import RyzenthTools

rt = RyzenthTools("sk-proj-xxxx")

response = await rt.aio.openai_images.create("....")

dict_to_obj = await response.to_obj()

img = await response.to_buffer_request(
    dict_to_obj.data[0].b64_json,
    return_image_base64=True,
    disabled_http=True
)