metaai-sdk 2.3.6__py3-none-any.whl → 3.0.1__py3-none-any.whl

metaai_api/api_server.py

@@ -107,12 +107,14 @@ class ImageRequest(BaseModel):
     new_conversation: bool = False
     media_ids: Optional[list] = None
     attachment_metadata: Optional[dict] = None  # {'file_size': int, 'mime_type': str}
+    orientation: Optional[str] = None  # 'VERTICAL', 'LANDSCAPE' (not HORIZONTAL), or 'SQUARE'
 
 
 class VideoRequest(BaseModel):
     prompt: str
     media_ids: Optional[list] = None
     attachment_metadata: Optional[dict] = None  # {'file_size': int, 'mime_type': str}
+    orientation: Optional[str] = None  # 'VERTICAL', 'LANDSCAPE', or 'SQUARE'
     wait_before_poll: int = Field(10, ge=0, le=60)
     max_attempts: int = Field(30, ge=1, le=60)
     wait_seconds: int = Field(5, ge=1, le=30)
@@ -206,7 +208,14 @@ async def chat(body: ChatRequest, cookies: Dict[str, str] = Depends(get_cookies)
         raise HTTPException(status_code=400, detail="Streaming not supported via HTTP JSON; set stream=false")
     ai = MetaAI(cookies=cookies, proxy=_get_proxies())
     try:
-        return cast(Dict[str, Any], ai.prompt(body.message, stream=False, new_conversation=body.new_conversation, media_ids=body.media_ids, attachment_metadata=body.attachment_metadata))
+        return cast(Dict[str, Any], await run_in_threadpool(
+            ai.prompt,
+            body.message,
+            stream=False,
+            new_conversation=body.new_conversation,
+            media_ids=body.media_ids,
+            attachment_metadata=body.attachment_metadata
+        ))
     except Exception as exc:  # noqa: BLE001
         await cache.refresh_after_error()
         raise HTTPException(status_code=502, detail=str(exc)) from exc
@@ -218,13 +227,15 @@ async def image(body: ImageRequest, cookies: Dict[str, str] = Depends(get_cookie
     try:
         # Automatically prepend "generate image of" to the prompt
         prompt = f"generate image of {body.prompt}" if not body.prompt.lower().startswith(("generate image", "create image")) else body.prompt
-        return cast(Dict[str, Any], ai.prompt(
-            prompt, 
-            stream=False, 
-            new_conversation=body.new_conversation, 
-            media_ids=body.media_ids, 
+        return cast(Dict[str, Any], await run_in_threadpool(
+            ai.prompt,
+            prompt,
+            stream=False,
+            new_conversation=body.new_conversation,
+            media_ids=body.media_ids,
             attachment_metadata=body.attachment_metadata,
-            is_image_generation=True  # Image generation uses DISCOVER entrypoint
+            is_image_generation=True,  # Image generation uses DISCOVER entrypoint
+            orientation=body.orientation  # Support VERTICAL, HORIZONTAL, SQUARE
         ))
     except Exception as exc:  # noqa: BLE001
         await cache.refresh_after_error()
@@ -233,6 +244,10 @@ async def image(body: ImageRequest, cookies: Dict[str, str] = Depends(get_cookie
 
 @app.post("/video")
 async def video(body: VideoRequest, cookies: Dict[str, str] = Depends(get_cookies)) -> Dict[str, Any]:
+    # Force refresh cookies before video generation for best results
+    await cache.refresh_if_needed(force=True)
+    cookies = await cache.snapshot()
+    
     ai = MetaAI(cookies=cookies, proxy=_get_proxies())
     try:
         # Automatically prepend "generate a video" to the prompt
@@ -242,6 +257,7 @@ async def video(body: VideoRequest, cookies: Dict[str, str] = Depends(get_cookie
             prompt,
             body.media_ids,
             body.attachment_metadata,
+            body.orientation,
             body.wait_before_poll,
             body.max_attempts,
             body.wait_seconds,
@@ -254,6 +270,10 @@ async def video(body: VideoRequest, cookies: Dict[str, str] = Depends(get_cookie
 
 @app.post("/video/async")
 async def video_async(body: VideoRequest, cookies: Dict[str, str] = Depends(get_cookies)) -> Dict[str, str]:
+    # Force refresh cookies before video generation
+    await cache.refresh_if_needed(force=True)
+    cookies = await cache.snapshot()
+    
     job = await jobs.create()
     asyncio.create_task(_run_video_job(job.job_id, body, cookies))
     return {"job_id": job.job_id, "status": "pending"}
@@ -322,6 +342,7 @@ async def _run_video_job(job_id: str, body: VideoRequest, cookies: Dict[str, str
             body.prompt,
             body.media_ids,
             body.attachment_metadata,
+            body.orientation,
             body.wait_before_poll,
             body.max_attempts,
             body.wait_seconds,

metaai_api/main.py

@@ -12,6 +12,8 @@ from metaai_api.utils import (
     generate_offline_threading_id,
     extract_value,
     format_response,
+    detect_challenge_page,
+    handle_meta_ai_challenge,
 )
 
 from metaai_api.utils import get_fb_session, get_session
@@ -29,7 +31,13 @@ class MetaAI:
     """
 
     def __init__(
-        self, fb_email: Optional[str] = None, fb_password: Optional[str] = None, cookies: Optional[dict] = None, proxy: Optional[dict] = None
+        self, 
+        fb_email: Optional[str] = None, 
+        fb_password: Optional[str] = None, 
+        cookies: Optional[dict] = None, 
+        proxy: Optional[dict] = None,
+        lsd: Optional[str] = None,
+        fb_dtsg: Optional[str] = None
     ):
         self.session = get_session()
         self.session.headers.update(
@@ -47,37 +55,116 @@ class MetaAI:
         
         if cookies is not None:
             self.cookies = cookies
+            # Add manually provided tokens if available
+            if lsd:
+                self.cookies["lsd"] = lsd
+            if fb_dtsg:
+                self.cookies["fb_dtsg"] = fb_dtsg
             # Auto-fetch lsd and fb_dtsg if not present in cookies
             if "lsd" not in self.cookies or "fb_dtsg" not in self.cookies:
                 self._fetch_missing_tokens()
         else:
             self.cookies = self.get_cookies()
+            # Override with manually provided tokens if available
+            if lsd:
+                self.cookies["lsd"] = lsd
+            if fb_dtsg:
+                self.cookies["fb_dtsg"] = fb_dtsg
             
         self.external_conversation_id = None
         self.offline_threading_id = None
 
-    def _fetch_missing_tokens(self):
+    def _fetch_missing_tokens(self, max_retries: int = 3):
         """
         Fetch lsd and fb_dtsg tokens if they're missing from cookies.
+        Handles Meta AI challenge pages automatically.
+        
+        Args:
+            max_retries (int): Maximum number of retry attempts.
         """
         try:
-            cookies_str = "; ".join([f"{k}={v}" for k, v in self.cookies.items() if v])
-            
             session = HTMLSession()
-            headers = {"cookie": cookies_str}
-            response = session.get("https://www.meta.ai/", headers=headers)
+            # Set cookies on session object (not as header string)
+            session.cookies.update(self.cookies)
             
-            if "lsd" not in self.cookies:
-                lsd = extract_value(response.text, start_str='"LSD",[],{"token":"', end_str='"')
-                if lsd:
-                    self.cookies["lsd"] = lsd
+            headers = {
+                "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+                "Accept-Language": "en-US,en;q=0.9",
+            }
             
-            if "fb_dtsg" not in self.cookies:
-                fb_dtsg = extract_value(response.text, start_str='DTSGInitData",[],{"token":"', end_str='"')
-                if fb_dtsg:
-                    self.cookies["fb_dtsg"] = fb_dtsg
+            for attempt in range(max_retries):
+                logging.info(f"Fetching tokens from Meta AI (attempt {attempt + 1}/{max_retries})...")
+                response = session.get("https://meta.ai", headers=headers)
+                
+                # Check if we got a challenge page
+                challenge_url = detect_challenge_page(response.text)
+                if challenge_url:
+                    logging.warning("Meta AI returned a challenge page. Attempting to handle it...")
+                    if handle_meta_ai_challenge(session, challenge_url=challenge_url, cookies_dict=self.cookies):
+                        # Retry fetching tokens after handling challenge
+                        response = session.get("https://meta.ai", headers=headers)
+                    else:
+                        logging.error("Failed to handle Meta AI challenge.")
+                        if attempt < max_retries - 1:
+                            time.sleep(2)
+                            continue
+                        else:
+                            break
+                
+                # Extract tokens from HTTP response - try multiple patterns
+                if "lsd" not in self.cookies:
+                    # Try JavaScript pattern first (original method)
+                    lsd = extract_value(response.text, start_str='"LSD",[],{"token":"', end_str='"}')  
+                    
+                    # If not found, try HTML input field pattern
+                    if not lsd:
+                        from bs4 import BeautifulSoup
+                        soup = BeautifulSoup(response.text, 'html.parser')
+                        lsd_input = soup.find("input", {"name": "lsd"})
+                        if lsd_input and lsd_input.get("value"):
+                            lsd = lsd_input["value"]  # type: ignore
+                    
+                    if lsd:
+                        self.cookies["lsd"] = lsd
+                        logging.info("Successfully fetched lsd token.")
+                    else:
+                        logging.warning("Could not extract lsd token from response.")
+                
+                if "fb_dtsg" not in self.cookies:
+                    # Try JavaScript pattern first (original method)
+                    fb_dtsg = extract_value(response.text, start_str='DTSGInitData",[],{"token":"', end_str='"')
+                    
+                    # If not found, try alternative patterns
+                    if not fb_dtsg:
+                        fb_dtsg = extract_value(response.text, start_str='"DTSGInitialData",[],{"token":"', end_str='"')
+                    if not fb_dtsg:
+                        fb_dtsg = extract_value(response.text, start_str='{"token":"', end_str='","async_get_token"')
+                    
+                    if fb_dtsg:
+                        self.cookies["fb_dtsg"] = fb_dtsg
+                        logging.info("Successfully fetched fb_dtsg token.")
+                    else:
+                        logging.warning("Could not extract fb_dtsg token from response.")
+                    if fb_dtsg:
+                        self.cookies["fb_dtsg"] = fb_dtsg
+                        logging.info("Successfully fetched fb_dtsg token.")
+                    else:
+                        logging.warning("Could not extract fb_dtsg token from response.")
+                
+                # Check if we got both tokens
+                if ("lsd" in self.cookies and self.cookies["lsd"]) and \
+                   ("fb_dtsg" in self.cookies and self.cookies["fb_dtsg"]):
+                    logging.info("Token fetch completed successfully.")
+                    break
+                    
+                if attempt < max_retries - 1:
+                    logging.warning(f"Tokens not fully fetched. Retrying in 2 seconds...")
+                    time.sleep(2)
+                    
         except Exception as e:
-            pass  # Silent fail, features may not work without tokens
+            logging.error(f"Error fetching tokens: {e}")
+            logging.warning("Some features may not work without lsd/fb_dtsg tokens.")
+            logging.info("Consider manually providing 'lsd' and 'fb_dtsg' tokens in the MetaAI constructor.")
 
     def get_access_token(self) -> str:
         """
@@ -619,6 +706,7 @@ class MetaAI:
     def get_cookies(self) -> dict:
         """
         Extracts necessary cookies from the Meta AI main page.
+        Handles challenge pages automatically.
 
         Returns:
             dict: A dictionary containing essential cookies.
@@ -629,10 +717,25 @@ class MetaAI:
         if self.fb_email is not None and self.fb_password is not None:
             fb_session = get_fb_session(self.fb_email, self.fb_password)
             headers = {"cookie": f"abra_sess={fb_session['abra_sess']}"}
+        
         response = session.get(
-            "https://www.meta.ai/",
+            "https://meta.ai",
             headers=headers,
         )
+        
+        # Check for challenge page
+        challenge_url = detect_challenge_page(response.text)
+        if challenge_url:
+            logging.warning("Meta AI returned a challenge page during get_cookies. Attempting to handle it...")
+            cookies_dict = {}
+            if fb_session:
+                cookies_dict = {"abra_sess": fb_session["abra_sess"]}
+            if handle_meta_ai_challenge(session, challenge_url=challenge_url, cookies_dict=cookies_dict):
+                # Retry after handling challenge
+                response = session.get("https://meta.ai", headers=headers)
+            else:
+                logging.error("Failed to handle challenge page in get_cookies.")
+        
         cookies = {
             "_js_datr": extract_value(
                 response.text, start_str='_js_datr":{"value":"', end_str='",'

metaai_api/utils.py

@@ -1,5 +1,6 @@
 import logging
 import random
+import re
 import time
 from typing import Dict, Optional
 
@@ -54,11 +55,87 @@ def extract_value(text: str, start_str: str, end_str: str) -> str:
     Returns:
         str: The extracted value.
     """
-    start = text.find(start_str) + len(start_str)
+    start = text.find(start_str)
+    if start == -1:
+        return ""
+    start += len(start_str)
     end = text.find(end_str, start)
+    if end == -1:
+        return ""
     return text[start:end]
 
 
+def detect_challenge_page(html_text: str) -> Optional[str]:
+    """
+    Detect if Meta AI returned a challenge/verification page.
+    
+    Args:
+        html_text (str): The HTML response text.
+    
+    Returns:
+        Optional[str]: The challenge verification URL if found, None otherwise.
+    """
+    # Check for challenge page indicators
+    if "executeChallenge" in html_text or "__rd_verify" in html_text:
+        # Extract the verification URL using regex
+        match = re.search(r"fetch\('(/__rd_verify[^']+)'", html_text)
+        if match:
+            return match.group(1)
+    return None
+
+
+def handle_meta_ai_challenge(session: requests.Session, base_url: str = "https://meta.ai", 
+                             challenge_url: Optional[str] = None, cookies_dict: Optional[dict] = None,
+                             max_retries: int = 3) -> bool:
+    """
+    Handle Meta AI challenge page by making the verification POST request.
+    
+    Args:
+        session (requests.Session): The requests session to use.
+        base_url (str): The base URL for Meta AI.
+        challenge_url (Optional[str]): The challenge verification URL.
+        cookies_dict (Optional[dict]): Cookies to include in the request.
+        max_retries (int): Maximum number of retry attempts.
+    
+    Returns:
+        bool: True if challenge was handled successfully, False otherwise.
+    """
+    if not challenge_url:
+        return False
+    
+    full_url = f"{base_url}{challenge_url}"
+    headers = {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        "Accept": "*/*",
+        "Accept-Language": "en-US,en;q=0.9",
+        "Referer": base_url,
+        "Origin": base_url,
+    }
+    
+    if cookies_dict:
+        cookies_str = "; ".join([f"{k}={v}" for k, v in cookies_dict.items() if v])
+        headers["Cookie"] = cookies_str
+    
+    try:
+        for attempt in range(max_retries):
+            logging.info(f"Handling Meta AI challenge (attempt {attempt + 1}/{max_retries})...")
+            response = session.post(full_url, headers=headers, timeout=10)
+            
+            if response.status_code == 200:
+                logging.info("Challenge handled successfully.")
+                # Wait a moment for the challenge to process
+                time.sleep(2)
+                return True
+            
+            time.sleep(1)
+        
+        logging.warning(f"Failed to handle challenge after {max_retries} attempts.")
+        return False
+    except Exception as e:
+        logging.error(f"Error handling Meta AI challenge: {e}")
+        return False
+
+
 def format_response(response: dict) -> str:
     """
     Formats the response from Meta AI to remove unnecessary characters.
@@ -140,8 +217,16 @@ def get_fb_session(email, password, proxies=None):
     soup = BeautifulSoup(response.text, "html.parser")
 
     # Parse necessary parameters from the login form
-    lsd = soup.find("input", {"name": "lsd"})["value"]
-    jazoest = soup.find("input", {"name": "jazoest"})["value"]
+    lsd_input = soup.find("input", {"name": "lsd"})
+    jazoest_input = soup.find("input", {"name": "jazoest"})
+    
+    if not lsd_input or not jazoest_input:
+        raise FacebookInvalidCredentialsException(
+            "Could not find login form parameters. Facebook may have changed their login page."
+        )
+    
+    lsd = lsd_input["value"]  # type: ignore
+    jazoest = jazoest_input["value"]  # type: ignore
 
     # Define the URL and body for the POST request to submit the login form
     post_url = "https://www.facebook.com/login/?next"
@@ -180,7 +265,7 @@ def get_fb_session(email, password, proxies=None):
     # Send the POST request
     session = requests.session()
     jar = cookies.RequestsCookieJar()
-    session.proxies = proxies
+    session.proxies = proxies  # type: ignore
     session.cookies = jar
 
     result = session.post(post_url, headers=headers, data=data)
@@ -245,7 +330,7 @@ def get_fb_session(email, password, proxies=None):
         "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
     }
     session = requests.session()
-    session.proxies = proxies
+    session.proxies = proxies  # type: ignore
     response = session.get(url, headers=headers, data=payload, allow_redirects=False)
 
     next_url = response.headers["Location"]
@@ -287,7 +372,7 @@ def get_cookies() -> dict:
         dict: A dictionary containing essential cookies.
     """
     session = HTMLSession()
-    response = session.get("https://www.meta.ai/")
+    response = session.get("https://meta.ai")
     return {
         "_js_datr": extract_value(
             response.text, start_str='_js_datr":{"value":"', end_str='",'

metaai_api/video_generation.py

@@ -74,7 +74,7 @@ class VideoGenerator:
         # Fetch Meta AI page with cookies
         session = HTMLSession()
         headers = {"cookie": cookies_str}
-        response = session.get("https://www.meta.ai/", headers=headers)
+        response = session.get("https://meta.ai", headers=headers)
         
         # Extract lsd and fb_dtsg
         lsd = extract_value(response.text, start_str='"LSD",[],{"token":"', end_str='"')

{metaai_sdk-2.3.6.dist-info → metaai_sdk-3.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metaai-sdk
-Version: 2.3.6
+Version: 3.0.1
 Summary: Feature-rich Python SDK for Meta AI - Chat, Image & Video Generation powered by Llama 3
 Author-email: Ashiq Hussain Mir <imseldrith@gmail.com>
 License-Expression: MIT
@@ -91,18 +91,18 @@ All in one SDK
 
 ### 🌟 Core Capabilities
 
-| Feature                      | Description                                      | Status   |
-| ---------------------------- | ------------------------------------------------ | -------- |
-| 💬 **Intelligent Chat**      | Powered by Llama 3 with internet access          | ✅ Ready |
-| 📤 **Image Upload**          | Upload & analyze images, generate similar images | ✅ Ready |
-| 🎨 **Image Generation**      | Create stunning AI-generated images              | ✅ Ready |
-| 🎬 **Video Generation**      | Generate videos from text or uploaded images     | ✅ Ready |
-| 🔍 **Image Analysis**        | Describe, analyze, and extract info from images  | ✅ Ready |
-| 🌐 **Real-time Data**        | Get current information via Bing integration     | ✅ Ready |
-| 📚 **Source Citations**      | Responses include verifiable sources             | ✅ Ready |
-| 🔄 **Streaming Support**     | Real-time response streaming                     | ✅ Ready |
-| 🔐 **Auto Token Management** | Automatic authentication handling                | ✅ Ready |
-| 🌍 **Proxy Support**         | Route requests through proxies                   | ✅ Ready |
+| Feature                        | Description                                      | Status   |
+| ------------------------------ | ------------------------------------------------ | -------- |
+| 💬 **Intelligent Chat**        | Powered by Llama 3 with internet access          | ✅ Ready |
+| 📤 **Image Upload**            | Upload & analyze images, generate similar images | ✅ Ready |
+| 🎨 **Image Generation**        | Create stunning AI-generated images              | ✅ Ready |
+| 🎬 **Video Generation**        | Generate videos from text or uploaded images     | ✅ Ready |
+| 🔍 **Image Analysis**          | Describe, analyze, and extract info from images  | ✅ Ready |
+| 🌐 **Real-time Data**          | Get current information via Bing integration     | ✅ Ready |
+| 📚 **Source Citations**        | Responses include verifiable sources             | ✅ Ready |
+| 🔄 **Streaming Support**       | Real-time response streaming                     | ✅ Ready |
+| 🔐 **Flexible Authentication** | Auto-fetch or manual token provision             | ✅ Ready |
+| 🌍 **Proxy Support**           | Route requests through proxies                   | ✅ Ready |
 
 ---
 
@@ -217,7 +217,57 @@ This calculation uses the compound interest formula: A = P(1 + r/n)^(nt)
 
 ---
 
-## 💬 Chat Features
+## � Authentication Options
+
+The SDK supports **flexible authentication** with two modes:
+
+### Mode 1: Automatic Token Fetching (Recommended)
+
+Provide basic cookies - `lsd` and `fb_dtsg` tokens are automatically fetched from Meta AI:
+
+```python
+from metaai_api import MetaAI
+
+# Provide basic cookies only
+cookies = {
+    "datr": "your_datr_value",
+    "abra_sess": "your_abra_sess_value",
+    "dpr": "1.25",
+    "wd": "1920x1080"
+}
+
+ai = MetaAI(cookies=cookies)
+# SDK automatically fetches lsd and fb_dtsg tokens!
+```
+
+### Mode 2: Manual Token Provision (Fallback)
+
+Provide all tokens manually if automatic fetching fails:
+
+```python
+from metaai_api import MetaAI
+
+# Provide cookies + manual tokens
+cookies = {
+    "datr": "your_datr_value",
+    "abra_sess": "your_abra_sess_value",
+    "dpr": "1.25",
+    "wd": "1920x1080"
+}
+
+ai = MetaAI(
+    cookies=cookies,
+    lsd="AVq1234567890",           # Manual token
+    fb_dtsg="ABCD:EFGH:123456789"  # Manual token
+)
+# No auto-fetch needed!
+```
+
+> **💡 Tip:** Start with **Mode 1** (automatic). Only use **Mode 2** if you encounter token fetching issues.
+
+---
+
+## �💬 Chat Features
 
 ### Streaming Responses
 
@@ -389,6 +439,11 @@ Create AI-generated videos from text descriptions!
 4. Click any request → **Headers** → Copy **Cookie** value
 5. Extract these values: `datr`, `abra_sess`, `dpr`, `wd`
 
+> **💡 Note:** The SDK supports **two authentication modes**:
+>
+> - **Automatic** (Recommended): Provide basic cookies, `lsd` and `fb_dtsg` tokens are auto-fetched
+> - **Manual**: Optionally provide `lsd` and `fb_dtsg` tokens directly if automatic fetching fails
+
 ### Example 1: Generate Your First Video
 
 ```python
@@ -442,6 +497,44 @@ else:
 🆔 Conversation ID: abc123-def456-ghi789
 ```
 
+### Example 1b: Manual Token Provision (Optional)
+
+If automatic token fetching fails or you prefer to provide tokens directly:
+
+```python
+from metaai_api import MetaAI
+
+# Your browser cookies + manually extracted tokens
+cookies = {
+    "datr": "your_datr_value_here",
+    "abra_sess": "your_abra_sess_value_here",
+    "dpr": "1.25",
+    "wd": "1920x1080"
+}
+
+# Initialize with manual tokens (no auto-fetch needed)
+ai = MetaAI(
+    cookies=cookies,
+    lsd="AVq1234567890",              # Manually extracted lsd token
+    fb_dtsg="ABCD:EFGH:123456789"     # Manually extracted fb_dtsg token
+)
+
+# Generate a video - tokens are already provided!
+result = ai.generate_video("A peaceful zen garden with koi fish")
+
+if result["success"]:
+    print("✅ Video generated successfully with manual tokens!")
+    print(f"🎬 Video URL: {result['video_urls'][0]}")
+```
+
+**How to extract `lsd` and `fb_dtsg` tokens:**
+
+1. Open https://meta.ai in your browser (logged in)
+2. Press **F12** → **Console** tab
+3. Run: `document.cookie`
+4. Look for `lsd=...` and `fb_dtsg=...` values
+5. Alternatively, right-click → **View Page Source** → Search for `"LSD",[],{"token":"` and `DTSGInitData",[],{"token":"`
+
 ### Example 2: Generate Multiple Videos
 
 ```python

metaai_sdk-3.0.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+metaai_api/__init__.py,sha256=YT4Dn_m1Fm3Hh10D4Z9jtmADjQHnZSsdtwIn8IlCjN4,714
+metaai_api/api_server.py,sha256=Tb5spAef-kKglEfGP96Fzruw8V0hHUKLqgrz04RDH0M,14000
+metaai_api/client.py,sha256=Th46qW1l8OS8Hu5pj0aGFn4iQNz62A3sbXko-LP-SAU,5263
+metaai_api/exceptions.py,sha256=MRRAppZa0OFA0QLSvC0nABgZN_Ll1dUq9JfhECTqV-Q,114
+metaai_api/image_upload.py,sha256=DQ2xqKdM1I_pF1rZBsB7-QTvXLzke2_0XiIOxFhpc70,6563
+metaai_api/main.py,sha256=PjK2aYjZ0FU17pot3p3n2mcyzMREqd2xnz59rsgRRGE,41918
+metaai_api/utils.py,sha256=xdQzu82rQEFqB3yaT0bEEaAg67fYugr2SQth9HdEOJo,15050
+metaai_api/video_generation.py,sha256=ENtyRN9nO49XBtPaAEVRdICchdVyEtnMCYLTha4kz1k,37480
+metaai_sdk-3.0.1.dist-info/licenses/LICENSE,sha256=hRLLSBixyX0tRh2k0iOGoF7nx-l-vBChNffFfVOIEtc,1290
+metaai_sdk-3.0.1.dist-info/METADATA,sha256=q3vaAK3OzrZnZ7g4i1o1g9lI9KxVGDTJ7lV9l4PlBJQ,31597
+metaai_sdk-3.0.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+metaai_sdk-3.0.1.dist-info/top_level.txt,sha256=R6YCiIQLYFKKaqhNZXDwXbpj1u01P_YhcMCVbJiDUJs,11
+metaai_sdk-3.0.1.dist-info/RECORD,,

metaai_sdk-2.3.6.dist-info/RECORD

@@ -1,13 +0,0 @@
-metaai_api/__init__.py,sha256=YT4Dn_m1Fm3Hh10D4Z9jtmADjQHnZSsdtwIn8IlCjN4,714
-metaai_api/api_server.py,sha256=hb1C3rEarPOHF6W-qqENaxrZWwn8A0qUrjSVlRtNV2s,13248
-metaai_api/client.py,sha256=Th46qW1l8OS8Hu5pj0aGFn4iQNz62A3sbXko-LP-SAU,5263
-metaai_api/exceptions.py,sha256=MRRAppZa0OFA0QLSvC0nABgZN_Ll1dUq9JfhECTqV-Q,114
-metaai_api/image_upload.py,sha256=DQ2xqKdM1I_pF1rZBsB7-QTvXLzke2_0XiIOxFhpc70,6563
-metaai_api/main.py,sha256=nskRHsJknxV_wJ25nJAetDodypKtQ_Lz2gpYqtfTyi0,36743
-metaai_api/utils.py,sha256=qzfIO3WkRH-gSV99b8RiECnMOku8lZEY3Jka9lTLExA,11979
-metaai_api/video_generation.py,sha256=JWrSyx7UhHFOHNiyNds7V_hGkwPHB_SiiApe9jQfp0U,37485
-metaai_sdk-2.3.6.dist-info/licenses/LICENSE,sha256=hRLLSBixyX0tRh2k0iOGoF7nx-l-vBChNffFfVOIEtc,1290
-metaai_sdk-2.3.6.dist-info/METADATA,sha256=iBoQvNSnECGFK-T2WKIO7tJjAnAmJ98-9h-ID9dzDgU,28998
-metaai_sdk-2.3.6.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-metaai_sdk-2.3.6.dist-info/top_level.txt,sha256=R6YCiIQLYFKKaqhNZXDwXbpj1u01P_YhcMCVbJiDUJs,11
-metaai_sdk-2.3.6.dist-info/RECORD,,