Update app.py

app.py

@@ -29,12 +29,13 @@ from typing import Dict, Any
 import re
 import asyncio
 import cloudscraper
-import httpx
-from bs4 import BeautifulSoup
-from pydantic import BaseModel
+
 
 tmp_dir = tempfile.gettempdir()
-BASE_URL = "https://chrunos-zam.hf.space"
+BASE_URL = "https://chrunos-multi.hf.space"
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 
 def env_to_cookies(env_content: str, output_file: str) -> None:
@@ -126,119 +127,10 @@ async def get_video_url(youtube_url: str):
 
 
 
-
-@app.get("/script")
-async def get_transcript(youtube_url: str, language: str = None):
-    try:
-        # Set up yt-dlp options
-        ydl_opts = {
-            'skip_download': True,
-            'writesubtitles': True,
-            'writeautomaticsub': True,
-            'outtmpl': '%(id)s.%(ext)s',
-            'noplaylist': True,
-            'cookiefile': "firefox-cookies.txt"
-        }
-        
-        # If a language is specified, only download that language
-        # Otherwise, we'll first get video info to determine the original language
-        if language:
-            ydl_opts['subtitleslangs'] = [language]
-        
-        env_to_cookies_from_env("firefox-cookies.txt")
-        logger.info(f"Current directory files (before): {os.listdir('.')}")
-        
-        # First, get video info without downloading anything
-        with yt_dlp.YoutubeDL({**ydl_opts, 'skip_download': True, 'writesubtitles': False, 'writeautomaticsub': False}) as ydl:
-            info = ydl.extract_info(youtube_url, download=False)
-            video_id = info['id']
-            logger.info(f"Video ID: {video_id}")
-            
-            # If no language specified, try to use the original language
-            if not language:
-                # Try to determine the original language if available in the info
-                if 'subtitles' in info and info['subtitles']:
-                    # Use the first available subtitle language
-                    available_languages = list(info['subtitles'].keys())
-                    if available_languages:
-                        language = available_languages[0]
-                        logger.info(f"Using detected language: {language}")
-                        ydl_opts['subtitleslangs'] = [language]
-                else:
-                    # Fall back to 'en' if can't determine
-                    language = 'en'
-                    ydl_opts['subtitleslangs'] = [language]
-        
-        # Now download the subtitle in the selected language
-        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-            ydl.extract_info(youtube_url, download=True)
-            
-            # Check actual downloaded files
-            logger.info(f"Current directory files (after extraction): {os.listdir('.')}")
-            
-            # Look for the subtitle file with the specified language
-            subtitle_files = [f for f in os.listdir('.')
-                             if f.startswith(video_id) and any(ext in f for ext in ['.vtt', '.srt', '.ttml', '.json3'])]
-            
-            # If specific language requested, filter for that language
-            if language:
-                lang_subtitle_files = [f for f in subtitle_files if language in f]
-                if lang_subtitle_files:
-                    subtitle_files = lang_subtitle_files
-            
-            logger.info(f"Potential subtitle files: {subtitle_files}")
-            
-            if subtitle_files:
-                # Process the first found subtitle file
-                subtitle_file = subtitle_files[0]
-                logger.info(f"Processing subtitle file: {subtitle_file}")
-                
-                with open(subtitle_file, 'r', encoding='utf-8') as f:
-                    content = f.read()
-                
-                # Add format-specific parsing
-                if subtitle_file.endswith('.json3'):
-                    import json
-                    subs = json.loads(content)
-                    text = ' '.join([e['segs'][0]['utf8'] for e in subs['events'] if e.get('segs')])
-                elif subtitle_file.endswith('.vtt'):
-                    text = ' '.join(line.strip() for line in content.split('\n') 
-                           if not line.startswith('WEBVTT') 
-                           and '-->' not in line 
-                           and not line.strip().isdigit()
-                           and line.strip())
-                elif subtitle_file.endswith('.srt'):
-                    # Simple SRT parsing - skip timestamps and numbers
-                    lines = []
-                    for line in content.split('\n'):
-                        if not line.strip().isdigit() and '-->' not in line and line.strip():
-                            lines.append(line.strip())
-                    text = ' '.join(lines)
-                else:
-                    text = f"Unsupported format: {subtitle_file}"
-                
-                # Clean up files to avoid cluttering the directory
-                for f in subtitle_files:
-                    try:
-                        os.remove(f)
-                    except:
-                        logger.warning(f"Could not remove file: {f}")
-                
-                detected_language = subtitle_file.split('.')[-2] if '.' in subtitle_file else "unknown"
-                return {"transcript": text, "language": detected_language}
-            
-            return {"transcript": f"No subtitle files found for {video_id}", "language": "none"}
-    except Exception as e:
-        logger.error(f"Error: {str(e)}", exc_info=True)
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-
 # Define a global temporary download directory
 global_download_dir = tempfile.mkdtemp()
 
-
-
+# Rate limiting dictionary
 class RateLimiter:
     def __init__(self, max_requests: int, time_window: timedelta):
         self.max_requests = max_requests
@@ -275,7 +167,7 @@ class RateLimiter:
 
 # Initialize rate limiter with 100 requests per day
 rate_limiter = RateLimiter(
-    max_requests=20,
+    max_requests=12,
     time_window=timedelta(days=1)
 )
 
@@ -308,16 +200,18 @@ class ApiRotator:
 
 # In your function:
 api_rotator = ApiRotator([
-    "https://dwnld.nichind.dev",
-    "https://cobalt-api.kwiatekmiki.com",
-    "https://yt.edd1e.xyz/",
+    "http://109.107.189.229:9000",
+    "https://dl01.yt-dl.click",   
+    "http://34.107.254.11",
+    "http://2.56.214.74:9000",
     "https://cobalt-api.ayo.tf",
-    "https://cblt.fariz.dev"
+    "https://dwnld.nichind.dev",
+    "https://cobalt-api.kwiatekmiki.com"        
 ])
 
 
 
-async def get_track_download_url(video_url: str) -> str:
+async def get_track_download_url(video_url: str, quality: str) -> str:
     apis = api_rotator.get_prioritized_apis()
     session = cloudscraper.create_scraper()  # Requires cloudscraper package
     headers = {
@@ -325,6 +219,11 @@ async def get_track_download_url(video_url: str) -> str:
         "Content-Type": "application/json",
         "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
     }
+    quality_lower = quality.lower()
+    if quality_lower == "mp3":
+        body_json = {"url": video_url, "audioFormat": "mp3", "downloadMode": "audio"}
+    else:
+        body_json = {"url": video_url, "videoQuality": quality, "filenameStyle": "pretty", "youtubeVideoCodec": "h264"}
 
     for i, api_url in enumerate(apis):
         try:
@@ -333,7 +232,7 @@ async def get_track_download_url(video_url: str) -> str:
             response = session.post(
                 api_url,
                 timeout=20,
-                json={"url": y_url, "videoQuality": "720", "filenameStyle": "pretty"},
+                json=body_json,
                 headers=headers
             )
             logger.info(f"Response status: {response.status_code}")
@@ -343,7 +242,7 @@ async def get_track_download_url(video_url: str) -> str:
                 json_response = response.json()
                 error_code = json_response.get("error", {}).get("code", "")
                 
-                if error_code == "error.api.content.video.unavailable":
+                if error_code == "error.api.content.video.age":
                     logger.warning(f"Video unavailable error from {api_url}")
                     break  # Only break for specific error
                 
@@ -359,192 +258,168 @@ async def get_track_download_url(video_url: str) -> str:
     return {"error": "Download URL not found"}
 
 
-def jio_search(query: str, quality: str) -> str:
-    try:
-        # Construct the API URL
-        api_url = f"https://saavn.dev/api/search/songs?query={query}"
-        session = cloudscraper.create_scraper()
-        # Make the API request
-        response = session.get(api_url)
-        # Check if the request was successful
-        response.raise_for_status()
-        # Get the data from the response
-        data = response.json().get("data")
-        if not data:
-            logger.error("No data found in the response.")
-            raise HTTPException(status_code=404, detail="No data found for the given query.")
-        # Get the song results
-        song_results = data.get("results")
-        if not song_results or len(song_results) == 0:
-            logger.error("No song results found in the response.")
-            raise HTTPException(status_code=404, detail="No song results found for the given query.")
-        # Iterate through each song result
-        for song in song_results:
-            download_urls = song.get("downloadUrl")
-            if download_urls:
-                for download_url in download_urls:
-                    if download_url.get("quality") == quality:
-                        return download_url.get("url")
-        logger.error(f"No download URL found for quality {quality} in the search results for query {query}.")
-        raise HTTPException(status_code=404, detail=f"No download URL found for quality {quality} in the search results for query {query}.")
-    except cloudscraper.exceptions.CloudflareChallengeError as cf_err:
-        logger.error(f"Cloudflare challenge error while searching for {query}: {cf_err}")
-        raise HTTPException(status_code=503, detail="Cloudflare challenge failed")
-    except HTTPException:
-        # Re - raise the HTTPException if it's already raised
-        raise
-    except Exception as e:
-        logger.error(f"Error while searching for {query}: {e}")
-        raise HTTPException(status_code=500, detail=f"An error occurred while searching: {str(e)}")
 
+restricted_domain = "chrunos.com"
+
+@app.post("/maxs")
+async def download_high_quality_video(request: Request):
+    user_ip = get_user_ip(request)
+    
+    if rate_limiter.is_rate_limited(user_ip):
+        current_count = rate_limiter.get_current_count(user_ip)
+        raise HTTPException(
+            status_code=429,
+            detail={
+                "error": "You have exceeded the maximum number of requests per day. Please try again tomorrow.",
+                "url": "https://t.me/chrunoss"
+            }
+        )
         
-def jio_fetch(url: str, quality: str) -> str:
-    try:
-        # Construct the API URL
-        api_url = f"https://saavn.dev/api/songs?link={url}"
-        session = cloudscraper.create_scraper()
-        # Make the API request
-        response = session.get(api_url)
-        # Check if the request was successful
-        response.raise_for_status()
-        data = response.json()
-        song_data = data.get("data")
-        if not song_data or len(song_data) == 0:
-            logger.error("No data found in the response.")
-            raise HTTPException(status_code=404, detail="No data found for the given URL.")
-        download_urls = song_data[0].get("downloadUrl")
-        if not download_urls:
-            logger.error("No download URLs found in the response.")
-            raise HTTPException(status_code=404, detail="No download URLs found for the given song.")
-        for download_url in download_urls:
-            if download_url.get("quality") == quality:
-                return download_url.get("url")
-        logger.error(f"No download URL found for quality {quality}.")
-        raise HTTPException(status_code=404, detail=f"No download URL found for quality {quality}.")
-    except cloudscraper.exceptions.CloudflareChallengeError as cf_err:
-        logger.error(f"Cloudflare challenge error while fetching {url}: {cf_err}")
-        raise HTTPException(status_code=503, detail="Cloudflare challenge failed")
-    except HTTPException:
-        # Re - raise the HTTPException if it's already raised
-        raise
-    except Exception as e:
-        logger.error(f"Error while fetching {url}: {e}")
-        raise HTTPException(status_code=500, detail=f"An error occurred while fetching: {str(e)}")
-        
-# Define the request model
-class JioDownloadRequest(BaseModel):
-    url: str = None
-    query: str = None
-    quality: str = None
+    data = await request.json()
     
-@app.post("/jio_dl")
-async def jio_download(request: JioDownloadRequest):
-    try:
-        url = request.url
-        query = request.query
-        quality = request.quality
-        if url and quality:
-            logger.info(f'input url: {url}')
-            download_url = jio_fetch(url, quality)
-            return {"download_url": download_url}
-        elif query:
-            logger.info(f'input query: {query}')
-            download_url = jio_search(query, quality)
-            return {"download_url": download_url}
-        else:
-            logger.error("Missing 'url' and 'quality' or 'query' in request data.")
-            raise HTTPException(status_code=400, detail="Missing 'url' and 'quality' or 'query' in request data")
-    except HTTPException:
-        # Re - raise the HTTPException if it's already raised
-        raise
-    except Exception as e:
-        logger.error(f"Error in jio_download: {e}")
-        raise HTTPException(status_code=500, detail=f"An error occurred during the operation: {str(e)}")
+    video_url = data.get('url')
+    is_youtube_url = re.search(r'(youtube\.com|youtu\.be)', video_url) is not None
+    if "t.me" in video_url or "chrunos.com" in video_url:
+        return {"error": f"{video_url} is not supported", "url": "https://t.me/chrunoss"}
         
+    quality = data.get('quality', '720')  # Default to 720 if not specified
+    logger.info(f'input: {video_url}, {quality}')
 
-@app.post("/jio_dls")
-async def jio_download(request: JioDownloadRequest):
-    try:
-        url = request.url
-        quality = request.quality
-        query = request.query
-        if quality == '320kbps':
-            return {
-                "error": "Quality 320kbps is for Premium users only",
-                "premium": "https://chrunos.com/premium-shortcuts/"
-            }
-        if url and quality:
-            logger.info(f'input url: {url}')
-            download_url = jio_fetch(url, quality)
-            return {"download_url": download_url}
-        elif query:
-            logger.info(f'input query: {query}')
-            download_url = jio_search(query, quality)
-            return {"download_url": download_url}
-        else:
-            logger.error("Missing 'url' and 'quality' or 'query' in request data.")
-            raise HTTPException(status_code=400, detail="Missing 'url' and 'quality' or 'query' in request data")
-    except HTTPException:
-        # Re - raise the HTTPException if it's already raised
-        raise
-    except Exception as e:
-        logger.error(f"Error in jio_download: {e}")
-        raise HTTPException(status_code=500, detail=f"An error occurred during the operation: {str(e)}")
-
+    # Check if the requested quality is above 1080p
+    if int(quality) > 720:
+        error_message = "Quality above 720p is for Premium Members Only. Please check the URL for more information."
+        help_url = "https://chrunos.com/premium-shortcuts/"  # Replace with your actual URL
+        return {"error": error_message, "url": help_url}
 
+    #cookiefile = "firefox-cookies.txt"
+    #env_to_cookies_from_env("firefox-cookies.txt")
 
+    timestamp = datetime.now().strftime('%Y%m%d%H%M%S')
+    output_template = str(Path(global_download_dir) / f'%(title).70s_{timestamp}.%(ext)s')
 
+    # Convert quality string to height
+    height_map = {
+        '480': 480,
+        '720': 720,
+        '1080': 1080
+    }
+    max_height = height_map.get(quality, 1080)  # Use the quality variable correctly
 
+    # Determine format string based on quality
+    format_str = f'bestvideo[height<={max_height}][vcodec^=avc]+bestaudio/best'
 
+    ydl_opts = {
+        'format': format_str,
+        'outtmpl': output_template,
+        'quiet': True,
+        'no_warnings': True,
+        'noprogress': True,
+        'merge_output_format': 'mp4'
+    }
 
+    if is_youtube_url:
+        dl_url = await get_track_download_url(video_url, quality)
+        if dl_url and "http" in dl_url:
+            return {"url": dl_url, "requests_remaining": rate_limiter.max_requests - rate_limiter.get_current_count(user_ip)}
+        else:
+            return {
+                "error": "Failed to Fetch the video."
+                }
+    else:
+        await run_in_threadpool(lambda: yt_dlp.YoutubeDL(ydl_opts).download([video_url]))
+    
+        downloaded_files = list(Path(global_download_dir).glob(f"*_{timestamp}.mp4"))
+        if not downloaded_files:
+            return {"error": "Download failed. Report error on Telegram", "url": "https://t.me/chrunoss"}
+    
+        downloaded_file = downloaded_files[0]
+        encoded_filename = urllib.parse.quote(downloaded_file.name)
+        download_url = f"{BASE_URL}/file/{encoded_filename}"
+    
+        
+    
+        gc.collect()
+    
+        return {"url": download_url}
 
 
-EXTRACT_API = os.getenv("EXTRACT_API")
+TRACT_API = os.getenv("EXTRACT_API")
 ALT_API = os.getenv("ALT_API")
 
-
 def extract_video_info(video_url: str) -> str:
-    api_urls = [f'{ALT_API}?url={video_url}', f'{EXTRACT_API}?url={video_url}']
-    for api_url in api_urls:
-        logger.info(api_url)
-        session = cloudscraper.create_scraper()
-        try:
-            response = session.get(api_url, timeout=20)
-
-            if response.status_code == 200:
-                json_response = response.json()
-                result = []
-                if 'formats' in json_response:
-                    for format_item in json_response['formats']:
-                        format_url = format_item.get('url')
-                        format_id = format_item.get('format_id')
-                        p_cookies = format_item.get('cookies')
-                        if format_id and format_url:
-                            result.append({
-                                "url": format_url,
-                                "format_id": format_id,
-                                "cookies": p_cookies
-                            })
-                    title = json_response.get('title')
-                    logger.info(title)
-                    if "pornhub.com" in video_url:
-                        p_result = [item for item in result if 'hls' in item['format_id']]
-                        return p_result
-                    else:
-                        if len(result) == 1:
-                            new_item = {
-                                "format_id": "This is Fake, Don't Choose This One",
-                                "url": "none"
-                            }
-                            result.append(new_item)
-                        return result
+    if "pornhub.com" in video_url:
+        EXTRACT_API = TRACT_API
+    else:
+        EXTRACT_API = ALT_API            
+    api_url = f'{EXTRACT_API}?url={video_url}'
+    logger.info(api_url)
+    session = cloudscraper.create_scraper()
+    try:
+        response = session.get(api_url, timeout=20)
+        
+        if response.status_code == 200:
+            json_response = response.json()
+            result = []
+            # 检查 formats 列表是否存在且不为空
+            if 'formats' in json_response:
+                for format_item in json_response['formats']:
+                    format_url = format_item.get('url')
+                    format_id = format_item.get('format_id')
+                    p_cookies = format_item.get('cookies')
+                    if format_id and format_url:
+                        result.append({
+                            "url": format_url,
+                            "format_id": format_id,
+                            "cookies": p_cookies
+                        })
+
+                title = json_response.get('title')
+                logger.info(title)
+                if "pornhub.com" in video_url:
+                    p_result = [item for item in result if 'hls' in item['format_id']]
+                    last_item = p_result[-1]
+                    second_last_item = p_result[-2]
+                    last_item["format_id"] = f'{last_item["format_id"]} - Chrunos Shortcuts Premium Only'
+                    last_item["url"] = 'https://chrunos.com/premium-shortcuts/'
+                    second_last_item["format_id"] = f'{second_last_item["format_id"]} - Chrunos Shortcuts Premium Only'
+                    second_last_item["url"] = 'https://chrunos.com/premium-shortcuts/'
+                    return p_result
                 else:
-                    return {"error": "No formats available"}
+                    new_result = result
+                    # Check if new_result has more than one item
+                    if len(new_result) > 1:
+                        # Get the last item
+                        last_item = new_result[-1]
+                        # Modify the format_id
+                        last_item["format_id"] = f'{last_item["format_id"]} - Chrunos Shortcuts Premium Only'
+                        # Modify the url
+                        last_item["url"] = 'https://chrunos.com/premium-shortcuts/'
+                    elif len(new_result) == 1:
+                        new_item = {"url": "https://chrunos.com/premium-shortcuts/",
+                         "format_id": "Best Qaulity Video - Chrunos Shortcuts Premium Only"                            
+                        }
+                        new_result.append(new_item)
+
+                    return new_result
             else:
-                logger.warning(f"Request failed with status code {response.status_code}, API: {api_url}")
-        except Exception as e:
-            logger.error(f"An error occurred: {e}")
-    return {"error": "Both APIs failed to provide valid results."}
+                if 'url' in json_response:
+                    download_url = json_response.get('url')
+                    thumbnail_url = json_response.get('thumbnail')
+                    return [
+                        {"url": download_url,
+                         "format_id": "Normal Quality Video"
+                        },
+                        {"url": thumbnail_url,
+                         "format_id": "thumbnail"},
+                        {"url": "https://chrunos.com/premium-shortcuts/",
+                         "format_id": "Best Qaulity Video - Chrunos Shortcuts Premium Only"}
+                    ]
+                return {"error": "No formats available. Report Error on Telegram"}
+        else:
+            return {"error": f"Request failed with status code {response.status_code}, API: {api_url}"}
+    except Exception as e:
+        logger.error(f"An error occurred: {e}")
+        return {"error": str(e)}
 
 
 @app.post("/test")
@@ -571,6 +446,7 @@ async def download_hls_video(request: Request):
         'noprogress': True,
         'merge_output_format': 'mp4'
     }
+
     try:
         await run_in_threadpool(lambda: yt_dlp.YoutubeDL(ydl_opts).download([hls_url]))
     except Exception as e:
@@ -589,61 +465,34 @@ async def download_hls_video(request: Request):
 
 
 
-async def get_audio_download_url(track_id: str, quality: str) -> str:
-    if quality == 'mp3':
-        type = 'audio'
-        quality = 128
-    else:
-        type = 'video'
-    donwnload_url = f'https://chrunos-shadl.hf.space/yt/dl?url={track_id}&type={type}&quality={quality}'
-    return donwnload_url
-    
 
-@app.post("/maxs")
+@app.post("/max")
 async def download_high_quality_video(request: Request):
-    user_ip = get_user_ip(request)
-    
-    if rate_limiter.is_rate_limited(user_ip):
-        current_count = rate_limiter.get_current_count(user_ip)
-        raise HTTPException(
-            status_code=429,
-            detail={
-                "error": "You have exceeded the maximum number of requests per day. Please try again tomorrow.",
-                "url": "https://t.me/chrunoss"
-            }
-        )
-
-    
     data = await request.json()
-    restricted_domain = "chrunos.com"
     video_url = data.get('url')
-    quality = data.get('quality', '720')  # Default to 1080p if not specified
-    logger.info(f'input url: {video_url}, {quality}')
-    is_youtube_url = re.search(r'(youtube\.com|youtu\.be|instagram\.com)', video_url) is not None
-    if video_url and restricted_domain in video_url:
-        return {"error": "What is wrong with you?", "url": "https://t.me/chrunoss"}
-     
+    quality = data.get('quality', '1080')  # Default to 1080p if not specified
+
     # Check if the requested quality is above 1080p
-    if int(quality) > 720:
-        error_message = "Quality above 720p is for Premium Members Only. Please check the URL for more information."
-        help_url = "https://chrunos.com/premium-shortcuts/"  # Replace with your actual URL
-        return {"error": error_message, "url": help_url}
+    #if int(quality) > 1080:
+     #   error_message = "Quality above 1080p is for premium users. Please check the URL for more information."
+      #  help_url = "https://chrunos.com/premium-shortcuts/"  # Replace with your actual URL
+       # return {"error": error_message, "url": help_url}
 
     cookiefile = "firefox-cookies.txt"
     env_to_cookies_from_env("firefox-cookies.txt")
 
     timestamp = datetime.now().strftime('%Y%m%d%H%M%S')
-    output_template = str(Path(global_download_dir) / f'%(title).70s_{timestamp}.%(ext)s')
+    output_template = str(Path(global_download_dir) / f'%(title)s_{timestamp}.%(ext)s')
 
     # Convert quality string to height
     height_map = {
-        '240': 240,
-        '360': 360,
         '480': 480,
         '720': 720,
-        '1080': 1080
+        '1080': 1080,
+        '1440': 1440,
+        '2160': 2160
     }
-    max_height = height_map.get(quality, 720)  # Use the quality variable correctly
+    max_height = height_map.get(quality, 1080)  # Use the quality variable correctly
 
     # Determine format string based on quality
     format_str = f'bestvideo[height<={max_height}][vcodec^=avc]+bestaudio/best'
@@ -654,22 +503,12 @@ async def download_high_quality_video(request: Request):
         'quiet': True,
         'no_warnings': True,
         'noprogress': True,
-        'merge_output_format': 'mp4'
+        'merge_output_format': 'mp4',
+        'cookiefile': cookiefile
     }
 
-    if is_youtube_url:
-        ydl_opts["cookiefile"] = "firefox-cookies.txt"
-        '''dl_url = await get_audio_download_url(video_url, quality)
-        if dl_url and "http" in dl_url:
-            return {"url": dl_url, "requests_remaining": rate_limiter.max_requests - rate_limiter.get_current_count(user_ip)}
-        else:
-            return {
-                "error": "Failed to Fetch the video."
-                }
-       '''
-    # else:
     await run_in_threadpool(lambda: yt_dlp.YoutubeDL(ydl_opts).download([video_url]))
-
+    
     downloaded_files = list(Path(global_download_dir).glob(f"*_{timestamp}.mp4"))
     if not downloaded_files:
         return {"error": "Download failed"}
@@ -677,38 +516,12 @@ async def download_high_quality_video(request: Request):
     downloaded_file = downloaded_files[0]
     encoded_filename = urllib.parse.quote(downloaded_file.name)
     download_url = f"{BASE_URL}/file/{encoded_filename}"
-
-
     gc.collect()
+    return {"url": download_url}
 
-    return {"url": download_url, "requests_remaining": rate_limiter.max_requests - rate_limiter.get_current_count(user_ip)}
-
-
-
-
-
-
-
-
-api_key_header = APIKeyHeader(name="X-API-Key")
-
-# Store this securely in your environment variables
-API_KEY = os.getenv("API_KEY")
-
-
-async def verify_api_key(api_key: str = Security(api_key_header)):
-    if api_key != API_KEY:
-        raise HTTPException(
-            status_code=403,
-            detail="Invalid API key"
-        )
-    return api_key
 
 @app.post("/audio")
-async def download_audio(
-    request: Request
-    #api_key: str = Security(verify_api_key)
-):
+async def download_audio(request: Request):
     user_ip = get_user_ip(request)
     
     if rate_limiter.is_rate_limited(user_ip):
@@ -722,6 +535,8 @@ async def download_audio(
         )
     data = await request.json()
     video_url = data.get('url')
+    is_youtube_url = re.search(r'(youtube\.com|youtu\.be)', video_url) is not None
+        
     #cookiefile = "firefox-cookies.txt"
     #env_to_cookies_from_env("firefox-cookies.txt")
 
@@ -734,7 +549,6 @@ async def download_audio(
         'quiet': True,
         'no_warnings': True,
         'noprogress': True,
-        #'cookiefile': cookiefile,
         'postprocessors': [{
             'key': 'FFmpegExtractAudio',
             'preferredcodec': 'mp3',
@@ -742,16 +556,15 @@ async def download_audio(
         }]
         
     }
-    is_youtube_url = re.search(r'(youtube\.com|youtu\.be)', video_url) is not None
     if is_youtube_url:
-        dl_url = await get_audio_download_url(video_url, 'mp3')
+        dl_url = await get_track_download_url(video_url, 'mp3')
         if dl_url and "http" in dl_url:
             return {"url": dl_url, "requests_remaining": rate_limiter.max_requests - rate_limiter.get_current_count(user_ip)}
         else:
             return {
-                "error": "Failed to Fetch the video."
+                "error": "Failed to Fetch the audio."
                 }
-    else:
+    else: 
         await run_in_threadpool(lambda: yt_dlp.YoutubeDL(ydl_opts).download([video_url]))
     
         downloaded_files = list(Path(global_download_dir).glob(f"*_{timestamp}.*"))
@@ -766,12 +579,9 @@ async def download_audio(
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
 
 @app.post("/search")
-async def search_and_download_song(request: Request,
-    api_key: str = Security(verify_api_key)
-):
+async def search_and_download_song(request: Request):
     data = await request.json()
     song_name = data.get('songname')
     artist_name = data.get('artist')
@@ -834,14 +644,3 @@ app.mount("/file", StaticFiles(directory=global_download_dir), name="downloads")
 
 
 
-
-
-
-
-@app.middleware("http")
-async def set_mime_type_middleware(request: Request, call_next):
-    response = await call_next(request)
-    if request.url.path.endswith(".mp4"):
-        response.headers["Content-Type"] = "video/mp4"
-    return response
-