utils.py

import requests
import json
from datetime import datetime
from openai import OpenAI
import time
import requests
from requests_ip_rotator import ApiGateway
import os
from requests.exceptions import RequestException
from tenacity import retry, stop_after_attempt, wait_exponential
import random
from typing import List, Dict
import logging
from dotenv import load_dotenv

load_dotenv()

logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

openai_key = os.getenv('OPENAI_KEY')

class ProxyManager:
    def __init__(self):
        self.proxy_configs = [
            {
                'username': '',
                'password': ' ',
                'host': 'pr.oxylabs.io',
                'port': '7777'
            },
            {
                'username': '',
                'password': ' _2',
                'host': 'pr.oxylabs.io',
                'port': '7777'
            },
            {
                'username': '',
                'password': ' _3',
                'host': 'pr.oxylabs.io',
                'port': '7777'
            }
        ]
        self.current_proxy_index = 0
        self.failed_proxies: Dict[int, int] = {} 
        self.max_failures = 3  #
        self.cooldown_period = 300  

    def get_current_proxy(self) -> dict:
        return {
            'http': self._format_proxy_url(self.current_proxy_index),
            'https': self._format_proxy_url(self.current_proxy_index)
        }

    def _format_proxy_url(self, index: int) -> str:
        config = self.proxy_configs[index]
        return f"pr.oxylabs.io:10000"

    def rotate_proxy(self) -> dict:
        self.failed_proxies[self.current_proxy_index] = time.time()
        
        attempts = 0
        while attempts < len(self.proxy_configs):
            self.current_proxy_index = (self.current_proxy_index + 1) % len(self.proxy_configs)
            
            if self.current_proxy_index in self.failed_proxies:
                cooldown_time = time.time() - self.failed_proxies[self.current_proxy_index]
                if cooldown_time > self.cooldown_period:
                    del self.failed_proxies[self.current_proxy_index]
                    break
            else:
                break
                
            attempts += 1
        
        if attempts == len(self.proxy_configs):
            raise ProxyRequestError("All proxies are in cooldown period")
            
        logger.info(f"Rotating to proxy {self.current_proxy_index}")
        return self.get_current_proxy()


proxy_manager = ProxyManager()
client = OpenAI(api_key=openai_key)


class ProxyRequestError(Exception):
    pass

@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=10))
def make_request_with_retry(method, url, session, **kwargs):
    try:
        kwargs['proxies'] = proxy_manager.get_current_proxy()
        response = getattr(session, method)(url, **kwargs)
        response.raise_for_status()
        return response
    except RequestException as e:
        logger.warning(f"Request failed with proxy {proxy_manager.current_proxy_index}: {str(e)}")
        try:
            kwargs['proxies'] = proxy_manager.rotate_proxy()
            logger.info(f"Retrying request with new proxy")
            response = getattr(session, method)(url, **kwargs)
            response.raise_for_status()
            return response
        except Exception as retry_error:
            logger.error(f"Retry failed with new proxy: {str(retry_error)}")
            raise ProxyRequestError(f"Request failed after proxy rotation: {str(retry_error)}")

def send_message(channel_id, session, message):
    params = {'ct': 'wdm'}   
    json_data = {
        'content': message,
        'attachments': [],
    }
    headers = {
        'accept': '*/*',
        'accept-language': 'en-US,en;q=0.9',
        'content-type': 'application/json',
        'origin': 'https://www.skool.com',
        'priority': 'u=1, i',
        'referer': 'https://www.skool.com/',
        'sec-ch-ua': '"Chromium";v="130", "Brave";v="130", "Not?A_Brand";v="99"',
        'sec-ch-ua-mobile': '?0',
        'sec-ch-ua-platform': '"Windows"',
        'sec-fetch-dest': 'empty',
        'sec-fetch-mode': 'cors',
        'sec-fetch-site': 'same-site',
        'sec-gpc': '1',
        'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36',
    }

    return make_request_with_retry(
        'post',
        f'https://api.skool.com/channels/{channel_id}/messages',
        session,
        params=params,
        json=json_data,
        headers=headers
    )

def login(email, password, session):
    try:
        session.cookies.set("client_id", "b70f1338975d4b6588b1257c508ce9a1", domain=".skool.com")
        session.cookies.set("auth_token", " ", domain=".skool.com")
        
        return  "hi"
    except Exception as e:
        logger.error(f"Login failed: {str(e)}")
        raise

def open_chat(session, member):
    response = make_request_with_retry(
        'post',
        f"https://api.skool.com/users/{member['id']}/chat-request?g=6f17b5fe3d964b69ad0cacf29d059afd",
        session
    )
    
    data = response.json()
    channel_id = data['channel']['id']
    
    make_request_with_retry(
        'options',
        f"https://api.skool.com/users/{member['id']}/chat-request?g=6f17b5fe3d964b69ad0cacf29d059afd",
        session
    )
    
    make_request_with_retry(
        'get',
        f"https://api.skool.com/channels/{channel_id}/messages?before=35&after=35",
        session
    )
    
    return channel_id


def on_new_member_join(member):
    session = requests.Session()
    print("(activated member join event)")
    login("trisanthsrini@gmail.com", "", session=session)
    
    if (member["id"] != "a3b908ccc5134090b8733749c97bb2a2"):
        channel_id = open_chat(session=session, member=member)
        message = f"""
                
                Hey {str(member['name']).split(" ")[0]},

                Welcome to the Rishab Academy Skool 🎉 This is not an automated message -- my name is Lucy, I'm a student success manager here.

                I wanted to understand what you're most interested in here at the community so I can send you some resources that could be helpful. What things are you most interested in:
                -  ACT/SAT
                -  Scholarships
                -  STEM research and science fair

                Or, it could be multiple! Just let me know. Super nice to meet you once again!

        """
        time.sleep(15)
        send_message(channel_id=channel_id, session=session, message=message)

    else: 
        print("Bot user.")





def get_new_messages(session):
    headers = {
        'accept': '*/*',
        'accept-language': 'en-US,en;q=0.9',
        'content-type': 'application/json',
        'origin': 'https://www.skool.com',
        'priority': 'u=1, i',
        'referer': 'https://www.skool.com/',
        'sec-ch-ua': '"Chromium";v="130", "Brave";v="130", "Not?A_Brand";v="99"',
        'sec-ch-ua-mobile': '?0',
        'sec-ch-ua-platform': '"Windows"',
        'sec-fetch-dest': 'empty',
        'sec-fetch-mode': 'cors',
        'sec-fetch-site': 'same-site',
        'sec-gpc': '1',
        'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36',
    }

    params = {
        'offset': '0',
        'limit': '30',
        'last': 'true',
        'unread-only': 'true',
    }

    response = make_request_with_retry(
        'get',
        'https://api.skool.com/self/chat-channels',
        session,
        params=params,
        headers=headers
    )
    return response.json()

def get_all_messages(session, channel_id):
    response = make_request_with_retry(
        'get',
        f"https://api.skool.com/channels/{channel_id}/messages?before=35&after=35",
        session
    )
    return response.json()["messages"]

def get_message_array(session, channel_id):
    r = make_request_with_retry(
        'get',
        f"https://api.skool.com/channels/{channel_id}/messages?before=35&after=35",
        session
    )
    data = r.json()["messages"]
    messages = convert_messages(data=data)
    return messages

def convert_messages(data):
    messages = []
    for item in data:
        role = 'assistant' if item['metadata']['src'] == 'a3b908ccc5134090b8733749c97bb2a2' else 'user'
        messages.append({'role': role, 'content': item['metadata']['content']})
    
    content = """
You are Lucy Rijker, a student support manager at. You are in a Skool community – an online platform – interacting with students and parents in an academic community run by Rishab Jain, a YouTuber and scientist who helps students with academic resources.


    """
    messages.insert(0, {'role': 'system', 'content': content})
    return messages

def handle_response(session, member):
    channel_id = open_chat(session, member)
    messages = get_message_array(session=session, channel_id=channel_id)
    logger.info("Getting AI response...")
    
    chat_completion = client.chat.completions.create(
        messages=messages,
        model="gpt-3.5-turbo",
    )
    response_text = chat_completion.choices[0].message.content.strip()
    
    logger.info("Sending response...")
    send_message(channel_id=channel_id, session=session, message=response_text)
    return chat_completion

def detect_new_message():
    session = requests.Session()
    try:
        login("trisanthsrin.com", "wdqawd", session=session)
        member = {
                "_id": {"$oid": "test"},
                "id": "test",
                "name": "test",
                "username": "test",
                "bio": "test",
                "last_synced": {"$date": "test"}
            }

        logger.info("Checking for new messages...")

        new_messages = get_new_messages(session=session)
        if new_messages["channels"] is not None:
            for i in new_messages["channels"][0]["user_ids"]:
                if i != "a3b908ccc5134090b8733749c97bb2a2":
                    member["id"] = i
                    logger.info(f"Detected New Message: {i}")
            handle_response(session=session, member=member)

    except ProxyRequestError as e:
        logger.error(f"Proxy error occurred: {str(e)}")
        time.sleep(30)
    except Exception as e:
        logger.error(f"Unexpected error: {str(e)}")
        time.sleep(30)
        
    time.sleep(5)

if __name__ == "__main__":
    try:
        logger.info("Starting Skool bot...")
        detect_new_message()
    except KeyboardInterrupt:
        logger.info("Shutting down Skool bot...")
    except Exception as e:
        logger.error(f"Fatal error: {str(e)}")