Python के साथ Sora 2 API: उदाहरणों सहित संपूर्ण मार्गदर्शिका

OpenAI API के साथ शुरुआत करना

शुरू करने के लिए, हमें एक OpenAI अकाउंट और एक API कुंजी बनानी होगी। ऐसा करने के लिए, उनके API key पेज पर जाएँ और ऊपर दाईं ओर "Create new secret key" पर क्लिक करें।

यह कुंजी OpenAI API को अनुरोध भेजने के लिए उपयोग की जाती है। हम इसे उस फोल्डर में .env नाम की फाइल में सेव करते हैं जहाँ हम अपने Python स्क्रिप्ट लिखते हैं। कुंजी को गुप्त रखें, क्योंकि कोई भी इसका उपयोग करके आपके अकाउंट से API के साथ इंटरैक्ट कर सकता है।

API कुंजी को .env फाइल में निम्न फॉर्मेट में पेस्ट करें:

OPENAI_API_KEY=<paste_api_key_here>संचालित द्वारा

ध्यान दें कि API का उपयोग निःशुल्क नहीं है, इसलिए वीडियो जनरेट करने में सक्षम होने से पहले अपने अकाउंट में बैलेंस जोड़ना आवश्यक है। संदर्भ के लिए, यहाँ Sora 2 की प्रति सेकंड की कीमत दी गई है:

Python के साथ Sora 2 वीडियो जनरेट करना

इस ट्यूटोरियल का सारा कोड इस GitHub रिपॉज़िटरी में मिल जाएगा।

Python से OpenAI API से संवाद करने के लिए, हम openai पैकेज का उपयोग करेंगे। ध्यान दें कि Sora API पर नया है, इसलिए पैकेज का हालिया वर्शन आवश्यक है।

इसे इंस्टॉल (या पहले से इंस्टॉल होने पर अपग्रेड) करने के लिए यह कमांड इस्तेमाल कर सकते हैं:

pip install --upgrade openaiसंचालित द्वारा

उसी फोल्डर में एक नई स्क्रिप्ट generate_video.py बनाएँ जहाँ पहले .env फाइल बनाई थी।

पहला कदम आवश्यक पैकेज इम्पोर्ट करना है। हम ये उपयोग करेंगे:

• os: ऑपरेटिंग सिस्टम से इंटरैक्ट करने के लिए बिल्ट-इन पैकेज;
• openai: उनकी API से इंटरैक्ट करने के लिए आधिकारिक OpenAI पैकेज;
• dotenv: .env फाइल से environment variables लोड करने में सहूलियत देने वाला पैकेज। यहाँ हम OpenAI API कुंजी लोड करने के लिए इसका उपयोग करते हैं।

import os
from openai import OpenAI 
from dotenv import load_dotenvसंचालित द्वारा

अगला कदम .env फाइल लोड करना है:

load_dotenv()
API_KEY = os.getenv("OPENAI_API_KEY")संचालित द्वारा

API कुंजी मेमोरी में लोड होने के साथ, हम OpenAI क्लाइंट को इनिशियलाइज़ कर सकते हैं, जो OpenAI API को अनुरोध भेजने की अनुमति देता है। हम os लाइब्रेरी से API कुंजी लोड करते हैं:

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

अंत में, हम क्लाइंट की videos.create फंक्शन का उपयोग करके वीडियो जनरेट करते हैं:

video = client.videos.create(
    prompt="A cat and a dog dancing",
)
print(video.id)संचालित द्वारा

जब हम वीडियो जनरेशन का अनुरोध करते हैं, तो हमें तुरंत वीडियो नहीं मिलता क्योंकि इसे बनने में समय लगता है। इसका मतलब है कि video वेरिएबल खुद वीडियो नहीं बल्कि वीडियो जनरेशन जॉब की जानकारी रखने वाला ऑब्जेक्ट है।

इसीलिए हमने वीडियो आइडेंटिफ़ायर प्रिंट किया। यह वह जानकारी है जिसकी हमें ज़रूरत होगी:

1. वीडियो जनरेशन की प्रगति को ट्रैक करने के लिए।
2. वीडियो प्राप्त करने के लिए।

हम नीचे इन दोनों चरणों को विस्तार से समझाएँगे।

यहाँ मुझे जो परिणाम मिला, वह है:

वीडियो की प्रगति ट्रैक करना

हम videos.retrieve() फंक्शन को जॉब आइडेंटिफ़ायर देकर किसी जॉब की स्थिति प्राप्त कर सकते हैं, इस तरह:

job = client.videos.retrieve(job_id)
status = job.status
progress = job.progress
print(f"Status: {status}, {progress}%")संचालित द्वारा

हमें वीडियो डाउनलोड करने में सक्षम होने के लिए प्रगति का 100% तक पहुँचना इंतज़ार करना होगा। सुविधा के लिए, हम एक फंक्शन wait_for_video_to_finish() बनाते हैं, जो जॉब के पूर्ण होने तक उसकी स्थिति मॉनिटर करता है:

def wait_for_video_to_finish(video_id, poll_interval=5, timeout=600):
    """
    Poll status until the video is ready or timeout is reached.
    Returns the final job info.
    """
    client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
    elapsed = 0  # Keep track of the elapsed time
    while elapsed < timeout:
        job = client.videos.retrieve(video_id)
        status = job.status
        progress = job.progress
        print(f"Status: {status}, {progress}%")
        if status == "completed":
            return job
        if status == "failed":
            raise RuntimeError(f"Failed to generate the video: {job.error.message}") 
        time.sleep(poll_interval)
        elapsed += poll_interval
    raise RuntimeError("Polling timed out")संचालित द्वारा

इस फंक्शन के तीन पैरामीटर हैं:

• video_id: उस वीडियो का आइडेंटिफ़ायर जिसे हम ट्रैक करना चाहते हैं।
• poll_interval: हर ट्रैकिंग अनुरोध के बीच हम कितने सेकंड इंतज़ार करते हैं।
• timeout: अधिकतम कितने सेकंड तक प्रतीक्षा करनी है।

यह फंक्शन समय-समय पर वीडियो की स्थिति जाँचता है जब तक कि यह पूरा न हो जाए या पोलिंग का समय समाप्त न हो जाए।

वीडियो डाउनलोड करना

अब जब हम वीडियो जनरेशन प्रक्रिया को ट्रैक कर सकते हैं, तो हमें ज़रूरत है कि यह पूरा होते ही इसे डाउनलोड करने का तरीका हो। हम videos.download_content() फंक्शन का उपयोग करके यह कर सकते हैं।

यह रहा वह फंक्शन जो यह करता है:

def download_video(video_id):
    client = get_client()
    response = client.videos.download_content(
        video_id=video_id,
    )
    video_bytes = response.read()
    with open(f"{video_id}.mp4", "wb") as f:
        f.write(video_bytes)संचालित द्वारा

पूरा Sora वीडियो जनरेशन वर्कफ़्लो

हम इन चरणों को साथ लाकर Sora के साथ एक वीडियो जनरेशन वर्कफ़्लो बना सकते हैं:

prompt = "A cat and a dog dancing"
video = client.videos.create(
    prompt="A cat and a dog dancing",
)
video_id = video.id
print(f"Started generating video with id {video_id}")
wait_for_video_to_finish(video_id)
download_video(video_id)संचालित द्वारा

वीडियो का आकार और अवधि सेट करना

ऊपर दी गई स्क्रिप्ट केवल एक टेक्स्ट प्रॉम्प्ट से वीडियो जनरेट करती है। हालाँकि, OpenAI Sora 2 API अन्य विकल्प भी देता है, जैसे:

• model: वीडियो जनरेट करने के लिए इस्तेमाल किया गया मॉडल। डिफ़ॉल्ट रूप से यह sora-2 है।
• resolution: वीडियो का आकार। डिफ़ॉल्ट रूप से वीडियो का आकार 720x1280 है।
• duration: वीडियो कितने सेकंड लंबा है। डिफ़ॉल्ट रूप से वीडियो 4 सेकंड लंबा होता है।

यहाँ मोड के अनुसार सभी संभावित मानों की तालिका है (बोल्ड में दिए मान डिफ़ॉल्ट हैं):

स्क्रिप्ट को उपयोग में आसान बनाने के लिए, हम बिल्ट-इन पैकेज argparse का उपयोग कर सकते हैं ताकि उपयोगकर्ता हर पैरामीटर का मान निर्दिष्ट कर सके।

यहाँ argparse के साथ prompt और model आर्ग्युमेंट सेट करने का उदाहरण है:

parser = argparse.ArgumentParser()
parser.add_argument(
    "--prompt", # Name of the argument
    required=True, # Specify that the argument is required
    help="The video prompt.", # Helper text
)
parser.add_argument(
    "--model",
    default="sora-2", # Specify a default value for the argument
    choices=["sora-2", "sora-2-pro"], # Specify a list of possible values for the argument
    help="Model to use (sora-2 or sora-2-pro).",
)संचालित द्वारा

आर्ग्युमेंट्स को लोड करने के लिए, हम parse_args() मेथड को इस तरह कॉल करते हैं:

args = parser.parse_args()
prompt = args.prompt
model = args.modelसंचालित द्वारा

generate_video_pipeline.py स्क्रिप्ट GitHub रिपॉज़िटरी में उन सभी हिस्सों को एक साथ रखती है जिन्हें हमने सीखा है, ताकि Sora 2 का उपयोग करके वीडियो जनरेट किया जा सके।

यहाँ टर्मिनल में विशेष पैरामीटर के साथ इसे चलाने का उदाहरण है:

python generate_video_pipeline.py --prompt "A family of dogs driving a car" --model sora-2-pro  --size 1280x720 --seconds 8संचालित द्वारा

यह परिणाम था:

Sora 2 API प्रॉम्प्ट टिप्स

OpenAI Sora 2 के लिए एक संपूर्ण प्रॉम्प्ट गाइड प्रदान करता है।

एक अच्छे Sora 2 प्रॉम्प्ट बनाने के मूलभूत विचार हैं:

• विवरण और स्वतंत्रता का संतुलन: विशिष्ट प्रॉम्प्ट नियंत्रण देते हैं; सरल प्रॉम्प्ट रचनात्मकता को आमंत्रित करते हैं।
• API में पैरामीटर सेट करें: मॉडल (sora-2 या sora-2-pro), रेज़ोल्यूशन, और क्लिप की लंबाई स्पष्ट रूप से परिभाषित करें।
• शॉट्स में सोचें: कैमरा फ्रेमिंग, लाइटिंग, विषय, और प्रति शॉट एक स्पष्ट एक्शन का वर्णन करें।
• दृश्यात्मक और ठोस बनें: “नीयन लाइट्स के नीचे गीला एस्फाल्ट” “एक सुंदर सड़क” से बेहतर है।
• मूवमेंट सादा रखें: एक विषय की क्रिया + एक कैमरा मूव सबसे अच्छा काम करता है।
• लाइट: स्थिरता के लिए रोशनी की क्वालिटी, दिशा और रंग पैलेट परिभाषित करें।
• इमेज रेफरेंस का उपयोग करें: स्टाइल और कम्पोज़िशन को एंकर करने के लिए एक दृश्य इनपुट जोड़ें।
• संवाद: छोटे, स्वाभाविक वाक्य; स्पष्ट लेबलिंग; प्रति क्लिप सीमित।
• Remix के साथ दोहराएँ: सटीक नियंत्रण के लिए एक बार में सिर्फ एक तत्व (लाइटिंग, लेंस, पैलेट) समायोजित करें।

वे इन विचारों को निम्न प्रॉम्प्ट टेम्पलेट में संजोते हैं:

[Prose scene description in plain language. Describe characters, costumes, scenery, weather and other details. Be as descriptive to generate a video that matches your vision.]
Cinematography:
Camera shot: [framing and angle, e.g. wide establishing shot, eye level]
Mood: [overall tone, e.g. cinematic and tense, playful and suspenseful, luxurious anticipation]
Actions:
- [Action 1: a clear, specific beat or gesture]
- [Action 2: another distinct beat within the clip]
- [Action 3: another action or dialogue line]
Dialogue:
[If the shot has dialogue, add short natural lines here or as part of the actions list. Keep them brief so they match the clip length.]संचालित द्वारा

टर्मिनल में लंबे प्रॉम्प्ट देना झंझटी है। उपयोगकर्ता अनुभव बेहतर करने के लिए, हम अपनी स्क्रिप्ट में बदलाव कर सकते हैं ताकि यदि प्रॉम्प्ट .txt पर समाप्त होता है, तो स्क्रिप्ट मान ले कि उपयोगकर्ता प्रॉम्प्ट वाले टेक्स्ट फाइल का पथ दे रहा है। 

इसे सपोर्ट करने के लिए स्क्रिप्ट को इस तरह अपडेट कर सकते हैं:

...
args = parser.parse_args()
prompt = args.prompt
if prompt.endswith(".txt"):
    with open(prompt, "rt") as f:
        prompt = f.read()
video_id = generate_video(prompt, args.model, args.size, args.seconds)
...संचालित द्वारा

इसे परखने के लिए, मैंने उसी फोल्डर में prompt.txt नाम की फाइल बनाई, जिसमें निम्न प्रॉम्प्ट है:

A polite green alien wearing a beret struggles to order croissants in broken French at a bustling Paris café.

Cinematography:
Camera shot: eye-level shot, warm morning light
Mood: whimsical and awkward
Actions:
The alien studies the pastry display, fascinated.
It points to the baguette, then accidentally eats the napkin.
The waiter shrugs, unfazed, and brings it another napkin.
Dialogue:
Alien (content): “Très… chewy.”संचालित द्वारा

वीडियो जनरेट करने के लिए, हम --prompt पैरामीटर पर prompt.txt देते हैं:

python generate_video_pipeline.py --prompt prompt.txt --model sora-2-pro  --size 1280x720 --seconds 8संचालित द्वारा

यह रहा वीडियो:

हम देखते हैं कि इसने प्रॉम्प्ट का पूरी तरह पालन नहीं किया। AI वीडियो मॉडलों के साथ मेरे अनुभव में, मुझे हमेशा बेहतर नतीजे मिले जब मैंने कई सरल वीडियो बनाए और उन्हें जोड़कर एक साथ रखा। 

हालाँकि, ऐसा करने के लिए, हमें उन्हें एकरूप रखना आना चाहिए। हम मॉडल को एक संदर्भ छवि देकर यह हासिल कर सकते हैं। यही हम आगे सीखेंगे।

छवियों के आधार पर Sora 2 वीडियो बनाना

किसी छवि के आधार पर वीडियो जनरेट करने के लिए, हम input_reference पैरामीटर का उपयोग करते हैं।

यहाँ एक कोड स्निपेट है जो दिखाता है कि किसी छवि को कैसे लोड करें और मॉडल को संदर्भ के रूप में दें:

f = open("image_reference.jpeg", "rb")

# Generate the video
video = client.videos.create(
    prompt="The two people walk away from each other.",
    input_reference=f
)

f.close()

wait_for_video_to_finish(video.id)
download_video(video.id)संचालित द्वारा

GitHub रिपॉज़िटरी में generate_video_with_reference.py स्क्रिप्ट इसका पूरी तरह काम करने वाला उदाहरण देती है। जब इसे संदर्भ छवि पर चलाया गया, तो हमें यह मिला:

संदर्भ छवि के काम करने के लिए, उसका आकार उसी के समान होना चाहिए जो वीडियो जनरेशन के लिए अनुरोधित किया गया था।

हम Pillow पैकेज का उपयोग करके मॉडल को देने से पहले संदर्भ छवि को स्वतः रीसाइज कर सकते हैं। ध्यान दें, हालाँकि, कि यदि मूल छवि का आस्पेक्ट रेशियो बहुत अलग है, तो यह विकृत हो जाएगी, और वीडियो शायद बहुत अच्छा नहीं होगा।

इसे इंस्टॉल करने के लिए, यह कमांड उपयोग करें:

pip install Pillowसंचालित द्वारा

sora.py स्क्रिप्ट generate_video() फंक्शन का ऐसा इम्प्लीमेंटेशन देती है जो हमारे पहले बनाए कोड को अनुकूलित करके, यदि कोई छवि दी गई हो, तो उसे रीसाइज कर देता है।

generate_video_pipeline_reference.py स्क्रिप्ट दिखाती है कि हम वीडियो जनरेशन स्क्रिप्ट में रेफरेंस पैरामीटर कैसे जोड़ सकते हैं।

यहाँ ऑटो-रीसाइज फीचर का उपयोग करके किसी फोटो से जनरेट किया गया एक उदाहरण है:

वीडियो रेफरेंस का उपयोग करना

हमने जो स्क्रिप्ट यहाँ बनाई है, वह छवि के साथ-साथ वीडियो रेफरेंस को संभालने के लिए भी तैयार है। हालाँकि, जब भी मैंने किसी दूसरे वीडियो को रेफरेंस के रूप में देकर वीडियो जनरेट करने की कोशिश की, तो मुझे यह त्रुटि मिली:

Video inpaint is not available for your organizationसंचालित द्वारा

उनके फ़ोरम के अनुसार, यह एक आम समस्या लगती है, जो इस ओर इशारा करती है कि यह फीचर अभी सभी के लिए API पर उपलब्ध नहीं है। हमें इसे उपयोग करने में सक्षम होने के लिए थोड़ा और इंतज़ार करना होगा।

अन्य सीमाएँ

जब मैं Sora 2 के साथ काम कर रहा था, तो मुझे अक्सर ऐसी समस्याएँ आईं जहाँ Sora ने वीडियो जनरेट करने से इनकार कर दिया, यह कहते हुए कि मॉडरेशन सिस्टम ने अनुरोध को ब्लॉक कर दिया:

RuntimeError: Video generation failed: Your request was blocked by our moderation system.संचालित द्वारा

मैं समझता हूँ कि इन प्रणालियों के लिए कड़ी मॉडरेशन ज़रूरी है, क्योंकि अगर उपयोगकर्ताओं को जो चाहें वैसा वीडियो जनरेट करने दिया जाए तो बहुत नुकसान हो सकता है। फिर भी, मुझे लगता है कि मॉडरेशन एल्गोरिथ्म को परिष्कृत करने की ज़रूरत है, क्योंकि इसने मेरे ज़्यादातर अनुरोधों को ब्लॉक कर दिया, जिसके कारण मुझे अपनी मूल योजना छोड़नी पड़ी।

जिन फ़ोटो को मैंने वीडियो में बदलने की कोशिश की, उनमें कोई संवेदनशील सामग्री या कॉपीराइट समस्या नहीं थी, क्योंकि सभी छवियाँ मेरी ही हैं। त्रुटि में यह भी कोई जानकारी नहीं होती कि इसे क्यों ब्लॉक किया गया।

यह समस्या बहुत अक्सर हुई, जिससे मेरे लिए कोई सार्थक चीज़ बनाना असंभव हो गया।

निष्कर्ष

Sora 2 AI-समर्थित वीडियो जनरेशन के लिए नए और रोमांचक अवसर खोलता है, और OpenAI API के माध्यम से इसकी उपलब्धता के कारण, इन अत्याधुनिक टूल्स को अपने Python वर्कफ़्लो में एकीकृत करना अब हर पृष्ठभूमि के डेवलपर्स के लिए सुलभ है।

इस ट्यूटोरियल का पालन करके, अब आपके पास सरल प्रॉम्प्ट्स से कस्टम वीडियो बनाने, एडवांस्ड पैरामीटर्स के साथ परिणाम को परिष्कृत करने, और अधिक स्थिरता के लिए इमेज रेफरेंस का लाभ उठाने की ठोस बुनियाद है। जैसे-जैसे API विकसित होगा, और भी फीचर्स — जिनमें मज़बूत वीडियो-टू-वीडियो क्षमताएँ शामिल हैं — उपलब्ध होंगे, जो आपके रचनात्मक टूलकिट का विस्तार करेंगे।

चाहे आप चंचल प्रॉम्प्ट्स के साथ प्रयोग कर रहे हों, जटिल स्टोरीबोर्ड बना रहे हों, या नेक्स्ट-जन मल्टीमीडिया ऐप्स विकसित कर रहे हों, Sora 2 आपके विचारों को जीवन देने का एक सशक्त तरीका प्रदान करता है। मैं हमारे Meta के नए SAM3 मॉडल के गाइड को भी देखने की सलाह देता हूँ।