Upload folder using huggingface_hub

modules/audio/service.py

@@ -1,9 +1,13 @@
+from fastapi import HTTPException
 from modules.audio.model import AudioRequest, AudioType
+from modules.dropbox.art import get_audible_art_url
+from modules.dropbox.audibles import get_audible_audio_url
 from modules.dropbox.audio import get_audio_urls, get_global_indices_with_audio
 from config import SanatanConfig
 from db import SanatanDatabase
 from typing import List
 
+
 async def svc_get_audio_urls(req: AudioRequest):
     config = SanatanConfig().get_scripture_by_name(req.scripture_name)
     audio_storage = config.get("audio_storage", "dropbox")
@@ -14,23 +18,28 @@ async def svc_get_audio_urls(req: AudioRequest):
         data = db.fetch_document_by_index(
             collection_name=config["collection_name"], index=req.global_index
         )
-        url = data.get("audio", data.get("audio_url", "" ))
+        url = data.get("audio", data.get("audio_url", ""))
         ## Temporary fix for bhagavat gita audio being moved in the source.
-        if(req.scripture_name == "bhagavat_gita"):
-            url = url.replace("https://cdn.vivekavani.com/wp-content/","https://vivekavani.com/wp-content/")
+        if req.scripture_name == "bhagavat_gita":
+            url = url.replace(
+                "https://cdn.vivekavani.com/wp-content/",
+                "https://vivekavani.com/wp-content/",
+            )
         urls = {"recitation": url}
     return urls
 
 
-async def svc_get_indices_with_audio(scripture_name: str, audio_type: AudioType) -> List[int]:
+async def svc_get_indices_with_audio(
+    scripture_name: str, audio_type: AudioType
+) -> List[int]:
     """
     Service function to get all global indices for a scripture
     that have audio files of the specified type.
-    
+
     Args:
         scripture_name: Name of the scripture.
         audio_type: AudioType enum value.
-    
+
     Returns:
         List[int]: Sorted list of global indices.
     """
@@ -53,3 +62,19 @@ async def svc_get_indices_with_audio(scripture_name: str, audio_type: AudioType)
         indices.sort()
 
     return indices
+
+
+async def svc_get_audible_audio_url(path: str):
+    if not path.startswith("_audibles/audio/"):
+        raise HTTPException(status_code=400, detail="Invalid audible path")
+
+    url = await get_audible_audio_url(path)
+    return url
+
+
+async def svc_get_audible_art_url(path: str):
+    if not path.startswith("_audibles/art/"):
+        raise HTTPException(status_code=400, detail="Invalid audible path")
+
+    url = await get_audible_art_url(path)
+    return url

modules/dropbox/art.py

@@ -0,0 +1,64 @@
+import asyncio
+import json
+import logging
+from datetime import datetime, timedelta, timezone
+from typing import List, Optional
+import dropbox
+from modules.dropbox.client import dbx
+from fastapi import HTTPException
+
+# Logger
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+
+# cache = { audible_path: {"url": ..., "expiry": ...} }
+audible_art_cache: dict[str, dict] = {}
+AUDIBLE_ART_CACHE_TTL = timedelta(hours=3, minutes=30)
+
+async def get_audible_art_url(art_path: str):
+    """
+    Returns a temporary Dropbox download URL for an audible art file.
+    Uses in-memory caching to avoid regenerating links too frequently.
+    """
+
+    if not art_path:
+        raise HTTPException(status_code=400, detail="art_path is required")
+
+    # Normalize path (ensure leading slash)
+    dropbox_path = (
+        art_path if art_path.startswith("/") else f"/{art_path}"
+    )
+
+    now = datetime.now(timezone.utc)
+
+    # 1️⃣ Check cache
+    cached = audible_art_cache.get(dropbox_path)
+    if cached and cached["expiry"] > now:
+        return {"art_url": cached["url"]}
+
+    # 2️⃣ Generate fresh Dropbox temp link
+    try:
+        temp_link = dbx.files_get_temporary_link(dropbox_path).link
+    except dropbox.exceptions.ApiError:
+        raise HTTPException(status_code=404, detail="Audible art not found")
+
+    # 3️⃣ Cache it
+    audible_art_cache[dropbox_path] = {
+        "url": temp_link,
+        "expiry": now + AUDIBLE_ART_CACHE_TTL,
+    }
+
+    return {"art_url": temp_link}
+
+
+async def cleanup_audible_art_cache(interval_seconds: int = 600):
+    while True:
+        now = datetime.now(timezone.utc)
+        expired = [
+            k for k, v in audible_art_cache.items()
+            if v["expiry"] <= now
+        ]
+        for k in expired:
+            del audible_art_cache[k]
+        await asyncio.sleep(interval_seconds)

modules/dropbox/audibles.py

@@ -0,0 +1,192 @@
+import asyncio
+import json
+import logging
+from datetime import datetime, timedelta, timezone
+from typing import List, Optional
+import dropbox
+from modules.dropbox.client import dbx
+from fastapi import HTTPException
+
+# Logger
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+
+# Cache: key = folder_path, value = {"timestamp": datetime, "data": List[dict]}
+_audible_cache: dict[str, dict] = {}
+CACHE_TTL = timedelta(hours=1)
+FOLDER_PATH = "/_audibles"
+
+async def fetch_audibles_from_dropbox() -> List[dict]:
+    """
+    Fetch all audible JSONs for a scripture from Dropbox with caching.
+    Expects files in "/_audibles/".
+    """
+    loop = asyncio.get_running_loop()
+    folder_path = FOLDER_PATH
+
+    # Check cache
+    cache_entry = _audible_cache.get(folder_path)
+    if cache_entry:
+        age = datetime.now() - cache_entry["timestamp"]
+        if age < CACHE_TTL:
+            logger.info(f"Using cached audibles for '{folder_path}' (age={age})")
+            return cache_entry["data"]
+
+    logger.info(f"Fetching audibles from Dropbox folder '{folder_path}'")
+    audibles: List[dict] = []
+
+    try:
+        # List folder contents (synchronously in executor)
+        res = await loop.run_in_executor(None, dbx.files_list_folder, folder_path)
+        for entry in res.entries:
+            if isinstance(entry, dropbox.files.FileMetadata) and entry.name.lower().endswith(".json"):
+                metadata, fres = await loop.run_in_executor(
+                    None, dbx.files_download, f"{folder_path}/{entry.name}"
+                )
+                data = fres.content.decode("utf-8")
+                audibles.append(json.loads(data))
+
+        # Update cache
+        _audible_cache[folder_path] = {"timestamp": datetime.now(), "data": audibles}
+        logger.info(f"Cached {len(audibles)} audibles for '{folder_path}'")
+        return audibles
+
+    except Exception as e:
+        logger.error(f"Error fetching audibles from '{folder_path}'", exc_info=e)
+        # fallback to cached data if available
+        if cache_entry:
+            logger.warning(f"Returning stale cached audibles for '{folder_path}'")
+            return cache_entry["data"]
+        else:
+            logger.warning(f"No cached audibles available for '{folder_path}'")
+            return []
+
+
+async def get_audible_summaries(page: int = 1, per_page: int = 10):
+    """
+    Returns paginated summaries: id, topic_name, artwork_url.
+    Sorted by topic_name.
+    """
+    all_audibles = await fetch_audibles_from_dropbox()
+
+    # Build summaries
+    summaries = [
+        {
+            "id": d.get("id"),
+            "topic_name": d.get("topic_name"),
+            "artwork_url": d.get("artwork_url"),
+        }
+        for d in all_audibles
+    ]
+
+    summaries.sort(key=lambda x: (x.get("topic_name") or "").lower())
+
+    # Pagination
+    total_items = len(summaries)
+    total_pages = (total_items + per_page - 1) // per_page
+    if page < 1 or page > total_pages:
+        logger.warning(f"Invalid page {page}. Must be between 1 and {total_pages}")
+        return {"page": page, "per_page": per_page, "total_pages": total_pages, "total_items": total_items, "data": []}
+
+    start = (page - 1) * per_page
+    end = start + per_page
+    paginated = summaries[start:end]
+
+    print("audible data = ",paginated)
+
+    return {
+        "page": page,
+        "per_page": per_page,
+        "total_pages": total_pages,
+        "total_items": total_items,
+        "data": paginated,
+    }
+
+
+async def get_audible_by_id(topic_id: int) -> Optional[dict]:
+    """
+    Fetch a single audible JSON by topic_id from Dropbox.
+    Uses in-memory caching per file.
+    """
+    loop = asyncio.get_running_loop()
+    file_path = f"{FOLDER_PATH}/{topic_id}.json"
+
+    # Check cache
+    cache_entry = _audible_cache.get(file_path)
+    if cache_entry:
+        age = datetime.now() - cache_entry["timestamp"]
+        if age < CACHE_TTL:
+            logger.info(f"Using cached audible for topic {topic_id} (age={age})")
+            return cache_entry["data"]
+
+    try:
+        logger.info(f"Fetching audible {topic_id} from Dropbox: {file_path}")
+        metadata, res = await loop.run_in_executor(None, dbx.files_download, file_path)
+        data = res.content.decode("utf-8")
+        audible = json.loads(data)
+
+        # Update cache
+        _audible_cache[file_path] = {"timestamp": datetime.now(), "data": audible}
+        return audible
+
+    except dropbox.exceptions.HttpError as e:
+        logger.error(f"Dropbox file not found: {file_path}", exc_info=e)
+        return None
+    except Exception as e:
+        logger.error(f"Error fetching audible {topic_id}", exc_info=e)
+        # fallback to cached data if available
+        if cache_entry:
+            logger.warning(f"Returning stale cached audible for topic {topic_id}")
+            return cache_entry["data"]
+        return None
+
+# cache = { audible_path: {"url": ..., "expiry": ...} }
+audible_audio_cache: dict[str, dict] = {}
+AUDIBLE_CACHE_TTL = timedelta(hours=3, minutes=30)
+
+async def get_audible_audio_url(audio_path: str):
+    """
+    Returns a temporary Dropbox download URL for an audible audio file.
+    Uses in-memory caching to avoid regenerating links too frequently.
+    """
+
+    if not audio_path:
+        raise HTTPException(status_code=400, detail="audio_path is required")
+
+    # Normalize path (ensure leading slash)
+    dropbox_path = (
+        audio_path if audio_path.startswith("/") else f"/{audio_path}"
+    )
+
+    now = datetime.now(timezone.utc)
+
+    # 1️⃣ Check cache
+    cached = audible_audio_cache.get(dropbox_path)
+    if cached and cached["expiry"] > now:
+        return {"audio_url": cached["url"]}
+
+    # 2️⃣ Generate fresh Dropbox temp link
+    try:
+        temp_link = dbx.files_get_temporary_link(dropbox_path).link
+    except dropbox.exceptions.ApiError:
+        raise HTTPException(status_code=404, detail="Audible audio not found")
+
+    # 3️⃣ Cache it
+    audible_audio_cache[dropbox_path] = {
+        "url": temp_link,
+        "expiry": now + AUDIBLE_CACHE_TTL,
+    }
+
+    return {"audio_url": temp_link}
+
+
+async def cleanup_audible_audio_cache(interval_seconds: int = 600):
+    while True:
+        now = datetime.now(timezone.utc)
+        expired = [
+            k for k, v in audible_audio_cache.items()
+            if v["expiry"] <= now
+        ]
+        for k in expired:
+            del audible_audio_cache[k]
+        await asyncio.sleep(interval_seconds)

server.py

@@ -13,8 +13,9 @@ from config import SanatanConfig
 from db import SanatanDatabase
 from metadata import MetadataWhereClause
 from modules.audio.model import AudioRequest, AudioType
-from modules.audio.service import svc_get_audio_urls, svc_get_indices_with_audio
+from modules.audio.service import svc_get_audible_art_url, svc_get_audible_audio_url, svc_get_audio_urls, svc_get_indices_with_audio
 from modules.config.categories import get_scripture_categories
+from modules.dropbox.audibles import get_audible_by_id, get_audible_summaries
 from modules.dropbox.discources import get_discourse_by_id, get_discourse_summaries
 from modules.firebase.messaging import FcmRequest, fcm_service
 from modules.languages.get_v2 import handle_fetch_languages_v2
@@ -634,4 +635,50 @@ async def send_broadcast_message(req: BroadcastRequest):
         body=req.body,
         data=req.data
     )
-    return response
+    return response
+
+@router.get("/audible/list")
+async def get_all_audibles(
+    page: int = Query(1, ge=1, description="Page number (1-indexed)"),
+    per_page: int = Query(10, ge=1, le=100, description="Number of items per page"),
+):
+    """
+    Returns a paginated list of audible topics.
+    Each topic includes:
+      - id
+      - topic_name
+      - artwork_url
+    """
+    result = await get_audible_summaries(page=page, per_page=per_page)
+    return result
+
+
+@router.get("/audible/find/{topic_id}")
+async def get_audible_detail(topic_id: int):
+    """
+    Returns the full details of a audible topic by its unique ID.
+    """
+    topic = await get_audible_by_id(topic_id)
+    if not topic:
+        raise HTTPException(status_code=404, detail="Audible topic not found")
+    return topic    
+
+@router.get("/audible/audio-url")
+async def get_audible_audio_url(path: str):
+    """
+    Returns the audio url of the audible by path
+    """
+    url = await svc_get_audible_audio_url(path)
+    if not url:
+        raise HTTPException(status_code=404, detail="Audible audio not found")
+    return url
+
+@router.get("/audible/art-url")
+async def get_audible_art_url(path: str):
+    """
+    Returns the art url of the audible by path
+    """
+    url = await svc_get_audible_art_url(path)
+    if not url:
+        raise HTTPException(status_code=404, detail="Audible art not found")
+    return url