Untitled

import requests
from threading import Thread
from time import sleep as slp
from time import time as getTime
from json import loads
from hashlib import sha1
from uuid import uuid4
import hmac
import names
import hashlib
from time import sleep 
import base64
from contextlib import suppress
#from BotAmino import *

import agorartc
import sys
from flask import Flask, request
current=[1]

class MyRtcEngineEventHandler(agorartc.RtcEngineEventHandlerBase):

    def __init__(self, rtc):
        super().__init__()
        self.rtc = rtc

    def onWarning(self, warn, msg):
        if warn != 1031:
            print(f"warn: {warn}")

    def onError(self, err, msg):
        print(f"err: {err}")

    def onJoinChannelSuccess(self, channel, uid, elapsed):
        print("onJoinChannelSuccess")
        rtc.muteLocalAudioStream(True)
        

    def onRejoinChannelSuccess(self, channel, uid, elapsed):
        print("onRejoinChannelSuccess")

    def onLeaveChannel(self, stats):
        print("onLeaveChannel")
    def onAudioMixingStateChanged(self,state,reason):
        print(state)
        if int(state)==710:
            rtc.muteLocalAudioStream(False)
            current.clear()
            current.append(0)

        if int(state)==713:
            rtc.muteLocalAudioStream(True)
            current.clear()
            current.append(1)
        print("compleated")



rtc = agorartc.createRtcEngineBridge()
eventHandler = MyRtcEngineEventHandler(rtc)
rtc.initEventHandler(eventHandler)

rtc.initialize("d544b053e3e94dd2a8f51c6668522372", None, agorartc.AREA_CODE_GLOB & 0xFFFFFFFF)
rtc.enableAudio()
rtc.setAudioProfile(6, 2)
from pprint import pprint
import time
sid="AnsiMSI6IG51bGwsICIwIjogMiwgIjMiOiAwLCAiMiI6ICI4ZDY1YzBkNS1iYWQzLTQwYTUtYmEwYS00YmQ0MTJkMWM1ZGUiLCAiNSI6IDE2NjYyODczMTQsICI0IjogIjEwMy4yMDEuMTM0Ljk5IiwgIjYiOiAxMDB9SuMX2S9TZdFuTlNL9ZRzQDPLW-Q"
import threading
appp = Flask(__name__)
#run_with_ngrok(app)
from yt_dlp import YoutubeDL
import os
import signal
port=sys.argv[-1]
name=names.get_first_name()
#rtc.joinChannel(token['channelKey'], token['channelName'], '', int(token['channelUid']))
#rtc.muteLocalAudioStream(True)
def telecharger(url):
    location="C:\\Users\\Administrator\\Desktop\\sss\\Agora-Python-SDK\\audio\\"
    file=f'{name}.mp3'
    
    
    music = None
    if ("=" in url and "/" in url and " " not in url) or ("/" in url and " " not in url):
        if "=" in url and "/" in url:
            music = url.rsplit("=", 1)[-1]
        elif "/" in url:
            music = url.rsplit("/")[-1]

        rtc.stopAudioMixing()
        try:
            path = os.path.join(location, file)
            os.remove(path)
        
        except Exception as e:
            print(e)
        ydl_opts = {
            'format': 'bestaudio/best',
            'postprocessors': [{
                'key': 'FFmpegExtractAudio',
                'preferredcodec': 'mp3',
                'preferredquality': '192',
                }],
            'extract-audio': True,
            'outtmpl': f"audio/{name}.mp3",
            }

        with YoutubeDL(ydl_opts) as ydl:
            video_length = ydl.extract_info(url,download=False).get('duration')
            print(video_length)
            if int(video_length)<420:
                ydl.extract_info(url,download=True)
                ydl.cache.remove()
                return "done"
            else:
                return "song length exceeded"

        
        

        
    #return "done"

@appp.route("/")
def lo():
    return "Hello Geeks!! from Google Colab"

@appp.route(f'/join', methods=['POST'])
def queon():
    token=loads(request.form.get('data'))
    print(token)
    rtc.joinChannel(token['channelKey'], token['channelName'], '', int(token['channelUid']))
    
    return "yo"

def stop(v):
    try:
        sig = getattr(signal, "SIGKILL", signal.SIGTERM)
        os.kill(os.getpid(), sig)
    except: pass

@appp.route('/type', methods=['POST'])
def leave():
    data=request.form.get("type")
    print(data)
    if data=="pause":
        rtc.pauseAudioMixing()
    if data=="resume":
        rtc.resumeAudioMixing()
    if data=="mute":
        rtc.muteLocalAudioStream(True)
    if data=="unmute":
        rtc.muteLocalAudioStream(False)
    if data=="leave":
        rtc.leaveChannel()
        Thread(target=stop,args=[""]).start()
    return "ill"

@appp.route('/volume', methods=['POST'])
def volume():
    data=request.form.get("volume")
    rtc.adjustAudioMixingVolume(int(data))
    return "tt"


@appp.route('/play', methods=['POST'])
def question():
    
    if current[0]==1:
        url=request.form.get("url")
        
        res=telecharger(url)
        if res=="done":
            rtc.startAudioMixing(f"audio/{name}.mp3", False, True, 1)
            return "done"
        else:
            return "song length exceeded"
    else:
        return "song currently playing"


if __name__ == "__main__":
  appp.run(port=port)