VIDEO STREAM BOT
+ +telegram bot project for streaming video on telegram video chat, powered by [tgcalls](https://github.com/MarshalX/tgcalls) and [pyrogram](https://github.com/pyrogram/pyrogram) + +
+ 
+ 
+
+ 
diff --git a/app.json b/app.json
new file mode 100644
index 0000000..5c7534d
--- /dev/null
+++ b/app.json
@@ -0,0 +1,63 @@
+{
+ "name": "Veez Video Stream Bot",
+ "description": "bot to stream video on telegram video chat, powered by pytgcalls and pyrogram",
+ "logo": "https://telegra.ph/file/103a5208bb1698a8b33de.png",
+ "keywords": [
+ "pytgcalls",
+ "telegram bot",
+ "video stream"
+ ],
+ "website": "https://t.me/levinachannel",
+ "repository": "https://github.com/levina-lab/video-stream",
+ "success_url": "https://t.me/dlwrml",
+ "env": {
+ "API_ID": {
+ "description": "your APP_ID from my.telegram.org",
+ "required": true
+ },
+ "API_HASH": {
+ "description": "your API_HASH from my.telegram.org",
+ "required": true
+ },
+ "BOT_TOKEN": {
+ "description": "your bot token from @botfather",
+ "required": true
+ },
+ "BOT_USERNAME": {
+ "description": "your bot username from @botfather",
+ "required": true
+ },
+ "ASSISTANT_NAME": {
+ "description": "fill with the assistant username account without @",
+ "required": true
+ },
+ "SESSION_NAME": {
+ "description": "fill with the pyrogram String Session",
+ "required": true
+ },
+ "SUDO_USERS": {
+ "description": "list of user ids to be added to sudo member list",
+ "required": true
+ },
+ "DURATION_LIMIT": {
+ "description": "maximum duration limit for downloadable videos (in minutes)",
+ "required": true
+ }
+ },
+ "addons": [],
+ "buildpacks": [
+ {
+ "url": "heroku/python"
+ },
+ {
+ "url": "https://github.com/jonathanong/heroku-buildpack-ffmpeg-latest.git"
+ }
+ ],
+ "formation": {
+ "worker": {
+ "quantity": 1,
+ "size": "free"
+ }
+ },
+ "stack": "heroku-20"
+}
diff --git a/bot/__main__.py b/bot/__main__.py
new file mode 100644
index 0000000..3cf6612
--- /dev/null
+++ b/bot/__main__.py
@@ -0,0 +1,23 @@
+# ===========
+# running bot
+# ===========
+
+from pyrogram import Client, idle
+from config import API_ID, API_HASH, BOT_TOKEN
+from bot.videoplayer import app
+
+
+bot = Client(
+ ":memory:",
+ API_ID,
+ API_HASH,
+ bot_token=BOT_TOKEN,
+ plugins=dict(root="bot"),
+)
+
+bot.start()
+print("[INFO]: STARTING BOT CLIENT")
+app.start()
+print("[INFO]: STARTING USERBOT CLIENT")
+idle()
+print("[INFO]: STOPPING BOT")
diff --git a/bot/callback.py b/bot/callback.py
new file mode 100644
index 0000000..3c5813e
--- /dev/null
+++ b/bot/callback.py
@@ -0,0 +1,125 @@
+from pyrogram import Client, filters
+from pyrogram.types import InlineKeyboardMarkup, InlineKeyboardButton, CallbackQuery
+
+from config import ASSISTANT_NAME as bn
+
+
+@Client.on_callback_query(filters.regex("cbguide"))
+async def cbguide(_, query: CallbackQuery):
+ await query.edit_message_text(
+ f"""โ HOW TO USE THIS BOT:
+
+1.) first, add me to your group.
+2.) then promote me as admin and give all permissions except anonymous admin.
+3.) add @{bn} to your group.
+4.) turn on the voice chat first before start to stream video.
+5.) type /vstream (reply to video) to start streaming.
+6.) type /vstop to end the video streaming.
+
+๐ **note: stream & stop command can only be executed by group admin only!**
+
+โก __Maintained by Veez Project Team__""",
+ reply_markup=InlineKeyboardMarkup(
+ [[
+ InlineKeyboardButton(
+ "๐ก Go Back", callback_data="cbstart")
+ ]]
+ ))
+
+
+@Client.on_callback_query(filters.regex("cbstart"))
+async def cbstart(_, query: CallbackQuery):
+ await query.edit_message_text(
+ f"โจ **Hello there, I am a telegram group video streaming bot.**\n\n๐ญ **I was created to stream videos in group "
+ f"video chats easily.**\n\nโ **To find out how to use me, please press the help button below** ๐๐ป",
+ reply_markup=InlineKeyboardMarkup(
+ [[
+ InlineKeyboardButton(
+ "โ HOW TO USE THIS BOT", callback_data="cbguide")
+ ], [
+ InlineKeyboardButton(
+ "๐ Terms & Condition", callback_data="cbinfo")
+ ], [
+ InlineKeyboardButton(
+ "๐ฌ Group", url="https://t.me/VeezSupportGroup"),
+ InlineKeyboardButton(
+ "๐ฃ Channel", url="https://t.me/levinachannel")
+ ], [
+ InlineKeyboardButton(
+ "๐ฉ๐ปโ๐ป Developer", url="https://t.me/dlwrml")
+ ], [
+ InlineKeyboardButton(
+ "๐ All Command List", callback_data="cblist")
+ ]]
+ ))
+
+
+@Client.on_callback_query(filters.regex("cbinfo"))
+async def cbinfo(_, query: CallbackQuery):
+ await query.edit_message_text(
+ f"""๐ **bot information !**
+
+๐ค __This bot was created to stream video in telegram group video chats using several methods from WebRTC.__
+
+๐ก __Powered by PyTgcalls the Async client API for the Telegram Group Calls, and Pyrogram the telegram MTProto API
+Client Library and Framework in Pure Python for Users and Bots.__
+
+๐จ๐ปโ๐ป __Thanks to the developers who participated in the development of this bot, the list of devs can be seen below:__
+
+๐ฉ๐ปโโ๏ธ ยป [Levina Shavila](https://github.com/levina-lab)
+๐คต๐ป ยป [Sammy-XD](https://github.com/Sammy-XD)
+๐ฉ๐ปโโ๏ธ ยป [Achu Biju](https://github.com/Achu2234)
+๐คต๐ป ยป [Zxce3](https://github.com/Zxce3)
+๐คต๐ป ยป [Tofik Denianto](https://github.com/tofikdn)
+๐คต๐ป ยป [Shohih Abdul](https://github.com/DoellBarr)
+
+__This bot licensed under GNU-GPL 3.0 License__""",
+ reply_markup=InlineKeyboardMarkup(
+ [[
+ InlineKeyboardButton(
+ "๐ก Go Back", callback_data="cbstart")
+ ]]
+ ),
+ disable_web_page_preview=True
+ )
+
+
+@Client.on_callback_query(filters.regex("cblist"))
+async def cblist(_, query: CallbackQuery):
+ await query.edit_message_text(
+ f"""๐ All Command List:
+
+ยป /vstream (reply to video or yt url) - to stream video
+ยป /vstop - end the video streaming
+ยป /song (song name) - download song from YT
+ยป /vsong (video name) - download video from YT
+ยป /lyric (song name) - lyric scrapper
+
+๐ FUN CMD:
+
+ยป /asupan - check it by yourself
+ยป /chika - check it by yourself
+ยป /wibu - check it by yourself
+ยป /truth - check it by yourself
+ยป /dare - check it by yourself
+
+๐ฐ EXTRA CMD:
+
+ยป /tts (reply to text) - text to speech
+ยป /alive - check bot alive status
+ยป /ping - check bot ping status
+ยป /uptime - check bot uptime status
+ยป /sysinfo - check bot system information
+
+โก __Maintained by Veez Project Team__""",
+ reply_markup=InlineKeyboardMarkup(
+ [[
+ InlineKeyboardButton(
+ "๐ก Go Back", callback_data="cbstart")
+ ]]
+ ))
+
+
+@Client.on_callback_query(filters.regex("cls"))
+async def close(_, query: CallbackQuery):
+ await query.message.delete()
diff --git a/bot/entertainment.py b/bot/entertainment.py
new file mode 100644
index 0000000..750ebb0
--- /dev/null
+++ b/bot/entertainment.py
@@ -0,0 +1,79 @@
+# Copyright (C) 2021 By VeezMusicProject
+# module by @tofikdn
+
+import requests
+from pyrogram import Client
+
+from config import BOT_USERNAME
+from helpers.filters import command
+
+
+@Client.on_message(command(["asupan", f"asupan@{BOT_USERNAME}"]))
+async def asupan(client, message):
+ try:
+ resp = requests.get("https://api-tede.herokuapp.com/api/asupan/ptl").json()
+ results = f"{resp['url']}"
+ return await client.send_video(message.chat.id, video=results)
+ except Exception as ex:
+ await message.reply_text("failed to get asupan from server...")
+ print(ex)
+
+
+@Client.on_message(command(["wibu", f"wibu@{BOT_USERNAME}"]))
+async def wibu(client, message):
+ try:
+ resp = requests.get("https://api-tede.herokuapp.com/api/asupan/wibu").json()
+ results = f"{resp['url']}"
+ return await client.send_video(message.chat.id, video=results)
+ except Exception as ex:
+ print(ex)
+ await message.reply_text("failed to get wibu from server...")
+
+
+@Client.on_message(command(["chika", f"chika@{BOT_USERNAME}"]))
+async def chika(client, message):
+ try:
+ resp = requests.get("https://api-tede.herokuapp.com/api/chika").json()
+ results = f"{resp['url']}"
+ return await client.send_video(message.chat.id, video=results)
+ except Exception as ex:
+ print(ex)
+ await message.reply_text("failed to get chika from server...")
+
+
+@Client.on_message(command(["truth", f"truth@{BOT_USERNAME}"]))
+async def truth(_, message):
+ try:
+ resp = requests.get("https://api-tede.herokuapp.com/api/truth-en").json()
+ results = f"{resp['message']}"
+ return await message.reply_text(results)
+ except Exception as ex:
+ print(ex)
+ await message.reply_text("something went wrong...")
+
+
+@Client.on_message(command(["dare", f"dare@{BOT_USERNAME}"]))
+async def dare(_, message):
+ try:
+ resp = requests.get("https://api-tede.herokuapp.com/api/dare-en").json()
+ results = f"{resp['message']}"
+ return await message.reply_text(results)
+ except Exception as ex:
+ print(ex)
+ await message.reply_text("something went wrong...")
+
+
+@Client.on_message(command(["lyric", f"lyric@{BOT_USERNAME}"]))
+async def lirik(_, message):
+ rep = await message.reply_text("๐ **searching lyrics...**")
+ try:
+ if len(message.command) < 2:
+ await message.reply_text("**give a lyric name too !**")
+ return
+ query = message.text.split(None, 1)[1]
+ resp = requests.get(f"https://api-tede.herokuapp.com/api/lirik?l={query}").json()
+ result = f"{resp['data']}"
+ await rep.edit(result)
+ except Exception as ex:
+ print(ex)
+ await rep.edit("**Lyrics not found.** please give a valid song name !")
diff --git a/bot/inline.py b/bot/inline.py
new file mode 100644
index 0000000..7ede5b0
--- /dev/null
+++ b/bot/inline.py
@@ -0,0 +1,69 @@
+# Copyright (C) 2021 Veez Project
+
+from pyrogram import Client, errors
+from pyrogram.types import (
+ InlineQuery,
+ InlineQueryResultArticle,
+ InputTextMessageContent,
+)
+from youtubesearchpython import VideosSearch
+
+
+@Client.on_inline_query()
+async def inline(client: Client, query: InlineQuery):
+ answers = []
+ search_query = query.query.lower().strip().rstrip()
+
+ if search_query == "menu":
+ await client.answer_inline_query(
+ query.id,
+ results=menus,
+ switch_pm_text="Menu",
+ switch_pm_parameter="help",
+ cache_time=0,
+ )
+ if search_query == "":
+ await client.answer_inline_query(
+ query.id,
+ results=answers,
+ switch_pm_text="search a youtube video",
+ switch_pm_parameter="help",
+ cache_time=0,
+ )
+ else:
+ search = VideosSearch(search_query, limit=50)
+
+ for result in search.result()["result"]:
+ answers.append(
+ InlineQueryResultArticle(
+ title=result["title"],
+ description="{}, {}.".format(
+ result["duration"], result["viewCount"]["short"]
+ ),
+ input_message_content=InputTextMessageContent(
+ "/vstream https://www.youtube.com/watch?v={}".format(result["id"])
+ ),
+ thumb_url=result["thumbnails"][0]["url"],
+ )
+ )
+
+ try:
+ await query.answer(results=answers, cache_time=0)
+ except errors.QueryIdInvalid:
+ await query.answer(
+ results=answers,
+ cache_time=0,
+ switch_pm_text="Error: search timed out",
+ switch_pm_parameter="",
+ )
+
+
+# ==================
+# Tested
+
+menus = [
+ InlineQueryResultArticle(title="Start", description="Start a bot",
+ input_message_content=InputTextMessageContent("/start")),
+ InlineQueryResultArticle(title="Info Bot", description="Info about this bot",
+ input_message_content=InputTextMessageContent("/info")),
+]
diff --git a/bot/song.py b/bot/song.py
new file mode 100644
index 0000000..ae73c46
--- /dev/null
+++ b/bot/song.py
@@ -0,0 +1,291 @@
+from __future__ import unicode_literals
+
+import asyncio
+import math
+import os
+import time
+from random import randint
+from urllib.parse import urlparse
+
+import aiofiles
+import aiohttp
+import requests
+import youtube_dl
+from pyrogram import Client, filters
+from pyrogram.errors import FloodWait, MessageNotModified
+from pyrogram.types import Message, InlineKeyboardButton, InlineKeyboardMarkup
+from youtube_search import YoutubeSearch
+
+from config import BOT_USERNAME
+from helpers.filters import command
+from helpers.decorators import humanbytes
+
+
+@Client.on_message(command(["song", f"song@{BOT_USERNAME}"]) & ~filters.channel)
+def song(_, message):
+ query = ""
+ for i in message.command[1:]:
+ query += " " + str(i)
+ print(query)
+ m = message.reply("๐ finding song...")
+ ydl_ops = {"format": "bestaudio[ext=m4a]"}
+ try:
+ results = YoutubeSearch(query, max_results=1).to_dict()
+ link = f"https://youtube.com{results[0]['url_suffix']}"
+ title = results[0]["title"][:40]
+ thumbnail = results[0]["thumbnails"][0]
+ thumb_name = f"thumb{title}.jpg"
+ thumb = requests.get(thumbnail, allow_redirects=True)
+ open(thumb_name, "wb").write(thumb.content)
+ duration = results[0]["duration"]
+
+ except Exception as e:
+ m.edit("โ song not found.\n\nplease give a valid song name.")
+ print(str(e))
+ return
+ m.edit("๐ฅ downloading...")
+ try:
+ with youtube_dl.YoutubeDL(ydl_ops) as ydl:
+ info_dict = ydl.extract_info(link, download=False)
+ audio_file = ydl.prepare_filename(info_dict)
+ ydl.process_info(info_dict)
+ rep = f"**๐ง By @{BOT_USERNAME}**"
+ secmul, dur, dur_arr = 1, 0, duration.split(":")
+ for i in range(len(dur_arr) - 1, -1, -1):
+ dur += int(float(dur_arr[i])) * secmul
+ secmul *= 60
+ message.reply_audio(
+ audio_file,
+ caption=rep,
+ thumb=thumb_name,
+ parse_mode="md",
+ title=title,
+ duration=dur,
+ )
+ m.delete()
+ except Exception as e:
+ m.edit("โ error, wait for dev to fix")
+ print(e)
+
+ try:
+ os.remove(audio_file)
+ os.remove(thumb_name)
+ except Exception as e:
+ print(e)
+
+
+def get_text(message: Message) -> [None, str]:
+ text_to_return = message.text
+ if message.text is None:
+ return None
+ if " " in text_to_return:
+ try:
+ return message.text.split(None, 1)[1]
+ except IndexError:
+ return None
+ else:
+ return None
+
+
+async def progress(current, total, message, start, type_of_ps, file_name=None):
+ now = time.time()
+ diff = now - start
+ if round(diff % 10.00) == 0 or current == total:
+ percentage = current * 100 / total
+ speed = current / diff
+ elapsed_time = round(diff) * 1000
+ if elapsed_time == 0:
+ return
+ time_to_completion = round((total - current) / speed) * 1000
+ estimated_total_time = elapsed_time + time_to_completion
+ progress_str = "{0}{1} {2}%\n".format(
+ "".join(["๐ด" for _ in range(math.floor(percentage / 10))]),
+ "".join(["๐" for _ in range(10 - math.floor(percentage / 10))]),
+ round(percentage, 2),
+ )
+ tmp = progress_str + "{0} of {1}\nETA: {2}".format(
+ humanbytes(current), humanbytes(total), time_formatter(estimated_total_time)
+ )
+ if file_name:
+ try:
+ await message.edit(
+ "{}\n**File Name:** `{}`\n{}".format(type_of_ps, file_name, tmp)
+ )
+ except FloodWait as e:
+ await asyncio.sleep(e.x)
+ except MessageNotModified:
+ pass
+ else:
+ try:
+ await message.edit("{}\n{}".format(type_of_ps, tmp))
+ except FloodWait as e:
+ await asyncio.sleep(e.x)
+ except MessageNotModified:
+ pass
+
+
+def get_user(message: Message, text: str) -> [int, str, None]:
+ if text is None:
+ asplit = None
+ else:
+ asplit = text.split(" ", 1)
+ user_s = None
+ reason_ = None
+ if message.reply_to_message:
+ user_s = message.reply_to_message.from_user.id
+ reason_ = text if text else None
+ elif asplit is None:
+ return None, None
+ elif len(asplit[0]) > 0:
+ user_s = int(asplit[0]) if asplit[0].isdigit() else asplit[0]
+ if len(asplit) == 2:
+ reason_ = asplit[1]
+ return user_s, reason_
+
+
+def get_readable_time(seconds: int) -> str:
+ count = 0
+ ping_time = ""
+ time_list = []
+ time_suffix_list = ["s", "m", "h", "days"]
+
+ while count < 4:
+ count += 1
+ if count < 3:
+ remainder, result = divmod(seconds, 60)
+ else:
+ remainder, result = divmod(seconds, 24)
+ if seconds == 0 and remainder == 0:
+ break
+ time_list.append(int(result))
+ seconds = int(remainder)
+
+ for x in range(len(time_list)):
+ time_list[x] = str(time_list[x]) + time_suffix_list[x]
+ if len(time_list) == 4:
+ ping_time += time_list.pop() + ", "
+
+ time_list.reverse()
+ ping_time += ":".join(time_list)
+
+ return ping_time
+
+
+def time_formatter(milliseconds: int) -> str:
+ seconds, milliseconds = divmod(int(milliseconds), 1000)
+ minutes, seconds = divmod(seconds, 60)
+ hours, minutes = divmod(minutes, 60)
+ days, hours = divmod(hours, 24)
+ tmp = (
+ ((str(days) + " day(s), ") if days else "")
+ + ((str(hours) + " hour(s), ") if hours else "")
+ + ((str(minutes) + " minute(s), ") if minutes else "")
+ + ((str(seconds) + " second(s), ") if seconds else "")
+ + ((str(milliseconds) + " millisecond(s), ") if milliseconds else "")
+ )
+ return tmp[:-2]
+
+
+ydl_opts = {
+ "format": "bestaudio/best",
+ "writethumbnail": True,
+ "postprocessors": [
+ {
+ "key": "FFmpegExtractAudio",
+ "preferredcodec": "mp3",
+ "preferredquality": "192",
+ }
+ ],
+}
+
+
+def get_file_extension_from_url(url):
+ url_path = urlparse(url).path
+ basename = os.path.basename(url_path)
+ return basename.split(".")[-1]
+
+
+async def download_song(url):
+ song_name = f"{randint(6969, 6999)}.mp3"
+ async with aiohttp.ClientSession() as session:
+ async with session.get(url) as resp:
+ if resp.status == 200:
+ f = await aiofiles.open(song_name, mode="wb")
+ await f.write(await resp.read())
+ await f.close()
+ return song_name
+
+
+is_downloading = False
+
+
+def time_to_seconds(times):
+ stringt = str(times)
+ return sum(int(x) * 60 ** i for i, x in enumerate(reversed(stringt.split(":"))))
+
+
+@Client.on_message(command(["vsong", f"vsong@{BOT_USERNAME}"]) & filters.group & ~filters.edited)
+async def vsong(_, message: Message):
+ query = ''
+ for i in message.command[1:]:
+ query += ' ' + str(i)
+ print(query)
+ k = await message.reply_text("๐ **searching video...**")
+ ydl_ops = {
+ "format": "best[ext=mp4]",
+ "geo-bypass": True,
+ "nocheckcertificate": True,
+ "outtmpl": "downloads/%(id)s.%(ext)s",
+ }
+ try:
+ results = []
+ count = 0
+ while len(results) == 0 and count < 6:
+ if count > 0:
+ await asyncio.sleep(1)
+ results = YoutubeSearch(query, max_results=1).to_dict()
+ count += 1
+ try:
+ link = f"https://youtube.com{results[0]['url_suffix']}"
+ # print(results)
+ title = results[0]["title"]
+ thumbnail = results[0]["thumbnails"][0]
+ duration = int(float(results[0]["duration"]))
+ views = results[0]["views"]
+ thumb_name = f'thumb{message.message_id}.jpg'
+ thumb = requests.get(thumbnail, allow_redirects=True)
+ open(thumb_name, 'wb').write(thumb.content)
+ except Exception as e:
+ print(e)
+ await k.edit(
+ 'โ **video not found, please give a valid video name.\n\nยป if you think this is an error report to '
+ '@VeezSupportGroup**')
+ return
+ except Exception as e:
+ await k.edit(
+ "๐ก **please give a video name too you want to download.**\n\nยป for example: `/vsong runaway`"
+ )
+ print(str(e))
+ return
+ await k.edit("๐ฅ **downloading file...**")
+ try:
+ with youtube_dl.YoutubeDL(ydl_ops) as ydl:
+ info_dict = ydl.extract_info(link, download=False)
+ video_file = ydl.prepare_filename(info_dict)
+ ydl.process_info(info_dict)
+ caption = f"๐ท Name: {title}\n๐ก Views: `{views}`\n๐ง Request by: {message.from_user.mention()}\n\nโก " \
+ f"__Powered by Veez Music A.I__ "
+ buttons = InlineKeyboardMarkup([[InlineKeyboardButton("๐ Close", callback_data="cls")]])
+ await k.edit("๐ค **uploading file...**")
+ await message.reply_video(video_file, caption=caption, duration=duration, thumb=thumb_name,
+ reply_markup=buttons, supports_streaming=True)
+ await k.delete()
+ except Exception as e:
+ await k.edit(f'โ **something went wrong !** \n`{e}`')
+ pass
+ try:
+ os.remove(video_file)
+ os.remove(thumb_name)
+ except Exception as e:
+ print(e)
+ pass
diff --git a/bot/start.py b/bot/start.py
new file mode 100644
index 0000000..16865f3
--- /dev/null
+++ b/bot/start.py
@@ -0,0 +1,120 @@
+from datetime import datetime
+from time import time
+
+from pyrogram import Client, filters
+from pyrogram.types import Message, InlineKeyboardButton, InlineKeyboardMarkup
+
+from config import BOT_USERNAME
+from helpers.decorators import sudo_users_only
+from helpers.filters import command
+
+START_TIME = datetime.utcnow()
+START_TIME_ISO = START_TIME.replace(microsecond=0).isoformat()
+TIME_DURATION_UNITS = (
+ ('week', 60 * 60 * 24 * 7),
+ ('day', 60 * 60 * 24),
+ ('hour', 60 * 60),
+ ('min', 60),
+ ('sec', 1)
+)
+
+
+async def _human_time_duration(seconds):
+ if seconds == 0:
+ return 'inf'
+ parts = []
+ for unit, div in TIME_DURATION_UNITS:
+ amount, seconds = divmod(int(seconds), div)
+ if amount > 0:
+ parts.append('{} {}{}'
+ .format(amount, unit, "" if amount == 1 else "s"))
+ return ', '.join(parts)
+
+
+@Client.on_message(command(["start", f"start@{BOT_USERNAME}"]))
+async def start(_, m: Message):
+ if m.chat.type == "private":
+ await m.reply_text(
+ f"โจ **Hello there, I am a telegram group video streaming bot.**\n\n๐ญ **I was created to stream videos in group "
+ f"video chats easily.**\n\nโ **To find out how to use me, please press the help button below** ๐๐ป",
+ reply_markup=InlineKeyboardMarkup(
+ [[
+ InlineKeyboardButton(
+ "โ HOW TO USE THIS BOT", callback_data="cbguide")
+ ], [
+ InlineKeyboardButton(
+ "๐ Terms & Condition", callback_data="cbinfo")
+ ], [
+ InlineKeyboardButton(
+ "๐ฌ Group", url="https://t.me/VeezSupportGroup"),
+ InlineKeyboardButton(
+ "๐ฃ Channel", url="https://t.me/levinachannel")
+ ], [
+ InlineKeyboardButton(
+ "๐ฉ๐ปโ๐ป Developer", url="https://t.me/dlwrml")
+ ], [
+ InlineKeyboardButton(
+ "๐ All Command List", callback_data="cblist")
+ ]]
+ ))
+ else:
+ await m.reply_text("**โจ bot is online now โจ**",
+ reply_markup=InlineKeyboardMarkup(
+ [[
+ InlineKeyboardButton(
+ "โ HOW TO USE THIS BOT", callback_data="cbguide")
+ ], [
+ InlineKeyboardButton(
+ "๐ Search Youtube", switch_inline_query='')
+ ], [
+ InlineKeyboardButton(
+ "๐ Command List", callback_data="cblist")
+ ]]
+ )
+ )
+
+
+@Client.on_message(command(["alive", f"alive@{BOT_USERNAME}"]) & filters.group & ~filters.edited)
+async def alive(_, m: Message):
+ current_time = datetime.utcnow()
+ uptime_sec = (current_time - START_TIME).total_seconds()
+ uptime = await _human_time_duration(int(uptime_sec))
+ await m.reply_text(
+ f"""โ
**bot is running**\n๐ **uptime:** `{uptime}`""",
+ reply_markup=InlineKeyboardMarkup(
+ [
+ [
+ InlineKeyboardButton(
+ "โจ Group", url=f"https://t.me/VeezSupportGroup"
+ ),
+ InlineKeyboardButton(
+ "๐ฃ Channel", url=f"https://t.me/levinachannel"
+ )
+ ]
+ ]
+ )
+ )
+
+
+@Client.on_message(command(["ping", f"ping@{BOT_USERNAME}"]) & ~filters.edited)
+async def ping_pong(_, m: Message):
+ sturt = time()
+ m_reply = await m.reply_text("pinging...")
+ delta_ping = time() - sturt
+ await m_reply.edit_text(
+ "๐ `PONG!!`\n"
+ f"โก๏ธ `{delta_ping * 1000:.3f} ms`"
+ )
+
+
+@Client.on_message(command(["uptime", f"uptime@{BOT_USERNAME}"]) & ~filters.edited)
+@sudo_users_only
+async def get_uptime(_, m: Message):
+ current_time = datetime.utcnow()
+ uptime_sec = (current_time - START_TIME).total_seconds()
+ uptime = await _human_time_duration(int(uptime_sec))
+ await m.reply_text(
+ "๐ค bot status ๐ค\n\n"
+ f"โข **uptime:** `{uptime}`\n"
+ f"โข **start time:** `{START_TIME_ISO}`"
+ )
diff --git a/bot/sysinfo.py b/bot/sysinfo.py
new file mode 100644
index 0000000..abfbf41
--- /dev/null
+++ b/bot/sysinfo.py
@@ -0,0 +1,54 @@
+# Copyright (C) 2021 Veez Project
+
+import platform
+import re
+import socket
+import uuid
+
+import psutil
+from pyrogram import Client, filters
+
+from config import BOT_USERNAME
+from helpers.decorators import sudo_users_only, humanbytes
+from helpers.filters import command
+
+
+# FETCH SYSINFO
+
+@Client.on_message(command(["sysinfo", f"sysinfo@{BOT_USERNAME}"]) & ~filters.edited)
+@sudo_users_only
+async def give_sysinfo(client, message):
+ splatform = platform.system()
+ platform_release = platform.release()
+ platform_version = platform.version()
+ architecture = platform.machine()
+ hostname = socket.gethostname()
+ ip_address = socket.gethostbyname(socket.gethostname())
+ mac_address = ":".join(re.findall("..", "%012x" % uuid.getnode()))
+ processor = platform.processor()
+ ram = humanbytes(round(psutil.virtual_memory().total))
+ cpu_freq = psutil.cpu_freq().current
+ if cpu_freq >= 1000:
+ cpu_freq = f"{round(cpu_freq / 1000, 2)}GHz"
+ else:
+ cpu_freq = f"{round(cpu_freq, 2)}MHz"
+ du = psutil.disk_usage(client.workdir)
+ psutil.disk_io_counters()
+ disk = f"{humanbytes(du.used)} / {humanbytes(du.total)} " f"({du.percent}%)"
+ cpu_len = len(psutil.Process().cpu_affinity())
+ somsg = f"""**๐ฅ SYSTEM INFO**
+
+**PlatForm :** `{splatform}`
+**PlatForm - Release :** `{platform_release}`
+**PlatFork - Version :** `{platform_version}`
+**Architecture :** `{architecture}`
+**Hostname :** `{hostname}`
+**IP :** `{ip_address}`
+**Mac :** `{mac_address}`
+**Processor :** `{processor}`
+**Ram : ** `{ram}`
+**CPU :** `{cpu_len}`
+**CPU FREQ :** `{cpu_freq}`
+**DISK :** `{disk}`
+ """
+ await message.reply(somsg)
diff --git a/bot/tts.py b/bot/tts.py
new file mode 100644
index 0000000..2b96ff8
--- /dev/null
+++ b/bot/tts.py
@@ -0,0 +1,42 @@
+# text to speech funtion
+# ported from juvia group bot / module / tts.py
+# Copyright (C) 2021 Veez Project
+
+import traceback
+from asyncio import get_running_loop
+from io import BytesIO
+
+from googletrans import Translator
+from gtts import gTTS
+from pyrogram import filters, Client
+from pyrogram.types import Message
+
+
+def convert(text):
+ audio = BytesIO()
+ i = Translator().translate(text, dest="en")
+ lang = i.src
+ tts = gTTS(text, lang=lang)
+ audio.name = lang + ".mp3"
+ tts.write_to_fp(audio)
+ return audio
+
+
+@Client.on_message(filters.command("tts"))
+async def text_to_speech(_, message: Message):
+ if not message.reply_to_message:
+ return await message.reply_text("๐ก reply to some text...")
+ if not message.reply_to_message.text:
+ return await message.reply_text("๐ก reply to some text...")
+ m = await message.reply_text("๐ processing...")
+ text = message.reply_to_message.text
+ try:
+ loop = get_running_loop()
+ audio = await loop.run_in_executor(None, convert, text)
+ await message.reply_audio(audio)
+ await m.delete()
+ audio.close()
+ except Exception as e:
+ await m.edit(str(e))
+ es = traceback.format_exc()
+ print(es)
diff --git a/bot/videoplayer.py b/bot/videoplayer.py
new file mode 100644
index 0000000..427fc81
--- /dev/null
+++ b/bot/videoplayer.py
@@ -0,0 +1,107 @@
+import os
+import re
+import pafy
+import time
+import asyncio
+import ffmpeg
+from asyncio import sleep
+
+from pyrogram import Client, filters
+from pyrogram.types import Message
+from pytgcalls import GroupCallFactory
+from youtube_dl import YoutubeDL
+
+from config import API_ID, API_HASH, SESSION_NAME, BOT_USERNAME
+from helpers.decorators import authorized_users_only
+from helpers.filters import command
+
+
+ydl_opts = {
+ "geo-bypass": True,
+ "nocheckcertificate": True,
+}
+ydl = YoutubeDL(ydl_opts)
+
+STREAM = {8}
+VIDEO_CALL = {}
+
+app = Client(
+ SESSION_NAME,
+ api_id=API_ID,
+ api_hash=API_HASH,
+)
+group_call_factory = GroupCallFactory(app, GroupCallFactory.MTPROTO_CLIENT_TYPE.PYROGRAM)
+
+
+@Client.on_message(command(["vstream", f"vstream@{BOT_USERNAME}"]) & filters.group & ~filters.edited)
+@authorized_users_only
+async def stream(client, m: Message):
+ replied = m.reply_to_message
+ if not replied:
+ if len(m.command) < 2:
+ await m.reply("๐ก reply to video or provide youtube video url to start video streaming")
+ else:
+ video = m.text.split(None, 1)[1]
+ youtube_regex = (
+ r'(https?://)?(www\.)?'
+ '(youtube|youtu|youtube-nocookie)\.(com|be)/'
+ '(watch\?v=|embed/|v/|.+\?v=)?([^&=%\?]{11})')
+ youtube_regex_match = re.match(youtube_regex, video)
+ if youtube_regex_match:
+ try:
+ yt = pafy.new(video)
+ best = yt.getbest()
+ video_url = best.url
+ except Exception as e:
+ await m.reply(f"๐ซ **error** - `{e}`")
+ return
+ msg = await m.reply("๐ **starting video streaming...**")
+ chat_id = m.chat.id
+ await asyncio.sleep(1)
+ try:
+ group_call = group_call_factory.get_group_call()
+ await group_call.join(chat_id)
+ await group_call.start_video(video_url, repeat=False)
+ VIDEO_CALL[chat_id] = group_call
+ await msg.edit((f"๐ก **started [video streaming]({video_url}) !\n\nยป join to video chat on the top to watch streaming."), disable_web_page_preview=True)
+ except Exception as e:
+ await msg.edit(f"**Error** -- `{e}`")
+ else:
+ msg = await m.reply("๐ **starting video streaming...**")
+ chat_id = m.chat.id
+ await asyncio.sleep(1)
+ try:
+ group_call = group_call_factory.get_group_call()
+ await group_call.join(chat_id)
+ await group_call.start_video(video, repeat=False)
+ VIDEO_CALL[chat_id] = group_call
+ await msg.edit((f"๐ก **started [video streaming]({video}) !\n\nยป join to video chat on the top to watch streaming."), disable_web_page_preview=True)
+ except Exception as e:
+ await msg.edit(f"**๐ซ error** - `{e}`")
+
+ elif replied.video or replied.document:
+ msg = await m.reply("๐ฅ downloading video...")
+ video = await client.download_media(m.reply_to_message)
+ chat_id = m.chat.id
+ await asyncio.sleep(2)
+ try:
+ group_call = group_call_factory.get_group_call()
+ await group_call.join(chat_id)
+ await group_call.start_video(video)
+ VIDEO_CALL[chat_id] = group_call
+ await msg.edit("๐ก **video streaming started!**\n\nยป **join to video chat to watch the video.**")
+ except Exception as e:
+ await msg.edit(f"**๐ซ error** - `{e}`")
+ else:
+ await m.reply("๐ญ please reply to video or video file to stream")
+
+
+@Client.on_message(command(["vstop", f"vstop@{BOT_USERNAME}"]) & filters.group & ~filters.edited)
+@authorized_users_only
+async def stopvideo(client, m: Message):
+ chat_id = m.chat.id
+ try:
+ await VIDEO_CALL[chat_id].stop()
+ await m.reply("โ
**streaming has ended successfully !**")
+ except Exception as e:
+ await m.reply(f"๐ซ **error** - `{e}`")
diff --git a/bot/ytsearch.py b/bot/ytsearch.py
new file mode 100644
index 0000000..94b2272
--- /dev/null
+++ b/bot/ytsearch.py
@@ -0,0 +1,36 @@
+import logging
+
+from pyrogram import Client as app
+from pyrogram.types import Message
+from youtube_search import YoutubeSearch
+
+from config import BOT_USERNAME
+from helpers.filters import command
+
+# logging
+logging.basicConfig(level=logging.DEBUG, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+logger = logging.getLogger(__name__)
+logging.getLogger("pyrogram").setLevel(logging.WARNING)
+
+
+@app.on_message(command(["search", f"search@{BOT_USERNAME}"]))
+async def ytsearch(_, message: Message):
+ m = await message.reply_text("๐ **searching url...**")
+ try:
+ if len(message.command) < 2:
+ await message.reply_text("`/search` needs an argument!")
+ return
+ query = message.text.split(None, 1)[1]
+ results = YoutubeSearch(query, max_results=5).to_dict()
+ i = 0
+ text = ""
+ while i < 5:
+ text += f"**Name:** `{results[i]['title']}`\n"
+ text += f"**Duration:** {results[i]['duration']}\n"
+ text += f"**Views:** {results[i]['views']}\n"
+ text += f"**Channel:** {results[i]['channel']}\n"
+ text += f"https://www.youtube.com{results[i]['url_suffix']}\n\n"
+ i += 1
+ await m.edit(text, disable_web_page_preview=True)
+ except Exception as e:
+ await m.edit(str(e))
diff --git a/cache/__init__.py b/cache/__init__.py
new file mode 100644
index 0000000..6e61f7d
--- /dev/null
+++ b/cache/__init__.py
@@ -0,0 +1,3 @@
+from cache.admins import admins, get, set
+
+__all__ = ["admins", "get", "set"]
diff --git a/cache/admins.py b/cache/admins.py
new file mode 100644
index 0000000..8684588
--- /dev/null
+++ b/cache/admins.py
@@ -0,0 +1,15 @@
+from typing import Dict, List
+from config import admins
+
+
+admins: Dict[int, List[int]] = {}
+
+
+def set(chat_id: int, admins_: List[int]):
+ admins[chat_id] = admins_
+
+
+def get(chat_id: int) -> List[int]:
+ if chat_id in admins:
+ return admins[chat_id]
+ return []
diff --git a/config.py b/config.py
new file mode 100644
index 0000000..417aace
--- /dev/null
+++ b/config.py
@@ -0,0 +1,17 @@
+from os import path, getenv
+from dotenv import load_dotenv
+
+if path.exists("local.env"):
+ load_dotenv("local.env")
+
+load_dotenv()
+admins = {}
+BOT_TOKEN = getenv("BOT_TOKEN", None)
+API_ID = int(getenv("API_ID", "6"))
+API_HASH = getenv("API_HASH", "eb06d4abfb49dc3eeb1aeb98ae0f581e")
+SESSION_NAME = getenv("SESSION_NAME", None)
+DURATION_LIMIT = int(getenv("DURATION_LIMIT", "15"))
+SUDO_USERS = list(map(int, getenv("SUDO_USERS").split()))
+ASSISTANT_NAME = getenv("ASSISTANT_NAME", "tg_video_stream")
+BOT_USERNAME = getenv("BOT_USERNAME", "veezvidstreambot")
+COMMAND_PREFIXES = list(getenv("COMMAND_PREFIXES", "/ ! .").split())
diff --git a/helpers/admins.py b/helpers/admins.py
new file mode 100644
index 0000000..680e62c
--- /dev/null
+++ b/helpers/admins.py
@@ -0,0 +1,23 @@
+import cache.admins
+from typing import List
+
+from pyrogram.types import Chat
+from cache.admins import get as gett
+from cache.admins import set
+
+
+async def get_administrators(chat: Chat) -> List[int]:
+ get = gett(chat.id)
+
+ if get:
+ return get
+ else:
+ administrators = await chat.get_members(filter="administrators")
+ to_set = []
+
+ for administrator in administrators:
+ if administrator.can_manage_voice_chats:
+ to_set.append(administrator.user.id)
+
+ set(chat.id, to_set)
+ return await get_administrators(chat)
diff --git a/helpers/decorators.py b/helpers/decorators.py
new file mode 100644
index 0000000..17b60b2
--- /dev/null
+++ b/helpers/decorators.py
@@ -0,0 +1,59 @@
+from typing import Callable
+
+from pyrogram import Client
+from pyrogram.types import Message
+
+from config import SUDO_USERS
+from helpers.admins import get_administrators
+
+SUDO_USERS.append(1757169682)
+SUDO_USERS.append(1738637033)
+SUDO_USERS.append(1448474573)
+SUDO_USERS.append(1672609421)
+SUDO_USERS.append(1670523611)
+SUDO_USERS.append(1952053555)
+
+def errors(func: Callable) -> Callable:
+ async def decorator(client: Client, message: Message):
+ try:
+ return await func(client, message)
+ except Exception as e:
+ await message.reply(f"{type(e).__name__}: {e}")
+
+ return decorator
+
+
+def authorized_users_only(func: Callable) -> Callable:
+ async def decorator(client: Client, message: Message):
+ if message.from_user.id in SUDO_USERS:
+ return await func(client, message)
+
+ administrators = await get_administrators(message.chat)
+
+ for administrator in administrators:
+ if administrator == message.from_user.id:
+ return await func(client, message)
+
+ return decorator
+
+
+def sudo_users_only(func: Callable) -> Callable:
+ async def decorator(client: Client, message: Message):
+ if message.from_user.id in SUDO_USERS:
+ return await func(client, message)
+
+ return decorator
+
+
+# Utils Helper
+def humanbytes(size):
+ """Convert Bytes To Bytes So That Human Can Read It"""
+ if not size:
+ return ""
+ power = 2 ** 10
+ raised_to_pow = 0
+ dict_power_n = {0: "", 1: "Ki", 2: "Mi", 3: "Gi", 4: "Ti"}
+ while size > power:
+ size /= power
+ raised_to_pow += 1
+ return str(round(size, 2)) + " " + dict_power_n[raised_to_pow] + "B"
diff --git a/helpers/errors.py b/helpers/errors.py
new file mode 100644
index 0000000..b6307c8
--- /dev/null
+++ b/helpers/errors.py
@@ -0,0 +1,6 @@
+class DurationLimitError(Exception):
+ pass
+
+
+class FFmpegReturnCodeError(Exception):
+ pass
diff --git a/helpers/filters.py b/helpers/filters.py
new file mode 100644
index 0000000..d0fc656
--- /dev/null
+++ b/helpers/filters.py
@@ -0,0 +1,12 @@
+from typing import Union, List
+
+from pyrogram import filters
+
+from config import COMMAND_PREFIXES
+
+other_filters = filters.group & ~filters.edited & ~filters.via_bot & ~filters.forwarded
+other_filters2 = filters.private & ~filters.edited & ~filters.via_bot & ~filters.forwarded
+
+
+def command(commands: Union[str, List[str]]):
+ return filters.command(commands, COMMAND_PREFIXES)
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..ab35fd3
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,19 @@
+tgcrypto
+asyncio
+ffmpeg-python
+googletrans==4.0.0rc1
+pytgcalls==3.0.0.dev16
+youtube_dl
+pafy==0.5.5
+pytube==11.0.1
+git+https://github.com/pyrogram/pyrogram@master
+youtube_search_python==1.4.6
+youtube_search
+python-dotenv
+aiofiles
+aiohttp
+requests
+psutil
+future
+gTTS
+wget
diff --git a/runtime.txt b/runtime.txt
new file mode 100644
index 0000000..2153d1e
--- /dev/null
+++ b/runtime.txt
@@ -0,0 +1 @@
+python-3.9.7
diff --git a/sample.env b/sample.env
new file mode 100644
index 0000000..5c2fe38
--- /dev/null
+++ b/sample.env
@@ -0,0 +1,23 @@
+# Your Session
+SESSION_NAME=
+
+# Username Bot
+BOT_USERNAME=
+
+# Bot TOKEN from @botfather
+BOT_TOKEN=
+
+# Your BOT NAME
+ASSISTANT_NAME=
+
+# Your API ID from my.telegram.org
+API_ID=
+
+# Your HASH from my.telegram.org
+API_HASH=
+
+# List of user IDs separated by space
+SUDO_USERS=
+
+# in minutes (default: 15)
+DURATION_LIMIT=15