Update app.py

app.py

@@ -1,331 +1,419 @@
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import HTMLResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from pydantic import BaseModel
+from ytmusicapi import YTMusic
 import os
-import re
+import logging
+import requests
+from datetime import datetime, timedelta
+from collections import defaultdict
 import time
 import asyncio
-from concurrent.futures import ThreadPoolExecutor
-from typing import List, Optional, Dict, Any
-from urllib.parse import urlparse
-from fastapi import FastAPI, HTTPException, Query, Request, BackgroundTasks
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse
-from pydantic import BaseModel
-from selenium import webdriver
-from selenium.webdriver.common.by import By
-from selenium.webdriver.support.ui import WebDriverWait
-from selenium.webdriver.support import expected_conditions as EC
-from selenium.webdriver.chrome.options import Options
-from selenium.common.exceptions import TimeoutException, NoSuchElementException, WebDriverException
-import uvicorn
-
-app = FastAPI(
-    title="Threads Media Extractor API",
-    description="Extract media URLs from Threads posts - Optimized version",
-    version="2.1.0"
-)
+import cloudscraper
+from urllib.parse import urlparse, parse_qs
+from collections import defaultdict
+import threading
+from typing import Optional, Dict, Any
 
-# Add CORS middleware
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
+app = FastAPI()
 
-# Global driver pool for reuse
-driver_pool = []
-executor = ThreadPoolExecutor(max_workers=2)
+# Mount static files and templates
+app.mount("/static", StaticFiles(directory="static"), name="static")
+templates = Jinja2Templates(directory="templates")
 
-class MediaItem(BaseModel):
+ytmusic = YTMusic()
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Pydantic models for request/response validation
+class SearchRequest(BaseModel):
+    query: str
+
+class MatchRequest(BaseModel):
     url: str
 
-class ThreadsResponse(BaseModel):
-    post_url: str
-    url: Optional[str] = None
-    picker: Optional[List[MediaItem]] = None
-    media_count: int
-    post_text: Optional[str] = None
-    author: Optional[str] = None
-    success: bool
-    processing_time: Optional[float] = None
+class TrackDownloadRequest(BaseModel):
+    track_id: str
+    quality: str = "128"
+
+class MatchResponse(BaseModel):
+    url: str
+    filename: str
+    track_id: str
 
 class ErrorResponse(BaseModel):
-    error: str
-    success: bool = False
-
-def create_optimized_driver():
-    """Create and configure optimized Chrome WebDriver"""
-    options = Options()
-    options.add_argument('--headless=new')  # Use new headless mode
-    options.add_argument('--no-sandbox')
-    options.add_argument('--disable-dev-shm-usage')
-    options.add_argument('--disable-gpu')
-    options.add_argument('--disable-extensions')
-    options.add_argument('--disable-plugins')
-    options.add_argument('--disable-default-apps')
-    options.add_argument('--disable-background-timer-throttling')
-    options.add_argument('--disable-backgrounding-occluded-windows')
-    options.add_argument('--disable-renderer-backgrounding')
-    options.add_argument('--disable-features=TranslateUI')
-    options.add_argument('--disable-ipc-flooding-protection')
-    
-    # Performance optimizations
-    options.add_argument('--memory-pressure-off')
-    options.add_argument('--max_old_space_size=4096')
-    options.add_argument('--window-size=1280,720')  # Smaller window
-    
-    # Network optimizations
-    options.add_argument('--aggressive-cache-discard')
-    options.add_argument('--disable-background-networking')
-    
-    # Disable unnecessary features
-    options.add_experimental_option('useAutomationExtension', False)
-    options.add_experimental_option("excludeSwitches", ["enable-automation"])
-    options.add_argument('--disable-blink-features=AutomationControlled')
-    
-    # User agent
-    options.add_argument('--user-agent=Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36')
-    
-    try:
-        driver = webdriver.Chrome(options=options)
-        driver.implicitly_wait(5)  # Reduced wait time
-        driver.set_page_load_timeout(15)  # Reduced timeout
-        
-        # Optimize browser settings
-        driver.execute_cdp_cmd('Network.setUserAgentOverride', {
-            "userAgent": 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
-        })
-        
-        return driver
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Failed to create browser driver: {str(e)}")
-
-def get_driver():
-    """Get driver from pool or create new one"""
-    if driver_pool:
-        return driver_pool.pop()
-    return create_optimized_driver()
-
-def return_driver(driver):
-    """Return driver to pool for reuse"""
-    if len(driver_pool) < 2:  # Keep max 2 drivers in pool
-        driver_pool.append(driver)
-    else:
+    detail: str
+    premium: Optional[str] = None
+
+@app.get("/", response_class=HTMLResponse)
+async def index(request: Request):
+    return templates.TemplateResponse("index.html", {"request": request})
+
+@app.post("/search")
+async def search(request: SearchRequest):
+    search_results = ytmusic.search(request.query, filter="songs")
+    return search_results
+
+@app.post("/searcht")
+async def searcht(request: SearchRequest):
+    logger.info(f"search query: {request.query}")
+    search_results = ytmusic.search(request.query, filter="songs")
+    first_song = next((song for song in search_results if 'videoId' in song and song['videoId']), {}) if search_results else {}
+    return first_song
+
+def extract_amazon_track_id(url: str) -> Optional[str]:
+    """
+    Extracts track ID from various Amazon Music URL formats.
+    """
+    if "music.amazon.com" not in url:
+        return None
+
+    parsed_url = urlparse(url)
+    query_params = parse_qs(parsed_url.query)
+
+    if "trackAsin" in query_params:
+        return query_params["trackAsin"][0]
+
+    path_parts = parsed_url.path.split('/')
+    if "tracks" in path_parts:
         try:
-            driver.quit()
-        except:
+            track_id_index = path_parts.index("tracks") + 1
+            if track_id_index < len(path_parts):
+                return path_parts[track_id_index]
+        except (ValueError, IndexError):
             pass
 
-def extract_post_id_from_url(url: str) -> Optional[str]:
-    """Extract post ID from Threads URL"""
-    patterns = [
-        r'threads\.net/@[^/]+/post/([A-Za-z0-9_-]+)',
-        r'threads\.net/t/([A-Za-z0-9_-]+)',
-        r'threads\.com/@[^/]+/post/([A-Za-z0-9_-]+)',
-        r'threads\.com/t/([A-Za-z0-9_-]+)',
-    ]
-    
-    for pattern in patterns:
-        match = re.search(pattern, url)
-        if match:
-            return match.group(1)
-    
+    logger.warning(f"Could not extract Amazon track ID from URL: {url}")
     return None
 
-def is_valid_threads_url(url: str) -> bool:
-    """Validate if URL is a valid Threads URL"""
+def get_song_link_info(url: str) -> Optional[Dict[str, Any]]:
+    """
+    Fetches track information from the Song.link API.
+    Uses requests.get() which is a blocking call.
+    """
+    api_base_url = "https://api.song.link/v1-alpha.1/links"
+    params = {"userCountry": "US"}
+
+    if "music.amazon.com" in url:
+        track_id = extract_amazon_track_id(url)
+        if track_id:
+            params["platform"] = "amazonMusic"
+            params["id"] = track_id
+            params["type"] = "song"
+        else:
+            params["url"] = url
+    else:
+        params["url"] = url
+
     try:
-        parsed = urlparse(url)
-        return (
-            parsed.netloc in ['threads.net', 'www.threads.net', 'threads.com', 'www.threads.com'] and
-            (('/post/' in parsed.path) or ('/t/' in parsed.path))
-        )
-    except:
-        return False
-
-def fast_extract_media(driver: webdriver.Chrome, url: str) -> Dict[str, Any]:
-    """Optimized media extraction with faster loading"""
-    media_urls = []
-    post_text = None
-    author = None
+        logger.info(f"Querying Song.link API with params: {params}")
+        response = requests.get(api_base_url, params=params, timeout=10)
+        response.raise_for_status()
+        return response.json()
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Error fetching from Song.link API: {e}")
+        return None
+
+def extract_url(links_by_platform: dict, platform: str) -> Optional[str]:
+    """
+    Extracts a specific platform URL from Song.link API response.
+    """
+    if platform in links_by_platform and links_by_platform[platform].get("url"):
+        return links_by_platform[platform]["url"]
     
-    try:
-        start_time = time.time()
-        
-        # Navigate to the URL
-        driver.get(url)
+    logger.warning(f"No URL found for platform '{platform}' in links: {links_by_platform.keys()}")
+    return None
+
+@app.post("/match", response_model=MatchResponse)
+async def match(request: MatchRequest):
+    """
+    Matches a given music track URL to a YouTube Music URL.
+    """
+    track_url = request.url
+    logger.info(f"Match endpoint: Processing URL: {track_url}")
+
+    track_info = get_song_link_info(track_url)
+    if not track_info:
+        logger.error(f"Match endpoint: Could not fetch track info for URL: {track_url}")
+        raise HTTPException(status_code=404, detail="Could not fetch track info from Song.link API.")
+
+    entity_unique_id = track_info.get("entityUniqueId")
+    title = None
+    artist = None
+
+    if entity_unique_id and entity_unique_id in track_info.get("entitiesByUniqueId", {}):
+        main_entity = track_info["entitiesByUniqueId"][entity_unique_id]
+        title = main_entity.get("title")
+        artist = main_entity.get("artistName")
+        logger.info(f"Match endpoint: Found main entity - Title: '{title}', Artist: '{artist}'")
+    else:
+        logger.warning(f"Match endpoint: Could not find main entity details for {track_url} using entityUniqueId: {entity_unique_id}")
         
-        # Wait for essential elements only
-        try:
-            WebDriverWait(driver, 8).until(
-                lambda d: d.execute_script("return document.readyState") == "complete"
-            )
-        except TimeoutException:
-            pass  # Continue even if timeout
+        # Fallback logic to find title/artist from other entities
+        for entity_id, entity_data in track_info.get("entitiesByUniqueId", {}).items():
+            if entity_data.get("title") and entity_data.get("artistName"):
+                title = entity_data.get("title")
+                artist = entity_data.get("artistName")
+                logger.info(f"Match endpoint: Using fallback entity - Title: '{title}', Artist: '{artist}' from entity ID {entity_id}")
+                break
+
+    if not title or not artist:
+        logger.error(f"Match endpoint: Could not determine title and artist for URL: {track_url}")
+        raise HTTPException(status_code=404, detail="Could not determine title and artist from Song.link info.")
+
+    youtube_url = extract_url(track_info.get("linksByPlatform", {}), "youtube")
+    
+    if youtube_url:
+        video_id = None
         
-        # Quick wait for dynamic content
-        time.sleep(1.5)  # Reduced from 3 seconds
+        if "v=" in youtube_url:
+            video_id = youtube_url.split("v=")[1].split("&")[0]
+        elif "youtu.be/" in youtube_url:
+            video_id = youtube_url.split("youtu.be/")[1].split("?")[0]
+
+        filename = f"{title} - {artist}" if title and artist else "Unknown Track - Unknown Artist"
+        logger.info(f"Match endpoint: Found direct YouTube URL: {youtube_url}, Video ID: {video_id}")
         
-        # Extract videos first (most important)
-        video_elements = driver.find_elements(By.TAG_NAME, 'video')
-        for video in video_elements:
-            src = video.get_attribute('src')
-            if src and src.startswith('http'):
-                media_urls.append(src)
-            
-            # Check source elements
-            sources = video.find_elements(By.TAG_NAME, 'source')
-            for source in sources:
-                src = source.get_attribute('src')
-                if src and src.startswith('http'):
-                    media_urls.append(src)
+        return MatchResponse(url=youtube_url, filename=filename, track_id=video_id)
+    else:
+        logger.info(f"Match endpoint: No direct YouTube URL. Searching YTMusic with: '{title} - {artist}'")
         
-        # If no videos found, look for images quickly
-        if not media_urls:
-            img_elements = driver.find_elements(By.TAG_NAME, 'img')[:10]  # Limit to first 10 images
-            for img in img_elements:
-                src = img.get_attribute('src')
-                if src and src.startswith('http') and any(ext in src.lower() for ext in ['.jpg', '.jpeg', '.png', '.gif', '.webp']):
-                    if not any(exclude in src.lower() for exclude in ['profile', 'avatar', 'icon', 'logo']):
-                        media_urls.append(src)
+        search_query = f'{title} {artist}'
+        search_results = ytmusic.search(search_query, filter="songs")
         
-        # Quick text extraction (optional, skip if taking too long)
+        if search_results:
+            first_song = next((song for song in search_results if song.get('videoId')), None)
+            
+            if first_song and first_song.get('videoId'):
+                video_id = first_song["videoId"]
+                ym_url = f'https://music.youtube.com/watch?v={video_id}'
+                
+                # Get artist name safely
+                artist_name = artist
+                if first_song.get('artists') and len(first_song['artists']) > 0:
+                    artist_name = first_song['artists'][0]['name']
+                
+                filename = f"{first_song.get('title', title)} - {artist_name}"
+                logger.info(f"Match endpoint: Found YTMusic search result - URL: {ym_url}, Video ID: {video_id}")
+                
+                return MatchResponse(filename=filename, url=ym_url, track_id=video_id)
+            else:
+                logger.error(f"Match endpoint: YTMusic search for '{search_query}' yielded no results with a videoId.")
+                raise HTTPException(status_code=404, detail="No matching video ID found on YouTube Music after search.")
+        else:
+            logger.error(f"Match endpoint: YTMusic search for '{search_query}' yielded no results.")
+            raise HTTPException(status_code=404, detail="No results found on YouTube Music for the track.")
+
+class ApiRotator:
+    def __init__(self, apis):
+        self.apis = apis
+        self.last_successful_index = None
+
+    def get_prioritized_apis(self):
+        if self.last_successful_index is not None:
+            rotated_apis = (
+                [self.apis[self.last_successful_index]] +
+                self.apis[:self.last_successful_index] +
+                self.apis[self.last_successful_index+1:]
+            )
+            return rotated_apis
+        return self.apis
+
+    def update_last_successful(self, index):
+        self.last_successful_index = index
+
+api_rotator = ApiRotator([
+    "https://dwnld.nichind.dev",
+    "https://yt.edd1e.xyz/",
+    "http://34.107.254.11"
+])
+
+async def get_track_download_url(track_id: str, quality: str) -> str:
+    apis = api_rotator.get_prioritized_apis()
+    session = cloudscraper.create_scraper()
+    
+    headers = {
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+    }
+
+    for i, api_url in enumerate(apis):
         try:
-            text_elements = driver.find_elements(By.CSS_SELECTOR, 'div[role="article"] span, article span')[:5]
-            for element in text_elements:
-                text = element.text.strip()
-                if text and len(text) > 10 and not post_text:
-                    post_text = text
+            logger.info(f"Attempting to get download URL from: {api_url}")
+            y_url = f"https://youtu.be/{track_id}"
+            
+            # Use asyncio to run the blocking request in a thread pool
+            loop = asyncio.get_event_loop()
+            response = await loop.run_in_executor(
+                None,
+                lambda: session.post(
+                    api_url,
+                    timeout=20,
+                    json={"url": y_url, "audioFormat": "mp3", "downloadMode": "audio", "audioBitrate": quality},
+                    headers=headers
+                )
+            )
+
+            logger.info(f"Response status: {response.status_code}")
+            logger.info(f"Response content: {response.content}")
+
+            if response.headers.get('content-type', '').startswith('application/json'):
+                json_response = response.json()
+                error_code = json_response.get("error", {}).get("code", "")
+                
+                if error_code == "error.api.content.video.unavailable":
+                    logger.warning(f"Video unavailable error from {api_url}")
                     break
-        except:
-            pass
-        
-        # Remove duplicates
-        seen = set()
-        unique_media_urls = []
-        for url in media_urls:
-            if url not in seen:
-                seen.add(url)
-                unique_media_urls.append(url)
-        
-        processing_time = time.time() - start_time
-        
-        return {
-            "media_urls": unique_media_urls,
-            "post_text": post_text,
-            "author": author,
-            "processing_time": processing_time
-        }
-        
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Error extracting media: {str(e)}")
+                
+                if "url" in json_response:
+                    api_rotator.update_last_successful(i)
+                    return json_response["url"]
 
-def extract_media_sync(url: str) -> Dict[str, Any]:
-    """Synchronous wrapper for thread execution"""
-    driver = None
-    try:
-        driver = get_driver()
-        result = fast_extract_media(driver, url)
-        return result
-    finally:
-        if driver:
-            return_driver(driver)
-
-@app.get("/", response_model=Dict[str, str])
-async def root():
-    """Root endpoint with API information"""
-    return {
-        "message": "Threads Media Extractor API v2.1 - Optimized",
-        "description": "Fast extraction of media URLs from Threads posts",
-        "version": "2.1.0",
-        "optimization": "Driver pooling, reduced timeouts, focused extraction"
-    }
+        except Exception as e:
+            logger.error(f"Failed with {api_url}: {str(e)}")
+            continue
 
-@app.get("/health")
-async def health_check():
-    """Health check endpoint"""
-    return {
-        "status": "healthy", 
-        "service": "threads-media-extractor", 
-        "version": "2.1.0",
-        "driver_pool_size": len(driver_pool)
-    }
+    logger.error(f"No download URL found")
+    return ""
 
-@app.get("/extract", response_model=ThreadsResponse)
-async def extract_media(url: str = Query(..., description="Threads post URL")):
-    """
-    Extract media URLs from a Threads post - Optimized version
-    
-    Args:
-        url: The Threads post URL to extract media from
-    
-    Returns:
-        ThreadsResponse with media URLs and metadata
-    """
+
+# Rate limiting dictionary
+class RateLimiter:
+    def __init__(self, max_requests: int, time_window: timedelta):
+        self.max_requests = max_requests
+        self.time_window = time_window
+        self.requests: Dict[str, list] = defaultdict(list)
     
-    # Validate URL
-    if not url:
-        raise HTTPException(status_code=400, detail="URL parameter is required")
+    def _cleanup_old_requests(self, user_ip: str) -> None:
+        """Remove requests that are outside the time window."""
+        current_time = time.time()
+        self.requests[user_ip] = [
+            timestamp for timestamp in self.requests[user_ip]
+            if current_time - timestamp < self.time_window.total_seconds()
+        ]
     
-    if not is_valid_threads_url(url):
-        raise HTTPException(status_code=400, detail="Invalid Threads URL format")
+    def is_rate_limited(self, user_ip: str) -> bool:
+        """Check if the user has exceeded their rate limit."""
+        self._cleanup_old_requests(user_ip)
+        
+        # Get current count after cleanup
+        current_count = len(self.requests[user_ip])
+        
+        # Add current request timestamp (incrementing the count)
+        current_time = time.time()
+        self.requests[user_ip].append(current_time)
+        
+        # Check if user has exceeded the maximum requests
+        return (current_count + 1) > self.max_requests
     
-    # Extract post ID
-    post_id = extract_post_id_from_url(url)
-    if not post_id:
-        raise HTTPException(status_code=400, detail="Could not extract post ID from URL")
+    def get_current_count(self, user_ip: str) -> int:
+        """Get the current request count for an IP."""
+        self._cleanup_old_requests(user_ip)
+        return len(self.requests[user_ip])
+
+
+# Initialize rate limiter with 100 requests per day
+rate_limiter = RateLimiter(
+    max_requests=6,
+    time_window=timedelta(days=1)
+)
+
+def get_user_ip(request: Request) -> str:
+    """Helper function to get user's IP address."""
+    forwarded = request.headers.get("X-Forwarded-For")
+    if forwarded:
+        return forwarded.split(",")[0]
+    return request.client.host
+
+
+class ApiRotator:
+    def __init__(self, apis):
+        self.apis = apis
+        self.last_successful_index = None
+
+    def get_prioritized_apis(self):
+        if self.last_successful_index is not None:
+            # Move the last successful API to the front
+            rotated_apis = (
+                [self.apis[self.last_successful_index]] + 
+                self.apis[:self.last_successful_index] + 
+                self.apis[self.last_successful_index+1:]
+            )
+            return rotated_apis
+        return self.apis
+
+    def update_last_successful(self, index):
+        self.last_successful_index = index
+
+@app.post("/track_dl")
+async def track_dl(request: TrackDownloadRequest, req: Request):
+    user_ip = get_user_ip(req)
     
+    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"
+            }
+        )
     try:
-        # Run extraction in thread pool for better async handling
-        loop = asyncio.get_event_loop()
-        extracted_data = await loop.run_in_executor(executor, extract_media_sync, url)
-        
-        media_urls = extracted_data["media_urls"]
-        media_count = len(media_urls)
-        
-        response_data = {
-            "post_url": url,
-            "media_count": media_count,
-            "post_text": extracted_data["post_text"],
-            "author": extracted_data["author"],
-            "success": True,
-            "processing_time": extracted_data.get("processing_time")
-        }
+        quality_num = int(request.quality)
+        if quality_num > 128 or request.quality.upper() == 'FLAC':
+            raise HTTPException(
+                status_code=400,
+                detail={
+                    "error": "Quality above 128 or FLAC is for Premium users Only.",
+                    "premium": "https://chrunos.com/premium-shortcuts/"
+                }
+            )
+
+        dl_url = await get_track_download_url(request.track_id, request.quality)
         
-        if media_count == 1:
-            response_data["url"] = media_urls[0]
+        if dl_url and "http" in dl_url:
+            return {
+                "url": dl_url,
+                "premium": "https://chrunos.com/premium-shortcuts/"
+            }
         else:
-            response_data["picker"] = [{"url": url} for url in media_urls]
-            
-        return ThreadsResponse(**response_data)
-        
-    except HTTPException:
-        raise
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
-
-@app.on_event("shutdown")
-async def shutdown_event():
-    """Clean up resources on shutdown"""
-    executor.shutdown(wait=False)
-    for driver in driver_pool:
-        try:
-            driver.quit()
-        except:
-            pass
+            raise HTTPException(
+                status_code=400,
+                detail={
+                    "error": "Failed to Fetch the Track.",
+                    "premium": "https://chrunos.com/premium-shortcuts/"
+                }
+            )
+
+    except ValueError:
+        raise HTTPException(
+            status_code=400,
+            detail={
+                "error": "Invalid quality value provided. It should be a valid integer or FLAC.",
+                "premium": "https://chrunos.com/premium-shortcuts/"
+            }
+        )
+
+@app.get("/get_artist")
+async def get_artist(id: str):
+    artist_info = ytmusic.get_artist(id)
+    return artist_info
+
+@app.get("/get_album")
+async def get_album(id: str):
+    album_info = ytmusic.get_album(id)
+    return album_info
+
+@app.get("/get_song")
+async def get_song(id: str):
+    song_info = ytmusic.get_song(id)
+    return song_info
 
-@app.exception_handler(HTTPException)
-async def http_exception_handler(request: Request, exc: HTTPException):
-    """Custom HTTP exception handler"""
-    return JSONResponse(
-        status_code=exc.status_code,
-        content={
-            "error": exc.detail,
-            "success": False,
-            "status_code": exc.status_code
-        }
-    )
-
-if __name__ == "__main__":
-    port = int(os.environ.get("PORT", 7860))
-    uvicorn.run(app, host="0.0.0.0", port=port)
+if __name__ == '__main__':
+    import uvicorn
+    uvicorn.run(app, host='0.0.0.0', port=7860)