Update app.py

app.py

@@ -1,26 +1,25 @@
 import requests
 from bs4 import BeautifulSoup
-from fastapi import FastAPI, Form
+from fastapi import FastAPI, BackgroundTasks, HTTPException, Form
 from fastapi.responses import PlainTextResponse, HTMLResponse
 from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel
 import re
+from concurrent.futures import ThreadPoolExecutor
 import urllib.parse
+import gradio as gr
 import fake_useragent as fake
 import random
 from dotenv import load_dotenv
 import os
 from tqdm import tqdm
 from faker import Faker
-import asyncio
-import time
-import threading
+import faker as fakexd
 
 load_dotenv()
 
 app = FastAPI()
 
-
 class Proxy(BaseModel):
     ip: str
     port: str
@@ -30,28 +29,24 @@ class VisitRequest(BaseModel):
     platform: str
     count: int
     delay: int
-    parallel_processes: int = 1 
+    parallel_processes: int
 
 app.mount("/static", StaticFiles(directory="static"), name="static")
 
 def get_random_proxy():
-    try:
-        pubproxy_url = "http://pubproxy.com/api/proxy?limit=1&type=http&https=true"
-        response = requests.get(pubproxy_url, verify=False)
-        data = response.json()
-        if data['data']:
-            proxy_data = data['data'][0]
-            return f"{proxy_data['ip']}:{proxy_data['port']}"
-        return None
-    except Exception as e:
-        print(f"Error getting proxy: {e}")
-        return None
+    pubproxy_url = "http://pubproxy.com/api/proxy?limit=1"
+    response = requests.get(pubproxy_url, verify=False)
+    data = response.json()
+    if data['data']:
+        proxy_data = data['data'][0]
+        return f"{proxy_data['ip']}:{proxy_data['port']}"
+    return None
 
 @app.get("/get_proxies", response_class=PlainTextResponse)
 def get_proxies():
     try:
         proxies = []
-        pubproxy_url = "http://pubproxy.com/api/proxy?limit=5&type=http&https=true"
+        pubproxy_url = "http://pubproxy.com/api/proxy?limit=5"
         response = requests.get(pubproxy_url, verify=False)
         data = response.json()
 
@@ -67,8 +62,7 @@ def get_proxies():
 @app.get("/rotate_ip", response_class=PlainTextResponse)
 def rotate_ip():
     try:
-        fake = Faker()
-        random_ip = fake.ipv4()
+        random_ip = fakexd.ipv4()
 
         headers = {
             "X-Forwarded-For": random_ip,
@@ -76,7 +70,7 @@ def rotate_ip():
             "X-Real-IP": random_ip
         }
 
-        test_url = "http://pubproxy.com/api/proxy?limit=1&type=http&https=true"
+        test_url = "http://pubproxy.com/api/proxy?limit=1&type=http&https=true&speed=60"
         response = requests.get(test_url, headers=headers, verify=False)
         data = response.json()
 
@@ -94,14 +88,10 @@ def extract_video_id(url: str, platform: str) -> str:
     url = urllib.parse.unquote(url)
     if platform == "instagram":
         match = re.search(r"instagram\.com/reel/([^/?]+)", url)
-        if not match:
-            match = re.search(r"instagram\.com/p/([^/?]+)", url) 
     elif platform == "tiktok":
         match = re.search(r"tiktok\.com/@[^/]+/video/(\d+)", url)
     elif platform == "youtube":
         match = re.search(r"youtube\.com/watch\?v=([^&]+)", url)
-        if not match:
-            match = re.search(r"youtu\.be/([^/?]+)", url)
     elif platform == "facebook":
         match = re.search(r"facebook\.com/.*/videos/(\d+)", url)
     elif platform == "twitch":
@@ -143,65 +133,212 @@ def instagram_login(username: str, password: str):
         raise HTTPException(status_code=401, detail="Authentication failed")
 
 def tiktok_login(username: str, password: str):
+    login_url = "https://www.tiktok.com/login/"
     session = requests.Session()
-    return session
+
+    login_data = {
+        "username": username,
+        "password": password
+    }
+
+    response = session.post(login_url, data=login_data)
+
+    if response.status_code == 200:
+        return session
+    else:
+        raise HTTPException(status_code=401, detail="Authentication failed")
 
 def youtube_login(username: str, password: str):
+    login_url = "https://accounts.google.com/ServiceLogin"
     session = requests.Session()
-    return session
+
+    login_data = {
+        "username": username,
+        "password": password
+    }
+
+    response = session.post(login_url, data=login_data)
+
+    if response.status_code == 200:
+        return session
+    else:
+        raise HTTPException(status_code=401, detail="Authentication failed")
 
 def facebook_login(username: str, password: str):
+    login_url = "https://www.facebook.com/login"
     session = requests.Session()
-    return session
+
+    login_data = {
+        "email": username,
+        "pass": password
+    }
+
+    response = session.post(login_url, data=login_data)
+
+    if response.status_code == 200:
+        return session
+    else:
+        raise HTTPException(status_code=401, detail="Authentication failed")
 
 def twitch_login(username: str, password: str):
+    login_url = "https://www.twitch.tv/login"
     session = requests.Session()
-    return session
+
+    login_data = {
+        "login": username,
+        "password": password
+    }
+
+    response = session.post(login_url, data=login_data)
+
+    if response.status_code == 200:
+        return session
+    else:
+        raise HTTPException(status_code=401, detail="Authentication failed")
 
 def spotify_login(username: str, password: str):
+    login_url = "https://accounts.spotify.com/api/token"
     session = requests.Session()
-    return session
 
-def simulate_view(video_id: str, platform: str, proxy: str, session: requests.Session):
+    login_data = {
+        "username": username,
+        "password": password
+    }
+
+    response = session.post(login_url, data=login_data)
+
+    if response.status_code == 200:
+        return session
+    else:
+        raise HTTPException(status_code=401, detail="Authentication failed")
+
+def simulate_instagram_view(video_id: str, proxy: str, session: requests.Session):
     proxies = {
-        "http": f"http://{proxy}"
+        "http": f"http://{proxy}",
+        "https": f"http://{proxy}"
     }
-    fake = Faker()
-    fake_ipv4 = fake.ipv4()
+    fake_ipv4 = fakexd.ipv4()
     headers = {
         "User-Agent": fake.user_agent(),
         "X-Forwarded-For": fake_ipv4,
         "Client-IP": fake_ipv4,
         "X-Real-IP": fake_ipv4
     }
-    
     try:
-        if platform == "instagram":
-            view_url = f"https://www.instagram.com/reel/{video_id}"
-        elif platform == "tiktok":
-            view_url = f"https://www.tiktok.com/@user/video/{video_id}"
-        elif platform == "youtube":
-            view_url = f"https://www.youtube.com/watch?v={video_id}"
-        elif platform == "facebook":
-            view_url = f"https://www.facebook.com/{video_id}"
-        elif platform == "twitch":
-            view_url = f"https://www.twitch.tv/videos/{video_id}"
-        elif platform == "spotify":
-            view_url = f"https://open.spotify.com/track/{video_id}"
-        else:
-            print(f"Unsupported platform: {platform}")
-            return
+        view_url = f"https://www.instagram.com/reel/{video_id}"
+        response = session.get(view_url, headers=headers, proxies=proxies)
+        embed_link = f"https://www.instagram.com/p/{video_id}/embed/"
+        embed_link_with_start = f"{embed_link}?start={rand(4, 8)}"
+        print(embed_link_with_start)
+    except Exception as e:
+        print(f"Error in simulate_instagram_view: {e}")
 
+def simulate_tiktok_view(video_id: str, proxy: str, session: requests.Session):
+    proxies = {
+        "http": f"http://{proxy}",
+        "https": f"http://{proxy}"
+    }
+    fake_ipv4 = fakexd.ipv4()
+    headers = {
+        "User-Agent": fake.user_agent(),
+        "X-Forwarded-For": fake_ipv4,
+        "Client-IP": fake_ipv4,
+        "X-Real-IP": fake_ipv4
+    }
+    try:
+        view_url = f"https://www.tiktok.com/@user/video/{video_id}"
         response = session.get(view_url, headers=headers, proxies=proxies)
-        if response.status_code == 200:
-            print(f"Successfully sent view to {platform} video: {video_id}")
-        else:
-            print(f"Failed to send view to {platform} video: {video_id}, Status Code: {response.status_code}")
+        embed_link = f"https://www.tiktok.com/embed/v/{video_id}"
+        embed_link_with_start = f"{embed_link}?start={rand(4, 8)}"
+        print(embed_link_with_start)
+    except Exception as e:
+        print(f"Error in simulate_tiktok_view: {e}")
 
+def simulate_youtube_view(video_id: str, proxy: str, session: requests.Session):
+    proxies = {
+        "http": f"http://{proxy}",
+        "https": f"http://{proxy}"
+    }
+    fake_ipv4 = fakexd.ipv4()
+    headers = {
+        "User-Agent": fake.user_agent(),
+        "X-Forwarded-For": fake_ipv4,
+        "Client-IP": fake_ipv4,
+        "X-Real-IP": fake_ipv4
+    }
+    try:
+        view_url = f"https://www.youtube.com/watch?v={video_id}"
+        response = session.get(view_url, headers=headers, proxies=proxies)
+        embed_link = f"https://www.youtube.com/embed/{video_id}"
+        embed_link_with_start = f"{embed_link}?controls=0&start={rand(4, 8)}"
+        print(embed_link_with_start)
+    except Exception as e:
+        print(f"Error in simulate_youtube_view: {e}")
+
+def simulate_facebook_view(video_id: str, proxy: str, session: requests.Session):
+    proxies = {
+        "http": f"http://{proxy}",
+        "https": f"http://{proxy}"
+    }
+    fake_ipv4 = fakexd.ipv4()
+    headers = {
+        "User-Agent": fake.user_agent(),
+        "X-Forwarded-For": fake_ipv4,
+        "Client-IP": fake_ipv4,
+        "X-Real-IP": fake_ipv4
+    }
+    try:
+        view_url = f"https://www.facebook.com/{video_id}"
+        response = session.get(view_url, headers=headers, proxies=proxies)
+        embed_link = f"https://www.facebook.com/plugins/video.php?href=https://www.facebook.com/{video_id}/&show_text=0&width=560&height=315"
+        embed_link_with_start = f"{embed_link}&start={rand(4, 8)}"
+        print(embed_link_with_start)
+    except Exception as e:
+        print(f"Error in simulate_facebook_view: {e}")
+
+def simulate_twitch_view(video_id: str, proxy: str, session: requests.Session):
+    proxies = {
+        "http": f"http://{proxy}",
+        "https": f"http://{proxy}"
+    }
+    fake_ipv4 = fakexd.ipv4()
+    headers = {
+        "User-Agent": fake.user_agent(),
+        "X-Forwarded-For": fake_ipv4,
+        "Client-IP": fake_ipv4,
+        "X-Real-IP": fake_ipv4
+    }
+    try:
+        view_url = f"https://www.twitch.tv/videos/{video_id}"
+        response = session.get(view_url, headers=headers, proxies=proxies)
+        embed_link = f"https://player.twitch.tv/?video=v{video_id}&parent=www.example.com&autoplay=false&muted=false"
+        embed_link_with_start = f"{embed_link}&start={rand(4, 8)}"
+        print(embed_link_with_start)
+    except Exception as e:
+        print(f"Error in simulate_twitch_view: {e}")
+
+def simulate_spotify_view(video_id: str, proxy: str, session: requests.Session):
+    proxies = {
+        "http": f"http://{proxy}",
+        "https": f"http://{proxy}"
+    }
+    fake_ipv4 = fakexd.ipv4()
+    headers = {
+        "User-Agent": fake.user_agent(),
+        "X-Forwarded-For": fake_ipv4,
+        "Client-IP": fake_ipv4,
+        "X-Real-IP": fake_ipv4
+    }
+    try:
+        view_url = f"https://open.spotify.com/track/{video_id}"
+        response = session.get(view_url, headers=headers, proxies=proxies)
+        embed_link = f"https://open.spotify.com/embed/track/{video_id}"
+        embed_link_with_start = f"{embed_link}?start={rand(4, 8)}"
+        print(embed_link_with_start)
     except Exception as e:
-        print(f"Error in simulate_view for {platform}: {e}")
+        print(f"Error in simulate_spotify_view: {e}")
 
-async def simulate_views(url: str, platform: str, count: int, delay: int, session: requests.Session):
+def simulate_views(url: str, platform: str, count: int, delay: int, parallel_processes: int, session: requests.Session):
     video_id = extract_video_id(url, platform)
     proxy = get_random_proxy()
     
@@ -209,20 +346,31 @@ async def simulate_views(url: str, platform: str, count: int, delay: int, sessio
         print("No proxy available.")
         return
 
-    for _ in tqdm(range(count), desc=f"Simulating views for {url}", unit="view"):
-        simulate_view(video_id, platform, proxy, session)
-        await asyncio.sleep(delay)
+    for _ in tqdm(range(count), desc=f"Simulating views for {url}"):
+        if platform == "instagram":
+            simulate_instagram_view(video_id, proxy, session)
+        elif platform == "tiktok":
+            simulate_tiktok_view(video_id, proxy, session)
+        elif platform == "youtube":
+            simulate_youtube_view(video_id, proxy, session)
+        elif platform == "facebook":
+            simulate_facebook_view(video_id, proxy, session)
+        elif platform == "twitch":
+            simulate_twitch_view(video_id, proxy, session)
+        elif platform == "spotify":
+            simulate_spotify_view(video_id, proxy, session)
 
 @app.post("/simulate_views")
 async def simulate_views_endpoint(request: VisitRequest):
     try:
         if os.getenv(f'{request.platform.upper()}_USER') and os.getenv(f'{request.platform.upper()}_PASSWORD'):
             session = authenticate(os.getenv(f'{request.platform.upper()}_USER'), os.getenv(f'{request.platform.upper()}_PASSWORD'), request.platform)
-            await simulate_views(
+            simulate_views(
                 url=request.url,
                 platform=request.platform,
                 count=request.count,
                 delay=request.delay,
+                parallel_processes=request.parallel_processes,
                 session=session
             )
             return PlainTextResponse("Views simulation started")
@@ -255,100 +403,23 @@ async def login(username: str = Form(...), password: str = Form(...), platform:
     except HTTPException as e:
         return e
 
-total_views = 0
-current_url_index = 0
-total_urls = 0
-simulation_running = False
-stop_event = threading.Event()
-
-@app.get("/views")
-def get_views():
-    return {"views": total_views}
-
-@app.get("/progress")
-def get_progress():
-    if total_urls > 0:
-        progress = (current_url_index / total_urls) * 100
-    else:
-        progress = 0
-    return {"progress": progress}
-
-@app.post("/start_simulation")
-async def start_simulation(urls: str = Form(...), platform: str = Form(...), count: int = Form(...), delay: int = Form(...), parallel_processes: int = Form(...)):
-    global total_views, current_url_index, total_urls, simulation_running, stop_event
-    
-    if simulation_running:
-        return {"message": "Simulation already running."}
-
+@app.post("/simulate")
+async def simulate(urls: str = Form(...), platform: str = Form(...), count: int = Form(...), delay: int = Form(...), parallel_processes: int = Form(...)):
     try:
         if os.getenv(f'{platform.upper()}_USER') and os.getenv(f'{platform.upper()}_PASSWORD'):
             session = authenticate(os.getenv(f'{platform.upper()}_USER'), os.getenv(f'{platform.upper()}_PASSWORD'), platform)
-            urls = urls.split("\n")
-            total_urls = len(urls)
-            current_url_index = 0
-            total_views = 0
-            simulation_running = True
-            stop_event.clear()
-
-            def run_simulation():
-                global total_views, current_url_index
-                for index in range(current_url_index, len(urls)):
-                    if stop_event.is_set():
-                        break
-                    try:
-                        url = urls[index]
-                        video_id = extract_video_id(url, platform)
-                        proxy = get_random_proxy()
-
-                        if not proxy:
-                            print("No proxy available.")
-                            continue
-
-                        fake = Faker()
-                        fake_ipv4 = fake.ipv4()
-                        headers = {
-                            "User-Agent": fake.user_agent(),
-                            "X-Forwarded-For": fake_ipv4,
-                            "Client-IP": fake_ipv4,
-                            "X-Real-IP": fake_ipv4
-                        }
-                        proxies = {
-                            "http": f"http://{proxy}"
-                        }
-
-                        for _ in range(count):
-                            if stop_event.is_set():
-                                break
-                            simulate_view(video_id, platform, proxy, session)
-                            total_views += 1
-                            time.sleep(delay)
-                    
-                        current_url_index = index + 1
-
-                    except Exception as e:
-                        print(f"Error processing URL {index+1}: {e}")
-                
-                global simulation_running
-                simulation_running = False
-                print("Simulation completed.")
-
-            thread = threading.Thread(target=run_simulation)
-            thread.start()
-            return {"message": "Simulation started."}
+            for index, url in enumerate(urls.split("\n")):
+                try:
+                    simulate_views(url, platform, count, delay, parallel_processes, session)
+                    print(f"Simulation started for URL {index+1}: {url}")
+                except Exception as e:
+                    print(f"Error processing URL {index+1}: {e}")
+            
+            return PlainTextResponse("Simulation completed.")
         else:
-            return {"message": "Credentials not found for this platform."}
+            return PlainTextResponse("Credentials not found for this platform.")
     except Exception as e:
-        return {"message": str(e)}
-
-@app.post("/stop_simulation")
-async def stop_simulation():
-    global simulation_running, stop_event
-    if simulation_running:
-        stop_event.set()
-        simulation_running = False
-        return {"message": "Simulation stopped."}
-    else:
-        return {"message": "Simulation is not running."}
+        return PlainTextResponse(str(e), status_code=500)
 
 @app.get("/")
 async def main_page():
@@ -418,30 +489,16 @@ async def main_page():
                         opacity: 1;
                     }
                 }
-                #progress-bar {
-                    width: 100%;
-                    height: 30px;
-                    background-color: #ddd;
-                    border-radius: 5px;
-                    overflow: hidden;
-                    margin-bottom: 20px;
-                }
-                #progress-bar-fill {
-                    height: 100%;
-                    background-color: #007bff;
-                    width: 0%;
-                    transition: width 0.5s ease-in-out;
-                }
             </style>
         </head>
         <body>
             <div class="container">
                 <h1>Video Views Simulator</h1>
-                <form action="/start_simulation" method="post">
+                <form action="/simulate" method="post">
                     <label for="urls">Video URLs (one per line):</label><br>
-                    <textarea id="urls" name="urls" required></textarea><br><br>
+                    <textarea id="urls" name="urls"></textarea><br><br>
                     <label for="platform">Platform:</label><br>
-                    <select id="platform" name="platform" required>
+                    <select id="platform" name="platform">
                         <option value="instagram">Instagram</option>
                         <option value="tiktok">TikTok</option>
                         <option value="youtube">YouTube</option>
@@ -449,72 +506,23 @@ async def main_page():
                         <option value="twitch">Twitch</option>
                         <option value="spotify">Spotify</option>
                     </select><br><br>
-                    <label for="count">Number of Views per Video:</label><br>
-                    <input type="number" id="count" name="count" value="1" min="1" required><br><br>
-                    <label for="delay">Delay Between Views (seconds):</label><br>
-                    <input type="number" id="delay" name="delay" value="1" min="1" required><br><br>
-                    <input type="submit" value="Start Simulation">
+                    <label for="count">Number of Views:</label><br>
+                    <input type="number" id="count" name="count" value="1"><br><br>
+                    <label for="delay">Delay (seconds):</label><br>
+                    <input type="number" id="delay" name="delay" value="1"><br><br>
+                    <label for="parallel_processes">Parallel Processes:</label><br>
+                    <input type="number" id="parallel_processes" name="parallel_processes" value="1"><br><br>
+                    <input type="submit" value="Simulate">
                 </form>
-                <br>
-                <button id="stop-button" onclick="stopSimulation()" style="display: none;">Stop Simulation</button>
-                <br>
-                <div id="progress-bar">
-                    <div id="progress-bar-fill"></div>
-                </div>
-                <p>Total Views: <span id="total-views">0</span></p>
             </div>
-            
-            <script>
-                let simulationRunning = false;
-
-                function updateProgress() {
-                    fetch('/progress')
-                        .then(response => response.json())
-                        .then(data => {
-                            const progressBarFill = document.getElementById('progress-bar-fill');
-                            progressBarFill.style.width = data.progress + '%';
-                        })
-                        .catch(error => console.error('Error updating progress:', error));
-                }
-                
-                function updateViews() {
-                    fetch('/views')
-                        .then(response => response.json())
-                        .then(data => {
-                            document.getElementById('total-views').innerText = data.views;
-                        })
-                        .catch(error => console.error('Error updating views:', error));
-                }
-
-                function startSimulation() {
-                    simulationRunning = true;
-                    document.getElementById('stop-button').style.display = 'block';
-                    setInterval(updateProgress, 1000); 
-                    setInterval(updateViews, 5000); 
-                }
-
-                function stopSimulation() {
-                    fetch('/stop_simulation', { method: 'POST' })
-                        .then(response => {
-                            if (response.ok) {
-                                simulationRunning = false;
-                                document.getElementById('stop-button').style.display = 'none';
-                                alert('Simulation stopped!');
-                            } else {
-                                alert('Error stopping simulation!');
-                            }
-                        })
-                        .catch(error => console.error('Error stopping simulation:', error));
-                }
-
-                const form = document.querySelector('form');
-                form.addEventListener('submit', startSimulation);
-            </script>
         </body>
         </html>
         """
     )
 
+def rand(min, max):
+    return random.randint(min, max)
+
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)