metaai-sdk 2.0.0__py3-none-any.whl

metaai_api/__init__.py

@@ -0,0 +1,20 @@
+"""MetaAI API - Python SDK for Meta AI powered by Llama 3.
+
+A modern, feature-rich Python SDK providing seamless access to Meta AI's capabilities:
+- Chat with Llama 3 (with real-time internet access)
+- Generate AI images
+- Create AI videos from text prompts
+- No API key required
+"""
+
+__version__ = "2.0.0"
+__author__ = "Meta AI SDK Team"
+__license__ = "MIT"
+__url__ = "https://github.com/mir-ashiq/metaai-api"
+
+from .main import MetaAI  # noqa
+from .client import send_animate_request
+from .video_generation import VideoGenerator  # noqa
+
+__all__ = ["MetaAI", "send_animate_request", "VideoGenerator"]
+

metaai_api/api_server.py

@@ -0,0 +1,256 @@
+import asyncio
+import contextlib
+import logging
+import os
+import time
+import uuid
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from dotenv import load_dotenv
+from fastapi import Depends, FastAPI, HTTPException
+from fastapi.concurrency import run_in_threadpool
+from pydantic import BaseModel, Field
+
+from metaai_api import MetaAI
+
+logger = logging.getLogger(__name__)
+
+# Load .env file if it exists
+env_path = Path(__file__).parent.parent.parent / ".env"
+if env_path.exists():
+    load_dotenv(env_path)
+    logger.info(f"Loaded environment variables from {env_path}")
+
+# Refresh interval (seconds) for keeping lsd/fb_dtsg/cookies fresh
+DEFAULT_REFRESH_SECONDS = 3600
+REFRESH_SECONDS = int(os.getenv("META_AI_REFRESH_INTERVAL_SECONDS", DEFAULT_REFRESH_SECONDS))
+
+
+class TokenCache:
+    """Thread-safe cache for Meta cookies and tokens."""
+
+    def __init__(self) -> None:
+        self._lock = asyncio.Lock()
+        self._cookies: Dict[str, str] = {}
+        self._last_refresh: float = 0.0
+
+    async def load_seed(self) -> None:
+        seed = {
+            "datr": os.getenv("META_AI_DATR", ""),
+            "abra_sess": os.getenv("META_AI_ABRA_SESS", ""),
+            "dpr": os.getenv("META_AI_DPR", ""),
+            "wd": os.getenv("META_AI_WD", ""),
+            "_js_datr": os.getenv("META_AI_JS_DATR", ""),
+            "abra_csrf": os.getenv("META_AI_ABRA_CSRF", ""),
+        }
+        missing = [k for k in ("datr", "abra_sess") if not seed.get(k)]
+        if missing:
+            raise RuntimeError(f"Missing required seed cookies: {', '.join(missing)}")
+        async with self._lock:
+            self._cookies = {k: v for k, v in seed.items() if v}
+            self._last_refresh = 0.0
+
+    async def refresh_if_needed(self, force: bool = False) -> None:
+        now = time.time()
+        if not force and (now - self._last_refresh) < REFRESH_SECONDS:
+            return
+        async with self._lock:
+            if not force and (time.time() - self._last_refresh) < REFRESH_SECONDS:
+                return
+            try:
+                ai = MetaAI(cookies=dict(self._cookies))
+                # MetaAI may fetch lsd/fb_dtsg; capture any updates
+                self._cookies = getattr(ai, "cookies", self._cookies)
+                self._last_refresh = time.time()
+            except Exception as exc:  # noqa: BLE001
+                logger.warning("Cookie refresh failed: %s", exc)
+                if force:
+                    raise
+
+    async def refresh_after_error(self) -> None:
+        await self.refresh_if_needed(force=True)
+
+    async def snapshot(self) -> Dict[str, str]:
+        async with self._lock:
+            return dict(self._cookies)
+
+
+cache = TokenCache()
+refresh_task: Optional[asyncio.Task] = None
+app = FastAPI(title="Meta AI API Service", version="0.1.0")
+
+
+def _get_proxies() -> Optional[Dict[str, str]]:
+    http_proxy = os.getenv("META_AI_PROXY_HTTP")
+    https_proxy = os.getenv("META_AI_PROXY_HTTPS")
+    if not http_proxy and not https_proxy:
+        return None
+    proxies: Dict[str, str] = {}
+    if http_proxy:
+        proxies["http"] = http_proxy
+    if https_proxy:
+        proxies["https"] = https_proxy
+    return proxies
+
+
+class ChatRequest(BaseModel):
+    message: str
+    stream: bool = False
+    new_conversation: bool = False
+
+
+class VideoRequest(BaseModel):
+    prompt: str
+    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)
+    verbose: bool = False
+
+
+class JobStatus(BaseModel):
+    job_id: str
+    status: str
+    created_at: float
+    updated_at: float
+    result: Optional[Dict[str, Any]] = None
+    error: Optional[str] = None
+
+
+class JobStore:
+    def __init__(self) -> None:
+        self._jobs: Dict[str, JobStatus] = {}
+        self._lock = asyncio.Lock()
+
+    async def create(self) -> JobStatus:
+        now = time.time()
+        job_id = str(uuid.uuid4())
+        job = JobStatus(job_id=job_id, status="pending", created_at=now, updated_at=now)
+        async with self._lock:
+            self._jobs[job_id] = job
+        return job
+
+    async def set_running(self, job_id: str) -> None:
+        await self._update(job_id, status="running")
+
+    async def set_result(self, job_id: str, result: Dict[str, Any]) -> None:
+        await self._update(job_id, status="succeeded", result=result, error=None)
+
+    async def set_error(self, job_id: str, error: str) -> None:
+        await self._update(job_id, status="failed", error=error)
+
+    async def get(self, job_id: str) -> JobStatus:
+        async with self._lock:
+            if job_id not in self._jobs:
+                raise KeyError(job_id)
+            return self._jobs[job_id]
+
+    async def _update(self, job_id: str, **fields: Any) -> None:
+        async with self._lock:
+            if job_id not in self._jobs:
+                raise KeyError(job_id)
+            job = self._jobs[job_id].copy(update=fields)
+            job.updated_at = time.time()
+            self._jobs[job_id] = job
+
+
+jobs = JobStore()
+
+
+async def get_cookies() -> Dict[str, str]:
+    await cache.refresh_if_needed()
+    return await cache.snapshot()
+
+
+@app.on_event("startup")
+async def _startup() -> None:
+    await cache.load_seed()
+    await cache.refresh_if_needed(force=True)
+    global refresh_task
+    refresh_task = asyncio.create_task(_refresh_loop())
+
+
+@app.on_event("shutdown")
+async def _shutdown() -> None:
+    global refresh_task
+    if refresh_task:
+        refresh_task.cancel()
+        with contextlib.suppress(asyncio.CancelledError):
+            await refresh_task
+
+
+@app.post("/chat")
+async def chat(body: ChatRequest, cookies: Dict[str, str] = Depends(get_cookies)) -> Dict[str, Any]:
+    if body.stream:
+        raise HTTPException(status_code=400, detail="Streaming not supported via HTTP JSON; set stream=false")
+    ai = MetaAI(cookies=cookies, proxy=_get_proxies())
+    try:
+        return ai.prompt(body.message, stream=False, new_conversation=body.new_conversation)
+    except Exception as exc:  # noqa: BLE001
+        await cache.refresh_after_error()
+        raise HTTPException(status_code=502, detail=str(exc)) from exc
+
+
+@app.post("/video")
+async def video(body: VideoRequest, cookies: Dict[str, str] = Depends(get_cookies)) -> Dict[str, Any]:
+    ai = MetaAI(cookies=cookies, proxy=_get_proxies())
+    try:
+        return await run_in_threadpool(
+            ai.generate_video,
+            body.prompt,
+            body.wait_before_poll,
+            body.max_attempts,
+            body.wait_seconds,
+            body.verbose,
+        )
+    except Exception as exc:  # noqa: BLE001
+        await cache.refresh_after_error()
+        raise HTTPException(status_code=502, detail=str(exc)) from exc
+
+
+@app.post("/video/async")
+async def video_async(body: VideoRequest, cookies: Dict[str, str] = Depends(get_cookies)) -> Dict[str, str]:
+    job = await jobs.create()
+    asyncio.create_task(_run_video_job(job.job_id, body, cookies))
+    return {"job_id": job.job_id, "status": "pending"}
+
+
+@app.get("/video/jobs/{job_id}")
+async def video_job_status(job_id: str) -> Dict[str, Any]:
+    try:
+        job = await jobs.get(job_id)
+        return job.dict()
+    except KeyError:
+        raise HTTPException(status_code=404, detail="Job not found")
+
+
+@app.get("/healthz")
+async def health() -> Dict[str, str]:
+    return {"status": "ok"}
+
+
+async def _run_video_job(job_id: str, body: VideoRequest, cookies: Dict[str, str]) -> None:
+    await jobs.set_running(job_id)
+    ai = MetaAI(cookies=cookies, proxy=_get_proxies())
+    try:
+        result = await run_in_threadpool(
+            ai.generate_video,
+            body.prompt,
+            body.wait_before_poll,
+            body.max_attempts,
+            body.wait_seconds,
+            body.verbose,
+        )
+        await jobs.set_result(job_id, result)
+    except Exception as exc:  # noqa: BLE001
+        await cache.refresh_after_error()
+        await jobs.set_error(job_id, str(exc))
+
+
+async def _refresh_loop() -> None:
+    while True:
+        try:
+            await cache.refresh_if_needed(force=True)
+        except Exception as exc:  # noqa: BLE001
+            logger.warning("Background refresh failed: %s", exc)
+        await asyncio.sleep(REFRESH_SECONDS)

metaai_api/client.py

@@ -0,0 +1,140 @@
+import json
+from typing import Dict, List
+
+import requests
+
+
+def _parse_cookie_header(raw_cookie: str) -> Dict[str, str]:
+    parts = [p.strip() for p in raw_cookie.split(";") if p.strip()]
+    cookies: Dict[str, str] = {}
+    for part in parts:
+        if "=" not in part:
+            continue
+        name, value = part.split("=", 1)
+        cookies[name.strip()] = value.strip()
+    return cookies
+
+
+def send_animate_request(user_cookie_header: str, prompt: str) -> Dict:
+    """Send a prompt to Meta AI's animate endpoint using provided cookies."""
+    cookies = _parse_cookie_header(user_cookie_header)
+
+    headers = {
+        "accept": "*/*",
+        "accept-language": "en-US,en;q=0.5",
+        "content-type": "multipart/form-data; boundary=----WebKitFormBoundarybkOB5PgK5hbMvG6A",
+        "origin": "https://www.meta.ai",
+        "priority": "u=1, i",
+        "referer": "https://www.meta.ai/",
+        "sec-ch-ua": '"Brave";v="141", "Not?A_Brand";v="8", "Chromium";v="141"',
+        "sec-ch-ua-full-version-list": '"Brave";v="141.0.0.0", "Not?A_Brand";v="8.0.0.0", "Chromium";v="141.0.0.0"',
+        "sec-ch-ua-mobile": "?0",
+        "sec-ch-ua-model": '""',
+        "sec-ch-ua-platform": '"Windows"',
+        "sec-ch-ua-platform-version": '"19.0.0"',
+        "sec-fetch-dest": "empty",
+        "sec-fetch-mode": "cors",
+        "sec-fetch-site": "same-origin",
+        "sec-gpc": "1",
+        "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36",
+        "x-asbd-id": "359341",
+        "x-fb-lsd": "MMUBfnMuJ_zHq68M_QsA9p",
+        "cookie": user_cookie_header,
+    }
+
+    params = {
+        "fb_dtsg": "NAfs8i5CfuTxSgY049krPWfh6MLk1zW--f6qnzvqgeEaPvOWcpH_esA:2:1763623145",
+        "jazoest": "25561",
+        "lsd": "MMUBfnMuJ_zHq68M_QsA9p",
+    }
+
+    variables = json.dumps({"message": {"sensitive_string_value": prompt}})
+
+    data = {
+        "av": (None, "813590375178585"),
+        "__user": (None, "0"),
+        "__a": (None, "1"),
+        "__req": (None, "1b"),
+        "__hs": (None, "20412.HYP:kadabra_pkg.2.1...0"),
+        "dpr": (None, "1"),
+        "__ccg": (None, "GOOD"),
+        "__rev": (None, "1030167105"),
+        "__s": (None, "pfvlzb:j08r3n:u2o3ge"),
+        "__hsi": (None, "7574782986293208112"),
+        "__dyn": (None, "7xeUjG1mxu1syUqxemh0no6u5U4e2C1vzEdE98K360CEbo19oe8hw2nVEtwMw6ywaq221FwpUO0n24oaEnxO0Bo7O2l0Fwqo31w9O1lwlE-U2zxe2GewbS361qw82dUlwhE-15wmo423-0j52oS0Io5d0bS1LBwNwKG0WE8oC1IwGw-wlUcE2-G2O7E5y1rwa211wo84y1ix-0QU4G"),
+        "__csr": (None, ""),
+        "__hsdp": (None, ""),
+        "__hblp": (None, ""),
+        "__sjsp": (None, ""),
+        "__comet_req": (None, "72"),
+        "fb_dtsg": (None, "NAfs8i5CfuTxSgY049krPWfh6MLk1zW--f6qnzvqgeEaPvOWcpH_esA:2:1763623145"),
+        "jazoest": (None, "25561"),
+        "lsd": (None, "MMUBfnMuJ_zHq68M_QsA9p"),
+        "__spin_r": (None, "1030167105"),
+        "__spin_b": (None, "trunk"),
+        "__spin_t": (None, "1763641598"),
+        "__jssesw": (None, "1"),
+        "__crn": (None, "comet.kadabra.KadabraPromptRoute"),
+        "fb_api_caller_class": (None, "RelayModern"),
+        "fb_api_req_friendly_name": (None, "useKadabraSendMessageMutation"),
+        "server_timestamps": (None, "true"),
+        "variables": (None, variables),
+        "doc_id": (None, "26069859009269605"),
+    }
+
+    response = requests.post(
+        "https://www.meta.ai/api/graphql/",
+        params=params,
+        cookies=cookies,
+        headers=headers,
+        data=data,
+    )
+    response.raise_for_status()
+    return response.json()
+
+
+def extract_video_urls_from_fetch_response(fetch_response: Dict) -> List[str]:
+    urls: List[str] = []
+
+    data = fetch_response.get("data", {})
+    fetch_post = data.get("xfb_genai_fetch_post") or data.get("xab_abra__xfb_genai_fetch_post") or {}
+
+    messages = fetch_post.get("messages", {}).get("edges", [])
+    for edge in messages:
+        node = edge.get("node", {})
+        content = node.get("content", {})
+        imagine_video = content.get("imagine_video") or {}
+
+        videos = imagine_video.get("videos", {}).get("nodes", [])
+        for video in videos:
+            uri = video.get("video_url") or video.get("uri")
+            if uri:
+                urls.append(uri)
+            delivery = video.get("videoDeliveryResponseResult") or {}
+            prog = delivery.get("progressive_urls", [])
+            for p in prog:
+                pu = p.get("progressive_url")
+                if pu:
+                    urls.append(pu)
+
+        single_video = imagine_video.get("video") or {}
+        if isinstance(single_video, dict):
+            uri = single_video.get("video_url") or single_video.get("uri")
+            if uri:
+                urls.append(uri)
+            delivery = single_video.get("videoDeliveryResponseResult") or {}
+            prog = delivery.get("progressive_urls", [])
+            for p in prog:
+                pu = p.get("progressive_url")
+                if pu:
+                    urls.append(pu)
+
+    # Deduplicate while preserving order
+    seen = set()
+    unique_urls: List[str] = []
+    for u in urls:
+        if u not in seen:
+            seen.add(u)
+            unique_urls.append(u)
+    return unique_urls
+

metaai_api/exceptions.py

@@ -0,0 +1,6 @@
+class FacebookInvalidCredentialsException(Exception):
+    pass
+
+
+class FacebookRegionBlocked(Exception):
+    pass