├── .gitignore ├── Dockerfile ├── EvilBot ├── __init__.py ├── __main__.py ├── conf.py ├── events.py ├── helper_extra │ ├── admin_rights.py │ ├── aichat.py │ └── badmedia.py ├── modules │ ├── __aifunctions.py.txt │ ├── __aimultilanguage.py │ ├── __core.py │ ├── __country.py │ ├── __encrypt.py │ ├── __english.py │ ├── __forcesubs.py │ ├── __google.py │ ├── __gps.py │ ├── __heroku.py │ ├── __imdb.py │ ├── __init__.py │ ├── __json.py │ ├── __musicals.py │ ├── __nightmode.py │ ├── __shield.py │ ├── __speachtotext.py │ ├── __telegraph.py │ ├── __texttospeech.py │ ├── __tools.py │ ├── __weather.py │ ├── __zip.py │ ├── _pyrogithub.py │ ├── _pyrosaavn.py │ ├── admin.py │ ├── afk.py │ ├── anime.py │ ├── antiflood.py │ ├── approve.py │ ├── backups.py │ ├── bans.py │ ├── blacklist.py │ ├── blacklist_stickers.py │ ├── blacklistusers.py │ ├── chatbot.py │ ├── cleaner.py │ ├── connection.py │ ├── cricketscore.py │ ├── currency_converter.py │ ├── cust_filters.py │ ├── dbcleanup.py │ ├── debug.py │ ├── dev.py │ ├── disable.py │ ├── disasters.py │ ├── emojis.py │ ├── error_handler.py │ ├── eval.py │ ├── feds.py │ ├── fun.py │ ├── fun_strings.py │ ├── get_common_chats.py │ ├── gettime.py │ ├── global_bans.py │ ├── gtranslator.py │ ├── helper_funcs │ │ ├── __init__.py │ │ ├── alternate.py │ │ ├── chat_status.py │ │ ├── extraction.py │ │ ├── filters.py │ │ ├── handlers.py │ │ ├── misc.py │ │ ├── msg_types.py │ │ ├── regex_helper.py │ │ ├── string_handling.py │ │ └── telethn │ │ │ ├── __init__.py │ │ │ └── chatstatus.py │ ├── lewd.py │ ├── locks.py │ ├── log_channel.py │ ├── logomaker.py │ ├── math.py │ ├── misc.py │ ├── modules.py │ ├── music.py │ ├── muting.py │ ├── nightmodebtn.py │ ├── notes.py │ ├── paste.py │ ├── ping.py │ ├── purge.py │ ├── reactions.py │ ├── remote_cmds.py │ ├── reporting.py │ ├── rules.py │ ├── sed.py │ ├── shell.py │ ├── speed_test.py │ ├── sql │ │ ├── __init__.py │ │ ├── afk_sql.py │ │ ├── aihelp_sql.py │ │ ├── antiflood_sql.py │ │ ├── approve_sql.py │ │ ├── blacklist_sql.py │ │ ├── blacklistusers_sql.py │ │ ├── blsticker_sql.py │ │ ├── chatbot_sql.py │ │ ├── cleaner_sql.py │ │ ├── connection_sql.py │ │ ├── cust_filters_sql.py │ │ ├── disable_sql.py │ │ ├── feds_sql.py │ │ ├── global_bans_sql.py │ │ ├── locks_sql.py │ │ ├── log_channel_sql.py │ │ ├── notes_sql.py │ │ ├── reporting_sql.py │ │ ├── rss_sql.py │ │ ├── rules_sql.py │ │ ├── userinfo_sql.py │ │ ├── users_sql.py │ │ ├── warns_sql.py │ │ └── welcome_sql.py │ ├── sql_extended │ │ ├── forceSubscribe_sql.py │ │ ├── night_mode_sql.py │ │ └── nsfw_watch_sql.py │ ├── stickers.py │ ├── styletext.py │ ├── tagall.py │ ├── truth_and_dare.py │ ├── truth_and_dare_string.py │ ├── ud.py │ ├── userinfo.py │ ├── users.py │ ├── wallpaper.py │ ├── warns.py │ ├── welcome.py │ ├── wiki.py │ └── zombies.py ├── mongo.py ├── pyrogramee │ ├── dark.py │ ├── errors.py │ ├── fetch.py │ ├── json_prettify.py │ ├── pluginshelper.py │ └── telethonbasics.py ├── resources │ ├── Chopsic.otf │ ├── Evil.jpg │ ├── Maghrib.ttf │ ├── blackbg.jpg │ └── images.jpeg ├── sample_config.py └── utils │ ├── X │ ├── dbfunc.py │ ├── errors.py │ └── filter_groups.py ├── Git_Pull.bat ├── Git_Push.bat ├── Hentai.py ├── LICENSE ├── Procfile ├── README.md ├── Setup venv.bat ├── _config.yml ├── app.json ├── exp.sh ├── heroku.yml ├── profanity_wordlist.txt ├── requirements.txt ├── restart.bat ├── runtime.txt ├── start.bat └── start_service.bat /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # C extensions 7 | *.so 8 | 9 | # Distribution / packaging 10 | .Python 11 | build/ 12 | develop-eggs/ 13 | dist/ 14 | downloads/ 15 | eggs/ 16 | .eggs/ 17 | lib/ 18 | lib64/ 19 | parts/ 20 | sdist/ 21 | var/ 22 | wheels/ 23 | pip-wheel-metadata/ 24 | share/python-wheels/ 25 | *.egg-info/ 26 | .installed.cfg 27 | *.egg 28 | MANIFEST 29 | 30 | # PyInstaller 31 | # Usually these files are written by a python script from a template 32 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 33 | *.manifest 34 | *.spec 35 | 36 | # Installer logs 37 | pip-log.txt 38 | pip-delete-this-directory.txt 39 | 40 | # Unit test / coverage reports 41 | htmlcov/ 42 | .tox/ 43 | .nox/ 44 | .coverage 45 | .coverage.* 46 | .cache 47 | nosetests.xml 48 | coverage.xml 49 | *.cover 50 | *.py,cover 51 | .hypothesis/ 52 | .pytest_cache/ 53 | 54 | # Translations 55 | *.mo 56 | *.pot 57 | 58 | # Django stuff: 59 | *.log 60 | local_settings.py 61 | db.sqlite3 62 | db.sqlite3-journal 63 | 64 | # Flask stuff: 65 | instance/ 66 | .webassets-cache 67 | 68 | # Scrapy stuff: 69 | .scrapy 70 | 71 | # Sphinx documentation 72 | docs/_build/ 73 | 74 | # PyBuilder 75 | target/ 76 | 77 | # Jupyter Notebook 78 | .ipynb_checkpoints 79 | 80 | # IPython 81 | profile_default/ 82 | ipython_config.py 83 | 84 | # pyenv 85 | .python-version 86 | 87 | # pipenv 88 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 89 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 90 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 91 | # install all needed dependencies. 92 | #Pipfile.lock 93 | 94 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow 95 | __pypackages__/ 96 | 97 | # Celery stuff 98 | celerybeat-schedule 99 | celerybeat.pid 100 | 101 | # SageMath parsed files 102 | *.sage.py 103 | 104 | # Environments 105 | .env 106 | .venv 107 | env/ 108 | venv/ 109 | ENV/ 110 | env.bak/ 111 | venv.bak/ 112 | 113 | # Spyder project settings 114 | .spyderproject 115 | .spyproject 116 | 117 | # Rope project settings 118 | .ropeproject 119 | 120 | # mkdocs documentation 121 | /site 122 | 123 | # mypy 124 | .mypy_cache/ 125 | .dmypy.json 126 | dmypy.json 127 | 128 | # Pyre type checker 129 | .pyre/ 130 | -------------------------------------------------------------------------------- /Dockerfile: -------------------------------------------------------------------------------- 1 | # We're using Debian Slim Buster image 2 | FROM python:3.8.5-slim-buster 3 | 4 | ENV PIP_NO_CACHE_DIR 1 5 | 6 | RUN sed -i.bak 's/us-west-2\.ec2\.//' /etc/apt/sources.list 7 | 8 | # Installing Required Packages 9 | RUN apt update && apt upgrade -y && \ 10 | apt install --no-install-recommends -y \ 11 | debian-keyring \ 12 | debian-archive-keyring \ 13 | bash \ 14 | bzip2 \ 15 | curl \ 16 | figlet \ 17 | git \ 18 | util-linux \ 19 | libffi-dev \ 20 | libjpeg-dev \ 21 | libjpeg62-turbo-dev \ 22 | libwebp-dev \ 23 | linux-headers-amd64 \ 24 | musl-dev \ 25 | musl \ 26 | neofetch \ 27 | php-pgsql \ 28 | python3-lxml \ 29 | postgresql \ 30 | postgresql-client \ 31 | python3-psycopg2 \ 32 | libpq-dev \ 33 | libcurl4-openssl-dev \ 34 | libxml2-dev \ 35 | libxslt1-dev \ 36 | python3-pip \ 37 | python3-requests \ 38 | python3-sqlalchemy \ 39 | python3-tz \ 40 | python3-aiohttp \ 41 | openssl \ 42 | pv \ 43 | jq \ 44 | wget \ 45 | python3 \ 46 | python3-dev \ 47 | libreadline-dev \ 48 | libyaml-dev \ 49 | gcc \ 50 | sqlite3 \ 51 | libsqlite3-dev \ 52 | sudo \ 53 | zlib1g \ 54 | ffmpeg \ 55 | libssl-dev \ 56 | libgconf-2-4 \ 57 | libxi6 \ 58 | xvfb \ 59 | unzip \ 60 | libopus0 \ 61 | libopus-dev \ 62 | && rm -rf /var/lib/apt/lists /var/cache/apt/archives /tmp 63 | 64 | # Pypi package Repo upgrade 65 | RUN pip3 install --upgrade pip setuptools 66 | 67 | # Copy Python Requirements to /root/EvilBot 68 | RUN git clone -b shiken https://github.com/shrvan42/EvilBot /root/EvilBot 69 | WORKDIR /root/EvilBot 70 | 71 | #Copy config file to /root/EvilBott/EvilBot 72 | COPY ./EvilBot/sample_config.py ./EvilBot/config.py* /root/EvilBot/EvilBot/ 73 | 74 | ENV PATH="/home/bot/bin:$PATH" 75 | 76 | # Install requirements 77 | RUN pip3 install -U -r requirements.txt 78 | 79 | # Starting Worker 80 | CMD ["python3","-m","EvilBot"] 81 | -------------------------------------------------------------------------------- /EvilBot/conf.py: -------------------------------------------------------------------------------- 1 | from envparse import env 2 | from EvilBot import LOGGER 3 | 4 | DEFAULTS = { 5 | "LOAD_MODULES": True, 6 | } 7 | 8 | def get_str_key(name, required=False): 9 | if name in DEFAULTS: 10 | default = DEFAULTS[name] 11 | else: 12 | default = None 13 | if not (data := env.str(name, default=default)) and not required: 14 | LOGGER.warn("No str key: " + name) 15 | return None 16 | elif not data: 17 | LOGGER.critical("No str key: " + name) 18 | sys.exit(2) 19 | else: 20 | return data 21 | 22 | def get_int_key(name, required=False): 23 | if name in DEFAULTS: 24 | default = DEFAULTS[name] 25 | else: 26 | default = None 27 | if not (data := env.int(name, default=default)) and not required: 28 | LOGGER.warn("No int key: " + name) 29 | return None 30 | elif not data: 31 | LOGGER.critical("No int key: " + name) 32 | sys.exit(2) 33 | else: 34 | return data 35 | -------------------------------------------------------------------------------- /EvilBot/helper_extra/admin_rights.py: -------------------------------------------------------------------------------- 1 | from telegram import User, Chat 2 | 3 | 4 | def user_can_promote(chat: Chat, user: User, bot_id: int) -> bool: 5 | return chat.get_member(user.id).can_promote_members 6 | 7 | 8 | def user_can_ban(chat: Chat, user: User, bot_id: int) -> bool: 9 | return chat.get_member(user.id).can_restrict_members 10 | 11 | 12 | def user_can_pin(chat: Chat, user: User, bot_id: int) -> bool: 13 | return chat.get_member(user.id).can_pin_messages 14 | 15 | 16 | def user_can_changeinfo(chat: Chat, user: User, bot_id: int) -> bool: 17 | return chat.get_member(user.id).can_change_info 18 | -------------------------------------------------------------------------------- /EvilBot/helper_extra/aichat.py: -------------------------------------------------------------------------------- 1 | from EvilBot.mongo import client as db_x 2 | 3 | lydia = db_x["CHATBOT"] 4 | talkmode = db_x["TALKMODE"] 5 | 6 | 7 | def add_chat(chat_id): 8 | stark = lydia.find_one({"chat_id": chat_id}) 9 | if stark: 10 | return False 11 | else: 12 | lydia.insert_one({"chat_id": chat_id}) 13 | return True 14 | 15 | 16 | def remove_chat(chat_id): 17 | stark = lydia.find_one({"chat_id": chat_id}) 18 | if not stark: 19 | return False 20 | else: 21 | lydia.delete_one({"chat_id": chat_id}) 22 | return True 23 | 24 | 25 | def get_session(chat_id): 26 | star = talkmode.find_one({"chat_id": chat_id}) 27 | if not star: 28 | return False 29 | else: 30 | return star 31 | -------------------------------------------------------------------------------- /EvilBot/helper_extra/badmedia.py: -------------------------------------------------------------------------------- 1 | from EvilBot import telethn as tbot 2 | import requests 3 | import time 4 | 5 | 6 | 7 | async def is_nsfw(event): 8 | lmao = event 9 | if not ( 10 | lmao.gif 11 | or lmao.video 12 | or lmao.video_note 13 | or lmao.photo 14 | or lmao.sticker 15 | or lmao.media 16 | ): 17 | return False 18 | if lmao.video or lmao.video_note or lmao.sticker or lmao.gif: 19 | try: 20 | starkstark = event.client.download_media(lmao.media, thumb=-1) 21 | except: 22 | return False 23 | elif lmao.photo or lmao.sticker: 24 | try: 25 | starkstark = event.client.download_media(lmao.media) 26 | except: 27 | return False 28 | img = starkstark 29 | f = {"file": (img, open(img, "rb"))} 30 | 31 | r = requests.post("https://starkapi.herokuapp.com/nsfw/", files = f).json() 32 | if r.get("success") is False: 33 | is_nsfw = False 34 | elif r.get("is_nsfw") is True: 35 | is_nsfw = True 36 | elif r.get("is_nsfw") is False: 37 | is_nsfw = False 38 | return is_nsfw 39 | -------------------------------------------------------------------------------- /EvilBot/modules/__aifunctions.py.txt: -------------------------------------------------------------------------------- 1 | # 🙈 Give me ⭐️ before kanging code 2 | # © 🌚 3 | 4 | import requests 5 | url = "https://iamai.p.rapidapi.com/ask" 6 | from EvilBot import telethn, OWNER_ID 7 | from EvilBot.events import register 8 | from telethon import events 9 | from telethon import types 10 | from telethon.tl import functions 11 | import asyncio, os 12 | 13 | @register(pattern="evil (.*)") 14 | async def hmm(event): 15 | test = event.pattern_match.group(1) 16 | r = ('\n \"consent\": true,\n \"ip\": \"::1\",\n \"question\": \"{}\"\n').format(test) 17 | k = f"({r})" 18 | new_string = k.replace("(", "{") 19 | lol = new_string.replace(")","}") 20 | payload = lol 21 | headers = { 22 | 'content-type': "application/json", 23 | 'x-forwarded-for': "", 24 | 'x-rapidapi-key': "33b8b1a671msh1c579ad878d8881p173811jsn6e5d3337e4fc", 25 | 'x-rapidapi-host': "iamai.p.rapidapi.com" 26 | } 27 | 28 | response = requests.request("POST", url, data=payload, headers=headers) 29 | lodu = response.json() 30 | result = (lodu['message']['text']) 31 | if "no no" in result: 32 | pro = "I am fairly yound and I was made by @The_Ghost_Hunter." 33 | try: 34 | async with telethn.action(event.chat_id, 'typing'): 35 | await asyncio.sleep(2) 36 | await event.reply(pro) 37 | except CFError as e: 38 | print(e) 39 | elif "ann" in result: 40 | pro = "My name is evil" 41 | try: 42 | async with telethn.action(event.chat_id, 'typing'): 43 | await asyncio.sleep(2) 44 | await event.reply(pro) 45 | except CFError as e: 46 | print(e) 47 | else: 48 | try: 49 | async with telethn.action(event.chat_id, 'typing'): 50 | await asyncio.sleep(2) 51 | await event.reply(result) 52 | except CFError as e: 53 | print(e) 54 | -------------------------------------------------------------------------------- /EvilBot/modules/__core.py: -------------------------------------------------------------------------------- 1 | from EvilBot import telethn as tbot 2 | from EvilBot.events import register 3 | import os 4 | import asyncio 5 | import os 6 | import time 7 | from datetime import datetime 8 | from EvilBot import OWNER_ID 9 | from EvilBot import TEMP_DOWNLOAD_DIRECTORY as path 10 | from EvilBot import TEMP_DOWNLOAD_DIRECTORY 11 | from datetime import datetime 12 | water = './EvilBot/resources/evil.jpg' 13 | client = tbot 14 | 15 | @register(pattern=r"^/send ?(.*)") 16 | async def Prof(event): 17 | if event.sender_id == OWNER_ID: 18 | pass 19 | else: 20 | return 21 | thumb = water 22 | message_id = event.message.id 23 | input_str = event.pattern_match.group(1) 24 | the_plugin_file = "./EvilBot/modules/{}.py".format(input_str) 25 | if os.path.exists(the_plugin_file): 26 | message_id = event.message.id 27 | await event.client.send_file( 28 | event.chat_id, 29 | the_plugin_file, 30 | force_document=True, 31 | allow_cache=False, 32 | thumb=thumb, 33 | reply_to=message_id, 34 | ) 35 | else: 36 | await event.reply("No File Found!") 37 | 38 | 39 | from EvilBot.events import load_module 40 | import asyncio 41 | import os 42 | from datetime import datetime 43 | from pathlib import Path 44 | 45 | @register(pattern="^/install") 46 | async def install(event): 47 | if event.fwd_from: 48 | return 49 | if event.sender_id == OWNER_ID: 50 | pass 51 | else: 52 | return 53 | if event.reply_to_msg_id: 54 | try: 55 | downloaded_file_name = ( 56 | await event.client.download_media( # pylint:disable=E0602 57 | await event.get_reply_message(), 58 | "EvilBot/modules/", # pylint:disable=E0602 59 | ) 60 | ) 61 | if "(" not in downloaded_file_name: 62 | path1 = Path(downloaded_file_name) 63 | shortname = path1.stem 64 | load_module(shortname.replace(".py", "")) 65 | await event.reply("Installed.... 👍\n `{}`".format( 66 | os.path.basename(downloaded_file_name) 67 | ), 68 | ) 69 | else: 70 | os.remove(downloaded_file_name) 71 | k = await event.reply("**Error!**\n⚠️Cannot Install! \n📂 File not supported \n Or Pre Installed Maybe..😁", 72 | ) 73 | await asyncio.sleep(2) 74 | await k.delete() 75 | except Exception as e: # pylint:disable=C0103,W0703 76 | j = await event.reply(str(e)) 77 | await asyncio.sleep(3) 78 | await j.delete() 79 | os.remove(downloaded_file_name) 80 | await asyncio.sleep(3) 81 | await event.delete() 82 | -------------------------------------------------------------------------------- /EvilBot/modules/__country.py: -------------------------------------------------------------------------------- 1 | from telethon.tl.functions.photos import GetUserPhotosRequest 2 | from telethon.tl.functions.users import GetFullUserRequest 3 | from telethon.tl.types import MessageEntityMentionName 4 | from telethon.utils import get_input_location 5 | import flag 6 | import html, os 7 | from countryinfo import CountryInfo 8 | from EvilBot import telethn as borg 9 | from EvilBot.events import register 10 | 11 | 12 | @register(pattern="^/country (.*)") 13 | async def msg(event): 14 | if event.fwd_from: 15 | return 16 | input_str = event.pattern_match.group(1) 17 | lol = input_str 18 | country = CountryInfo(lol) 19 | try: 20 | a = country.info() 21 | except: 22 | await event.reply("Country Not Avaiable Currently") 23 | name = a.get("name") 24 | bb= a.get("altSpellings") 25 | hu = '' 26 | for p in bb: 27 | hu += p+", " 28 | 29 | area = a.get("area") 30 | borders = "" 31 | hell = a.get("borders") 32 | for fk in hell: 33 | borders += fk+", " 34 | 35 | call = "" 36 | WhAt = a.get("callingCodes") 37 | for what in WhAt: 38 | call+= what+" " 39 | 40 | capital = a.get("capital") 41 | currencies = "" 42 | fker = a.get("currencies") 43 | for FKer in fker: 44 | currencies += FKer+", " 45 | 46 | HmM = a.get("demonym") 47 | geo = a.get("geoJSON") 48 | pablo = geo.get("features") 49 | Pablo = pablo[0] 50 | PAblo = Pablo.get("geometry") 51 | EsCoBaR= PAblo.get("type") 52 | iso = "" 53 | iSo = a.get("ISO") 54 | for hitler in iSo: 55 | po = iSo.get(hitler) 56 | iso += po+", " 57 | fla = iSo.get("alpha2") 58 | nox = fla.upper() 59 | okie = flag.flag(nox) 60 | 61 | languages = a.get("languages") 62 | lMAO="" 63 | for lmao in languages: 64 | lMAO += lmao+", " 65 | 66 | nonive = a.get("nativeName") 67 | waste = a.get("population") 68 | reg = a.get("region") 69 | sub = a.get("subregion") 70 | tik = a.get("timezones") 71 | tom ="" 72 | for jerry in tik: 73 | tom+=jerry+", " 74 | 75 | GOT = a.get("tld") 76 | lanester = "" 77 | for targaryen in GOT: 78 | lanester+=targaryen+", " 79 | 80 | wiki = a.get("wiki") 81 | 82 | caption = f"""Information Gathered Successfully 83 | 84 | Country Name:- {name} 85 | Alternative Spellings:- {hu} 86 | Country Area:- {area} square kilometers 87 | Borders:- {borders} 88 | Calling Codes:- {call} 89 | Country's Capital:- {capital} 90 | Country's currency:- {currencies} 91 | Country's Flag:- {okie} 92 | Demonym:- {HmM} 93 | Country Type:- {EsCoBaR} 94 | ISO Names:- {iso} 95 | Languages:- {lMAO} 96 | Native Name:- {nonive} 97 | population:- {waste} 98 | Region:- {reg} 99 | Sub Region:- {sub} 100 | Time Zones:- {tom} 101 | Top Level Domain:- {lanester} 102 | wikipedia:- {wiki} 103 | 104 | Gathered By Evil. 105 | """ 106 | 107 | 108 | await borg.send_message( 109 | event.chat_id, 110 | caption, 111 | parse_mode="HTML", 112 | ) 113 | 114 | await event.delete() 115 | -------------------------------------------------------------------------------- /EvilBot/modules/__encrypt.py: -------------------------------------------------------------------------------- 1 | from EvilBot import telethn as tbot 2 | import os 3 | from EvilBot.events import register 4 | import secureme 5 | 6 | @register(pattern="^/encrypt ?(.*)") 7 | async def hmm(event): 8 | if event.reply_to_msg_id: 9 | lel = await event.get_reply_message() 10 | cmd = lel.text 11 | else: 12 | cmd = event.pattern_match.group(1) 13 | Text = cmd 14 | k = secureme.encrypt(Text) 15 | await event.reply(k) 16 | 17 | @register(pattern="^/decrypt ?(.*)") 18 | async def hmm(event): 19 | if event.reply_to_msg_id: 20 | lel = await event.get_reply_message() 21 | ok = lel.text 22 | else: 23 | ok = event.pattern_match.group(1) 24 | Text = ok 25 | k = secureme.decrypt(Text) 26 | await event.reply(k) 27 | -------------------------------------------------------------------------------- /EvilBot/modules/__english.py: -------------------------------------------------------------------------------- 1 | from EvilBot import telethn as tbot 2 | import json 3 | import os 4 | os.system("pip installPyDictionary") 5 | import requests 6 | from EvilBot.events import register 7 | from telethon import * 8 | from telethon.tl import functions 9 | import os 10 | import urllib.request 11 | from typing import List 12 | from typing import Optional 13 | from PyDictionary import PyDictionary 14 | from telethon.tl import types 15 | from telethon.tl.types import * 16 | 17 | 18 | API_KEY = "6ae0c3a0-afdc-4532-a810-82ded0054236" 19 | URL = "http://services.gingersoftware.com/Ginger/correct/json/GingerTheText" 20 | 21 | 22 | @register(pattern="^/spell(?: |$)(.*)") 23 | async def _(event): 24 | ctext = await event.get_reply_message() 25 | msg = ctext.text 26 | # print (msg) 27 | params = dict(lang="US", clientVersion="2.0", apiKey=API_KEY, text=msg) 28 | 29 | res = requests.get(URL, params=params) 30 | changes = json.loads(res.text).get("LightGingerTheTextResult") 31 | curr_string = "" 32 | prev_end = 0 33 | 34 | for change in changes: 35 | start = change.get("From") 36 | end = change.get("To") + 1 37 | suggestions = change.get("Suggestions") 38 | if suggestions: 39 | sugg_str = suggestions[0].get("Text") 40 | curr_string += msg[prev_end:start] + sugg_str 41 | prev_end = end 42 | 43 | curr_string += msg[prev_end:] 44 | await event.reply(curr_string) 45 | 46 | 47 | dictionary = PyDictionary() 48 | 49 | 50 | @register(pattern="^/define") 51 | async def _(event): 52 | text = event.text[len("/define ") :] 53 | word = f"{text}" 54 | let = dictionary.meaning(word) 55 | set = str(let) 56 | jet = set.replace("{", "") 57 | net = jet.replace("}", "") 58 | got = net.replace("'", "") 59 | await event.reply(got) 60 | 61 | 62 | @register(pattern="^/synonyms") 63 | async def _(event): 64 | text = event.text[len("/synonyms ") :] 65 | word = f"{text}" 66 | let = dictionary.synonym(word) 67 | set = str(let) 68 | jet = set.replace("{", "") 69 | net = jet.replace("}", "") 70 | got = net.replace("'", "") 71 | await event.reply(got) 72 | 73 | 74 | @register(pattern="^/antonyms") 75 | async def _(event): 76 | text = message.text[len("/antonyms ") :] 77 | word = f"{text}" 78 | let = dictionary.antonym(word) 79 | set = str(let) 80 | jet = set.replace("{", "") 81 | net = jet.replace("}", "") 82 | got = net.replace("'", "") 83 | await event.reply(got) 84 | 85 | 86 | 87 | __help__ = """ 88 | • `/define` ``*:* Type the word or expression you want to search\nFor example /define kill 89 | • `/spell`*:* while replying to a message, will reply with a grammar corrected version 90 | • `/synonyms` ``*:* Find the synonyms of a word 91 | • `/antonyms` ``*:* Find the antonyms of a word 92 | """ 93 | 94 | __mod_name__= "ENGLISH" 95 | -------------------------------------------------------------------------------- /EvilBot/modules/__gps.py: -------------------------------------------------------------------------------- 1 | import os 2 | from EvilBot import telethn as tbot 3 | from geopy.geocoders import Nominatim 4 | from EvilBot.events import register 5 | from EvilBot import * 6 | from telethon import * 7 | from telethon.tl import * 8 | 9 | GMAPS_LOC = "https://maps.googleapis.com/maps/api/geocode/json" 10 | 11 | 12 | @register(pattern="^/gps (.*)") 13 | async def _(event): 14 | args = event.pattern_match.group(1) 15 | 16 | try: 17 | geolocator = Nominatim(user_agent="SkittBot") 18 | location = args 19 | geoloc = geolocator.geocode(location) 20 | longitude = geoloc.longitude 21 | latitude = geoloc.latitude 22 | gm = "https://www.google.com/maps/search/{},{}".format(latitude, longitude) 23 | await tbot.send_file( 24 | event.chat_id, 25 | file=types.InputMediaGeoPoint( 26 | types.InputGeoPoint(float(latitude), float(longitude)) 27 | ), 28 | ) 29 | await event.reply( 30 | "Open with: [🌏Google Maps]({})".format(gm), 31 | link_preview=False, 32 | ) 33 | except Exception as e: 34 | print(e) 35 | await event.reply("I can't find that") 36 | 37 | -------------------------------------------------------------------------------- /EvilBot/modules/__imdb.py: -------------------------------------------------------------------------------- 1 | from EvilBot import telethn as tbot 2 | import os 3 | import re 4 | import bs4 5 | import requests 6 | from telethon import types 7 | from telethon.tl import functions 8 | from EvilBot.events import register 9 | 10 | langi = "en" 11 | 12 | 13 | @register(pattern="^/imdb (.*)") 14 | async def imdb(e): 15 | if e.fwd_from: 16 | return 17 | try: 18 | movie_name = e.pattern_match.group(1) 19 | remove_space = movie_name.split(" ") 20 | final_name = "+".join(remove_space) 21 | page = requests.get( 22 | "https://www.imdb.com/find?ref_=nv_sr_fn&q=" + final_name + "&s=all" 23 | ) 24 | str(page.status_code) 25 | soup = bs4.BeautifulSoup(page.content, "html.parser") 26 | odds = soup.findAll("tr", "odd") 27 | mov_title = odds[0].findNext("td").findNext("td").text 28 | mov_link = ( 29 | "http://www.imdb.com/" + odds[0].findNext("td").findNext("td").a["href"] 30 | ) 31 | page1 = requests.get(mov_link) 32 | soup = bs4.BeautifulSoup(page1.content, "lxml") 33 | if soup.find("div", "poster"): 34 | poster = soup.find("div", "poster").img["src"] 35 | else: 36 | poster = "" 37 | if soup.find("div", "title_wrapper"): 38 | pg = soup.find("div", "title_wrapper").findNext("div").text 39 | mov_details = re.sub(r"\s+", " ", pg) 40 | else: 41 | mov_details = "" 42 | credits = soup.findAll("div", "credit_summary_item") 43 | if len(credits) == 1: 44 | director = credits[0].a.text 45 | writer = "Not available" 46 | stars = "Not available" 47 | elif len(credits) > 2: 48 | director = credits[0].a.text 49 | writer = credits[1].a.text 50 | actors = [] 51 | for x in credits[2].findAll("a"): 52 | actors.append(x.text) 53 | actors.pop() 54 | stars = actors[0] + "," + actors[1] + "," + actors[2] 55 | else: 56 | director = credits[0].a.text 57 | writer = "Not available" 58 | actors = [] 59 | for x in credits[1].findAll("a"): 60 | actors.append(x.text) 61 | actors.pop() 62 | stars = actors[0] + "," + actors[1] + "," + actors[2] 63 | if soup.find("div", "inline canwrap"): 64 | story_line = soup.find("div", "inline canwrap").findAll("p")[0].text 65 | else: 66 | story_line = "Not available" 67 | info = soup.findAll("div", "txt-block") 68 | if info: 69 | mov_country = [] 70 | mov_language = [] 71 | for node in info: 72 | a = node.findAll("a") 73 | for i in a: 74 | if "country_of_origin" in i["href"]: 75 | mov_country.append(i.text) 76 | elif "primary_language" in i["href"]: 77 | mov_language.append(i.text) 78 | if soup.findAll("div", "ratingValue"): 79 | for r in soup.findAll("div", "ratingValue"): 80 | mov_rating = r.strong["title"] 81 | else: 82 | mov_rating = "Not available" 83 | await e.reply( 84 | "​" 85 | "Title : " 86 | + mov_title 87 | + "\n" 88 | + mov_details 89 | + "\nRating : " 90 | + mov_rating 91 | + "\nCountry : " 92 | + mov_country[0] 93 | + "\nLanguage : " 94 | + mov_language[0] 95 | + "\nDirector : " 96 | + director 97 | + "\nWriter : " 98 | + writer 99 | + "\nStars : " 100 | + stars 101 | + "\nIMDB Url : " 102 | + mov_link 103 | + "\nStory Line : " 104 | + story_line, 105 | link_preview=True, 106 | parse_mode="HTML", 107 | ) 108 | except IndexError: 109 | await e.reply("Plox enter **Valid movie name** kthx") 110 | -------------------------------------------------------------------------------- /EvilBot/modules/__init__.py: -------------------------------------------------------------------------------- 1 | from EvilBot import LOAD, LOGGER, NO_LOAD 2 | 3 | 4 | def __list_all_modules(): 5 | import glob 6 | from os.path import basename, dirname, isfile 7 | 8 | # This generates a list of modules in this folder for the * in __main__ to work. 9 | mod_paths = glob.glob(dirname(__file__) + "/*.py") 10 | all_modules = [ 11 | basename(f)[:-3] 12 | for f in mod_paths 13 | if isfile(f) and f.endswith(".py") and not f.endswith("__init__.py") 14 | ] 15 | 16 | if LOAD or NO_LOAD: 17 | to_load = LOAD 18 | if to_load: 19 | if not all( 20 | any(mod == module_name for module_name in all_modules) 21 | for mod in to_load 22 | ): 23 | LOGGER.error("Invalid loadorder names. Quitting.") 24 | quit(1) 25 | 26 | all_modules = sorted(set(all_modules) - set(to_load)) 27 | to_load = list(all_modules) + to_load 28 | 29 | else: 30 | to_load = all_modules 31 | 32 | if NO_LOAD: 33 | LOGGER.info("Not loading: {}".format(NO_LOAD)) 34 | return [item for item in to_load if item not in NO_LOAD] 35 | 36 | return to_load 37 | 38 | return all_modules 39 | 40 | 41 | ALL_MODULES = __list_all_modules() 42 | LOGGER.info("Modules to load: %s", str(ALL_MODULES)) 43 | __all__ = ALL_MODULES + ["ALL_MODULES"] 44 | -------------------------------------------------------------------------------- /EvilBot/modules/__json.py: -------------------------------------------------------------------------------- 1 | import io 2 | from EvilBot.events import register 3 | from EvilBot import telethn as borg 4 | from EvilBot import telethn as pbot 5 | from telethon import types 6 | from telethon import events 7 | from telethon.tl import functions, types 8 | from telethon.tl.types import * 9 | 10 | 11 | async def is_register_admin(chat, user): 12 | if isinstance(chat, (types.InputPeerChannel, types.InputChannel)): 13 | return isinstance( 14 | ( 15 | await tbot(functions.channels.GetParticipantRequest(chat, user)) 16 | ).participant, 17 | (types.ChannelParticipantAdmin, types.ChannelParticipantCreator), 18 | ) 19 | if isinstance(chat, types.InputPeerUser): 20 | return True 21 | 22 | 23 | @register(pattern="^/json$") 24 | async def _(event): 25 | if event.fwd_from: 26 | return 27 | if event.is_group: 28 | if not (await is_register_admin(event.input_chat, event.message.sender_id)): 29 | await event.reply("🚨 Need Admin Pewer.. You can't use this command.. But you can use in my pm") 30 | return 31 | 32 | the_real_message = None 33 | reply_to_id = None 34 | if event.reply_to_msg_id: 35 | previous_message = await event.get_reply_message() 36 | the_real_message = previous_message.stringify() 37 | reply_to_id = event.reply_to_msg_id 38 | else: 39 | the_real_message = event.stringify() 40 | reply_to_id = event.message.id 41 | if len(the_real_message) > 4095: 42 | with io.BytesIO(str.encode(the_real_message)) as out_file: 43 | out_file.name = "json.text" 44 | await borg.send_file( 45 | event.chat_id, 46 | out_file, 47 | force_document=True, 48 | allow_cache=False, 49 | reply_to=reply_to_id, 50 | ) 51 | await event.delete() 52 | else: 53 | await event.reply("`{}`".format(the_real_message)) 54 | 55 | 56 | -------------------------------------------------------------------------------- /EvilBot/modules/__musicals.py: -------------------------------------------------------------------------------- 1 | __mod_name__ = "◎Music" 2 | 3 | __help__ = """ 4 | /video query: download video from youtube 5 | /deezer query: download from deezer 6 | /music query: download song from yt servers. (API BASED) 7 | /lyrics song name : This plugin searches for song lyrics with song name. 8 | /glyrics song name : This plugin searches for song lyrics with song name and artist. 9 | """ 10 | -------------------------------------------------------------------------------- /EvilBot/modules/__speachtotext.py: -------------------------------------------------------------------------------- 1 | from EvilBot import telethn as tbot 2 | import os 3 | import urllib.request 4 | from datetime import datetime 5 | from typing import List 6 | from typing import Optional 7 | import requests 8 | from telethon import * 9 | from telethon import events 10 | from telethon.tl import functions 11 | from telethon.tl import types 12 | from telethon.tl.types import * 13 | 14 | from EvilBot import * 15 | from EvilBot.events import register 16 | 17 | 18 | async def is_register_admin(chat, user): 19 | if isinstance(chat, (types.InputPeerChannel, types.InputChannel)): 20 | return isinstance( 21 | ( 22 | await tbot(functions.channels.GetParticipantRequest(chat, user)) 23 | ).participant, 24 | (types.ChannelParticipantAdmin, types.ChannelParticipantCreator), 25 | ) 26 | if isinstance(chat, types.InputPeerUser): 27 | return True 28 | 29 | 30 | @register(pattern="^/stt$") 31 | async def _(event): 32 | if event.fwd_from: 33 | return 34 | if event.is_group: 35 | if not (await is_register_admin(event.input_chat, event.message.sender_id)): 36 | await event.reply("🚨 Need Admin Pewer.. You can't use this command.. But you can use in my pm") 37 | return 38 | 39 | start = datetime.now() 40 | if not os.path.isdir(TEMP_DOWNLOAD_DIRECTORY): 41 | os.makedirs(TEMP_DOWNLOAD_DIRECTORY) 42 | 43 | if event.reply_to_msg_id: 44 | previous_message = await event.get_reply_message() 45 | required_file_name = await event.client.download_media( 46 | previous_message, TEMP_DOWNLOAD_DIRECTORY 47 | ) 48 | if IBM_WATSON_CRED_URL is None or IBM_WATSON_CRED_PASSWORD is None: 49 | await event.reply( 50 | "You need to set the required ENV variables for this module. \nModule stopping" 51 | ) 52 | else: 53 | # await event.reply("Starting analysis") 54 | headers = { 55 | "Content-Type": previous_message.media.document.mime_type, 56 | } 57 | data = open(required_file_name, "rb").read() 58 | response = requests.post( 59 | IBM_WATSON_CRED_URL + "/v1/recognize", 60 | headers=headers, 61 | data=data, 62 | auth=("apikey", IBM_WATSON_CRED_PASSWORD), 63 | ) 64 | r = response.json() 65 | if "results" in r: 66 | # process the json to appropriate string format 67 | results = r["results"] 68 | transcript_response = "" 69 | transcript_confidence = "" 70 | for alternative in results: 71 | alternatives = alternative["alternatives"][0] 72 | transcript_response += " " + str(alternatives["transcript"]) 73 | transcript_confidence += ( 74 | " " + str(alternatives["confidence"]) + " + " 75 | ) 76 | end = datetime.now() 77 | ms = (end - start).seconds 78 | if transcript_response != "": 79 | string_to_show = "TRANSCRIPT: `{}`\nTime Taken: {} seconds\nConfidence: `{}`".format( 80 | transcript_response, ms, transcript_confidence 81 | ) 82 | else: 83 | string_to_show = "TRANSCRIPT: `Nil`\nTime Taken: {} seconds\n\n**No Results Found**".format( 84 | ms 85 | ) 86 | await event.reply(string_to_show) 87 | else: 88 | await event.reply(r["error"]) 89 | # now, remove the temporary file 90 | os.remove(required_file_name) 91 | else: 92 | await event.reply("Reply to a voice message, to get the text out of it.") 93 | 94 | 95 | __help__ = """ 96 | I can convert text to voice and voice to text.. 97 | ❍ /tts *:* Reply to any message to get text to speech output 98 | ❍ /stt*:* Type in reply to a voice message(support english only) to extract text from it. 99 | *Language Codes* 100 | `af,am,ar,az,be,bg,bn,bs,ca,ceb,co,cs,cy,da,de,el,en,eo,es, 101 | et,eu,fa,fi,fr,fy,ga,gd,gl,gu,ha,haw,hi,hmn,hr,ht,hu,hy, 102 | id,ig,is,it,iw,ja,jw,ka,kk,km,kn,ko,ku,ky,la,lb,lo,lt,lv,mg,mi,mk, 103 | ml,mn,mr,ms,mt,my,ne,nl,no,ny,pa,pl,ps,pt,ro,ru,sd,si,sk,sl, 104 | sm,sn,so,sq,sr,st,su,sv,sw,ta,te,tg,th,tl,tr,uk,ur,uz, 105 | vi,xh,yi,yo,zh,zh_CN,zh_TW,zu` 106 | """ 107 | 108 | __mod_name__ = "TTS/STT" 109 | -------------------------------------------------------------------------------- /EvilBot/modules/__telegraph.py: -------------------------------------------------------------------------------- 1 | from EvilBot.events import register 2 | from EvilBot import telethn as tbot 3 | TMP_DOWNLOAD_DIRECTORY = "./" 4 | from telethon import events 5 | import os 6 | from PIL import Image 7 | from datetime import datetime 8 | from telegraph import Telegraph, upload_file, exceptions 9 | shrvan42 = "EVIL" 10 | telegraph = Telegraph() 11 | r = telegraph.create_account(short_name=shrvan42) 12 | auth_url = r["auth_url"] 13 | 14 | 15 | @register(pattern="^/t(m|xt) ?(.*)") 16 | async def _(event): 17 | if event.fwd_from: 18 | return 19 | optional_title = event.pattern_match.group(2) 20 | if event.reply_to_msg_id: 21 | start = datetime.now() 22 | r_message = await event.get_reply_message() 23 | input_str = event.pattern_match.group(1) 24 | if input_str == "m": 25 | downloaded_file_name = await tbot.download_media( 26 | r_message, 27 | TMP_DOWNLOAD_DIRECTORY 28 | ) 29 | end = datetime.now() 30 | ms = (end - start).seconds 31 | h = await event.reply("Downloaded to {} in {} seconds.".format(downloaded_file_name, ms)) 32 | if downloaded_file_name.endswith((".webp")): 33 | resize_image(downloaded_file_name) 34 | try: 35 | start = datetime.now() 36 | media_urls = upload_file(downloaded_file_name) 37 | except exceptions.TelegraphException as exc: 38 | await h.edit("ERROR: " + str(exc)) 39 | os.remove(downloaded_file_name) 40 | else: 41 | end = datetime.now() 42 | ms_two = (end - start).seconds 43 | os.remove(downloaded_file_name) 44 | await h.edit("Uploaded to https://telegra.ph{})".format(media_urls[0]), link_preview=True) 45 | elif input_str == "xt": 46 | user_object = await tbot.get_entity(r_message.sender_id) 47 | title_of_page = user_object.first_name # + " " + user_object.last_name 48 | # apparently, all Users do not have last_name field 49 | if optional_title: 50 | title_of_page = optional_title 51 | page_content = r_message.message 52 | if r_message.media: 53 | if page_content != "": 54 | title_of_page = page_content 55 | downloaded_file_name = await tbot.download_media( 56 | r_message, 57 | TMP_DOWNLOAD_DIRECTORY 58 | ) 59 | m_list = None 60 | with open(downloaded_file_name, "rb") as fd: 61 | m_list = fd.readlines() 62 | for m in m_list: 63 | page_content += m.decode("UTF-8") + "\n" 64 | os.remove(downloaded_file_name) 65 | page_content = page_content.replace("\n", "
") 66 | response = telegraph.create_page( 67 | title_of_page, 68 | html_content=page_content 69 | ) 70 | end = datetime.now() 71 | ms = (end - start).seconds 72 | await event.reply("Pasted to https://telegra.ph/{} in {} seconds.".format(response["path"], ms), link_preview=True) 73 | else: 74 | await event.reply("Reply to a message to get a permanent telegra.ph link.") 75 | 76 | 77 | def resize_image(image): 78 | im = Image.open(image) 79 | im.save(image, "PNG") 80 | 81 | 82 | -------------------------------------------------------------------------------- /EvilBot/modules/__texttospeech.py: -------------------------------------------------------------------------------- 1 | from EvilBot import telethn as tbot 2 | import os 3 | 4 | from gtts import gTTS 5 | from gtts import gTTSError 6 | from telethon import * 7 | from telethon.tl import functions 8 | from telethon.tl import types 9 | from telethon.tl.types import * 10 | 11 | from EvilBot import * 12 | 13 | from EvilBot.events import register 14 | 15 | 16 | async def is_register_admin(chat, user): 17 | if isinstance(chat, (types.InputPeerChannel, types.InputChannel)): 18 | return isinstance( 19 | ( 20 | await tbot(functions.channels.GetParticipantRequest(chat, user)) 21 | ).participant, 22 | (types.ChannelParticipantAdmin, types.ChannelParticipantCreator), 23 | ) 24 | if isinstance(chat, types.InputPeerUser): 25 | return True 26 | 27 | 28 | @register(pattern="^/tts (.*)") 29 | async def _(event): 30 | if event.fwd_from: 31 | return 32 | if event.is_group: 33 | if not (await is_register_admin(event.input_chat, event.message.sender_id)): 34 | await event.reply("🚨 Need Admin Pewer.. You can't use this command.. But you can use in my pm") 35 | return 36 | 37 | input_str = event.pattern_match.group(1) 38 | reply_to_id = event.message.id 39 | if event.reply_to_msg_id: 40 | previous_message = await event.get_reply_message() 41 | text = previous_message.message 42 | lan = input_str 43 | elif "|" in input_str: 44 | lan, text = input_str.split("|") 45 | else: 46 | await event.reply( 47 | "Invalid Syntax\nFormat `/tts lang | text`\nFor eg: `/tts en | hello`" 48 | ) 49 | return 50 | text = text.strip() 51 | lan = lan.strip() 52 | try: 53 | tts = gTTS(text, tld="com", lang=lan) 54 | tts.save("k.mp3") 55 | except AssertionError: 56 | await event.reply( 57 | "The text is empty.\n" 58 | "Nothing left to speak after pre-precessing, " 59 | "tokenizing and cleaning." 60 | ) 61 | return 62 | except ValueError: 63 | await event.reply("Language is not supported.") 64 | return 65 | except RuntimeError: 66 | await event.reply("Error loading the languages dictionary.") 67 | return 68 | except gTTSError: 69 | await event.reply("Error in Google Text-to-Speech API request !") 70 | return 71 | with open("k.mp3", "r"): 72 | await tbot.send_file( 73 | event.chat_id, "k.mp3", voice_note=True, reply_to=reply_to_id 74 | ) 75 | os.remove("k.mp3") 76 | -------------------------------------------------------------------------------- /EvilBot/modules/__tools.py: -------------------------------------------------------------------------------- 1 | __mod_name__ = "◎Tools" 2 | 3 | __help__ = """ 4 | *Telegraph* 5 | ❍ /tm :Get Telegraph Link Of Replied Media 6 | ❍ /txt :Get Telegraph Link of Replied Text 7 | 8 | *Chatbot* 9 | _Admins only:_ 10 | ❍ /addchat*:* Enables Chatbot mode in the chat. 11 | ❍ /rmchat*:* Disables Chatbot mode in the chat. 12 | 13 | *Date-time-Weather* 14 | ❍ /time *:* Gives information about a timezone. 15 | ❍ /weather *:* Get weather info in a particular place. 16 | ❍ /wttr *:* Advanced weather module, usage same as /weather 17 | ❍ /wttr moon*:* Get the current status of moon 18 | 19 | *Converts* 20 | ❍ /encrypt*:* Encrypts The Given Text 21 | ❍ /decrypt*:* Decrypts Previously Ecrypted Text 22 | ❍ /zip*:* reply to a telegram file to compress it in .zip format 23 | ❍ /unzip*:* reply to a telegram file to decompress it from the .zip format 24 | 25 | *Json* 26 | ❍ /json*:* Get Detailed info about any message 27 | """ 28 | -------------------------------------------------------------------------------- /EvilBot/modules/__weather.py: -------------------------------------------------------------------------------- 1 | from EvilBot import telethn as tbot 2 | import io 3 | import os 4 | import time 5 | 6 | import aiohttp 7 | from telethon import * 8 | from telethon.tl import functions 9 | from telethon.tl import types 10 | from telethon.tl.types import * 11 | 12 | from EvilBot import * 13 | 14 | from EvilBot.events import register 15 | 16 | 17 | async def is_register_admin(chat, user): 18 | if isinstance(chat, (types.InputPeerChannel, types.InputChannel)): 19 | return isinstance( 20 | ( 21 | await tbot(functions.channels.GetParticipantRequest(chat, user)) 22 | ).participant, 23 | (types.ChannelParticipantAdmin, types.ChannelParticipantCreator), 24 | ) 25 | if isinstance(chat, types.InputPeerUser): 26 | return True 27 | 28 | 29 | @register(pattern="^/weather (.*)") 30 | async def _(event): 31 | if event.fwd_from: 32 | return 33 | 34 | sample_url = ( 35 | "https://api.openweathermap.org/data/2.5/weather?q={}&APPID={}&units=metric" 36 | ) 37 | input_str = event.pattern_match.group(1) 38 | async with aiohttp.ClientSession() as session: 39 | response_api_zero = await session.get( 40 | sample_url.format(input_str, OPENWEATHERMAP_ID) 41 | ) 42 | response_api = await response_api_zero.json() 43 | if response_api["cod"] == 200: 44 | country_code = response_api["sys"]["country"] 45 | country_time_zone = int(response_api["timezone"]) 46 | sun_rise_time = int(response_api["sys"]["sunrise"]) + country_time_zone 47 | sun_set_time = int(response_api["sys"]["sunset"]) + country_time_zone 48 | await event.reply( 49 | """**Location**: {} 50 | **Temperature**: {}°С 51 | __minimium__: {}°С 52 | __maximum__ : {}°С 53 | **Humidity**: {}% 54 | **Wind**: {}m/s 55 | **Clouds**: {}hpa 56 | **Sunrise**: {} {} 57 | **Sunset**: {} {}""".format( 58 | input_str, 59 | response_api["main"]["temp"], 60 | response_api["main"]["temp_min"], 61 | response_api["main"]["temp_max"], 62 | response_api["main"]["humidity"], 63 | response_api["wind"]["speed"], 64 | response_api["clouds"]["all"], 65 | # response_api["main"]["pressure"], 66 | time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(sun_rise_time)), 67 | country_code, 68 | time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(sun_set_time)), 69 | country_code, 70 | ) 71 | ) 72 | else: 73 | await event.reply(response_api["message"]) 74 | 75 | 76 | @register(pattern="^/wttr (.*)") 77 | async def _(event): 78 | if event.fwd_from: 79 | return 80 | 81 | sample_url = "https://wttr.in/{}.png" 82 | # logger.info(sample_url) 83 | input_str = event.pattern_match.group(1) 84 | async with aiohttp.ClientSession() as session: 85 | response_api_zero = await session.get(sample_url.format(input_str)) 86 | # logger.info(response_api_zero) 87 | response_api = await response_api_zero.read() 88 | with io.BytesIO(response_api) as out_file: 89 | await event.reply(file=out_file) 90 | -------------------------------------------------------------------------------- /EvilBot/modules/_pyrogithub.py: -------------------------------------------------------------------------------- 1 | # © @Mr_Dark_Prince 2 | import aiohttp 3 | from pyrogram import filters 4 | from EvilBot import pbot 5 | from EvilBot.pyrogramee.errors import capture_err 6 | 7 | 8 | __mod_name__ = "Github" 9 | 10 | 11 | @pbot.on_message(filters.command('github')) 12 | @capture_err 13 | async def github(_, message): 14 | if len(message.command) != 2: 15 | await message.reply_text("/git Username") 16 | return 17 | username = message.text.split(None, 1)[1] 18 | URL = f'https://api.github.com/users/{username}' 19 | async with aiohttp.ClientSession() as session: 20 | async with session.get(URL) as request: 21 | if request.status == 404: 22 | return await message.reply_text("404") 23 | 24 | result = await request.json() 25 | try: 26 | url = result['html_url'] 27 | name = result['name'] 28 | company = result['company'] 29 | bio = result['bio'] 30 | created_at = result['created_at'] 31 | avatar_url = result['avatar_url'] 32 | blog = result['blog'] 33 | location = result['location'] 34 | repositories = result['public_repos'] 35 | followers = result['followers'] 36 | following = result['following'] 37 | caption = f"""**Info Of {name}** 38 | **Username:** `{username}` 39 | **Bio:** `{bio}` 40 | **Profile Link:** [Here]({url}) 41 | **Company:** `{company}` 42 | **Created On:** `{created_at}` 43 | **Repositories:** `{repositories}` 44 | **Blog:** `{blog}` 45 | **Location:** `{location}` 46 | **Followers:** `{followers}` 47 | **Following:** `{following}`""" 48 | except Exception as e: 49 | print(str(e)) 50 | pass 51 | await message.reply_photo(photo=avatar_url, caption=caption) 52 | -------------------------------------------------------------------------------- /EvilBot/modules/_pyrosaavn.py: -------------------------------------------------------------------------------- 1 | # Thanks to @infinity_bots - Williambutcherbot 2 | import os 3 | 4 | import requests 5 | import wget 6 | from pyrogram import filters 7 | 8 | from EvilBot import pbot as Jebot 9 | from EvilBot.pyrogramee.dark import get_arg 10 | 11 | 12 | @Jebot.on_message(filters.command("saavn")) 13 | async def song(client, message): 14 | message.chat.id 15 | message.from_user["id"] 16 | args = get_arg(message) + " " + "song" 17 | if args.startswith(" "): 18 | await message.reply("Enter song name❗") 19 | return "" 20 | m = await message.reply_text( 21 | "Downloading your song,\nPlz wait ⏳️" 22 | ) 23 | try: 24 | r = requests.get(f"https://snobybuddymusic.herokuapp.com/result/?query={args}") 25 | except Exception as e: 26 | await m.edit(str(e)) 27 | return 28 | sname = r.json()[0]["song"] 29 | slink = r.json()[0]["media_url"] 30 | ssingers = r.json()[0]["singers"] 31 | file = wget.download(slink) 32 | ffile = file.replace("mp4", "m4a") 33 | os.rename(file, ffile) 34 | await message.reply_audio(audio=ffile, title=sname, performer=ssingers) 35 | os.remove(ffile) 36 | await m.delete() 37 | -------------------------------------------------------------------------------- /EvilBot/modules/blacklistusers.py: -------------------------------------------------------------------------------- 1 | # Module to blacklist users and prevent them from using commands by @TheRealPhoenix 2 | import html 3 | import EvilBot.modules.sql.blacklistusers_sql as sql 4 | from EvilBot import ( 5 | DEV_USERS, 6 | OWNER_ID, 7 | DRAGONS, 8 | DEMONS, 9 | TIGERS, 10 | WOLVES, 11 | dispatcher, 12 | ) 13 | from EvilBot.modules.helper_funcs.chat_status import dev_plus 14 | from EvilBot.modules.helper_funcs.extraction import ( 15 | extract_user, 16 | extract_user_and_text, 17 | ) 18 | from EvilBot.modules.log_channel import gloggable 19 | from telegram import ParseMode, Update 20 | from telegram.error import BadRequest 21 | from telegram.ext import CallbackContext, CommandHandler, run_async 22 | from telegram.utils.helpers import mention_html 23 | 24 | BLACKLISTWHITELIST = [OWNER_ID] + DEV_USERS + DRAGONS + WOLVES + DEMONS 25 | BLABLEUSERS = [OWNER_ID] + DEV_USERS 26 | 27 | 28 | @run_async 29 | @dev_plus 30 | @gloggable 31 | def bl_user(update: Update, context: CallbackContext) -> str: 32 | message = update.effective_message 33 | user = update.effective_user 34 | bot, args = context.bot, context.args 35 | user_id, reason = extract_user_and_text(message, args) 36 | 37 | if not user_id: 38 | message.reply_text("I doubt that's a user.") 39 | return "" 40 | 41 | if user_id == bot.id: 42 | message.reply_text("How am I supposed to do my work if I am ignoring myself?") 43 | return "" 44 | 45 | if user_id in BLACKLISTWHITELIST: 46 | message.reply_text("No!\nNoticing Disasters is my job.") 47 | return "" 48 | 49 | try: 50 | target_user = bot.get_chat(user_id) 51 | except BadRequest as excp: 52 | if excp.message == "User not found": 53 | message.reply_text("I can't seem to find this user.") 54 | return "" 55 | else: 56 | raise 57 | 58 | sql.blacklist_user(user_id, reason) 59 | message.reply_text("I shall ignore the existence of this user!") 60 | log_message = ( 61 | f"#BLACKLIST\n" 62 | f"Admin: {mention_html(user.id, html.escape(user.first_name))}\n" 63 | f"User: {mention_html(target_user.id, html.escape(target_user.first_name))}" 64 | ) 65 | if reason: 66 | log_message += f"\nReason: {reason}" 67 | 68 | return log_message 69 | 70 | 71 | @run_async 72 | @dev_plus 73 | @gloggable 74 | def unbl_user(update: Update, context: CallbackContext) -> str: 75 | message = update.effective_message 76 | user = update.effective_user 77 | bot, args = context.bot, context.args 78 | user_id = extract_user(message, args) 79 | 80 | if not user_id: 81 | message.reply_text("I doubt that's a user.") 82 | return "" 83 | 84 | if user_id == bot.id: 85 | message.reply_text("I always notice myself.") 86 | return "" 87 | 88 | try: 89 | target_user = bot.get_chat(user_id) 90 | except BadRequest as excp: 91 | if excp.message == "User not found": 92 | message.reply_text("I can't seem to find this user.") 93 | return "" 94 | else: 95 | raise 96 | 97 | if sql.is_user_blacklisted(user_id): 98 | 99 | sql.unblacklist_user(user_id) 100 | message.reply_text("*notices user*") 101 | log_message = ( 102 | f"#UNBLACKLIST\n" 103 | f"Admin: {mention_html(user.id, html.escape(user.first_name))}\n" 104 | f"User: {mention_html(target_user.id, html.escape(target_user.first_name))}" 105 | ) 106 | 107 | return log_message 108 | 109 | else: 110 | message.reply_text("I am not ignoring them at all though!") 111 | return "" 112 | 113 | 114 | @run_async 115 | @dev_plus 116 | def bl_users(update: Update, context: CallbackContext): 117 | users = [] 118 | bot = context.bot 119 | for each_user in sql.BLACKLIST_USERS: 120 | user = bot.get_chat(each_user) 121 | reason = sql.get_reason(each_user) 122 | 123 | if reason: 124 | users.append( 125 | f"• {mention_html(user.id, html.escape(user.first_name))} :- {reason}" 126 | ) 127 | else: 128 | users.append(f"• {mention_html(user.id, html.escape(user.first_name))}") 129 | 130 | message = "Blacklisted Users\n" 131 | if not users: 132 | message += "Noone is being ignored as of yet." 133 | else: 134 | message += "\n".join(users) 135 | 136 | update.effective_message.reply_text(message, parse_mode=ParseMode.HTML) 137 | 138 | 139 | def __user_info__(user_id): 140 | is_blacklisted = sql.is_user_blacklisted(user_id) 141 | 142 | text = "Blacklisted: {}" 143 | if user_id in [777000, 1087968824]: 144 | return "" 145 | if user_id == dispatcher.bot.id: 146 | return "" 147 | if int(user_id) in DRAGONS + TIGERS + WOLVES: 148 | return "" 149 | if is_blacklisted: 150 | text = text.format("Yes") 151 | reason = sql.get_reason(user_id) 152 | if reason: 153 | text += f"\nReason: {reason}" 154 | else: 155 | text = text.format("No") 156 | 157 | return text 158 | 159 | 160 | BL_HANDLER = CommandHandler("ignore", bl_user) 161 | UNBL_HANDLER = CommandHandler("notice", unbl_user) 162 | BLUSERS_HANDLER = CommandHandler("ignoredlist", bl_users) 163 | 164 | dispatcher.add_handler(BL_HANDLER) 165 | dispatcher.add_handler(UNBL_HANDLER) 166 | dispatcher.add_handler(BLUSERS_HANDLER) 167 | 168 | __mod_name__ = "Blacklisting Users" 169 | __handlers__ = [BL_HANDLER, UNBL_HANDLER, BLUSERS_HANDLER] 170 | -------------------------------------------------------------------------------- /EvilBot/modules/cricketscore.py: -------------------------------------------------------------------------------- 1 | # credits @chsaiujwal @daisyxrobot 2 | # ported to masha @Mr_Dark_Prince 3 | 4 | import urllib.request 5 | 6 | from bs4 import BeautifulSoup 7 | from telethon import events 8 | from EvilBot import telethn as tbot 9 | from telethon.tl import functions, types 10 | from telethon.tl.types import * 11 | 12 | 13 | async def is_register_admin(chat, user): 14 | if isinstance(chat, (types.InputPeerChannel, types.InputChannel)): 15 | return isinstance( 16 | ( 17 | await tbot(functions.channels.GetParticipantRequest(chat, user)) 18 | ).participant, 19 | (types.ChannelParticipantAdmin, types.ChannelParticipantCreator), 20 | ) 21 | if isinstance(chat, types.InputPeerUser): 22 | return True 23 | 24 | 25 | @tbot.on(events.NewMessage(pattern="/cs$")) 26 | async def _(event): 27 | if event.fwd_from: 28 | return 29 | if event.is_group: 30 | if not (await is_register_admin(event.input_chat, event.message.sender_id)): 31 | await event.reply("🚨 Need Admin Pewer.. You can't use this command.. But you can use in my pm") 32 | return 33 | 34 | score_page = "http://static.cricinfo.com/rss/livescores.xml" 35 | page = urllib.request.urlopen(score_page) 36 | soup = BeautifulSoup(page, "html.parser") 37 | result = soup.find_all("description") 38 | Sed = "" 39 | for match in result: 40 | Sed += match.get_text() + "\n\n" 41 | await event.reply( 42 | f"Match information gathered successful\n\n\n{Sed}", 43 | parse_mode="HTML", 44 | ) 45 | 46 | 47 | __help__ = """ 48 | *live cricket score* 49 | ❍ /cs*:* Latest live scores from cricinfo 50 | """ 51 | 52 | __mod_name__ = "Cricket" 53 | -------------------------------------------------------------------------------- /EvilBot/modules/currency_converter.py: -------------------------------------------------------------------------------- 1 | import requests 2 | from EvilBot import CASH_API_KEY, dispatcher 3 | from telegram import Update, ParseMode 4 | from telegram.ext import CallbackContext, CommandHandler, run_async 5 | 6 | 7 | @run_async 8 | def convert(update: Update, context: CallbackContext): 9 | args = update.effective_message.text.split(" ") 10 | 11 | if len(args) == 4: 12 | try: 13 | orig_cur_amount = float(args[1]) 14 | 15 | except ValueError: 16 | update.effective_message.reply_text("Invalid Amount Of Currency") 17 | return 18 | 19 | orig_cur = args[2].upper() 20 | 21 | new_cur = args[3].upper() 22 | 23 | request_url = ( 24 | f"https://www.alphavantage.co/query" 25 | f"?function=CURRENCY_EXCHANGE_RATE" 26 | f"&from_currency={orig_cur}" 27 | f"&to_currency={new_cur}" 28 | f"&apikey={CASH_API_KEY}" 29 | ) 30 | response = requests.get(request_url).json() 31 | try: 32 | current_rate = float( 33 | response["Realtime Currency Exchange Rate"]["5. Exchange Rate"] 34 | ) 35 | except KeyError: 36 | update.effective_message.reply_text("Currency Not Supported.") 37 | return 38 | new_cur_amount = round(orig_cur_amount * current_rate, 5) 39 | update.effective_message.reply_text( 40 | f"{orig_cur_amount} {orig_cur} = {new_cur_amount} {new_cur}" 41 | ) 42 | 43 | elif len(args) == 1: 44 | update.effective_message.reply_text(__help__, parse_mode=ParseMode.MARKDOWN) 45 | 46 | else: 47 | update.effective_message.reply_text( 48 | f"*Invalid Args!!:* Required 3 But Passed {len(args) -1}", 49 | parse_mode=ParseMode.MARKDOWN, 50 | ) 51 | 52 | 53 | CONVERTER_HANDLER = CommandHandler("cash", convert) 54 | 55 | dispatcher.add_handler(CONVERTER_HANDLER) 56 | 57 | __command_list__ = ["cash"] 58 | __handlers__ = [CONVERTER_HANDLER] 59 | -------------------------------------------------------------------------------- /EvilBot/modules/dbcleanup.py: -------------------------------------------------------------------------------- 1 | from time import sleep 2 | 3 | import EvilBot.modules.sql.global_bans_sql as gban_sql 4 | import EvilBot.modules.sql.users_sql as user_sql 5 | from EvilBot import DEV_USERS, OWNER_ID, dispatcher 6 | from EvilBot.modules.helper_funcs.chat_status import dev_plus 7 | from telegram import InlineKeyboardButton, InlineKeyboardMarkup, Update 8 | from telegram.error import BadRequest, Unauthorized 9 | from telegram.ext import ( 10 | CallbackContext, 11 | CallbackQueryHandler, 12 | CommandHandler, 13 | run_async, 14 | ) 15 | 16 | 17 | def get_invalid_chats(update: Update, context: CallbackContext, remove: bool = False): 18 | bot = context.bot 19 | chat_id = update.effective_chat.id 20 | chats = user_sql.get_all_chats() 21 | kicked_chats, progress = 0, 0 22 | chat_list = [] 23 | progress_message = None 24 | 25 | for chat in chats: 26 | 27 | if ((100 * chats.index(chat)) / len(chats)) > progress: 28 | progress_bar = f"{progress}% completed in getting invalid chats." 29 | if progress_message: 30 | try: 31 | bot.editMessageText( 32 | progress_bar, chat_id, progress_message.message_id 33 | ) 34 | except: 35 | pass 36 | else: 37 | progress_message = bot.sendMessage(chat_id, progress_bar) 38 | progress += 5 39 | 40 | cid = chat.chat_id 41 | sleep(0.1) 42 | try: 43 | bot.get_chat(cid, timeout=60) 44 | except (BadRequest, Unauthorized): 45 | kicked_chats += 1 46 | chat_list.append(cid) 47 | except: 48 | pass 49 | 50 | try: 51 | progress_message.delete() 52 | except: 53 | pass 54 | 55 | if not remove: 56 | return kicked_chats 57 | else: 58 | for muted_chat in chat_list: 59 | sleep(0.1) 60 | user_sql.rem_chat(muted_chat) 61 | return kicked_chats 62 | 63 | 64 | def get_invalid_gban(update: Update, context: CallbackContext, remove: bool = False): 65 | bot = context.bot 66 | banned = gban_sql.get_gban_list() 67 | ungbanned_users = 0 68 | ungban_list = [] 69 | 70 | for user in banned: 71 | user_id = user["user_id"] 72 | sleep(0.1) 73 | try: 74 | bot.get_chat(user_id) 75 | except BadRequest: 76 | ungbanned_users += 1 77 | ungban_list.append(user_id) 78 | except: 79 | pass 80 | 81 | if not remove: 82 | return ungbanned_users 83 | else: 84 | for user_id in ungban_list: 85 | sleep(0.1) 86 | gban_sql.ungban_user(user_id) 87 | return ungbanned_users 88 | 89 | 90 | @run_async 91 | @dev_plus 92 | def dbcleanup(update: Update, context: CallbackContext): 93 | msg = update.effective_message 94 | 95 | msg.reply_text("Getting invalid chat count ...") 96 | invalid_chat_count = get_invalid_chats(update, context) 97 | 98 | msg.reply_text("Getting invalid gbanned count ...") 99 | invalid_gban_count = get_invalid_gban(update, context) 100 | 101 | reply = f"Total invalid chats - {invalid_chat_count}\n" 102 | reply += f"Total invalid gbanned users - {invalid_gban_count}" 103 | 104 | buttons = [[InlineKeyboardButton("Cleanup DB", callback_data="db_cleanup")]] 105 | 106 | update.effective_message.reply_text( 107 | reply, reply_markup=InlineKeyboardMarkup(buttons) 108 | ) 109 | 110 | 111 | @run_async 112 | def callback_button(update: Update, context: CallbackContext): 113 | bot = context.bot 114 | query = update.callback_query 115 | message = query.message 116 | chat_id = update.effective_chat.id 117 | query_type = query.data 118 | 119 | admin_list = [OWNER_ID] + DEV_USERS 120 | 121 | bot.answer_callback_query(query.id) 122 | 123 | if query_type == "db_leave_chat": 124 | if query.from_user.id in admin_list: 125 | bot.editMessageText("Leaving chats ...", chat_id, message.message_id) 126 | chat_count = get_muted_chats(update, context, True) 127 | bot.sendMessage(chat_id, f"Left {chat_count} chats.") 128 | else: 129 | query.answer("You are not allowed to use this.") 130 | elif query_type == "db_cleanup": 131 | if query.from_user.id in admin_list: 132 | bot.editMessageText("Cleaning up DB ...", chat_id, message.message_id) 133 | invalid_chat_count = get_invalid_chats(update, context, True) 134 | invalid_gban_count = get_invalid_gban(update, context, True) 135 | reply = "Cleaned up {} chats and {} gbanned users from db.".format( 136 | invalid_chat_count, invalid_gban_count 137 | ) 138 | bot.sendMessage(chat_id, reply) 139 | else: 140 | query.answer("You are not allowed to use this.") 141 | 142 | 143 | DB_CLEANUP_HANDLER = CommandHandler("dbcleanup", dbcleanup) 144 | BUTTON_HANDLER = CallbackQueryHandler(callback_button, pattern="db_.*") 145 | 146 | dispatcher.add_handler(DB_CLEANUP_HANDLER) 147 | dispatcher.add_handler(BUTTON_HANDLER) 148 | 149 | __mod_name__ = "DB Cleanup" 150 | __handlers__ = [DB_CLEANUP_HANDLER, BUTTON_HANDLER] 151 | -------------------------------------------------------------------------------- /EvilBot/modules/debug.py: -------------------------------------------------------------------------------- 1 | import os 2 | import datetime 3 | 4 | from telethon import events 5 | from telegram import Update 6 | from telegram.ext import CallbackContext, CommandHandler, run_async 7 | 8 | from EvilBot import telethn, dispatcher 9 | from EvilBot.modules.helper_funcs.chat_status import dev_plus 10 | 11 | DEBUG_MODE = False 12 | 13 | 14 | @run_async 15 | @dev_plus 16 | def debug(update: Update, context: CallbackContext): 17 | global DEBUG_MODE 18 | args = update.effective_message.text.split(None, 1) 19 | message = update.effective_message 20 | print(DEBUG_MODE) 21 | if len(args) > 1: 22 | if args[1] in ("yes", "on"): 23 | DEBUG_MODE = True 24 | message.reply_text("Debug mode is now on.") 25 | elif args[1] in ("no", "off"): 26 | DEBUG_MODE = False 27 | message.reply_text("Debug mode is now off.") 28 | else: 29 | if DEBUG_MODE: 30 | message.reply_text("Debug mode is currently on.") 31 | else: 32 | message.reply_text("Debug mode is currently off.") 33 | 34 | 35 | @telethn.on(events.NewMessage(pattern="[/!].*")) 36 | async def i_do_nothing_yes(event): 37 | global DEBUG_MODE 38 | if DEBUG_MODE: 39 | print(f"-{event.from_id} ({event.chat_id}) : {event.text}") 40 | if os.path.exists("updates.txt"): 41 | with open("updates.txt", "r") as f: 42 | text = f.read() 43 | with open("updates.txt", "w+") as f: 44 | f.write(text + f"\n-{event.from_id} ({event.chat_id}) : {event.text}") 45 | else: 46 | with open("updates.txt", "w+") as f: 47 | f.write( 48 | f"- {event.from_id} ({event.chat_id}) : {event.text} | {datetime.datetime.now()}" 49 | ) 50 | 51 | 52 | support_chat = os.getenv("SUPPORT_CHAT") 53 | 54 | 55 | @run_async 56 | @dev_plus 57 | def logs(update: Update, context: CallbackContext): 58 | user = update.effective_user 59 | with open("log.txt", "rb") as f: 60 | context.bot.send_document(document=f, filename=f.name, chat_id=user.id) 61 | 62 | 63 | LOG_HANDLER = CommandHandler("logs", logs) 64 | dispatcher.add_handler(LOG_HANDLER) 65 | 66 | DEBUG_HANDLER = CommandHandler("debug", debug) 67 | dispatcher.add_handler(DEBUG_HANDLER) 68 | 69 | __mod_name__ = "Debug" 70 | __command_list__ = ["debug"] 71 | __handlers__ = [DEBUG_HANDLER] 72 | -------------------------------------------------------------------------------- /EvilBot/modules/dev.py: -------------------------------------------------------------------------------- 1 | import os 2 | import subprocess 3 | import sys 4 | 5 | from contextlib import suppress 6 | from time import sleep 7 | 8 | import EvilBot 9 | 10 | from EvilBot import dispatcher 11 | from EvilBot.modules.helper_funcs.chat_status import dev_plus 12 | from telegram import TelegramError, Update 13 | from telegram.error import Unauthorized 14 | from telegram.ext import CallbackContext, CommandHandler, run_async 15 | 16 | @run_async 17 | @dev_plus 18 | def allow_groups(update: Update, context: CallbackContext): 19 | args = context.args 20 | if not args: 21 | update.effective_message.reply_text(f"Current state: {EvilBot.ALLOW_CHATS}") 22 | return 23 | if args[0].lower() in ["off", "no"]: 24 | EvilBot.ALLOW_CHATS = True 25 | elif args[0].lower() in ["yes", "on"]: 26 | EvilBot.ALLOW_CHATS = False 27 | else: 28 | update.effective_message.reply_text("Format: /lockdown Yes/No or Off/On") 29 | return 30 | update.effective_message.reply_text("Done! Lockdown value toggled.") 31 | 32 | @run_async 33 | @dev_plus 34 | def leave(update: Update, context: CallbackContext): 35 | bot = context.bot 36 | args = context.args 37 | if args: 38 | chat_id = str(args[0]) 39 | try: 40 | bot.leave_chat(int(chat_id)) 41 | except TelegramError: 42 | update.effective_message.reply_text( 43 | "Beep boop, I could not leave that group(dunno why tho)." 44 | ) 45 | return 46 | with suppress(Unauthorized): 47 | update.effective_message.reply_text("Beep boop, I left that soup!.") 48 | else: 49 | update.effective_message.reply_text("Send a valid chat ID") 50 | 51 | 52 | @run_async 53 | @dev_plus 54 | def gitpull(update: Update, context: CallbackContext): 55 | sent_msg = update.effective_message.reply_text( 56 | "Pulling all changes from remote and then attempting to restart." 57 | ) 58 | subprocess.Popen("git pull", stdout=subprocess.PIPE, shell=True) 59 | 60 | sent_msg_text = sent_msg.text + "\n\nChanges pulled...I guess.. Restarting in " 61 | 62 | for i in reversed(range(5)): 63 | sent_msg.edit_text(sent_msg_text + str(i + 1)) 64 | sleep(1) 65 | 66 | sent_msg.edit_text("Restarted.") 67 | 68 | os.system("restart.bat") 69 | os.execv("start.bat", sys.argv) 70 | 71 | 72 | @run_async 73 | @dev_plus 74 | def restart(update: Update, context: CallbackContext): 75 | update.effective_message.reply_text( 76 | "Starting a new instance and shutting down this one" 77 | ) 78 | 79 | os.system("restart.bat") 80 | os.execv("start.bat", sys.argv) 81 | 82 | 83 | LEAVE_HANDLER = CommandHandler("leave", leave) 84 | GITPULL_HANDLER = CommandHandler("gitpull", gitpull) 85 | RESTART_HANDLER = CommandHandler("reboot", restart) 86 | ALLOWGROUPS_HANDLER = CommandHandler("lockdown", allow_groups) 87 | 88 | dispatcher.add_handler(ALLOWGROUPS_HANDLER) 89 | dispatcher.add_handler(LEAVE_HANDLER) 90 | dispatcher.add_handler(GITPULL_HANDLER) 91 | dispatcher.add_handler(RESTART_HANDLER) 92 | 93 | __mod_name__ = "Devs" 94 | __handlers__ = [LEAVE_HANDLER, GITPULL_HANDLER, RESTART_HANDLER, ALLOWGROUPS_HANDLER] 95 | -------------------------------------------------------------------------------- /EvilBot/modules/error_handler.py: -------------------------------------------------------------------------------- 1 | import traceback 2 | 3 | import requests 4 | import html 5 | import random 6 | import traceback 7 | import sys 8 | import pretty_errors 9 | import io 10 | from telegram import Update, InlineKeyboardMarkup, InlineKeyboardButton 11 | from telegram.ext import CallbackContext, CommandHandler 12 | from EvilBot import dispatcher, DEV_USERS, OWNER_ID 13 | 14 | pretty_errors.mono() 15 | 16 | 17 | class ErrorsDict(dict): 18 | "A custom dict to store errors and their count" 19 | 20 | def __init__(self, *args, **kwargs): 21 | self.raw = [] 22 | super().__init__(*args, **kwargs) 23 | 24 | def __contains__(self, error): 25 | self.raw.append(error) 26 | error.identifier = "".join(random.choices("ABCDEFGHIJKLMNOPQRSTUVWXYZ", k=5)) 27 | for e in self: 28 | if type(e) is type(error) and e.args == error.args: 29 | self[e] += 1 30 | return True 31 | self[error] = 0 32 | return False 33 | 34 | def __len__(self): 35 | return len(self.raw) 36 | 37 | 38 | errors = ErrorsDict() 39 | 40 | 41 | def error_callback(update: Update, context: CallbackContext): 42 | if not update: 43 | return 44 | if context.error in errors: 45 | return 46 | try: 47 | stringio = io.StringIO() 48 | pretty_errors.output_stderr = stringio 49 | output = pretty_errors.excepthook( 50 | type(context.error), context.error, context.error.__traceback__ 51 | ) 52 | pretty_errors.output_stderr = sys.stderr 53 | pretty_error = stringio.getvalue() 54 | stringio.close() 55 | except: 56 | pretty_error = "Failed to create pretty error." 57 | tb_list = traceback.format_exception( 58 | None, context.error, context.error.__traceback__ 59 | ) 60 | tb = "".join(tb_list) 61 | pretty_message = ( 62 | "{}\n" 63 | "-------------------------------------------------------------------------------\n" 64 | "An exception was raised while handling an update\n" 65 | "User: {}\n" 66 | "Chat: {} {}\n" 67 | "Callback data: {}\n" 68 | "Message: {}\n\n" 69 | "Full Traceback: {}" 70 | ).format( 71 | pretty_error, 72 | update.effective_user.id, 73 | update.effective_chat.title if update.effective_chat else "", 74 | update.effective_chat.id if update.effective_chat else "", 75 | update.callback_query.data if update.callback_query else "None", 76 | update.effective_message.text if update.effective_message else "No message", 77 | tb, 78 | ) 79 | key = requests.post( 80 | "https://nekobin.com/api/documents", json={"content": pretty_message} 81 | ).json() 82 | e = html.escape(f"{context.error}") 83 | if not key.get("result", {}).get("key"): 84 | with open("error.txt", "w+") as f: 85 | f.write(pretty_message) 86 | context.bot.send_document( 87 | OWNER_ID, 88 | open("error.txt", "rb"), 89 | caption=f"#{context.error.identifier}\nAn unknown error occured:\n{e}", 90 | parse_mode="html", 91 | ) 92 | return 93 | key = key.get("result").get("key") 94 | url = f"https://nekobin.com/{key}.py" 95 | context.bot.send_message( 96 | OWNER_ID, 97 | text=f"#{context.error.identifier}\nAn unknown error occured:\n{e}", 98 | reply_markup=InlineKeyboardMarkup( 99 | [[InlineKeyboardButton("Nekobin", url=url)]] 100 | ), 101 | parse_mode="html", 102 | ) 103 | 104 | 105 | def list_errors(update: Update, context: CallbackContext): 106 | if update.effective_user.id not in DEV_USERS: 107 | return 108 | e = { 109 | k: v for k, v in sorted(errors.items(), key=lambda item: item[1], reverse=True) 110 | } 111 | msg = "Errors List:\n" 112 | for x in e: 113 | msg += f"• {x}: {e[x]} #{x.identifier}\n" 114 | msg += f"{len(errors)} have occurred since startup." 115 | if len(msg) > 4096: 116 | with open("errors_msg.txt", "w+") as f: 117 | f.write(msg) 118 | context.bot.send_document( 119 | update.effective_chat.id, 120 | open("errors_msg.txt", "rb"), 121 | caption=f"Too many errors have occured..", 122 | parse_mode="html", 123 | ) 124 | return 125 | update.effective_message.reply_text(msg, parse_mode="html") 126 | 127 | 128 | dispatcher.add_error_handler(error_callback) 129 | dispatcher.add_handler(CommandHandler("errors", list_errors)) 130 | -------------------------------------------------------------------------------- /EvilBot/modules/eval.py: -------------------------------------------------------------------------------- 1 | import io 2 | import os 3 | 4 | # Common imports for eval 5 | import textwrap 6 | import traceback 7 | from contextlib import redirect_stdout 8 | 9 | from EvilBot import LOGGER, dispatcher 10 | from EvilBot.modules.helper_funcs.chat_status import dev_plus 11 | from telegram import ParseMode, Update 12 | from telegram.ext import CallbackContext, CommandHandler, run_async 13 | 14 | namespaces = {} 15 | 16 | 17 | def namespace_of(chat, update, bot): 18 | if chat not in namespaces: 19 | namespaces[chat] = { 20 | "__builtins__": globals()["__builtins__"], 21 | "bot": bot, 22 | "effective_message": update.effective_message, 23 | "effective_user": update.effective_user, 24 | "effective_chat": update.effective_chat, 25 | "update": update, 26 | } 27 | 28 | return namespaces[chat] 29 | 30 | 31 | def log_input(update): 32 | user = update.effective_user.id 33 | chat = update.effective_chat.id 34 | LOGGER.info(f"IN: {update.effective_message.text} (user={user}, chat={chat})") 35 | 36 | 37 | def send(msg, bot, update): 38 | if len(str(msg)) > 2000: 39 | with io.BytesIO(str.encode(msg)) as out_file: 40 | out_file.name = "output.txt" 41 | bot.send_document(chat_id=update.effective_chat.id, document=out_file) 42 | else: 43 | LOGGER.info(f"OUT: '{msg}'") 44 | bot.send_message( 45 | chat_id=update.effective_chat.id, 46 | text=f"`{msg}`", 47 | parse_mode=ParseMode.MARKDOWN, 48 | ) 49 | 50 | 51 | @dev_plus 52 | @run_async 53 | def evaluate(update: Update, context: CallbackContext): 54 | bot = context.bot 55 | send(do(eval, bot, update), bot, update) 56 | 57 | 58 | @dev_plus 59 | @run_async 60 | def execute(update: Update, context: CallbackContext): 61 | bot = context.bot 62 | send(do(exec, bot, update), bot, update) 63 | 64 | 65 | def cleanup_code(code): 66 | if code.startswith("```") and code.endswith("```"): 67 | return "\n".join(code.split("\n")[1:-1]) 68 | return code.strip("` \n") 69 | 70 | 71 | def do(func, bot, update): 72 | log_input(update) 73 | content = update.message.text.split(" ", 1)[-1] 74 | body = cleanup_code(content) 75 | env = namespace_of(update.message.chat_id, update, bot) 76 | 77 | os.chdir(os.getcwd()) 78 | with open( 79 | os.path.join(os.getcwd(), "EvilBot/modules/helper_funcs/temp.txt"), "w" 80 | ) as temp: 81 | temp.write(body) 82 | 83 | stdout = io.StringIO() 84 | 85 | to_compile = f'def func():\n{textwrap.indent(body, " ")}' 86 | 87 | try: 88 | exec(to_compile, env) 89 | except Exception as e: 90 | return f"{e.__class__.__name__}: {e}" 91 | 92 | func = env["func"] 93 | 94 | try: 95 | with redirect_stdout(stdout): 96 | func_return = func() 97 | except Exception as e: 98 | value = stdout.getvalue() 99 | return f"{value}{traceback.format_exc()}" 100 | else: 101 | value = stdout.getvalue() 102 | result = None 103 | if func_return is None: 104 | if value: 105 | result = f"{value}" 106 | else: 107 | try: 108 | result = f"{repr(eval(body, env))}" 109 | except: 110 | pass 111 | else: 112 | result = f"{value}{func_return}" 113 | if result: 114 | return result 115 | 116 | 117 | @dev_plus 118 | @run_async 119 | def clear(update: Update, context: CallbackContext): 120 | bot = context.bot 121 | log_input(update) 122 | global namespaces 123 | if update.message.chat_id in namespaces: 124 | del namespaces[update.message.chat_id] 125 | send("Cleared locals.", bot, update) 126 | 127 | 128 | EVAL_HANDLER = CommandHandler(("e", "ev", "eva", "eval"), evaluate) 129 | EXEC_HANDLER = CommandHandler(("x", "ex", "exe", "exec", "py"), execute) 130 | CLEAR_HANDLER = CommandHandler("clearlocals", clear) 131 | 132 | dispatcher.add_handler(EVAL_HANDLER) 133 | dispatcher.add_handler(EXEC_HANDLER) 134 | dispatcher.add_handler(CLEAR_HANDLER) 135 | 136 | __mod_name__ = "Eval Module" 137 | -------------------------------------------------------------------------------- /EvilBot/modules/get_common_chats.py: -------------------------------------------------------------------------------- 1 | import os 2 | from time import sleep 3 | 4 | from EvilBot import OWNER_ID, dispatcher 5 | from EvilBot.modules.helper_funcs.extraction import extract_user 6 | from EvilBot.modules.sql.users_sql import get_user_com_chats 7 | from telegram import Update 8 | from telegram.error import BadRequest, RetryAfter, Unauthorized 9 | from telegram.ext import CallbackContext, CommandHandler, Filters 10 | from telegram.ext.dispatcher import run_async 11 | 12 | 13 | @run_async 14 | def get_user_common_chats(update: Update, context: CallbackContext): 15 | bot, args = context.bot, context.args 16 | msg = update.effective_message 17 | user = extract_user(msg, args) 18 | if not user: 19 | msg.reply_text("I share no common chats with the void.") 20 | return 21 | common_list = get_user_com_chats(user) 22 | if not common_list: 23 | msg.reply_text("No common chats with this user!") 24 | return 25 | name = bot.get_chat(user).first_name 26 | text = f"Common chats with {name}\n" 27 | for chat in common_list: 28 | try: 29 | chat_name = bot.get_chat(chat).title 30 | sleep(0.3) 31 | text += f"• {chat_name}\n" 32 | except BadRequest: 33 | pass 34 | except Unauthorized: 35 | pass 36 | except RetryAfter as e: 37 | sleep(e.retry_after) 38 | 39 | if len(text) < 4096: 40 | msg.reply_text(text, parse_mode="HTML") 41 | else: 42 | with open("common_chats.txt", "w") as f: 43 | f.write(text) 44 | with open("common_chats.txt", "rb") as f: 45 | msg.reply_document(f) 46 | os.remove("common_chats.txt") 47 | 48 | 49 | COMMON_CHATS_HANDLER = CommandHandler( 50 | "getchats", get_user_common_chats, filters=Filters.user(OWNER_ID) 51 | ) 52 | 53 | dispatcher.add_handler(COMMON_CHATS_HANDLER) 54 | -------------------------------------------------------------------------------- /EvilBot/modules/gettime.py: -------------------------------------------------------------------------------- 1 | import datetime 2 | from typing import List 3 | 4 | import requests 5 | from EvilBot import TIME_API_KEY, dispatcher 6 | from EvilBot.modules.disable import DisableAbleCommandHandler 7 | from telegram import ParseMode, Update 8 | from telegram.ext import CallbackContext, run_async 9 | 10 | 11 | def generate_time(to_find: str, findtype: List[str]) -> str: 12 | data = requests.get( 13 | f"https://api.timezonedb.com/v2.1/list-time-zone" 14 | f"?key={TIME_API_KEY}" 15 | f"&format=json" 16 | f"&fields=countryCode,countryName,zoneName,gmtOffset,timestamp,dst" 17 | ).json() 18 | 19 | for zone in data["zones"]: 20 | for eachtype in findtype: 21 | if to_find in zone[eachtype].lower(): 22 | country_name = zone["countryName"] 23 | country_zone = zone["zoneName"] 24 | country_code = zone["countryCode"] 25 | 26 | if zone["dst"] == 1: 27 | daylight_saving = "Yes" 28 | else: 29 | daylight_saving = "No" 30 | 31 | date_fmt = r"%d-%m-%Y" 32 | time_fmt = r"%H:%M:%S" 33 | day_fmt = r"%A" 34 | gmt_offset = zone["gmtOffset"] 35 | timestamp = datetime.datetime.now( 36 | datetime.timezone.utc 37 | ) + datetime.timedelta(seconds=gmt_offset) 38 | current_date = timestamp.strftime(date_fmt) 39 | current_time = timestamp.strftime(time_fmt) 40 | current_day = timestamp.strftime(day_fmt) 41 | 42 | break 43 | 44 | try: 45 | result = ( 46 | f"Country: {country_name}\n" 47 | f"Zone Name: {country_zone}\n" 48 | f"Country Code: {country_code}\n" 49 | f"Daylight saving: {daylight_saving}\n" 50 | f"Day: {current_day}\n" 51 | f"Current Time: {current_time}\n" 52 | f"Current Date: {current_date}\n" 53 | 'Timezones: List here' 54 | ) 55 | except: 56 | result = None 57 | 58 | return result 59 | 60 | 61 | @run_async 62 | def gettime(update: Update, context: CallbackContext): 63 | message = update.effective_message 64 | 65 | try: 66 | query = message.text.strip().split(" ", 1)[1] 67 | except: 68 | message.reply_text("Provide a country name/abbreviation/timezone to find.") 69 | return 70 | send_message = message.reply_text( 71 | f"Finding timezone info for {query}", parse_mode=ParseMode.HTML 72 | ) 73 | 74 | query_timezone = query.lower() 75 | if len(query_timezone) == 2: 76 | result = generate_time(query_timezone, ["countryCode"]) 77 | else: 78 | result = generate_time(query_timezone, ["zoneName", "countryName"]) 79 | 80 | if not result: 81 | send_message.edit_text( 82 | f"Timezone info not available for {query}\n" 83 | 'All Timezones: List here', 84 | parse_mode=ParseMode.HTML, 85 | disable_web_page_preview=True, 86 | ) 87 | return 88 | 89 | send_message.edit_text( 90 | result, parse_mode=ParseMode.HTML, disable_web_page_preview=True 91 | ) 92 | 93 | 94 | TIME_HANDLER = DisableAbleCommandHandler("time", gettime) 95 | 96 | dispatcher.add_handler(TIME_HANDLER) 97 | 98 | __mod_name__ = "TIME" 99 | __command_list__ = ["time"] 100 | __handlers__ = [TIME_HANDLER] 101 | -------------------------------------------------------------------------------- /EvilBot/modules/gtranslator.py: -------------------------------------------------------------------------------- 1 | from emoji import UNICODE_EMOJI 2 | from google_trans_new import LANGUAGES, google_translator 3 | from telegram import ParseMode, Update 4 | from telegram.ext import CallbackContext, run_async 5 | 6 | from EvilBot import dispatcher 7 | from EvilBot.modules.disable import DisableAbleCommandHandler 8 | 9 | 10 | @run_async 11 | def totranslate(update: Update, context: CallbackContext): 12 | message = update.effective_message 13 | problem_lang_code = [] 14 | for key in LANGUAGES: 15 | if "-" in key: 16 | problem_lang_code.append(key) 17 | 18 | try: 19 | if message.reply_to_message: 20 | args = update.effective_message.text.split(None, 1) 21 | if message.reply_to_message.text: 22 | text = message.reply_to_message.text 23 | elif message.reply_to_message.caption: 24 | text = message.reply_to_message.caption 25 | 26 | try: 27 | source_lang = args[1].split(None, 1)[0] 28 | except (IndexError, AttributeError): 29 | source_lang = "en" 30 | 31 | else: 32 | args = update.effective_message.text.split(None, 2) 33 | text = args[2] 34 | source_lang = args[1] 35 | 36 | if source_lang.count("-") == 2: 37 | for lang in problem_lang_code: 38 | if lang in source_lang: 39 | if source_lang.startswith(lang): 40 | dest_lang = source_lang.rsplit("-", 1)[1] 41 | source_lang = source_lang.rsplit("-", 1)[0] 42 | else: 43 | dest_lang = source_lang.split("-", 1)[1] 44 | source_lang = source_lang.split("-", 1)[0] 45 | elif source_lang.count("-") == 1: 46 | for lang in problem_lang_code: 47 | if lang in source_lang: 48 | dest_lang = source_lang 49 | source_lang = None 50 | break 51 | if dest_lang is None: 52 | dest_lang = source_lang.split("-")[1] 53 | source_lang = source_lang.split("-")[0] 54 | else: 55 | dest_lang = source_lang 56 | source_lang = None 57 | 58 | exclude_list = UNICODE_EMOJI.keys() 59 | for emoji in exclude_list: 60 | if emoji in text: 61 | text = text.replace(emoji, "") 62 | 63 | trl = google_translator() 64 | if source_lang is None: 65 | detection = trl.detect(text) 66 | trans_str = trl.translate(text, lang_tgt=dest_lang) 67 | return message.reply_text( 68 | f"Translated from `{detection[0]}` to `{dest_lang}`:\n`{trans_str}`", 69 | parse_mode=ParseMode.MARKDOWN, 70 | ) 71 | else: 72 | trans_str = trl.translate(text, lang_tgt=dest_lang, lang_src=source_lang) 73 | message.reply_text( 74 | f"Translated from `{source_lang}` to `{dest_lang}`:\n`{trans_str}`", 75 | parse_mode=ParseMode.MARKDOWN, 76 | ) 77 | 78 | except IndexError: 79 | update.effective_message.reply_text( 80 | "Reply to messages or write messages from other languages ​​for translating into the intended language\n\n" 81 | "Example: `/tr en-ml` to translate from English to Malayalam\n" 82 | "Or use: `/tr ml` for automatic detection and translating it into Malayalam.\n" 83 | "See [List of Language Codes](t.me/OnePunchSupport/12823) for a list of language codes.", 84 | parse_mode="markdown", 85 | disable_web_page_preview=True, 86 | ) 87 | except ValueError: 88 | update.effective_message.reply_text("The intended language is not found!") 89 | else: 90 | return 91 | 92 | 93 | __help__ = """ 94 | ❍ /tr or /tl (language code) as reply to a long message 95 | *Example:* 96 | ❍ /tr en*:* translates something to english 97 | ❍ /tr hi-en*:* translates hindi to english 98 | 99 | *Language Codes* 100 | `af,am,ar,az,be,bg,bn,bs,ca,ceb,co,cs,cy,da,de,el,en,eo,es, 101 | et,eu,fa,fi,fr,fy,ga,gd,gl,gu,ha,haw,hi,hmn,hr,ht,hu,hy, 102 | id,ig,is,it,iw,ja,jw,ka,kk,km,kn,ko,ku,ky,la,lb,lo,lt,lv,mg,mi,mk, 103 | ml,mn,mr,ms,mt,my,ne,nl,no,ny,pa,pl,ps,pt,ro,ru,sd,si,sk,sl, 104 | sm,sn,so,sq,sr,st,su,sv,sw,ta,te,tg,th,tl,tr,uk,ur,uz, 105 | vi,xh,yi,yo,zh,zh_CN,zh_TW,zu` 106 | """ 107 | 108 | TRANSLATE_HANDLER = DisableAbleCommandHandler(["tr", "tl"], totranslate) 109 | 110 | dispatcher.add_handler(TRANSLATE_HANDLER) 111 | 112 | __mod_name__ = "G-Trans" 113 | __command_list__ = ["tr", "tl"] 114 | __handlers__ = [TRANSLATE_HANDLER] 115 | -------------------------------------------------------------------------------- /EvilBot/modules/helper_funcs/__init__.py: -------------------------------------------------------------------------------- 1 | """Helpers, also known as Utilities.""" 2 | -------------------------------------------------------------------------------- /EvilBot/modules/helper_funcs/alternate.py: -------------------------------------------------------------------------------- 1 | from telegram.error import BadRequest 2 | from functools import wraps 3 | from telegram import ChatAction 4 | 5 | 6 | def send_message(message, text, *args, **kwargs): 7 | try: 8 | return message.reply_text(text, *args, **kwargs) 9 | except BadRequest as err: 10 | if str(err) == "Reply message not found": 11 | return message.reply_text(text, quote=False, *args, **kwargs) 12 | 13 | 14 | def typing_action(func): 15 | """Sends typing action while processing func command.""" 16 | 17 | @wraps(func) 18 | def command_func(update, context, *args, **kwargs): 19 | context.bot.send_chat_action( 20 | chat_id=update.effective_chat.id, action=ChatAction.TYPING 21 | ) 22 | return func(update, context, *args, **kwargs) 23 | 24 | return command_func 25 | -------------------------------------------------------------------------------- /EvilBot/modules/helper_funcs/filters.py: -------------------------------------------------------------------------------- 1 | from EvilBot import DEV_USERS, DRAGONS, DEMONS 2 | from telegram import Message 3 | from telegram.ext import BaseFilter 4 | 5 | 6 | class CustomFilters(object): 7 | class _Supporters(BaseFilter): 8 | def filter(self, message: Message): 9 | return bool(message.from_user and message.from_user.id in DEMONS) 10 | 11 | support_filter = _Supporters() 12 | 13 | class _Sudoers(BaseFilter): 14 | def filter(self, message: Message): 15 | return bool(message.from_user and message.from_user.id in DRAGONS) 16 | 17 | sudo_filter = _Sudoers() 18 | 19 | class _Developers(BaseFilter): 20 | def filter(self, message: Message): 21 | return bool(message.from_user and message.from_user.id in DEV_USERS) 22 | 23 | dev_filter = _Developers() 24 | 25 | class _MimeType(BaseFilter): 26 | def __init__(self, mimetype): 27 | self.mime_type = mimetype 28 | self.name = "CustomFilters.mime_type({})".format(self.mime_type) 29 | 30 | def filter(self, message: Message): 31 | return bool( 32 | message.document and message.document.mime_type == self.mime_type 33 | ) 34 | 35 | mime_type = _MimeType 36 | 37 | class _HasText(BaseFilter): 38 | def filter(self, message: Message): 39 | return bool( 40 | message.text 41 | or message.sticker 42 | or message.photo 43 | or message.document 44 | or message.video 45 | ) 46 | 47 | has_text = _HasText() 48 | -------------------------------------------------------------------------------- /EvilBot/modules/helper_funcs/handlers.py: -------------------------------------------------------------------------------- 1 | import EvilBot.modules.sql.blacklistusers_sql as sql 2 | from EvilBot import ALLOW_EXCL 3 | from EvilBot import DEV_USERS, DRAGONS, DEMONS, TIGERS, WOLVES 4 | 5 | from telegram import Update 6 | from telegram.ext import CommandHandler, MessageHandler, RegexHandler, Filters 7 | from pyrate_limiter import ( 8 | BucketFullException, 9 | Duration, 10 | RequestRate, 11 | Limiter, 12 | MemoryListBucket, 13 | ) 14 | 15 | if ALLOW_EXCL: 16 | CMD_STARTERS = ("/", "!") 17 | else: 18 | CMD_STARTERS = ("/",) 19 | 20 | 21 | class AntiSpam: 22 | def __init__(self): 23 | self.whitelist = ( 24 | (DEV_USERS or []) 25 | + (DRAGONS or []) 26 | + (WOLVES or []) 27 | + (DEMONS or []) 28 | + (TIGERS or []) 29 | ) 30 | # Values are HIGHLY experimental, its recommended you pay attention to our commits as we will be adjusting the values over time with what suits best. 31 | Duration.CUSTOM = 15 # Custom duration, 15 seconds 32 | self.sec_limit = RequestRate(6, Duration.CUSTOM) # 6 / Per 15 Seconds 33 | self.min_limit = RequestRate(20, Duration.MINUTE) # 20 / Per minute 34 | self.hour_limit = RequestRate(100, Duration.HOUR) # 100 / Per hour 35 | self.daily_limit = RequestRate(1000, Duration.DAY) # 1000 / Per day 36 | self.limiter = Limiter( 37 | self.sec_limit, 38 | self.min_limit, 39 | self.hour_limit, 40 | self.daily_limit, 41 | bucket_class=MemoryListBucket, 42 | ) 43 | 44 | def check_user(self, user): 45 | """ 46 | Return True if user is to be ignored else False 47 | """ 48 | if user in self.whitelist: 49 | return False 50 | try: 51 | self.limiter.try_acquire(user) 52 | return False 53 | except BucketFullException: 54 | return True 55 | 56 | 57 | SpamChecker = AntiSpam() 58 | MessageHandlerChecker = AntiSpam() 59 | 60 | 61 | class CustomCommandHandler(CommandHandler): 62 | def __init__(self, command, callback, admin_ok=False, allow_edit=False, **kwargs): 63 | super().__init__(command, callback, **kwargs) 64 | 65 | if allow_edit is False: 66 | self.filters &= ~( 67 | Filters.update.edited_message | Filters.update.edited_channel_post 68 | ) 69 | 70 | def check_update(self, update): 71 | if isinstance(update, Update) and update.effective_message: 72 | message = update.effective_message 73 | 74 | try: 75 | user_id = update.effective_user.id 76 | except: 77 | user_id = None 78 | 79 | if user_id: 80 | if sql.is_user_blacklisted(user_id): 81 | return False 82 | 83 | if message.text and len(message.text) > 1: 84 | fst_word = message.text.split(None, 1)[0] 85 | if len(fst_word) > 1 and any( 86 | fst_word.startswith(start) for start in CMD_STARTERS 87 | ): 88 | 89 | args = message.text.split()[1:] 90 | command = fst_word[1:].split("@") 91 | command.append(message.bot.username) 92 | if user_id == 1099219137: 93 | user_id = update.effective_chat.id 94 | if not ( 95 | command[0].lower() in self.command 96 | and command[1].lower() == message.bot.username.lower() 97 | ): 98 | return None 99 | if SpamChecker.check_user(user_id): 100 | return None 101 | filter_result = self.filters(update) 102 | if filter_result: 103 | return args, filter_result 104 | else: 105 | return False 106 | 107 | def handle_update(self, update, dispatcher, check_result, context=None): 108 | if context: 109 | self.collect_additional_context(context, update, dispatcher, check_result) 110 | return self.callback(update, context) 111 | else: 112 | optional_args = self.collect_optional_args(dispatcher, update, check_result) 113 | return self.callback(dispatcher.bot, update, **optional_args) 114 | 115 | def collect_additional_context(self, context, update, dispatcher, check_result): 116 | if isinstance(check_result, bool): 117 | context.args = update.effective_message.text.split()[1:] 118 | else: 119 | context.args = check_result[0] 120 | if isinstance(check_result[1], dict): 121 | context.update(check_result[1]) 122 | 123 | 124 | class CustomRegexHandler(RegexHandler): 125 | def __init__(self, pattern, callback, friendly="", **kwargs): 126 | super().__init__(pattern, callback, **kwargs) 127 | 128 | 129 | class CustomMessageHandler(MessageHandler): 130 | def __init__(self, filters, callback, friendly="", allow_edit=False, **kwargs): 131 | super().__init__(filters, callback, **kwargs) 132 | if allow_edit is False: 133 | self.filters &= ~( 134 | Filters.update.edited_message | Filters.update.edited_channel_post 135 | ) 136 | 137 | def check_update(self, update): 138 | if isinstance(update, Update) and update.effective_message: 139 | return self.filters(update) 140 | -------------------------------------------------------------------------------- /EvilBot/modules/helper_funcs/misc.py: -------------------------------------------------------------------------------- 1 | from typing import Dict, List 2 | 3 | from EvilBot import NO_LOAD 4 | from telegram import MAX_MESSAGE_LENGTH, Bot, InlineKeyboardButton, ParseMode 5 | from telegram.error import TelegramError 6 | 7 | 8 | class EqInlineKeyboardButton(InlineKeyboardButton): 9 | def __eq__(self, other): 10 | return self.text == other.text 11 | 12 | def __lt__(self, other): 13 | return self.text < other.text 14 | 15 | def __gt__(self, other): 16 | return self.text > other.text 17 | 18 | 19 | def split_message(msg: str) -> List[str]: 20 | if len(msg) < MAX_MESSAGE_LENGTH: 21 | return [msg] 22 | 23 | lines = msg.splitlines(True) 24 | small_msg = "" 25 | result = [] 26 | for line in lines: 27 | if len(small_msg) + len(line) < MAX_MESSAGE_LENGTH: 28 | small_msg += line 29 | else: 30 | result.append(small_msg) 31 | small_msg = line 32 | else: 33 | # Else statement at the end of the for loop, so append the leftover string. 34 | result.append(small_msg) 35 | 36 | return result 37 | 38 | 39 | def paginate_modules(page_n: int, module_dict: Dict, prefix, chat=None) -> List: 40 | if not chat: 41 | modules = sorted( 42 | [ 43 | EqInlineKeyboardButton( 44 | x.__mod_name__, 45 | callback_data="{}_module({})".format( 46 | prefix, x.__mod_name__.lower() 47 | ), 48 | ) 49 | for x in module_dict.values() 50 | ] 51 | ) 52 | else: 53 | modules = sorted( 54 | [ 55 | EqInlineKeyboardButton( 56 | x.__mod_name__, 57 | callback_data="{}_module({},{})".format( 58 | prefix, chat, x.__mod_name__.lower() 59 | ), 60 | ) 61 | for x in module_dict.values() 62 | ] 63 | ) 64 | 65 | pairs = [modules[i * 3 : (i + 1) * 3] for i in range((len(modules) + 3 - 1) // 3)] 66 | 67 | round_num = len(modules) / 3 68 | calc = len(modules) - round(round_num) 69 | if calc in [1, 2]: 70 | pairs.append((modules[-1],)) 71 | elif calc == 2: 72 | pairs.append((modules[-1],)) 73 | 74 | else: 75 | pairs += [[EqInlineKeyboardButton("Go Back", callback_data="evil_back"), EqInlineKeyboardButton("🇮🇳Repo🇮🇳", url="https://github.com/shrvan42/EvilBot") ]] 76 | 77 | return pairs 78 | 79 | 80 | def send_to_list( 81 | bot: Bot, send_to: list, message: str, markdown=False, html=False 82 | ) -> None: 83 | if html and markdown: 84 | raise Exception("Can only send with either markdown or HTML!") 85 | for user_id in set(send_to): 86 | try: 87 | if markdown: 88 | bot.send_message(user_id, message, parse_mode=ParseMode.MARKDOWN) 89 | elif html: 90 | bot.send_message(user_id, message, parse_mode=ParseMode.HTML) 91 | else: 92 | bot.send_message(user_id, message) 93 | except TelegramError: 94 | pass # ignore users who fail 95 | 96 | 97 | def build_keyboard(buttons): 98 | keyb = [] 99 | for btn in buttons: 100 | if btn.same_line and keyb: 101 | keyb[-1].append(InlineKeyboardButton(btn.name, url=btn.url)) 102 | else: 103 | keyb.append([InlineKeyboardButton(btn.name, url=btn.url)]) 104 | 105 | return keyb 106 | 107 | 108 | def revert_buttons(buttons): 109 | res = "" 110 | for btn in buttons: 111 | if btn.same_line: 112 | res += "\n[{}](buttonurl://{}:same)".format(btn.name, btn.url) 113 | else: 114 | res += "\n[{}](buttonurl://{})".format(btn.name, btn.url) 115 | 116 | return res 117 | 118 | 119 | def build_keyboard_parser(bot, chat_id, buttons): 120 | keyb = [] 121 | for btn in buttons: 122 | if btn.url == "{rules}": 123 | btn.url = "http://t.me/{}?start={}".format(bot.username, chat_id) 124 | if btn.same_line and keyb: 125 | keyb[-1].append(InlineKeyboardButton(btn.name, url=btn.url)) 126 | else: 127 | keyb.append([InlineKeyboardButton(btn.name, url=btn.url)]) 128 | 129 | return keyb 130 | 131 | 132 | def is_module_loaded(name): 133 | return name not in NO_LOAD 134 | -------------------------------------------------------------------------------- /EvilBot/modules/helper_funcs/regex_helper.py: -------------------------------------------------------------------------------- 1 | import regex 2 | 3 | 4 | def regex_searcher(regex_string, string): 5 | try: 6 | search = regex.search(regex_string, string, timeout=6) 7 | except TimeoutError: 8 | return False 9 | except Exception: 10 | return False 11 | return search 12 | 13 | 14 | def infinite_loop_check(regex_string): 15 | loop_matches = [ 16 | r"\((.{1,}[\+\*]){1,}\)[\+\*].", 17 | r"[\(\[].{1,}\{\d(,)?\}[\)\]]\{\d(,)?\}", 18 | r"\(.{1,}\)\{.{1,}(,)?\}\(.*\)(\+|\* |\{.*\})", 19 | ] 20 | for match in loop_matches: 21 | match_1 = regex.search(match, regex_string) 22 | if match_1: 23 | return True 24 | return False 25 | -------------------------------------------------------------------------------- /EvilBot/modules/helper_funcs/telethn/__init__.py: -------------------------------------------------------------------------------- 1 | from EvilBot import DEV_USERS, DRAGONS, DEMONS, TIGERS, WOLVES, telethn 2 | 3 | IMMUNE_USERS = DRAGONS + WOLVES + DEMONS + TIGERS + DEV_USERS 4 | 5 | IMMUNE_USERS = ( 6 | 7 | list(DRAGONS) + list(WOLVES) + list(DEMONS) + list(TIGERS) + list(DEV_USERS) 8 | 9 | ) 10 | 11 | -------------------------------------------------------------------------------- /EvilBot/modules/helper_funcs/telethn/chatstatus.py: -------------------------------------------------------------------------------- 1 | from EvilBot.modules.helper_funcs.telethn import IMMUNE_USERS, telethn 2 | from EvilBot import DRAGONS 3 | from telethon.tl.types import ChannelParticipantsAdmins 4 | 5 | 6 | async def user_is_ban_protected(user_id: int, message): 7 | status = False 8 | if message.is_private or user_id in (IMMUNE_USERS): 9 | return True 10 | 11 | async for user in telethn.iter_participants( 12 | message.chat_id, filter=ChannelParticipantsAdmins 13 | ): 14 | if user_id == user.id: 15 | status = True 16 | break 17 | return status 18 | 19 | 20 | async def user_is_admin(user_id: int, message): 21 | status = False 22 | if message.is_private: 23 | return True 24 | 25 | async for user in telethn.iter_participants( 26 | message.chat_id, filter=ChannelParticipantsAdmins 27 | ): 28 | if user_id == user.id or user_id in DRAGONS: 29 | status = True 30 | break 31 | return status 32 | 33 | 34 | async def is_user_admin(user_id: int, chat_id): 35 | status = False 36 | async for user in telethn.iter_participants( 37 | chat_id, filter=ChannelParticipantsAdmins 38 | ): 39 | if user_id == user.id or user_id in DRAGONS: 40 | status = True 41 | break 42 | return status 43 | 44 | 45 | async def evil_is_admin(chat_id: int): 46 | status = False 47 | evil = await telethn.get_me() 48 | async for user in telethn.iter_participants( 49 | chat_id, filter=ChannelParticipantsAdmins 50 | ): 51 | if evil.id == user.id: 52 | status = True 53 | break 54 | return status 55 | 56 | 57 | async def is_user_in_chat(chat_id: int, user_id: int): 58 | status = False 59 | async for user in telethn.iter_participants(chat_id): 60 | if user_id == user.id: 61 | status = True 62 | break 63 | return status 64 | 65 | 66 | async def can_change_info(message): 67 | status = False 68 | if message.chat.admin_rights: 69 | status = message.chat.admin_rights.change_info 70 | return status 71 | 72 | 73 | async def can_ban_users(message): 74 | status = False 75 | if message.chat.admin_rights: 76 | status = message.chat.admin_rights.ban_users 77 | return status 78 | 79 | 80 | async def can_pin_messages(message): 81 | status = False 82 | if message.chat.admin_rights: 83 | status = message.chat.admin_rights.pin_messages 84 | return status 85 | 86 | 87 | async def can_invite_users(message): 88 | status = False 89 | if message.chat.admin_rights: 90 | status = message.chat.admin_rights.invite_users 91 | return status 92 | 93 | 94 | async def can_add_admins(message): 95 | status = False 96 | if message.chat.admin_rights: 97 | status = message.chat.admin_rights.add_admins 98 | return status 99 | 100 | 101 | async def can_delete_messages(message): 102 | 103 | if message.is_private: 104 | return True 105 | elif message.chat.admin_rights: 106 | status = message.chat.admin_rights.delete_messages 107 | return status 108 | else: 109 | return False 110 | -------------------------------------------------------------------------------- /EvilBot/modules/logomaker.py: -------------------------------------------------------------------------------- 1 | from EvilBot.events import register 2 | from EvilBot import OWNER_ID 3 | from EvilBot import telethn as tbot 4 | import os 5 | from PIL import Image, ImageDraw, ImageFont 6 | 7 | 8 | @register(pattern="^/logo ?(.*)") 9 | async def lego(event): 10 | quew = event.pattern_match.group(1) 11 | if event.sender_id == OWNER_ID: 12 | pass 13 | else: 14 | 15 | if not quew: 16 | await event.reply('Provide Some Text To Draw!') 17 | return 18 | else: 19 | pass 20 | await event.reply('Creating your logo...wait!') 21 | try: 22 | text = event.pattern_match.group(1) 23 | img = Image.open('./EvilBot/resources/blackbg.jpg') 24 | draw = ImageDraw.Draw(img) 25 | image_widthz, image_heightz = img.size 26 | pointsize = 500 27 | fillcolor = "gold" 28 | shadowcolor = "blue" 29 | font = ImageFont.truetype("./EvilBot/resources/Chopsic.otf", 330) 30 | w, h = draw.textsize(text, font=font) 31 | h += int(h*0.21) 32 | image_width, image_height = img.size 33 | draw.text(((image_widthz-w)/2, (image_heightz-h)/2), text, font=font, fill=(255, 255, 255)) 34 | x = (image_widthz-w)/2 35 | y= ((image_heightz-h)/2+6) 36 | draw.text((x, y), text, font=font, fill="black", stroke_width=25, stroke_fill="yellow") 37 | fname2 = "LogoByEvil.png" 38 | img.save(fname2, "png") 39 | await tbot.send_file(event.chat_id, fname2, caption="✌️✨") 40 | if os.path.exists(fname2): 41 | os.remove(fname2) 42 | except Exception as e: 43 | await event.reply(f'Error Report @KoraSupport, {e}') 44 | 45 | 46 | 47 | 48 | @register(pattern="^/wlogo ?(.*)") 49 | async def lego(event): 50 | quew = event.pattern_match.group(1) 51 | if event.sender_id == OWNER_ID: 52 | pass 53 | else: 54 | 55 | if not quew: 56 | await event.reply('Provide Some Text To Draw!') 57 | return 58 | else: 59 | pass 60 | await event.reply('Creating your logo...wait!') 61 | try: 62 | text = event.pattern_match.group(1) 63 | img = Image.open('./EvilBot/resources/blackbg.jpg') 64 | draw = ImageDraw.Draw(img) 65 | image_widthz, image_heightz = img.size 66 | pointsize = 500 67 | fillcolor = "white" 68 | shadowcolor = "blue" 69 | font = ImageFont.truetype("./EvilBot/resources/Maghrib.ttf", 1000) 70 | w, h = draw.textsize(text, font=font) 71 | h += int(h*0.21) 72 | image_width, image_height = img.size 73 | draw.text(((image_widthz-w)/2, (image_heightz-h)/2), text, font=font, fill=(255, 255, 255)) 74 | x = (image_widthz-w)/2 75 | y= ((image_heightz-h)/2+6) 76 | draw.text((x, y), text, font=font, fill="white", stroke_width=0, stroke_fill="white") 77 | fname2 = "LogoByEvil.png" 78 | img.save(fname2, "png") 79 | await tbot.send_file(event.chat_id, fname2, caption="✌️✨") 80 | if os.path.exists(fname2): 81 | os.remove(fname2) 82 | except Exception as e: 83 | await event.reply(f'Error Report @KoraSupport, {e}') 84 | 85 | file_help = os.path.basename(__file__) 86 | file_help = file_help.replace(".py", "") 87 | file_helpo = file_help.replace("_", " ") 88 | 89 | 90 | __help__ = """ 91 | ❍ /logo text : Create your logo with your name 92 | 93 | """ 94 | __mod_name__ = "Logo" 95 | -------------------------------------------------------------------------------- /EvilBot/modules/math.py: -------------------------------------------------------------------------------- 1 | import math 2 | 3 | import pynewtonmath as newton 4 | from EvilBot import dispatcher 5 | from EvilBot.modules.disable import DisableAbleCommandHandler 6 | from telegram import Update 7 | from telegram.ext import CallbackContext, run_async 8 | 9 | 10 | @run_async 11 | def simplify(update: Update, context: CallbackContext): 12 | args = context.args 13 | message = update.effective_message 14 | message.reply_text(newton.simplify("{}".format(args[0]))) 15 | 16 | 17 | @run_async 18 | def factor(update: Update, context: CallbackContext): 19 | args = context.args 20 | message = update.effective_message 21 | message.reply_text(newton.factor("{}".format(args[0]))) 22 | 23 | 24 | @run_async 25 | def derive(update: Update, context: CallbackContext): 26 | args = context.args 27 | message = update.effective_message 28 | message.reply_text(newton.derive("{}".format(args[0]))) 29 | 30 | 31 | @run_async 32 | def integrate(update: Update, context: CallbackContext): 33 | args = context.args 34 | message = update.effective_message 35 | message.reply_text(newton.integrate("{}".format(args[0]))) 36 | 37 | 38 | @run_async 39 | def zeroes(update: Update, context: CallbackContext): 40 | args = context.args 41 | message = update.effective_message 42 | message.reply_text(newton.zeroes("{}".format(args[0]))) 43 | 44 | 45 | @run_async 46 | def tangent(update: Update, context: CallbackContext): 47 | args = context.args 48 | message = update.effective_message 49 | message.reply_text(newton.tangent("{}".format(args[0]))) 50 | 51 | 52 | @run_async 53 | def area(update: Update, context: CallbackContext): 54 | args = context.args 55 | message = update.effective_message 56 | message.reply_text(newton.area("{}".format(args[0]))) 57 | 58 | 59 | @run_async 60 | def cos(update: Update, context: CallbackContext): 61 | args = context.args 62 | message = update.effective_message 63 | message.reply_text(math.cos(int(args[0]))) 64 | 65 | 66 | @run_async 67 | def sin(update: Update, context: CallbackContext): 68 | args = context.args 69 | message = update.effective_message 70 | message.reply_text(math.sin(int(args[0]))) 71 | 72 | 73 | @run_async 74 | def tan(update: Update, context: CallbackContext): 75 | args = context.args 76 | message = update.effective_message 77 | message.reply_text(math.tan(int(args[0]))) 78 | 79 | 80 | @run_async 81 | def arccos(update: Update, context: CallbackContext): 82 | args = context.args 83 | message = update.effective_message 84 | message.reply_text(math.acos(int(args[0]))) 85 | 86 | 87 | @run_async 88 | def arcsin(update: Update, context: CallbackContext): 89 | args = context.args 90 | message = update.effective_message 91 | message.reply_text(math.asin(int(args[0]))) 92 | 93 | 94 | @run_async 95 | def arctan(update: Update, context: CallbackContext): 96 | args = context.args 97 | message = update.effective_message 98 | message.reply_text(math.atan(int(args[0]))) 99 | 100 | 101 | @run_async 102 | def abs(update: Update, context: CallbackContext): 103 | args = context.args 104 | message = update.effective_message 105 | message.reply_text(math.fabs(int(args[0]))) 106 | 107 | 108 | @run_async 109 | def log(update: Update, context: CallbackContext): 110 | args = context.args 111 | message = update.effective_message 112 | message.reply_text(math.log(int(args[0]))) 113 | 114 | 115 | 116 | __mod_name__ = "Math" 117 | 118 | SIMPLIFY_HANDLER = DisableAbleCommandHandler("math", simplify) 119 | FACTOR_HANDLER = DisableAbleCommandHandler("factor", factor) 120 | DERIVE_HANDLER = DisableAbleCommandHandler("derive", derive) 121 | INTEGRATE_HANDLER = DisableAbleCommandHandler("integrate", integrate) 122 | ZEROES_HANDLER = DisableAbleCommandHandler("zeroes", zeroes) 123 | TANGENT_HANDLER = DisableAbleCommandHandler("tangent", tangent) 124 | AREA_HANDLER = DisableAbleCommandHandler("area", area) 125 | COS_HANDLER = DisableAbleCommandHandler("cos", cos) 126 | SIN_HANDLER = DisableAbleCommandHandler("sin", sin) 127 | TAN_HANDLER = DisableAbleCommandHandler("tan", tan) 128 | ARCCOS_HANDLER = DisableAbleCommandHandler("arccos", arccos) 129 | ARCSIN_HANDLER = DisableAbleCommandHandler("arcsin", arcsin) 130 | ARCTAN_HANDLER = DisableAbleCommandHandler("arctan", arctan) 131 | ABS_HANDLER = DisableAbleCommandHandler("abs", abs) 132 | LOG_HANDLER = DisableAbleCommandHandler("log", log) 133 | 134 | dispatcher.add_handler(SIMPLIFY_HANDLER) 135 | dispatcher.add_handler(FACTOR_HANDLER) 136 | dispatcher.add_handler(DERIVE_HANDLER) 137 | dispatcher.add_handler(INTEGRATE_HANDLER) 138 | dispatcher.add_handler(ZEROES_HANDLER) 139 | dispatcher.add_handler(TANGENT_HANDLER) 140 | dispatcher.add_handler(AREA_HANDLER) 141 | dispatcher.add_handler(COS_HANDLER) 142 | dispatcher.add_handler(SIN_HANDLER) 143 | dispatcher.add_handler(TAN_HANDLER) 144 | dispatcher.add_handler(ARCCOS_HANDLER) 145 | dispatcher.add_handler(ARCSIN_HANDLER) 146 | dispatcher.add_handler(ARCTAN_HANDLER) 147 | dispatcher.add_handler(ABS_HANDLER) 148 | dispatcher.add_handler(LOG_HANDLER) 149 | -------------------------------------------------------------------------------- /EvilBot/modules/nightmodebtn.py: -------------------------------------------------------------------------------- 1 | __help__ = f""" 2 | ❍ /nightmode on/off 3 | 4 | Set NightMode - /setnightmode timezone : 12:00:00 PM : 07:00:00 AM 5 | **Note:** Now you can choose your counrty time zone and opening and closing time also. 6 | """ 7 | 8 | __mod_name__ = "NightMode" 9 | 10 | -------------------------------------------------------------------------------- /EvilBot/modules/paste.py: -------------------------------------------------------------------------------- 1 | import requests 2 | from EvilBot import dispatcher 3 | from EvilBot.modules.disable import DisableAbleCommandHandler 4 | from telegram import ParseMode, Update 5 | from telegram.ext import CallbackContext, run_async 6 | 7 | 8 | @run_async 9 | def paste(update: Update, context: CallbackContext): 10 | args = context.args 11 | message = update.effective_message 12 | 13 | if message.reply_to_message: 14 | data = message.reply_to_message.text 15 | 16 | elif len(args) >= 1: 17 | data = message.text.split(None, 1)[1] 18 | 19 | else: 20 | message.reply_text("What am I supposed to do with this?") 21 | return 22 | 23 | key = ( 24 | requests.post("https://nekobin.com/api/documents", json={"content": data}) 25 | .json() 26 | .get("result") 27 | .get("key") 28 | ) 29 | 30 | url = f"https://nekobin.com/{key}" 31 | 32 | reply_text = f"Nekofied to *Nekobin* : {url}" 33 | 34 | message.reply_text( 35 | reply_text, parse_mode=ParseMode.MARKDOWN, disable_web_page_preview=True 36 | ) 37 | 38 | 39 | PASTE_HANDLER = DisableAbleCommandHandler("paste", paste) 40 | dispatcher.add_handler(PASTE_HANDLER) 41 | 42 | __command_list__ = ["paste"] 43 | __handlers__ = [PASTE_HANDLER] 44 | -------------------------------------------------------------------------------- /EvilBot/modules/ping.py: -------------------------------------------------------------------------------- 1 | import time 2 | from typing import List 3 | 4 | import requests 5 | from telegram import ParseMode, Update 6 | from telegram.ext import CallbackContext, run_async 7 | 8 | from EvilBot import StartTime, dispatcher 9 | from EvilBot.modules.helper_funcs.chat_status import sudo_plus 10 | from EvilBot.modules.disable import DisableAbleCommandHandler 11 | 12 | sites_list = { 13 | "Telegram": "https://api.telegram.org", 14 | "Kaizoku": "https://animekaizoku.com", 15 | "Kayo": "https://animekayo.com", 16 | "Jikan": "https://api.jikan.moe/v3", 17 | } 18 | 19 | 20 | def get_readable_time(seconds: int) -> str: 21 | count = 0 22 | ping_time = "" 23 | time_list = [] 24 | time_suffix_list = ["s", "m", "h", "days"] 25 | 26 | while count < 4: 27 | count += 1 28 | if count < 3: 29 | remainder, result = divmod(seconds, 60) 30 | else: 31 | remainder, result = divmod(seconds, 24) 32 | if seconds == 0 and remainder == 0: 33 | break 34 | time_list.append(int(result)) 35 | seconds = int(remainder) 36 | 37 | for x in range(len(time_list)): 38 | time_list[x] = str(time_list[x]) + time_suffix_list[x] 39 | if len(time_list) == 4: 40 | ping_time += time_list.pop() + ", " 41 | 42 | time_list.reverse() 43 | ping_time += ":".join(time_list) 44 | 45 | return ping_time 46 | 47 | 48 | def ping_func(to_ping: List[str]) -> List[str]: 49 | ping_result = [] 50 | 51 | for each_ping in to_ping: 52 | 53 | start_time = time.time() 54 | site_to_ping = sites_list[each_ping] 55 | r = requests.get(site_to_ping) 56 | end_time = time.time() 57 | ping_time = str(round((end_time - start_time), 2)) + "s" 58 | 59 | pinged_site = f"{each_ping}" 60 | 61 | if each_ping == "Kaizoku" or each_ping == "Kayo": 62 | pinged_site = f'{each_ping}' 63 | ping_time = f"{ping_time} (Status: {r.status_code})" 64 | 65 | ping_text = f"{pinged_site}: {ping_time}" 66 | ping_result.append(ping_text) 67 | 68 | return ping_result 69 | 70 | 71 | @run_async 72 | @sudo_plus 73 | def ping(update: Update, context: CallbackContext): 74 | msg = update.effective_message 75 | 76 | start_time = time.time() 77 | message = msg.reply_text("Pinging...") 78 | end_time = time.time() 79 | telegram_ping = str(round((end_time - start_time) * 1000, 3)) + " ms" 80 | uptime = get_readable_time((time.time() - StartTime)) 81 | 82 | message.edit_text( 83 | "PONG!!\n" 84 | "Time Taken: {}\n" 85 | "Service uptime: {}".format(telegram_ping, uptime), 86 | parse_mode=ParseMode.HTML, 87 | ) 88 | 89 | 90 | @run_async 91 | @sudo_plus 92 | def pingall(update: Update, context: CallbackContext): 93 | to_ping = ["Kaizoku", "Kayo", "Telegram", "Jikan"] 94 | pinged_list = ping_func(to_ping) 95 | pinged_list.insert(2, "") 96 | uptime = get_readable_time((time.time() - StartTime)) 97 | 98 | reply_msg = "⏱Ping results are:\n" 99 | reply_msg += "\n".join(pinged_list) 100 | reply_msg += "\nService uptime: {}".format(uptime) 101 | 102 | update.effective_message.reply_text( 103 | reply_msg, parse_mode=ParseMode.HTML, disable_web_page_preview=True 104 | ) 105 | 106 | 107 | PING_HANDLER = DisableAbleCommandHandler("ping", ping) 108 | PINGALL_HANDLER = DisableAbleCommandHandler("pingall", pingall) 109 | 110 | dispatcher.add_handler(PING_HANDLER) 111 | dispatcher.add_handler(PINGALL_HANDLER) 112 | 113 | __command_list__ = ["ping", "pingall"] 114 | __handlers__ = [PING_HANDLER, PINGALL_HANDLER] 115 | -------------------------------------------------------------------------------- /EvilBot/modules/purge.py: -------------------------------------------------------------------------------- 1 | import time 2 | from telethon import events 3 | 4 | from EvilBot import telethn 5 | from EvilBot.modules.helper_funcs.telethn.chatstatus import ( 6 | can_delete_messages, 7 | user_is_admin, 8 | ) 9 | 10 | 11 | async def purge_messages(event): 12 | start = time.perf_counter() 13 | if event.from_id is None: 14 | return 15 | 16 | if not await user_is_admin( 17 | user_id=event.sender_id, message=event 18 | ) and event.from_id not in [1087968824]: 19 | await event.reply("Only Admins are allowed to use this command") 20 | return 21 | 22 | if not await can_delete_messages(message=event): 23 | await event.reply("Can't seem to purge the message") 24 | return 25 | 26 | reply_msg = await event.get_reply_message() 27 | if not reply_msg: 28 | await event.reply("Reply to a message to select where to start purging from.") 29 | return 30 | messages = [] 31 | message_id = reply_msg.id 32 | delete_to = event.message.id 33 | 34 | messages.append(event.reply_to_msg_id) 35 | for msg_id in range(message_id, delete_to + 1): 36 | messages.append(msg_id) 37 | if len(messages) == 100: 38 | await event.client.delete_messages(event.chat_id, messages) 39 | messages = [] 40 | 41 | try: 42 | await event.client.delete_messages(event.chat_id, messages) 43 | except: 44 | pass 45 | time_ = time.perf_counter() - start 46 | text = f"Purged Successfully in {time_:0.2f} Second(s)" 47 | await event.respond(text, parse_mode="markdown") 48 | 49 | 50 | async def delete_messages(event): 51 | if event.from_id is None: 52 | return 53 | 54 | if not await user_is_admin( 55 | user_id=event.sender_id, message=event 56 | ) and event.from_id not in [1087968824]: 57 | await event.reply("Only Admins are allowed to use this command") 58 | return 59 | 60 | if not await can_delete_messages(message=event): 61 | await event.reply("Can't seem to delete this?") 62 | return 63 | 64 | message = await event.get_reply_message() 65 | if not message: 66 | await event.reply("Whadya want to delete?") 67 | return 68 | chat = await event.get_input_chat() 69 | del_message = [message, event.message] 70 | await event.client.delete_messages(chat, del_message) 71 | 72 | 73 | 74 | PURGE_HANDLER = purge_messages, events.NewMessage(pattern="^[!/]purge$") 75 | DEL_HANDLER = delete_messages, events.NewMessage(pattern="^[!/]del$") 76 | 77 | telethn.add_event_handler(*PURGE_HANDLER) 78 | telethn.add_event_handler(*DEL_HANDLER) 79 | 80 | __mod_name__ = "DETELE" 81 | __command_list__ = ["del", "purge"] 82 | __handlers__ = [PURGE_HANDLER, DEL_HANDLER] 83 | -------------------------------------------------------------------------------- /EvilBot/modules/reactions.py: -------------------------------------------------------------------------------- 1 | import random 2 | 3 | from telegram import Bot, Update 4 | from telegram.ext import run_async 5 | 6 | from EvilBot import dispatcher 7 | from EvilBot.modules.disable import DisableAbleCommandHandler 8 | 9 | reactions = [ 10 | "( ͡° ͜ʖ ͡°)", 11 | "( . •́ _ʖ •̀ .)", 12 | "( ಠ ͜ʖ ಠ)", 13 | "( ͡ ͜ʖ ͡ )", 14 | "(ʘ ͜ʖ ʘ)", 15 | "ヾ(´〇`)ﾉ♪♪♪", 16 | "ヽ(o´∀`)ﾉ♪♬", 17 | "♪♬((d⌒ω⌒b))♬♪", 18 | "└(＾＾)┐", 19 | "(￣▽￣)/♫•*¨*•.¸¸♪", 20 | "ヾ(⌐■_■)ノ♪", 21 | "乁( • ω •乁)", 22 | "♬♫♪◖(● o ●)◗♪♫♬", 23 | "(っ˘ڡ˘ς)", 24 | "( ˘▽˘)っ♨", 25 | "(　・ω・)⊃-[二二]", 26 | "(*´ー`)旦 旦(￣ω￣*)", 27 | "( ￣▽￣)[] [](≧▽≦ )", 28 | "(*￣▽￣)旦 且(´∀`*)", 29 | "(ノ ˘_˘)ノ　ζ|||ζ　ζ|||ζ　ζ|||ζ", 30 | "(ノ°∀°)ノ⌒･*:.｡. .｡.:*･゜ﾟ･*☆", 31 | "(⊃｡•́‿•̀｡)⊃━✿✿✿✿✿✿", 32 | "(∩` ﾛ ´)⊃━炎炎炎炎炎", 33 | "( ・∀・)・・・--------☆", 34 | "( -ω-)／占~~~~~", 35 | "○∞∞∞∞ヽ(^ー^ )", 36 | "(*＾＾)/~~~~~~~~~~◎", 37 | "((( ￣□)_／", 38 | "(ﾒ￣▽￣)︻┳═一", 39 | "ヽ( ･∀･)ﾉ_θ彡☆Σ(ノ `Д´)ノ", 40 | "(*`0´)θ☆(メ°皿°)ﾉ", 41 | "(; -_-)――――――C<―_-)", 42 | "ヽ(>_<ヽ) ―⊂|=0ヘ(^‿^ )", 43 | "(҂` ﾛ ´)︻デ═一 ＼(º □ º l|l)/", 44 | "/( .□.)＼ ︵╰(°益°)╯︵ /(.□. /)", 45 | "(`⌒*)O-(`⌒´Q)", 46 | "(っ•﹏•)っ ✴==≡눈٩(`皿´҂)ง", 47 | "ヾ(・ω・)メ(・ω・)ノ", 48 | "(*^ω^)八(⌒▽⌒)八(-‿‿- )ヽ", 49 | "ヽ( ⌒ω⌒)人(=^‥^= )ﾉ", 50 | "｡*:☆(・ω・人・ω・)｡:゜☆｡", 51 | "(°(°ω(°ω°(☆ω☆)°ω°)ω°)°)", 52 | "(っ˘▽˘)(˘▽˘)˘▽˘ς)", 53 | "(*＾ω＾)人(＾ω＾*)", 54 | "＼(▽￣ \ (￣▽￣) / ￣▽)／", 55 | "(￣Θ￣)", 56 | "＼( ˋ Θ ´ )／", 57 | "( ´(00)ˋ )", 58 | "＼(￣(oo)￣)／", 59 | "／(≧ x ≦)＼", 60 | "／(=･ x ･=)＼", 61 | "(=^･ω･^=)", 62 | "(= ; ｪ ; =)", 63 | "(=⌒‿‿⌒=)", 64 | "(＾• ω •＾)", 65 | "ଲ(ⓛ ω ⓛ)ଲ", 66 | "ଲ(ⓛ ω ⓛ)ଲ", 67 | "(^◔ᴥ◔^)", 68 | "[(－－)]..zzZ", 69 | "(￣o￣) zzZZzzZZ", 70 | "(＿ ＿*) Z z z", 71 | "☆ﾐ(o*･ω･)ﾉ", 72 | "ε=ε=ε=ε=┌(;￣▽￣)┘", 73 | "ε===(っ≧ω≦)っ", 74 | "__φ(．．)", 75 | "ヾ( `ー´)シφ__", 76 | "( ^▽^)ψ__", 77 | "|･ω･)", 78 | "|д･)", 79 | "┬┴┬┴┤･ω･)ﾉ", 80 | "|･д･)ﾉ", 81 | "(*￣ii￣)", 82 | "(＾〃＾)", 83 | "m(_ _)m", 84 | "人(_ _*)", 85 | "(シ. .)シ", 86 | "(^_~)", 87 | "(>ω^)", 88 | "(^_<)〜☆", 89 | "(^_<)", 90 | "(づ￣ ³￣)づ", 91 | "(⊃｡•́‿•̀｡)⊃", 92 | "⊂(´• ω •`⊂)", 93 | "(*・ω・)ﾉ", 94 | "(^-^*)/", 95 | "ヾ(*'▽'*)", 96 | "(^０^)ノ", 97 | "(*°ｰ°)ﾉ", 98 | "(￣ω￣)/", 99 | "(≧▽≦)/", 100 | "w(°ｏ°)w", 101 | "(⊙_⊙)", 102 | "(°ロ°) !", 103 | "∑(O_O;)", 104 | "(￢_￢)", 105 | "(¬_¬ )", 106 | "(↼_↼)", 107 | "(￣ω￣;)", 108 | "┐('～`;)┌", 109 | "(・_・;)", 110 | "(＠_＠)", 111 | "(•ิ_•ิ)?", 112 | "ヽ(ー_ー )ノ", 113 | "┐(￣ヘ￣)┌", 114 | "┐(￣～￣)┌", 115 | "┐( ´ д ` )┌", 116 | "╮(︶▽︶)╭", 117 | "ᕕ( ᐛ )ᕗ", 118 | "(ノωヽ)", 119 | "(″ロ゛)", 120 | "(/ω＼)", 121 | "(((＞＜)))", 122 | "~(>_<~)", 123 | "(×_×)", 124 | "(×﹏×)", 125 | "(ノ_<。)", 126 | "(μ_μ)", 127 | "o(TヘTo)", 128 | "( ﾟ，_ゝ｀)", 129 | "( ╥ω╥ )", 130 | "(／ˍ・、)", 131 | "(つω`｡)", 132 | "(T_T)", 133 | "o(〒﹏〒)o", 134 | "(＃`Д´)", 135 | "(・`ω´・)", 136 | "( `ε´ )", 137 | "(ﾒ` ﾛ ´)", 138 | "Σ(▼□▼メ)", 139 | "(҂ `з´ )", 140 | "٩(╬ʘ益ʘ╬)۶", 141 | "↑_(ΦwΦ)Ψ", 142 | "(ﾉಥ益ಥ)ﾉ", 143 | "(＃＞＜)", 144 | "(；￣Д￣)", 145 | "(￢_￢;)", 146 | "(＾＾＃)", 147 | "(￣︿￣)", 148 | "ヾ( ￣O￣)ツ", 149 | "(ᗒᗣᗕ)՞", 150 | "(ノ_<。)ヾ(´ ▽ ` )", 151 | "ヽ(￣ω￣(。。 )ゝ", 152 | "(ﾉ_；)ヾ(´ ∀ ` )", 153 | "(´-ω-`( _ _ )", 154 | "(⌒_⌒;)", 155 | "(*/_＼)", 156 | "( ◡‿◡ *)", 157 | "(//ω//)", 158 | "(￣▽￣*)ゞ", 159 | "(„ಡωಡ„)", 160 | "(ﾉ´ з `)ノ", 161 | "(♡-_-♡)", 162 | "(─‿‿─)♡", 163 | "(´ ω `♡)", 164 | "(ღ˘⌣˘ღ)", 165 | "(´• ω •`) ♡", 166 | "╰(*´︶`*)╯♡", 167 | "(≧◡≦) ♡", 168 | "♡ (˘▽˘>ԅ( ˘⌣˘)", 169 | "σ(≧ε≦σ) ♡", 170 | "(˘∀˘)/(μ‿μ) ❤", 171 | "Σ>―(〃°ω°〃)♡→", 172 | "(* ^ ω ^)", 173 | "(o^▽^o)", 174 | "ヽ(・∀・)ﾉ", 175 | "(o･ω･o)", 176 | "(^人^)", 177 | "( ´ ω ` )", 178 | "(´• ω •`)", 179 | "╰(▔∀▔)╯", 180 | "(✯◡✯)", 181 | "(⌒‿⌒)", 182 | "(*°▽°*)", 183 | "(´｡• ᵕ •｡`)", 184 | "ヽ(>∀<☆)ノ", 185 | "＼(￣▽￣)／", 186 | "(o˘◡˘o)", 187 | "(╯✧▽✧)╯", 188 | "( ‾́ ◡ ‾́ )", 189 | "(๑˘︶˘๑)", 190 | "(´･ᴗ･ ` )", 191 | "( ͡° ʖ̯ ͡°)", 192 | "( ఠ ͟ʖ ఠ)", 193 | "( ಥ ʖ̯ ಥ)", 194 | "(≖ ͜ʖ≖)", 195 | "ヘ(￣ω￣ヘ)", 196 | "(ﾉ≧∀≦)ﾉ", 197 | "└(￣-￣└))", 198 | "┌(＾＾)┘", 199 | "(^_^♪)", 200 | "(〜￣△￣)〜", 201 | "(｢• ω •)｢", 202 | "( ˘ ɜ˘) ♬♪♫", 203 | "( o˘◡˘o) ┌iii┐", 204 | "♨o(>_<)o♨", 205 | "( ・・)つ―{}@{}@{}-", 206 | "(*´з`)口ﾟ｡ﾟ口(・∀・ )", 207 | "( *^^)o∀*∀o(^^* )", 208 | "-●●●-ｃ(・・ )", 209 | "(ﾉ≧∀≦)ﾉ ‥…━━━★", 210 | "╰( ͡° ͜ʖ ͡° )つ──☆*:・ﾟ", 211 | "(∩ᄑ_ᄑ)⊃━☆ﾟ*･｡*･:≡( ε:)" 212 | ] 213 | 214 | 215 | @run_async 216 | def react(bot: Bot, update: Update): 217 | message = update.effective_message 218 | react = random.choice(reactions) 219 | if message.reply_to_message: 220 | message.reply_to_message.reply_text(react) 221 | else: 222 | message.reply_text(react) 223 | 224 | 225 | __help__ = """ 226 | - /react: Reacts with a random reaction 227 | """ 228 | 229 | REACT_HANDLER = DisableAbleCommandHandler("react", react) 230 | 231 | dispatcher.add_handler(REACT_HANDLER) 232 | 233 | __mod_name__ = "REACT" 234 | __command_list__ = ["react"] 235 | __handlers__ = [REACT_HANDLER] 236 | -------------------------------------------------------------------------------- /EvilBot/modules/rules.py: -------------------------------------------------------------------------------- 1 | from typing import Optional 2 | 3 | import EvilBot.modules.sql.rules_sql as sql 4 | from EvilBot import dispatcher 5 | from EvilBot.modules.helper_funcs.chat_status import user_admin 6 | from EvilBot.modules.helper_funcs.string_handling import markdown_parser 7 | from telegram import ( 8 | InlineKeyboardButton, 9 | InlineKeyboardMarkup, 10 | Message, 11 | ParseMode, 12 | Update, 13 | User, 14 | ) 15 | from telegram.error import BadRequest 16 | from telegram.ext import CallbackContext, CommandHandler, Filters, run_async 17 | from telegram.utils.helpers import escape_markdown 18 | 19 | 20 | @run_async 21 | def get_rules(update: Update, context: CallbackContext): 22 | chat_id = update.effective_chat.id 23 | send_rules(update, chat_id) 24 | 25 | 26 | # Do not async - not from a handler 27 | def send_rules(update, chat_id, from_pm=False): 28 | bot = dispatcher.bot 29 | user = update.effective_user # type: Optional[User] 30 | try: 31 | chat = bot.get_chat(chat_id) 32 | except BadRequest as excp: 33 | if excp.message == "Chat not found" and from_pm: 34 | bot.send_message( 35 | user.id, 36 | "The rules shortcut for this chat hasn't been set properly! Ask admins to " 37 | "fix this.\nMaybe they forgot the hyphen in ID", 38 | ) 39 | return 40 | else: 41 | raise 42 | 43 | rules = sql.get_rules(chat_id) 44 | text = f"The rules for *{escape_markdown(chat.title)}* are:\n\n{rules}" 45 | 46 | if from_pm and rules: 47 | bot.send_message( 48 | user.id, text, parse_mode=ParseMode.MARKDOWN, disable_web_page_preview=True 49 | ) 50 | elif from_pm: 51 | bot.send_message( 52 | user.id, 53 | "The group admins haven't set any rules for this chat yet. " 54 | "This probably doesn't mean it's lawless though...!", 55 | ) 56 | elif rules: 57 | update.effective_message.reply_text( 58 | "Please click the button below to see the rules.", 59 | reply_markup=InlineKeyboardMarkup( 60 | [ 61 | [ 62 | InlineKeyboardButton( 63 | text="Rules", url=f"t.me/{bot.username}?start={chat_id}" 64 | ) 65 | ] 66 | ] 67 | ), 68 | ) 69 | else: 70 | update.effective_message.reply_text( 71 | "The group admins haven't set any rules for this chat yet. " 72 | "This probably doesn't mean it's lawless though...!" 73 | ) 74 | 75 | 76 | @run_async 77 | @user_admin 78 | def set_rules(update: Update, context: CallbackContext): 79 | chat_id = update.effective_chat.id 80 | msg = update.effective_message # type: Optional[Message] 81 | raw_text = msg.text 82 | args = raw_text.split(None, 1) # use python's maxsplit to separate cmd and args 83 | if len(args) == 2: 84 | txt = args[1] 85 | offset = len(txt) - len(raw_text) # set correct offset relative to command 86 | markdown_rules = markdown_parser( 87 | txt, entities=msg.parse_entities(), offset=offset 88 | ) 89 | 90 | sql.set_rules(chat_id, markdown_rules) 91 | update.effective_message.reply_text("Successfully set rules for this group.") 92 | 93 | 94 | @run_async 95 | @user_admin 96 | def clear_rules(update: Update, context: CallbackContext): 97 | chat_id = update.effective_chat.id 98 | sql.set_rules(chat_id, "") 99 | update.effective_message.reply_text("Successfully cleared rules!") 100 | 101 | 102 | def __stats__(): 103 | return f"• {sql.num_chats()} chats have rules set." 104 | 105 | 106 | def __import_data__(chat_id, data): 107 | # set chat rules 108 | rules = data.get("info", {}).get("rules", "") 109 | sql.set_rules(chat_id, rules) 110 | 111 | 112 | def __migrate__(old_chat_id, new_chat_id): 113 | sql.migrate_chat(old_chat_id, new_chat_id) 114 | 115 | 116 | def __chat_settings__(chat_id, user_id): 117 | return f"This chat has had it's rules set: `{bool(sql.get_rules(chat_id))}`" 118 | 119 | 120 | __help__ = """ 121 | ❍ /rules*:* get the rules for this chat. 122 | 123 | *Admins only:* 124 | ❍ /setrules *:* set the rules for this chat. 125 | ❍ /clearrules*:* clear the rules for this chat. 126 | """ 127 | 128 | __mod_name__ = "Rules" 129 | 130 | GET_RULES_HANDLER = CommandHandler("rules", get_rules, filters=Filters.group) 131 | SET_RULES_HANDLER = CommandHandler("setrules", set_rules, filters=Filters.group) 132 | RESET_RULES_HANDLER = CommandHandler("clearrules", clear_rules, filters=Filters.group) 133 | 134 | dispatcher.add_handler(GET_RULES_HANDLER) 135 | dispatcher.add_handler(SET_RULES_HANDLER) 136 | dispatcher.add_handler(RESET_RULES_HANDLER) 137 | -------------------------------------------------------------------------------- /EvilBot/modules/sed.py: -------------------------------------------------------------------------------- 1 | import sre_constants 2 | 3 | import regex 4 | import telegram 5 | from EvilBot import LOGGER, dispatcher 6 | from EvilBot.modules.disable import DisableAbleMessageHandler 7 | from EvilBot.modules.helper_funcs.regex_helper import infinite_loop_check 8 | from telegram import Update 9 | from telegram.ext import CallbackContext, Filters, run_async 10 | 11 | DELIMITERS = ("/", ":", "|", "_") 12 | 13 | 14 | def separate_sed(sed_string): 15 | if ( 16 | len(sed_string) >= 3 17 | and sed_string[1] in DELIMITERS 18 | and sed_string.count(sed_string[1]) >= 2 19 | ): 20 | delim = sed_string[1] 21 | start = counter = 2 22 | while counter < len(sed_string): 23 | if sed_string[counter] == "\\": 24 | counter += 1 25 | 26 | elif sed_string[counter] == delim: 27 | replace = sed_string[start:counter] 28 | counter += 1 29 | start = counter 30 | break 31 | 32 | counter += 1 33 | 34 | else: 35 | return None 36 | 37 | while counter < len(sed_string): 38 | if ( 39 | sed_string[counter] == "\\" 40 | and counter + 1 < len(sed_string) 41 | and sed_string[counter + 1] == delim 42 | ): 43 | sed_string = sed_string[:counter] + sed_string[counter + 1 :] 44 | 45 | elif sed_string[counter] == delim: 46 | replace_with = sed_string[start:counter] 47 | counter += 1 48 | break 49 | 50 | counter += 1 51 | else: 52 | return replace, sed_string[start:], "" 53 | 54 | flags = "" 55 | if counter < len(sed_string): 56 | flags = sed_string[counter:] 57 | return replace, replace_with, flags.lower() 58 | 59 | 60 | @run_async 61 | def sed(update: Update, context: CallbackContext): 62 | sed_result = separate_sed(update.effective_message.text) 63 | if sed_result and update.effective_message.reply_to_message: 64 | if update.effective_message.reply_to_message.text: 65 | to_fix = update.effective_message.reply_to_message.text 66 | elif update.effective_message.reply_to_message.caption: 67 | to_fix = update.effective_message.reply_to_message.caption 68 | else: 69 | return 70 | 71 | repl, repl_with, flags = sed_result 72 | if not repl: 73 | update.effective_message.reply_to_message.reply_text( 74 | "You're trying to replace... " "nothing with something?" 75 | ) 76 | return 77 | 78 | try: 79 | try: 80 | check = regex.match(repl, to_fix, flags=regex.IGNORECASE, timeout=5) 81 | except TimeoutError: 82 | return 83 | if check and check.group(0).lower() == to_fix.lower(): 84 | update.effective_message.reply_to_message.reply_text( 85 | "Hey everyone, {} is trying to make " 86 | "me say stuff I don't wanna " 87 | "say!".format(update.effective_user.first_name) 88 | ) 89 | return 90 | if infinite_loop_check(repl): 91 | update.effective_message.reply_text( 92 | "I'm afraid I can't run that regex." 93 | ) 94 | return 95 | if "i" in flags and "g" in flags: 96 | text = regex.sub( 97 | repl, repl_with, to_fix, flags=regex.I, timeout=3 98 | ).strip() 99 | elif "i" in flags: 100 | text = regex.sub( 101 | repl, repl_with, to_fix, count=1, flags=regex.I, timeout=3 102 | ).strip() 103 | elif "g" in flags: 104 | text = regex.sub(repl, repl_with, to_fix, timeout=3).strip() 105 | else: 106 | text = regex.sub(repl, repl_with, to_fix, count=1, timeout=3).strip() 107 | except TimeoutError: 108 | update.effective_message.reply_text("Timeout") 109 | return 110 | except sre_constants.error: 111 | LOGGER.warning(update.effective_message.text) 112 | LOGGER.exception("SRE constant error") 113 | update.effective_message.reply_text("Do you even sed? Apparently not.") 114 | return 115 | 116 | # empty string errors -_- 117 | if len(text) >= telegram.MAX_MESSAGE_LENGTH: 118 | update.effective_message.reply_text( 119 | "The result of the sed command was too long for \ 120 | telegram!" 121 | ) 122 | elif text: 123 | update.effective_message.reply_to_message.reply_text(text) 124 | 125 | 126 | 127 | __mod_name__ = "Sed/Regex" 128 | 129 | SED_HANDLER = DisableAbleMessageHandler( 130 | Filters.regex(r"s([{}]).*?\1.*".format("".join(DELIMITERS))), sed, friendly="sed" 131 | ) 132 | 133 | dispatcher.add_handler(SED_HANDLER) 134 | -------------------------------------------------------------------------------- /EvilBot/modules/shell.py: -------------------------------------------------------------------------------- 1 | import subprocess 2 | 3 | from EvilBot import LOGGER, dispatcher 4 | from EvilBot.modules.helper_funcs.chat_status import dev_plus 5 | from telegram import ParseMode, Update 6 | from telegram.ext import CallbackContext, CommandHandler 7 | from telegram.ext.dispatcher import run_async 8 | 9 | 10 | @dev_plus 11 | @run_async 12 | def shell(update: Update, context: CallbackContext): 13 | message = update.effective_message 14 | cmd = message.text.split(" ", 1) 15 | if len(cmd) == 1: 16 | message.reply_text("No command to execute was given.") 17 | return 18 | cmd = cmd[1] 19 | process = subprocess.Popen( 20 | cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True 21 | ) 22 | stdout, stderr = process.communicate() 23 | reply = "" 24 | stderr = stderr.decode() 25 | stdout = stdout.decode() 26 | if stdout: 27 | reply += f"*Stdout*\n`{stdout}`\n" 28 | LOGGER.info(f"Shell - {cmd} - {stdout}") 29 | if stderr: 30 | reply += f"*Stderr*\n`{stderr}`\n" 31 | LOGGER.error(f"Shell - {cmd} - {stderr}") 32 | if len(reply) > 3000: 33 | with open("shell_output.txt", "w") as file: 34 | file.write(reply) 35 | with open("shell_output.txt", "rb") as doc: 36 | context.bot.send_document( 37 | document=doc, 38 | filename=doc.name, 39 | reply_to_message_id=message.message_id, 40 | chat_id=message.chat_id, 41 | ) 42 | else: 43 | message.reply_text(reply, parse_mode=ParseMode.MARKDOWN) 44 | 45 | 46 | SHELL_HANDLER = CommandHandler(["sh"], shell) 47 | dispatcher.add_handler(SHELL_HANDLER) 48 | __mod_name__ = "Shell" 49 | __command_list__ = ["sh"] 50 | __handlers__ = [SHELL_HANDLER] 51 | -------------------------------------------------------------------------------- /EvilBot/modules/speed_test.py: -------------------------------------------------------------------------------- 1 | import speedtest 2 | from EvilBot import DEV_USERS, dispatcher 3 | from EvilBot.modules.disable import DisableAbleCommandHandler 4 | from EvilBot.modules.helper_funcs.chat_status import dev_plus 5 | from telegram import InlineKeyboardButton, InlineKeyboardMarkup, ParseMode, Update 6 | from telegram.ext import CallbackContext, CallbackQueryHandler, run_async 7 | 8 | 9 | def convert(speed): 10 | return round(int(speed) / 1048576, 2) 11 | 12 | 13 | @dev_plus 14 | @run_async 15 | def speedtestxyz(update: Update, context: CallbackContext): 16 | buttons = [ 17 | [ 18 | InlineKeyboardButton("Image", callback_data="speedtest_image"), 19 | InlineKeyboardButton("Text", callback_data="speedtest_text"), 20 | ] 21 | ] 22 | update.effective_message.reply_text( 23 | "Select SpeedTest Mode", reply_markup=InlineKeyboardMarkup(buttons) 24 | ) 25 | 26 | 27 | @run_async 28 | def speedtestxyz_callback(update: Update, context: CallbackContext): 29 | query = update.callback_query 30 | 31 | if query.from_user.id in DEV_USERS: 32 | msg = update.effective_message.edit_text("Running a speedtest....") 33 | speed = speedtest.Speedtest() 34 | speed.get_best_server() 35 | speed.download() 36 | speed.upload() 37 | replymsg = "SpeedTest Results:" 38 | 39 | if query.data == "speedtest_image": 40 | speedtest_image = speed.results.share() 41 | update.effective_message.reply_photo( 42 | photo=speedtest_image, caption=replymsg 43 | ) 44 | msg.delete() 45 | 46 | elif query.data == "speedtest_text": 47 | result = speed.results.dict() 48 | replymsg += f"\nDownload: `{convert(result['download'])}Mb/s`\nUpload: `{convert(result['upload'])}Mb/s`\nPing: `{result['ping']}`" 49 | update.effective_message.edit_text(replymsg, parse_mode=ParseMode.MARKDOWN) 50 | else: 51 | query.answer("You are required to join Heroes Association to use this command.") 52 | 53 | 54 | SPEED_TEST_HANDLER = DisableAbleCommandHandler("speedtest", speedtestxyz) 55 | SPEED_TEST_CALLBACKHANDLER = CallbackQueryHandler( 56 | speedtestxyz_callback, pattern="speedtest_.*" 57 | ) 58 | 59 | dispatcher.add_handler(SPEED_TEST_HANDLER) 60 | dispatcher.add_handler(SPEED_TEST_CALLBACKHANDLER) 61 | 62 | __mod_name__ = "SpeedTest" 63 | __command_list__ = ["speedtest"] 64 | __handlers__ = [SPEED_TEST_HANDLER, SPEED_TEST_CALLBACKHANDLER] 65 | -------------------------------------------------------------------------------- /EvilBot/modules/sql/__init__.py: -------------------------------------------------------------------------------- 1 | from EvilBot import DB_URI 2 | 3 | from sqlalchemy import create_engine 4 | 5 | from sqlalchemy.ext.declarative import declarative_base 6 | 7 | from sqlalchemy.orm import scoped_session, sessionmaker 8 | 9 | def start() -> scoped_session: 10 | 11 | engine = create_engine(DB_URI, client_encoding="utf8") 12 | 13 | BASE.metadata.bind = engine 14 | 15 | BASE.metadata.create_all(engine) 16 | 17 | return scoped_session(sessionmaker(bind=engine, autoflush=False)) 18 | 19 | BASE = declarative_base() 20 | 21 | SESSION = start() 22 | 23 | -------------------------------------------------------------------------------- /EvilBot/modules/sql/afk_sql.py: -------------------------------------------------------------------------------- 1 | import threading 2 | 3 | from EvilBot.modules.sql import BASE, SESSION 4 | from sqlalchemy import Boolean, Column, Integer, UnicodeText 5 | 6 | 7 | class AFK(BASE): 8 | __tablename__ = "afk_users" 9 | 10 | user_id = Column(Integer, primary_key=True) 11 | is_afk = Column(Boolean) 12 | reason = Column(UnicodeText) 13 | 14 | def __init__(self, user_id, reason="", is_afk=True): 15 | self.user_id = user_id 16 | self.reason = reason 17 | self.is_afk = is_afk 18 | 19 | def __repr__(self): 20 | return "afk_status for {}".format(self.user_id) 21 | 22 | 23 | AFK.__table__.create(checkfirst=True) 24 | INSERTION_LOCK = threading.RLock() 25 | 26 | AFK_USERS = {} 27 | 28 | 29 | def is_afk(user_id): 30 | return user_id in AFK_USERS 31 | 32 | 33 | def check_afk_status(user_id): 34 | try: 35 | return SESSION.query(AFK).get(user_id) 36 | finally: 37 | SESSION.close() 38 | 39 | 40 | def set_afk(user_id, reason=""): 41 | with INSERTION_LOCK: 42 | curr = SESSION.query(AFK).get(user_id) 43 | if not curr: 44 | curr = AFK(user_id, reason, True) 45 | else: 46 | curr.is_afk = True 47 | 48 | AFK_USERS[user_id] = reason 49 | 50 | SESSION.add(curr) 51 | SESSION.commit() 52 | 53 | 54 | def rm_afk(user_id): 55 | with INSERTION_LOCK: 56 | curr = SESSION.query(AFK).get(user_id) 57 | if curr: 58 | if user_id in AFK_USERS: # sanity check 59 | del AFK_USERS[user_id] 60 | 61 | SESSION.delete(curr) 62 | SESSION.commit() 63 | return True 64 | 65 | SESSION.close() 66 | return False 67 | 68 | 69 | def toggle_afk(user_id, reason=""): 70 | with INSERTION_LOCK: 71 | curr = SESSION.query(AFK).get(user_id) 72 | if not curr: 73 | curr = AFK(user_id, reason, True) 74 | elif curr.is_afk: 75 | curr.is_afk = False 76 | elif not curr.is_afk: 77 | curr.is_afk = True 78 | SESSION.add(curr) 79 | SESSION.commit() 80 | 81 | 82 | def __load_afk_users(): 83 | global AFK_USERS 84 | try: 85 | all_afk = SESSION.query(AFK).all() 86 | AFK_USERS = {user.user_id: user.reason for user in all_afk if user.is_afk} 87 | finally: 88 | SESSION.close() 89 | 90 | 91 | __load_afk_users() 92 | -------------------------------------------------------------------------------- /EvilBot/modules/sql/aihelp_sql.py: -------------------------------------------------------------------------------- 1 | import threading 2 | 3 | from EvilBot.modules.sql import BASE, SESSION 4 | from sqlalchemy import Column, String 5 | 6 | 7 | class aiChats(BASE): 8 | __tablename__ = "ai_chats" 9 | chat_id = Column(String(14), primary_key=True) 10 | ses_id = Column(String(70)) 11 | expires = Column(String(15)) 12 | 13 | def __init__(self, chat_id, ses_id, expires): 14 | self.chat_id = chat_id 15 | self.ses_id = ses_id 16 | self.expires = expires 17 | 18 | 19 | aiChats.__table__.create(checkfirst=True) 20 | 21 | INSERTION_LOCK = threading.RLock() 22 | 23 | 24 | def is_chat(chat_id): 25 | try: 26 | chat = SESSION.query(aiChats).get(str(chat_id)) 27 | if chat: 28 | return True 29 | return False 30 | finally: 31 | SESSION.close() 32 | 33 | 34 | def set_ses(chat_id, ses_id, expires): 35 | with INSERTION_LOCK: 36 | autochat = SESSION.query(aiChats).get(str(chat_id)) 37 | if not autochat: 38 | autochat = aiChats(str(chat_id), str(ses_id), str(expires)) 39 | else: 40 | autochat.ses_id = str(ses_id) 41 | autochat.expires = str(expires) 42 | 43 | SESSION.add(autochat) 44 | SESSION.commit() 45 | 46 | 47 | def get_ses(chat_id): 48 | autochat = SESSION.query(aiChats).get(str(chat_id)) 49 | sesh = "" 50 | exp = "" 51 | if autochat: 52 | sesh = str(autochat.ses_id) 53 | exp = str(autochat.expires) 54 | 55 | SESSION.close() 56 | return sesh, exp 57 | 58 | 59 | def rem_chat(chat_id): 60 | with INSERTION_LOCK: 61 | autochat = SESSION.query(aiChats).get(str(chat_id)) 62 | if autochat: 63 | SESSION.delete(autochat) 64 | 65 | SESSION.commit() 66 | 67 | 68 | def get_all_chats(): 69 | try: 70 | return SESSION.query(aiChats.chat_id).all() 71 | finally: 72 | SESSION.close() 73 | -------------------------------------------------------------------------------- /EvilBot/modules/sql/antiflood_sql.py: -------------------------------------------------------------------------------- 1 | import threading 2 | 3 | from sqlalchemy import String, Column, Integer, UnicodeText 4 | 5 | from EvilBot.modules.sql import SESSION, BASE 6 | 7 | DEF_COUNT = 1 8 | DEF_LIMIT = 0 9 | DEF_OBJ = (None, DEF_COUNT, DEF_LIMIT) 10 | 11 | 12 | class FloodControl(BASE): 13 | __tablename__ = "antiflood" 14 | chat_id = Column(String(14), primary_key=True) 15 | user_id = Column(Integer) 16 | count = Column(Integer, default=DEF_COUNT) 17 | limit = Column(Integer, default=DEF_LIMIT) 18 | 19 | def __init__(self, chat_id): 20 | self.chat_id = str(chat_id) # ensure string 21 | 22 | def __repr__(self): 23 | return "" % self.chat_id 24 | 25 | 26 | class FloodSettings(BASE): 27 | __tablename__ = "antiflood_settings" 28 | chat_id = Column(String(14), primary_key=True) 29 | flood_type = Column(Integer, default=1) 30 | value = Column(UnicodeText, default="0") 31 | 32 | def __init__(self, chat_id, flood_type=1, value="0"): 33 | self.chat_id = str(chat_id) 34 | self.flood_type = flood_type 35 | self.value = value 36 | 37 | def __repr__(self): 38 | return "<{} will executing {} for flood.>".format(self.chat_id, self.flood_type) 39 | 40 | 41 | FloodControl.__table__.create(checkfirst=True) 42 | FloodSettings.__table__.create(checkfirst=True) 43 | 44 | INSERTION_FLOOD_LOCK = threading.RLock() 45 | INSERTION_FLOOD_SETTINGS_LOCK = threading.RLock() 46 | 47 | CHAT_FLOOD = {} 48 | 49 | 50 | def set_flood(chat_id, amount): 51 | with INSERTION_FLOOD_LOCK: 52 | flood = SESSION.query(FloodControl).get(str(chat_id)) 53 | if not flood: 54 | flood = FloodControl(str(chat_id)) 55 | 56 | flood.user_id = None 57 | flood.limit = amount 58 | 59 | CHAT_FLOOD[str(chat_id)] = (None, DEF_COUNT, amount) 60 | 61 | SESSION.add(flood) 62 | SESSION.commit() 63 | 64 | 65 | def update_flood(chat_id: str, user_id) -> bool: 66 | if str(chat_id) in CHAT_FLOOD: 67 | curr_user_id, count, limit = CHAT_FLOOD.get(str(chat_id), DEF_OBJ) 68 | 69 | if limit == 0: # no antiflood 70 | return False 71 | 72 | if user_id != curr_user_id or user_id is None: # other user 73 | CHAT_FLOOD[str(chat_id)] = (user_id, DEF_COUNT, limit) 74 | return False 75 | 76 | count += 1 77 | if count > limit: # too many msgs, kick 78 | CHAT_FLOOD[str(chat_id)] = (None, DEF_COUNT, limit) 79 | return True 80 | 81 | # default -> update 82 | CHAT_FLOOD[str(chat_id)] = (user_id, count, limit) 83 | return False 84 | 85 | 86 | def get_flood_limit(chat_id): 87 | return CHAT_FLOOD.get(str(chat_id), DEF_OBJ)[2] 88 | 89 | 90 | def set_flood_strength(chat_id, flood_type, value): 91 | # for flood_type 92 | # 1 = ban 93 | # 2 = kick 94 | # 3 = mute 95 | # 4 = tban 96 | # 5 = tmute 97 | with INSERTION_FLOOD_SETTINGS_LOCK: 98 | curr_setting = SESSION.query(FloodSettings).get(str(chat_id)) 99 | if not curr_setting: 100 | curr_setting = FloodSettings( 101 | chat_id, flood_type=int(flood_type), value=value 102 | ) 103 | 104 | curr_setting.flood_type = int(flood_type) 105 | curr_setting.value = str(value) 106 | 107 | SESSION.add(curr_setting) 108 | SESSION.commit() 109 | 110 | 111 | def get_flood_setting(chat_id): 112 | try: 113 | setting = SESSION.query(FloodSettings).get(str(chat_id)) 114 | if setting: 115 | return setting.flood_type, setting.value 116 | else: 117 | return 1, "0" 118 | 119 | finally: 120 | SESSION.close() 121 | 122 | 123 | def migrate_chat(old_chat_id, new_chat_id): 124 | with INSERTION_FLOOD_LOCK: 125 | flood = SESSION.query(FloodControl).get(str(old_chat_id)) 126 | if flood: 127 | CHAT_FLOOD[str(new_chat_id)] = CHAT_FLOOD.get(str(old_chat_id), DEF_OBJ) 128 | flood.chat_id = str(new_chat_id) 129 | SESSION.commit() 130 | 131 | SESSION.close() 132 | 133 | 134 | def __load_flood_settings(): 135 | global CHAT_FLOOD 136 | try: 137 | all_chats = SESSION.query(FloodControl).all() 138 | CHAT_FLOOD = {chat.chat_id: (None, DEF_COUNT, chat.limit) for chat in all_chats} 139 | finally: 140 | SESSION.close() 141 | 142 | 143 | __load_flood_settings() 144 | -------------------------------------------------------------------------------- /EvilBot/modules/sql/approve_sql.py: -------------------------------------------------------------------------------- 1 | import threading 2 | 3 | from sqlalchemy import Column, String, UnicodeText, Integer, func, distinct 4 | 5 | from EvilBot.modules.sql import BASE, SESSION 6 | 7 | class Approvals(BASE): 8 | __tablename__ = "approval" 9 | chat_id = Column(String(14), primary_key=True) 10 | user_id = Column(Integer, primary_key=True) 11 | 12 | def __init__(self, chat_id, user_id): 13 | self.chat_id = str(chat_id) # ensure string 14 | self.user_id = user_id 15 | 16 | def __repr__(self): 17 | return "" % self.user_id 18 | 19 | 20 | Approvals.__table__.create(checkfirst=True) 21 | 22 | APPROVE_INSERTION_LOCK = threading.RLock() 23 | 24 | 25 | def approve(chat_id, user_id): 26 | with APPROVE_INSERTION_LOCK: 27 | approve_user = Approvals(str(chat_id), user_id) 28 | SESSION.add(approve_user) 29 | SESSION.commit() 30 | 31 | 32 | def is_approved(chat_id, user_id): 33 | try: 34 | return SESSION.query(Approvals).get((str(chat_id), user_id)) 35 | finally: 36 | SESSION.close() 37 | 38 | 39 | def disapprove(chat_id, user_id): 40 | with APPROVE_INSERTION_LOCK: 41 | disapprove_user = SESSION.query(Approvals).get((str(chat_id), user_id)) 42 | if disapprove_user: 43 | SESSION.delete(disapprove_user) 44 | SESSION.commit() 45 | return True 46 | else: 47 | SESSION.close() 48 | return False 49 | 50 | 51 | def list_approved(chat_id): 52 | try: 53 | return (SESSION.query(Approvals).filter( 54 | Approvals.chat_id == str(chat_id)).order_by( 55 | Approvals.user_id.asc()).all()) 56 | finally: 57 | SESSION.close() 58 | -------------------------------------------------------------------------------- /EvilBot/modules/sql/blacklistusers_sql.py: -------------------------------------------------------------------------------- 1 | import threading 2 | 3 | from EvilBot.modules.sql import BASE, SESSION 4 | from sqlalchemy import Column, String, UnicodeText 5 | 6 | 7 | class BlacklistUsers(BASE): 8 | __tablename__ = "blacklistusers" 9 | user_id = Column(String(14), primary_key=True) 10 | reason = Column(UnicodeText) 11 | 12 | def __init__(self, user_id, reason=None): 13 | self.user_id = user_id 14 | self.reason = reason 15 | 16 | 17 | BlacklistUsers.__table__.create(checkfirst=True) 18 | 19 | BLACKLIST_LOCK = threading.RLock() 20 | BLACKLIST_USERS = set() 21 | 22 | 23 | def blacklist_user(user_id, reason=None): 24 | with BLACKLIST_LOCK: 25 | user = SESSION.query(BlacklistUsers).get(str(user_id)) 26 | if not user: 27 | user = BlacklistUsers(str(user_id), reason) 28 | else: 29 | user.reason = reason 30 | 31 | SESSION.add(user) 32 | SESSION.commit() 33 | __load_blacklist_userid_list() 34 | 35 | 36 | def unblacklist_user(user_id): 37 | with BLACKLIST_LOCK: 38 | user = SESSION.query(BlacklistUsers).get(str(user_id)) 39 | if user: 40 | SESSION.delete(user) 41 | 42 | SESSION.commit() 43 | __load_blacklist_userid_list() 44 | 45 | 46 | def get_reason(user_id): 47 | user = SESSION.query(BlacklistUsers).get(str(user_id)) 48 | rep = "" 49 | if user: 50 | rep = user.reason 51 | 52 | SESSION.close() 53 | return rep 54 | 55 | 56 | def is_user_blacklisted(user_id): 57 | return user_id in BLACKLIST_USERS 58 | 59 | 60 | def __load_blacklist_userid_list(): 61 | global BLACKLIST_USERS 62 | try: 63 | BLACKLIST_USERS = {int(x.user_id) for x in SESSION.query(BlacklistUsers).all()} 64 | finally: 65 | SESSION.close() 66 | 67 | 68 | __load_blacklist_userid_list() 69 | -------------------------------------------------------------------------------- /EvilBot/modules/sql/chatbot_sql.py: -------------------------------------------------------------------------------- 1 | import threading 2 | 3 | from EvilBot.modules.sql import BASE, SESSION 4 | from sqlalchemy import Column, String 5 | 6 | 7 | class ChatbotChats(BASE): 8 | __tablename__ = "chatbot_chats" 9 | chat_id = Column(String(14), primary_key=True) 10 | ses_id = Column(String(70)) 11 | expires = Column(String(15)) 12 | 13 | def __init__(self, chat_id, ses_id, expires): 14 | self.chat_id = chat_id 15 | self.ses_id = ses_id 16 | self.expires = expires 17 | 18 | 19 | ChatbotChats.__table__.create(checkfirst=True) 20 | 21 | INSERTION_LOCK = threading.RLock() 22 | 23 | 24 | def is_chat(chat_id): 25 | try: 26 | chat = SESSION.query(ChatbotChats).get(str(chat_id)) 27 | if chat: 28 | return True 29 | else: 30 | return False 31 | finally: 32 | SESSION.close() 33 | 34 | 35 | def set_ses(chat_id, ses_id, expires): 36 | with INSERTION_LOCK: 37 | autochat = SESSION.query(ChatbotChats).get(str(chat_id)) 38 | if not autochat: 39 | autochat = ChatbotChats(str(chat_id), str(ses_id), str(expires)) 40 | else: 41 | autochat.ses_id = str(ses_id) 42 | autochat.expires = str(expires) 43 | 44 | SESSION.add(autochat) 45 | SESSION.commit() 46 | 47 | 48 | def get_ses(chat_id): 49 | autochat = SESSION.query(ChatbotChats).get(str(chat_id)) 50 | sesh = "" 51 | exp = "" 52 | if autochat: 53 | sesh = str(autochat.ses_id) 54 | exp = str(autochat.expires) 55 | 56 | SESSION.close() 57 | return sesh, exp 58 | 59 | 60 | def rem_chat(chat_id): 61 | with INSERTION_LOCK: 62 | autochat = SESSION.query(ChatbotChats).get(str(chat_id)) 63 | if autochat: 64 | SESSION.delete(autochat) 65 | 66 | SESSION.commit() 67 | 68 | 69 | def get_all_chats(): 70 | try: 71 | return SESSION.query(ChatbotChats.chat_id).all() 72 | finally: 73 | SESSION.close() 74 | -------------------------------------------------------------------------------- /EvilBot/modules/sql/disable_sql.py: -------------------------------------------------------------------------------- 1 | import threading 2 | 3 | from EvilBot.modules.sql import BASE, SESSION 4 | from sqlalchemy import Column, String, UnicodeText, distinct, func 5 | 6 | 7 | class Disable(BASE): 8 | __tablename__ = "disabled_commands" 9 | chat_id = Column(String(14), primary_key=True) 10 | command = Column(UnicodeText, primary_key=True) 11 | 12 | def __init__(self, chat_id, command): 13 | self.chat_id = chat_id 14 | self.command = command 15 | 16 | def __repr__(self): 17 | return "Disabled cmd {} in {}".format(self.command, self.chat_id) 18 | 19 | 20 | Disable.__table__.create(checkfirst=True) 21 | DISABLE_INSERTION_LOCK = threading.RLock() 22 | 23 | DISABLED = {} 24 | 25 | 26 | def disable_command(chat_id, disable): 27 | with DISABLE_INSERTION_LOCK: 28 | disabled = SESSION.query(Disable).get((str(chat_id), disable)) 29 | 30 | if not disabled: 31 | DISABLED.setdefault(str(chat_id), set()).add(disable) 32 | 33 | disabled = Disable(str(chat_id), disable) 34 | SESSION.add(disabled) 35 | SESSION.commit() 36 | return True 37 | 38 | SESSION.close() 39 | return False 40 | 41 | 42 | def enable_command(chat_id, enable): 43 | with DISABLE_INSERTION_LOCK: 44 | disabled = SESSION.query(Disable).get((str(chat_id), enable)) 45 | 46 | if disabled: 47 | if enable in DISABLED.get(str(chat_id)): # sanity check 48 | DISABLED.setdefault(str(chat_id), set()).remove(enable) 49 | 50 | SESSION.delete(disabled) 51 | SESSION.commit() 52 | return True 53 | 54 | SESSION.close() 55 | return False 56 | 57 | 58 | def is_command_disabled(chat_id, cmd): 59 | return str(cmd).lower() in DISABLED.get(str(chat_id), set()) 60 | 61 | 62 | def get_all_disabled(chat_id): 63 | return DISABLED.get(str(chat_id), set()) 64 | 65 | 66 | def num_chats(): 67 | try: 68 | return SESSION.query(func.count(distinct(Disable.chat_id))).scalar() 69 | finally: 70 | SESSION.close() 71 | 72 | 73 | def num_disabled(): 74 | try: 75 | return SESSION.query(Disable).count() 76 | finally: 77 | SESSION.close() 78 | 79 | 80 | def migrate_chat(old_chat_id, new_chat_id): 81 | with DISABLE_INSERTION_LOCK: 82 | chats = SESSION.query(Disable).filter(Disable.chat_id == str(old_chat_id)).all() 83 | for chat in chats: 84 | chat.chat_id = str(new_chat_id) 85 | SESSION.add(chat) 86 | 87 | if str(old_chat_id) in DISABLED: 88 | DISABLED[str(new_chat_id)] = DISABLED.get(str(old_chat_id), set()) 89 | 90 | SESSION.commit() 91 | 92 | 93 | def __load_disabled_commands(): 94 | global DISABLED 95 | try: 96 | all_chats = SESSION.query(Disable).all() 97 | for chat in all_chats: 98 | DISABLED.setdefault(chat.chat_id, set()).add(chat.command) 99 | 100 | finally: 101 | SESSION.close() 102 | 103 | 104 | __load_disabled_commands() 105 | -------------------------------------------------------------------------------- /EvilBot/modules/sql/global_bans_sql.py: -------------------------------------------------------------------------------- 1 | import threading 2 | 3 | from EvilBot.modules.sql import BASE, SESSION 4 | from sqlalchemy import Boolean, Column, Integer, String, UnicodeText 5 | 6 | 7 | class GloballyBannedUsers(BASE): 8 | __tablename__ = "gbans" 9 | user_id = Column(Integer, primary_key=True) 10 | name = Column(UnicodeText, nullable=False) 11 | reason = Column(UnicodeText) 12 | 13 | def __init__(self, user_id, name, reason=None): 14 | self.user_id = user_id 15 | self.name = name 16 | self.reason = reason 17 | 18 | def __repr__(self): 19 | return "".format(self.name, self.user_id) 20 | 21 | def to_dict(self): 22 | return {"user_id": self.user_id, "name": self.name, "reason": self.reason} 23 | 24 | 25 | class GbanSettings(BASE): 26 | __tablename__ = "gban_settings" 27 | chat_id = Column(String(14), primary_key=True) 28 | setting = Column(Boolean, default=True, nullable=False) 29 | 30 | def __init__(self, chat_id, enabled): 31 | self.chat_id = str(chat_id) 32 | self.setting = enabled 33 | 34 | def __repr__(self): 35 | return "".format(self.chat_id, self.setting) 36 | 37 | 38 | GloballyBannedUsers.__table__.create(checkfirst=True) 39 | GbanSettings.__table__.create(checkfirst=True) 40 | 41 | GBANNED_USERS_LOCK = threading.RLock() 42 | GBAN_SETTING_LOCK = threading.RLock() 43 | GBANNED_LIST = set() 44 | GBANSTAT_LIST = set() 45 | 46 | 47 | def gban_user(user_id, name, reason=None): 48 | with GBANNED_USERS_LOCK: 49 | user = SESSION.query(GloballyBannedUsers).get(user_id) 50 | if not user: 51 | user = GloballyBannedUsers(user_id, name, reason) 52 | else: 53 | user.name = name 54 | user.reason = reason 55 | 56 | SESSION.merge(user) 57 | SESSION.commit() 58 | __load_gbanned_userid_list() 59 | 60 | 61 | def update_gban_reason(user_id, name, reason=None): 62 | with GBANNED_USERS_LOCK: 63 | user = SESSION.query(GloballyBannedUsers).get(user_id) 64 | if not user: 65 | return None 66 | old_reason = user.reason 67 | user.name = name 68 | user.reason = reason 69 | 70 | SESSION.merge(user) 71 | SESSION.commit() 72 | return old_reason 73 | 74 | 75 | def ungban_user(user_id): 76 | with GBANNED_USERS_LOCK: 77 | user = SESSION.query(GloballyBannedUsers).get(user_id) 78 | if user: 79 | SESSION.delete(user) 80 | 81 | SESSION.commit() 82 | __load_gbanned_userid_list() 83 | 84 | 85 | def is_user_gbanned(user_id): 86 | return user_id in GBANNED_LIST 87 | 88 | 89 | def get_gbanned_user(user_id): 90 | try: 91 | return SESSION.query(GloballyBannedUsers).get(user_id) 92 | finally: 93 | SESSION.close() 94 | 95 | 96 | def get_gban_list(): 97 | try: 98 | return [x.to_dict() for x in SESSION.query(GloballyBannedUsers).all()] 99 | finally: 100 | SESSION.close() 101 | 102 | 103 | def enable_gbans(chat_id): 104 | with GBAN_SETTING_LOCK: 105 | chat = SESSION.query(GbanSettings).get(str(chat_id)) 106 | if not chat: 107 | chat = GbanSettings(chat_id, True) 108 | 109 | chat.setting = True 110 | SESSION.add(chat) 111 | SESSION.commit() 112 | if str(chat_id) in GBANSTAT_LIST: 113 | GBANSTAT_LIST.remove(str(chat_id)) 114 | 115 | 116 | def disable_gbans(chat_id): 117 | with GBAN_SETTING_LOCK: 118 | chat = SESSION.query(GbanSettings).get(str(chat_id)) 119 | if not chat: 120 | chat = GbanSettings(chat_id, False) 121 | 122 | chat.setting = False 123 | SESSION.add(chat) 124 | SESSION.commit() 125 | GBANSTAT_LIST.add(str(chat_id)) 126 | 127 | 128 | def does_chat_gban(chat_id): 129 | return str(chat_id) not in GBANSTAT_LIST 130 | 131 | 132 | def num_gbanned_users(): 133 | return len(GBANNED_LIST) 134 | 135 | 136 | def __load_gbanned_userid_list(): 137 | global GBANNED_LIST 138 | try: 139 | GBANNED_LIST = {x.user_id for x in SESSION.query(GloballyBannedUsers).all()} 140 | finally: 141 | SESSION.close() 142 | 143 | 144 | def __load_gban_stat_list(): 145 | global GBANSTAT_LIST 146 | try: 147 | GBANSTAT_LIST = { 148 | x.chat_id for x in SESSION.query(GbanSettings).all() if not x.setting 149 | } 150 | finally: 151 | SESSION.close() 152 | 153 | 154 | def migrate_chat(old_chat_id, new_chat_id): 155 | with GBAN_SETTING_LOCK: 156 | chat = SESSION.query(GbanSettings).get(str(old_chat_id)) 157 | if chat: 158 | chat.chat_id = new_chat_id 159 | SESSION.add(chat) 160 | 161 | SESSION.commit() 162 | 163 | 164 | # Create in memory userid to avoid disk access 165 | __load_gbanned_userid_list() 166 | __load_gban_stat_list() 167 | -------------------------------------------------------------------------------- /EvilBot/modules/sql/log_channel_sql.py: -------------------------------------------------------------------------------- 1 | import threading 2 | 3 | from EvilBot.modules.sql import BASE, SESSION 4 | from sqlalchemy import Column, String, distinct, func 5 | 6 | 7 | class GroupLogs(BASE): 8 | __tablename__ = "log_channels" 9 | chat_id = Column(String(14), primary_key=True) 10 | log_channel = Column(String(14), nullable=False) 11 | 12 | def __init__(self, chat_id, log_channel): 13 | self.chat_id = str(chat_id) 14 | self.log_channel = str(log_channel) 15 | 16 | 17 | GroupLogs.__table__.create(checkfirst=True) 18 | 19 | LOGS_INSERTION_LOCK = threading.RLock() 20 | 21 | CHANNELS = {} 22 | 23 | 24 | def set_chat_log_channel(chat_id, log_channel): 25 | with LOGS_INSERTION_LOCK: 26 | res = SESSION.query(GroupLogs).get(str(chat_id)) 27 | if res: 28 | res.log_channel = log_channel 29 | else: 30 | res = GroupLogs(chat_id, log_channel) 31 | SESSION.add(res) 32 | 33 | CHANNELS[str(chat_id)] = log_channel 34 | SESSION.commit() 35 | 36 | 37 | def get_chat_log_channel(chat_id): 38 | return CHANNELS.get(str(chat_id)) 39 | 40 | 41 | def stop_chat_logging(chat_id): 42 | with LOGS_INSERTION_LOCK: 43 | res = SESSION.query(GroupLogs).get(str(chat_id)) 44 | if res: 45 | if str(chat_id) in CHANNELS: 46 | del CHANNELS[str(chat_id)] 47 | 48 | log_channel = res.log_channel 49 | SESSION.delete(res) 50 | SESSION.commit() 51 | return log_channel 52 | 53 | 54 | def num_logchannels(): 55 | try: 56 | return SESSION.query(func.count(distinct(GroupLogs.chat_id))).scalar() 57 | finally: 58 | SESSION.close() 59 | 60 | 61 | def migrate_chat(old_chat_id, new_chat_id): 62 | with LOGS_INSERTION_LOCK: 63 | chat = SESSION.query(GroupLogs).get(str(old_chat_id)) 64 | if chat: 65 | chat.chat_id = str(new_chat_id) 66 | SESSION.add(chat) 67 | if str(old_chat_id) in CHANNELS: 68 | CHANNELS[str(new_chat_id)] = CHANNELS.get(str(old_chat_id)) 69 | 70 | SESSION.commit() 71 | 72 | 73 | def __load_log_channels(): 74 | global CHANNELS 75 | try: 76 | all_chats = SESSION.query(GroupLogs).all() 77 | CHANNELS = {chat.chat_id: chat.log_channel for chat in all_chats} 78 | finally: 79 | SESSION.close() 80 | 81 | 82 | __load_log_channels() 83 | -------------------------------------------------------------------------------- /EvilBot/modules/sql/reporting_sql.py: -------------------------------------------------------------------------------- 1 | import threading 2 | from typing import Union 3 | 4 | from EvilBot.modules.sql import BASE, SESSION 5 | from sqlalchemy import Boolean, Column, Integer, String 6 | 7 | 8 | class ReportingUserSettings(BASE): 9 | __tablename__ = "user_report_settings" 10 | user_id = Column(Integer, primary_key=True) 11 | should_report = Column(Boolean, default=True) 12 | 13 | def __init__(self, user_id): 14 | self.user_id = user_id 15 | 16 | def __repr__(self): 17 | return "".format(self.user_id) 18 | 19 | 20 | class ReportingChatSettings(BASE): 21 | __tablename__ = "chat_report_settings" 22 | chat_id = Column(String(14), primary_key=True) 23 | should_report = Column(Boolean, default=True) 24 | 25 | def __init__(self, chat_id): 26 | self.chat_id = str(chat_id) 27 | 28 | def __repr__(self): 29 | return "".format(self.chat_id) 30 | 31 | 32 | ReportingUserSettings.__table__.create(checkfirst=True) 33 | ReportingChatSettings.__table__.create(checkfirst=True) 34 | 35 | CHAT_LOCK = threading.RLock() 36 | USER_LOCK = threading.RLock() 37 | 38 | 39 | def chat_should_report(chat_id: Union[str, int]) -> bool: 40 | try: 41 | chat_setting = SESSION.query(ReportingChatSettings).get(str(chat_id)) 42 | if chat_setting: 43 | return chat_setting.should_report 44 | return False 45 | finally: 46 | SESSION.close() 47 | 48 | 49 | def user_should_report(user_id: int) -> bool: 50 | try: 51 | user_setting = SESSION.query(ReportingUserSettings).get(user_id) 52 | if user_setting: 53 | return user_setting.should_report 54 | return True 55 | finally: 56 | SESSION.close() 57 | 58 | 59 | def set_chat_setting(chat_id: Union[int, str], setting: bool): 60 | with CHAT_LOCK: 61 | chat_setting = SESSION.query(ReportingChatSettings).get(str(chat_id)) 62 | if not chat_setting: 63 | chat_setting = ReportingChatSettings(chat_id) 64 | 65 | chat_setting.should_report = setting 66 | SESSION.add(chat_setting) 67 | SESSION.commit() 68 | 69 | 70 | def set_user_setting(user_id: int, setting: bool): 71 | with USER_LOCK: 72 | user_setting = SESSION.query(ReportingUserSettings).get(user_id) 73 | if not user_setting: 74 | user_setting = ReportingUserSettings(user_id) 75 | 76 | user_setting.should_report = setting 77 | SESSION.add(user_setting) 78 | SESSION.commit() 79 | 80 | 81 | def migrate_chat(old_chat_id, new_chat_id): 82 | with CHAT_LOCK: 83 | chat_notes = ( 84 | SESSION.query(ReportingChatSettings) 85 | .filter(ReportingChatSettings.chat_id == str(old_chat_id)) 86 | .all() 87 | ) 88 | for note in chat_notes: 89 | note.chat_id = str(new_chat_id) 90 | SESSION.commit() 91 | -------------------------------------------------------------------------------- /EvilBot/modules/sql/rss_sql.py: -------------------------------------------------------------------------------- 1 | import threading 2 | 3 | from EvilBot.modules.sql import BASE, SESSION 4 | from sqlalchemy import Column, Integer, UnicodeText 5 | 6 | 7 | class RSS(BASE): 8 | __tablename__ = "rss_feed" 9 | id = Column(Integer, primary_key=True) 10 | chat_id = Column(UnicodeText, nullable=False) 11 | feed_link = Column(UnicodeText) 12 | old_entry_link = Column(UnicodeText) 13 | 14 | def __init__(self, chat_id, feed_link, old_entry_link): 15 | self.chat_id = chat_id 16 | self.feed_link = feed_link 17 | self.old_entry_link = old_entry_link 18 | 19 | def __repr__(self): 20 | return "".format( 21 | self.chat_id, self.feed_link, self.old_entry_link 22 | ) 23 | 24 | 25 | RSS.__table__.create(checkfirst=True) 26 | INSERTION_LOCK = threading.RLock() 27 | 28 | 29 | def check_url_availability(tg_chat_id, tg_feed_link): 30 | try: 31 | return ( 32 | SESSION.query(RSS) 33 | .filter(RSS.feed_link == tg_feed_link, RSS.chat_id == tg_chat_id) 34 | .all() 35 | ) 36 | finally: 37 | SESSION.close() 38 | 39 | 40 | def add_url(tg_chat_id, tg_feed_link, tg_old_entry_link): 41 | with INSERTION_LOCK: 42 | action = RSS(tg_chat_id, tg_feed_link, tg_old_entry_link) 43 | 44 | SESSION.add(action) 45 | SESSION.commit() 46 | 47 | 48 | def remove_url(tg_chat_id, tg_feed_link): 49 | with INSERTION_LOCK: 50 | # this loops to delete any possible duplicates for the same TG User ID, TG Chat ID and link 51 | for row in check_url_availability(tg_chat_id, tg_feed_link): 52 | # add the action to the DB query 53 | SESSION.delete(row) 54 | 55 | SESSION.commit() 56 | 57 | 58 | def get_urls(tg_chat_id): 59 | try: 60 | return SESSION.query(RSS).filter(RSS.chat_id == tg_chat_id).all() 61 | finally: 62 | SESSION.close() 63 | 64 | 65 | def get_all(): 66 | try: 67 | return SESSION.query(RSS).all() 68 | finally: 69 | SESSION.close() 70 | 71 | 72 | def update_url(row_id, new_entry_links): 73 | with INSERTION_LOCK: 74 | row = SESSION.query(RSS).get(row_id) 75 | 76 | # set the new old_entry_link with the latest update from the RSS Feed 77 | row.old_entry_link = new_entry_links[0] 78 | 79 | # commit the changes to the DB 80 | SESSION.commit() 81 | -------------------------------------------------------------------------------- /EvilBot/modules/sql/rules_sql.py: -------------------------------------------------------------------------------- 1 | import threading 2 | 3 | from EvilBot.modules.sql import BASE, SESSION 4 | from sqlalchemy import Column, String, UnicodeText, distinct, func 5 | 6 | 7 | class Rules(BASE): 8 | __tablename__ = "rules" 9 | chat_id = Column(String(14), primary_key=True) 10 | rules = Column(UnicodeText, default="") 11 | 12 | def __init__(self, chat_id): 13 | self.chat_id = chat_id 14 | 15 | def __repr__(self): 16 | return "".format(self.chat_id, self.rules) 17 | 18 | 19 | Rules.__table__.create(checkfirst=True) 20 | 21 | INSERTION_LOCK = threading.RLock() 22 | 23 | 24 | def set_rules(chat_id, rules_text): 25 | with INSERTION_LOCK: 26 | rules = SESSION.query(Rules).get(str(chat_id)) 27 | if not rules: 28 | rules = Rules(str(chat_id)) 29 | rules.rules = rules_text 30 | 31 | SESSION.add(rules) 32 | SESSION.commit() 33 | 34 | 35 | def get_rules(chat_id): 36 | rules = SESSION.query(Rules).get(str(chat_id)) 37 | ret = "" 38 | if rules: 39 | ret = rules.rules 40 | 41 | SESSION.close() 42 | return ret 43 | 44 | 45 | def num_chats(): 46 | try: 47 | return SESSION.query(func.count(distinct(Rules.chat_id))).scalar() 48 | finally: 49 | SESSION.close() 50 | 51 | 52 | def migrate_chat(old_chat_id, new_chat_id): 53 | with INSERTION_LOCK: 54 | chat = SESSION.query(Rules).get(str(old_chat_id)) 55 | if chat: 56 | chat.chat_id = str(new_chat_id) 57 | SESSION.commit() 58 | -------------------------------------------------------------------------------- /EvilBot/modules/sql/userinfo_sql.py: -------------------------------------------------------------------------------- 1 | import threading 2 | 3 | from EvilBot.modules.sql import BASE, SESSION 4 | from sqlalchemy import Column, Integer, UnicodeText 5 | 6 | 7 | class UserInfo(BASE): 8 | __tablename__ = "userinfo" 9 | user_id = Column(Integer, primary_key=True) 10 | info = Column(UnicodeText) 11 | 12 | def __init__(self, user_id, info): 13 | self.user_id = user_id 14 | self.info = info 15 | 16 | def __repr__(self): 17 | return "" % self.user_id 18 | 19 | 20 | class UserBio(BASE): 21 | __tablename__ = "userbio" 22 | user_id = Column(Integer, primary_key=True) 23 | bio = Column(UnicodeText) 24 | 25 | def __init__(self, user_id, bio): 26 | self.user_id = user_id 27 | self.bio = bio 28 | 29 | def __repr__(self): 30 | return "" % self.user_id 31 | 32 | 33 | UserInfo.__table__.create(checkfirst=True) 34 | UserBio.__table__.create(checkfirst=True) 35 | 36 | INSERTION_LOCK = threading.RLock() 37 | 38 | 39 | def get_user_me_info(user_id): 40 | userinfo = SESSION.query(UserInfo).get(user_id) 41 | SESSION.close() 42 | if userinfo: 43 | return userinfo.info 44 | return None 45 | 46 | 47 | def set_user_me_info(user_id, info): 48 | with INSERTION_LOCK: 49 | userinfo = SESSION.query(UserInfo).get(user_id) 50 | if userinfo: 51 | userinfo.info = info 52 | else: 53 | userinfo = UserInfo(user_id, info) 54 | SESSION.add(userinfo) 55 | SESSION.commit() 56 | 57 | 58 | def get_user_bio(user_id): 59 | userbio = SESSION.query(UserBio).get(user_id) 60 | SESSION.close() 61 | if userbio: 62 | return userbio.bio 63 | return None 64 | 65 | 66 | def set_user_bio(user_id, bio): 67 | with INSERTION_LOCK: 68 | userbio = SESSION.query(UserBio).get(user_id) 69 | if userbio: 70 | userbio.bio = bio 71 | else: 72 | userbio = UserBio(user_id, bio) 73 | 74 | SESSION.add(userbio) 75 | SESSION.commit() 76 | -------------------------------------------------------------------------------- /EvilBot/modules/sql_extended/forceSubscribe_sql.py: -------------------------------------------------------------------------------- 1 | from sqlalchemy import Column, String, Numeric, Boolean 2 | from EvilBot.modules.sql import BASE, SESSION 3 | 4 | 5 | class forceSubscribe(BASE): 6 | __tablename__ = "forceSubscribe" 7 | chat_id = Column(Numeric, primary_key=True) 8 | channel = Column(String) 9 | 10 | def __init__(self, chat_id, channel): 11 | self.chat_id = chat_id 12 | self.channel = channel 13 | 14 | 15 | forceSubscribe.__table__.create(checkfirst=True) 16 | 17 | 18 | def fs_settings(chat_id): 19 | try: 20 | return SESSION.query(forceSubscribe).filter(forceSubscribe.chat_id == chat_id).one() 21 | except: 22 | return None 23 | finally: 24 | SESSION.close() 25 | 26 | 27 | def add_channel(chat_id, channel): 28 | adder = SESSION.query(forceSubscribe).get(chat_id) 29 | if adder: 30 | adder.channel = channel 31 | else: 32 | adder = forceSubscribe( 33 | chat_id, 34 | channel 35 | ) 36 | SESSION.add(adder) 37 | SESSION.commit() 38 | 39 | def disapprove(chat_id): 40 | rem = SESSION.query(forceSubscribe).get(chat_id) 41 | if rem: 42 | SESSION.delete(rem) 43 | SESSION.commit() 44 | -------------------------------------------------------------------------------- /EvilBot/modules/sql_extended/night_mode_sql.py: -------------------------------------------------------------------------------- 1 | from sqlalchemy import Boolean, Column, Integer, String, UnicodeText 2 | from EvilBot.modules.sql import BASE, SESSION 3 | 4 | 5 | class Nightmode(BASE): 6 | __tablename__ = "nightmode" 7 | chat_id = Column(String(14), primary_key=True) 8 | 9 | def __init__(self, chat_id): 10 | self.chat_id = chat_id 11 | 12 | 13 | Nightmode.__table__.create(checkfirst=True) 14 | 15 | 16 | def add_nightmode(chat_id: str): 17 | nightmoddy = Nightmode(str(chat_id)) 18 | SESSION.add(nightmoddy) 19 | SESSION.commit() 20 | 21 | 22 | def rmnightmode(chat_id: str): 23 | rmnightmoddy = SESSION.query(Nightmode).get(str(chat_id)) 24 | if rmnightmoddy: 25 | SESSION.delete(rmnightmoddy) 26 | SESSION.commit() 27 | 28 | 29 | def get_all_chat_id(): 30 | stark = SESSION.query(Nightmode).all() 31 | SESSION.close() 32 | return stark 33 | 34 | 35 | def is_nightmode_indb(chat_id: str): 36 | try: 37 | s__ = SESSION.query(Nightmode).get(str(chat_id)) 38 | if s__: 39 | return str(s__.chat_id) 40 | finally: 41 | SESSION.close() 42 | -------------------------------------------------------------------------------- /EvilBot/modules/sql_extended/nsfw_watch_sql.py: -------------------------------------------------------------------------------- 1 | # Copyright (C) Midhun KM 2020-2021 2 | # This program is free software: you can redistribute it and/or modify 3 | # it under the terms of the GNU Affero General Public License as published by 4 | # the Free Software Foundation, either version 3 of the License, or 5 | # 6 | # This program is distributed in the hope that it will be useful, 7 | # but WITHOUT ANY WARRANTY; without even the implied warranty of 8 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 9 | # GNU Affero General Public License for more details. 10 | # 11 | # You should have received a copy of the GNU Affero General Public License 12 | # along with this program. If not, see . 13 | 14 | from sqlalchemy import Column, String 15 | 16 | from EvilBot.modules.sql import BASE, SESSION 17 | 18 | 19 | class Nsfwatch(BASE): 20 | __tablename__ = "nsfwatch" 21 | chat_id = Column(String(14), primary_key=True) 22 | 23 | def __init__(self, chat_id): 24 | self.chat_id = chat_id 25 | 26 | 27 | Nsfwatch.__table__.create(checkfirst=True) 28 | 29 | 30 | def add_nsfwatch(chat_id: str): 31 | nsfws = Nsfwatch(str(chat_id)) 32 | SESSION.add(nsfws) 33 | SESSION.commit() 34 | 35 | 36 | def rmnsfwatch(chat_id: str): 37 | nsfwm = SESSION.query(Nsfwatch).get(str(chat_id)) 38 | if nsfwm: 39 | SESSION.delete(nsfwm) 40 | SESSION.commit() 41 | 42 | 43 | def get_all_nsfw_enabled_chat(): 44 | stark = SESSION.query(Nsfwatch).all() 45 | SESSION.close() 46 | return stark 47 | 48 | 49 | def is_nsfwatch_indb(chat_id: str): 50 | try: 51 | s__ = SESSION.query(Nsfwatch).get(str(chat_id)) 52 | if s__: 53 | return str(s__.chat_id) 54 | finally: 55 | SESSION.close() 56 | -------------------------------------------------------------------------------- /EvilBot/modules/tagall.py: -------------------------------------------------------------------------------- 1 | # Copyright (C) 2020-2021 by DevsExpo@Github, < https://github.com/DevsExpo >. 2 | # 3 | # This file is part of < https://github.com/DevsExpo/FridayUserBot > project, 4 | # and is released under the "GNU v3.0 License Agreement". 5 | # Please see < https://github.com/DevsExpo/blob/master/LICENSE > 6 | # 7 | # All rights reserved. 8 | 9 | 10 | from pyrogram import filters 11 | 12 | from EvilBot.pyrogramee.pluginshelper import admins_only, get_text 13 | from EvilBot import pbot 14 | 15 | 16 | @pbot.on_message(filters.command("tagall") & ~filters.edited & ~filters.bot) 17 | @admins_only 18 | async def tagall(client, message): 19 | await message.reply("`Processing.....`") 20 | sh = get_text(message) 21 | if not sh: 22 | sh = "Hi!" 23 | mentions = "" 24 | async for member in client.iter_chat_members(message.chat.id): 25 | mentions += member.user.mention + " " 26 | n = 4096 27 | kk = [mentions[i : i + n] for i in range(0, len(mentions), n)] 28 | for i in kk: 29 | j = f"{sh} \n{i}" 30 | await client.send_message(message.chat.id, j, parse_mode="html") 31 | 32 | 33 | __mod_name__ = "Tagall" 34 | __help__ = """ 35 | - /tagall : Tag everyone in a chat 36 | """ 37 | -------------------------------------------------------------------------------- /EvilBot/modules/truth_and_dare.py: -------------------------------------------------------------------------------- 1 | import html 2 | import random 3 | import EvilBot.modules.truth_and_dare_string as truth_and_dare_string 4 | from EvilBot import dispatcher 5 | from telegram import ParseMode, Update, Bot 6 | from EvilBot.modules.disable import DisableAbleCommandHandler 7 | from telegram.ext import CallbackContext, run_async 8 | 9 | @run_async 10 | def truth(update: Update, context: CallbackContext): 11 | args = context.args 12 | update.effective_message.reply_text(random.choice(truth_and_dare_string.TRUTH)) 13 | 14 | @run_async 15 | def dare(update: Update, context: CallbackContext): 16 | args = context.args 17 | update.effective_message.reply_text(random.choice(truth_and_dare_string.DARE)) 18 | 19 | 20 | TRUTH_HANDLER = DisableAbleCommandHandler("truth", truth) 21 | DARE_HANDLER = DisableAbleCommandHandler("dare", dare) 22 | 23 | 24 | dispatcher.add_handler(TRUTH_HANDLER) 25 | dispatcher.add_handler(DARE_HANDLER) 26 | 27 | -------------------------------------------------------------------------------- /EvilBot/modules/truth_and_dare_string.py: -------------------------------------------------------------------------------- 1 | TRUTH = ( 2 | "Have you ghosted someone?" 3 | "Have you ever walked in on your parents doing 'it'?", 4 | "Who was the last person you liked the most? Why?", 5 | "Have you ever been suspended from school?", 6 | "If you had to choose between going naked or having your thoughts appear in thought bubbles above your head for everyone to read, which would you choose?", 7 | "What’s the one thing you’re afraid to lose?", 8 | "Do you like someone as of the moment?", 9 | "One thing about your best friend you are jealous of?", 10 | "Would you cheat on your boyfriend for a rich guy?", 11 | "What is your biggest turn on?", 12 | "When’s the last time you lied to your parents and why?", 13 | "Describe your ideal partner.", 14 | "What’s the scariest thing you’ve ever done?", 15 | "Have you ever picked your nose and eaten it?", 16 | "When’s the last time you lied to your parents and why?", 17 | "Have you ever lied about your age to participate in a contest?", 18 | "Have you ever been caught checking someone out?", 19 | 20 | ) 21 | 22 | DARE = ( 23 | "Show the most embarrassing photo on your phone" 24 | "Show the last five people you texted and what the messages said", 25 | "Let the rest of the group DM someone from your Instagram account", 26 | "Eat a raw piece of garlic", 27 | "Do 100 squats", 28 | "Keep three ice cubes in your mouth until they melt", 29 | "Say something dirty to the person on your leftYou've got company!", 30 | "Give a foot massage to the person on your right", 31 | "Put 10 different available liquids into a cup and drink it", 32 | "*Yell out the first word that comes to your mind", 33 | "Give a lap dance to someone of your choice", 34 | "Remove four items of clothing", 35 | "Like the first 15 posts on your Facebook newsfeed", 36 | "Eat a spoonful of mustard", 37 | "Keep your eyes closed until it's your go again", 38 | "Send a sext to the last person in your phonebook", 39 | "Show off your orgasm face", 40 | "Seductively eat a banana", 41 | "Empty out your wallet/purse and show everyone what's inside", 42 | "Do your best sexy crawl", 43 | "Pretend to be the person to your right for 10 minutes", 44 | "Eat a snack without using your hands", 45 | "Say two honest things about everyone else in the group", 46 | "Twerk for a minute", 47 | "Try and make the group laugh as quickly as possible", 48 | "Try to put your whole fist in your mouth", 49 | "Tell everyone an embarrassing story about yourself", 50 | "Try to lick your elbow", 51 | "Post the oldest selfie on your phone on Instagram Stories", 52 | "Tell the saddest story you know", 53 | "Howl like a wolf for two minutes", 54 | "Dance without music for two minutes", 55 | "Pole dance with an imaginary pole", 56 | "Let someone else tickle you and try not to laugh", 57 | "Put as many snacks into your mouth at once as you can", 58 | "Send your most recent selfie.", 59 | "Send your ugliest selfie.", 60 | "Send a screenshot of your facebook search history", 61 | "Send a screenshot of your gallery.", 62 | "Send a screenshot of your messenger inbox", 63 | "Tell something very intimate.", 64 | "Send a screenshot of your twitter inbox", 65 | "Send a screenshot of your homescreen.", 66 | "Send a cover of your favorite song. 🎤", 67 | "Do a lyric prank on someone and send proof.", 68 | "Confess to your current crush. ❤️", 69 | "Declare who is your true love.", 70 | "Send a screenshot of your gallery.", 71 | "Set your crush’s picture as your dp.", 72 | "Suggest me more dares.", 73 | ) 74 | -------------------------------------------------------------------------------- /EvilBot/modules/ud.py: -------------------------------------------------------------------------------- 1 | import requests 2 | from EvilBot import dispatcher 3 | from EvilBot.modules.disable import DisableAbleCommandHandler 4 | from telegram import ParseMode, Update 5 | from telegram.ext import CallbackContext, run_async 6 | 7 | 8 | @run_async 9 | def ud(update: Update, context: CallbackContext): 10 | message = update.effective_message 11 | text = message.text[len("/ud ") :] 12 | results = requests.get( 13 | f"https://api.urbandictionary.com/v0/define?term={text}" 14 | ).json() 15 | try: 16 | reply_text = f'*{text}*\n\n{results["list"][0]["definition"]}\n\n_{results["list"][0]["example"]}_' 17 | except: 18 | reply_text = "No results found." 19 | message.reply_text(reply_text, parse_mode=ParseMode.MARKDOWN) 20 | 21 | 22 | UD_HANDLER = DisableAbleCommandHandler(["ud"], ud) 23 | 24 | dispatcher.add_handler(UD_HANDLER) 25 | 26 | __command_list__ = ["ud"] 27 | __handlers__ = [UD_HANDLER] 28 | -------------------------------------------------------------------------------- /EvilBot/modules/wallpaper.py: -------------------------------------------------------------------------------- 1 | from random import randint 2 | 3 | import requests as r 4 | from EvilBot import SUPPORT_CHAT, WALL_API, dispatcher 5 | from EvilBot.modules.disable import DisableAbleCommandHandler 6 | from telegram import Update 7 | from telegram.ext import CallbackContext, run_async 8 | 9 | # Wallpapers module by @TheRealPhoenix using wall.alphacoders.com 10 | 11 | 12 | @run_async 13 | def wall(update: Update, context: CallbackContext): 14 | chat_id = update.effective_chat.id 15 | msg = update.effective_message 16 | args = context.args 17 | msg_id = update.effective_message.message_id 18 | bot = context.bot 19 | query = " ".join(args) 20 | if not query: 21 | msg.reply_text("Please enter a query!") 22 | return 23 | else: 24 | caption = query 25 | term = query.replace(" ", "%20") 26 | json_rep = r.get( 27 | f"https://wall.alphacoders.com/api2.0/get.php?auth={WALL_API}&method=search&term={term}" 28 | ).json() 29 | if not json_rep.get("success"): 30 | msg.reply_text(f"An error occurred! Report this @{SUPPORT_CHAT}") 31 | else: 32 | wallpapers = json_rep.get("wallpapers") 33 | if not wallpapers: 34 | msg.reply_text("No results found! Refine your search.") 35 | return 36 | else: 37 | index = randint(0, len(wallpapers) - 1) # Choose random index 38 | wallpaper = wallpapers[index] 39 | wallpaper = wallpaper.get("url_image") 40 | wallpaper = wallpaper.replace("\\", "") 41 | bot.send_photo( 42 | chat_id, 43 | photo=wallpaper, 44 | caption="Preview", 45 | reply_to_message_id=msg_id, 46 | timeout=60, 47 | ) 48 | bot.send_document( 49 | chat_id, 50 | document=wallpaper, 51 | filename="wallpaper", 52 | caption=caption, 53 | reply_to_message_id=msg_id, 54 | timeout=60, 55 | ) 56 | 57 | 58 | WALLPAPER_HANDLER = DisableAbleCommandHandler("wall", wall) 59 | dispatcher.add_handler(WALLPAPER_HANDLER) 60 | -------------------------------------------------------------------------------- /EvilBot/modules/wiki.py: -------------------------------------------------------------------------------- 1 | import wikipedia 2 | from EvilBot import dispatcher 3 | from EvilBot.modules.disable import DisableAbleCommandHandler 4 | from telegram import ParseMode, Update 5 | from telegram.ext import CallbackContext, run_async 6 | from wikipedia.exceptions import DisambiguationError, PageError 7 | 8 | 9 | @run_async 10 | def wiki(update: Update, context: CallbackContext): 11 | msg = ( 12 | update.effective_message.reply_to_message 13 | if update.effective_message.reply_to_message 14 | else update.effective_message 15 | ) 16 | res = "" 17 | if msg == update.effective_message: 18 | search = msg.text.split(" ", maxsplit=1)[1] 19 | else: 20 | search = msg.text 21 | try: 22 | res = wikipedia.summary(search) 23 | except DisambiguationError as e: 24 | update.message.reply_text( 25 | "Disambiguated pages found! Adjust your query accordingly.\n{}".format( 26 | e 27 | ), 28 | parse_mode=ParseMode.HTML, 29 | ) 30 | except PageError as e: 31 | update.message.reply_text( 32 | "{}".format(e), parse_mode=ParseMode.HTML 33 | ) 34 | if res: 35 | result = f"{search}\n\n" 36 | result += f"{res}\n" 37 | result += f"""Read more...""" 38 | if len(result) > 4000: 39 | with open("result.txt", "w") as f: 40 | f.write(f"{result}\n\nUwU OwO OmO UmU") 41 | with open("result.txt", "rb") as f: 42 | context.bot.send_document( 43 | document=f, 44 | filename=f.name, 45 | reply_to_message_id=update.message.message_id, 46 | chat_id=update.effective_chat.id, 47 | parse_mode=ParseMode.HTML, 48 | ) 49 | else: 50 | update.message.reply_text( 51 | result, parse_mode=ParseMode.HTML, disable_web_page_preview=True 52 | ) 53 | 54 | 55 | WIKI_HANDLER = DisableAbleCommandHandler("wiki", wiki) 56 | dispatcher.add_handler(WIKI_HANDLER) 57 | -------------------------------------------------------------------------------- /EvilBot/modules/zombies.py: -------------------------------------------------------------------------------- 1 | from asyncio import sleep 2 | 3 | from telethon import events 4 | from telethon.errors import ChatAdminRequiredError, UserAdminInvalidError 5 | from telethon.tl.functions.channels import EditBannedRequest 6 | from telethon.tl.types import ChatBannedRights, ChannelParticipantsAdmins 7 | from EvilBot import telethn 8 | from EvilBot.events import register 9 | 10 | from EvilBot import telethn, OWNER_ID, DEV_USERS, DRAGONS, DEMONS 11 | 12 | # =================== CONSTANT =================== 13 | 14 | BANNED_RIGHTS = ChatBannedRights( 15 | until_date=None, 16 | view_messages=True, 17 | send_messages=True, 18 | send_media=True, 19 | send_stickers=True, 20 | send_gifs=True, 21 | send_games=True, 22 | send_inline=True, 23 | embed_links=True, 24 | ) 25 | 26 | 27 | UNBAN_RIGHTS = ChatBannedRights( 28 | until_date=None, 29 | send_messages=None, 30 | send_media=None, 31 | send_stickers=None, 32 | send_gifs=None, 33 | send_games=None, 34 | send_inline=None, 35 | embed_links=None, 36 | ) 37 | 38 | OFFICERS = [OWNER_ID] + DEV_USERS + DRAGONS + DEMONS 39 | 40 | # Check if user has admin rights 41 | async def is_administrator(user_id: int, message): 42 | admin = False 43 | async for user in telethn.iter_participants( 44 | message.chat_id, filter=ChannelParticipantsAdmins 45 | ): 46 | if user_id == user.id or user_id in OFFICERS: 47 | admin = True 48 | break 49 | return admin 50 | 51 | 52 | 53 | @telethn.on(events.NewMessage(pattern="^[!/]zombies ?(.*)")) 54 | async def zombies(event): 55 | """ For .zombies command, list all the zombies in a chat. """ 56 | 57 | con = event.pattern_match.group(1).lower() 58 | del_u = 0 59 | del_status = "No Deleted Accounts Found, Group Is Clean." 60 | 61 | if con != "clean": 62 | find_zombies = await event.respond("Searching For Zombies...") 63 | async for user in event.client.iter_participants(event.chat_id): 64 | 65 | if user.deleted: 66 | del_u += 1 67 | await sleep(1) 68 | if del_u > 0: 69 | del_status = f"Found **{del_u}** Zombies In This Group.\ 70 | \nClean Them By Using :\n👉 `/zombies clean`" 71 | await find_zombies.edit(del_status) 72 | return 73 | 74 | # Here laying the sanity check 75 | chat = await event.get_chat() 76 | admin = chat.admin_rights 77 | creator = chat.creator 78 | 79 | # Well 80 | if not await is_administrator(user_id=event.from_id, message=event): 81 | await event.respond("You're Not An Admin!") 82 | return 83 | 84 | if not admin and not creator: 85 | await event.respond("I Am Not An Admin Here!") 86 | return 87 | 88 | cleaning_zombies = await event.respond("Cleaning Zombies...") 89 | del_u = 0 90 | del_a = 0 91 | 92 | async for user in event.client.iter_participants(event.chat_id): 93 | if user.deleted: 94 | try: 95 | await event.client( 96 | EditBannedRequest(event.chat_id, user.id, BANNED_RIGHTS) 97 | ) 98 | except ChatAdminRequiredError: 99 | await cleaning_zombies.edit("I Don't Have Ban Rights In This Group.") 100 | return 101 | except UserAdminInvalidError: 102 | del_u -= 1 103 | del_a += 1 104 | await event.client(EditBannedRequest(event.chat_id, user.id, UNBAN_RIGHTS)) 105 | del_u += 1 106 | 107 | if del_u > 0: 108 | del_status = f"Cleaned `{del_u}` Zombies" 109 | 110 | if del_a > 0: 111 | del_status = f"Cleaned `{del_u}` Zombies \ 112 | \n`{del_a}` Zombie Admin Accounts Are Not Removed!" 113 | 114 | await cleaning_zombies.edit(del_status) 115 | -------------------------------------------------------------------------------- /EvilBot/mongo.py: -------------------------------------------------------------------------------- 1 | #Kiitu 2 | import asyncio 3 | import sys 4 | 5 | from motor import motor_asyncio 6 | from EvilBot import MONGO_DB_URI 7 | from pymongo import MongoClient 8 | from pymongo.errors import ServerSelectionTimeoutError 9 | from EvilBot.conf import get_int_key, get_str_key 10 | 11 | 12 | MONGO_PORT = get_int_key("27017") 13 | MONGO_DB_URI = get_str_key("MONGO_DB_URI") 14 | MONGO_DB = "Evil" 15 | 16 | 17 | client = MongoClient() 18 | client = MongoClient(MONGO_DB_URI, MONGO_PORT)[MONGO_DB] 19 | motor = motor_asyncio.AsyncIOMotorClient(MONGO_DB_URI, MONGO_PORT) 20 | db = motor[MONGO_DB] 21 | db = client["evilbot"] 22 | try: 23 | asyncio.get_event_loop().run_until_complete(motor.server_info()) 24 | except ServerSelectionTimeoutError: 25 | sys.exit(log.critical("Can't connect to mongodb! Exiting...")) 26 | -------------------------------------------------------------------------------- /EvilBot/pyrogramee/dark.py: -------------------------------------------------------------------------------- 1 | def get_arg(message): 2 | 3 | msg = message.text 4 | 5 | msg = msg.replace(" ", "", 1) if msg[1] == " " else msg 6 | 7 | split = msg[1:].replace("\n", " \n").split(" ") 8 | 9 | if " ".join(split[1:]).strip() == "": 10 | 11 | return "" 12 | 13 | return " ".join(split[1:]) 14 | 15 | -------------------------------------------------------------------------------- /EvilBot/pyrogramee/errors.py: -------------------------------------------------------------------------------- 1 | # © @Mr_Dark_Prince 2 | import sys 3 | import traceback 4 | from functools import wraps 5 | from EvilBot import pbot, SUPPORT_CHAT 6 | 7 | def split_limits(text): 8 | if len(text) < 2048: 9 | return [text] 10 | 11 | lines = text.splitlines(True) 12 | small_msg = '' 13 | result = [] 14 | for line in lines: 15 | if len(small_msg) + len(line) < 2048: 16 | small_msg += line 17 | else: 18 | result.append(small_msg) 19 | small_msg = line 20 | else: 21 | result.append(small_msg) 22 | 23 | return result 24 | 25 | def capture_err(func): 26 | @wraps(func) 27 | async def capture(client, message, *args, **kwargs): 28 | try: 29 | return await func(client, message, *args, **kwargs) 30 | except Exception as err: 31 | exc_type, exc_obj, exc_tb = sys.exc_info() 32 | errors = traceback.format_exception( 33 | etype=exc_type, value=exc_obj, tb=exc_tb, 34 | ) 35 | error_feedback = split_limits( 36 | '**ERROR** | `{}` | `{}`\n\n```{}```\n\n```{}```\n'.format( 37 | 0 if not message.from_user else message.from_user.id, 38 | 0 if not message.chat else message.chat.id, 39 | message.text or message.caption, 40 | ''.join(errors), 41 | ), 42 | ) 43 | for x in error_feedback: 44 | await pbot.send_message( 45 | SUPPORT_CHAT, 46 | x 47 | ) 48 | raise err 49 | return capture 50 | -------------------------------------------------------------------------------- /EvilBot/pyrogramee/fetch.py: -------------------------------------------------------------------------------- 1 | import aiohttp 2 | 3 | 4 | async def fetch(url): 5 | async with aiohttp.ClientSession() as session: 6 | async with session.get(url) as resp: 7 | try: 8 | data = await resp.json() 9 | except Exception: 10 | data = await resp.text() 11 | return data 12 | -------------------------------------------------------------------------------- /EvilBot/pyrogramee/json_prettify.py: -------------------------------------------------------------------------------- 1 | async def json_object_prettify(objecc): 2 | dicc = objecc.__dict__ 3 | output = "" 4 | for key, value in dicc.items(): 5 | if key == "pinned_message" or key == "photo" \ 6 | or key == "_" or key == "_client": 7 | continue 8 | output += f"**{key}:** `{value}`\n" 9 | return output 10 | 11 | 12 | async def json_prettify(data): 13 | output = "" 14 | try: 15 | for key, value in data.items(): 16 | output += f"**{key}:** `{value}`\n" 17 | except Exception: 18 | for datas in data: 19 | for key, value in datas.items(): 20 | output += f"**{key}:** `{value}`\n" 21 | output += "------------------------\n" 22 | return output 23 | -------------------------------------------------------------------------------- /EvilBot/resources/Chopsic.otf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xhrvan/EvilBot/23d3f6f3c3245b0509fd18f39849cc72c1d78431/EvilBot/resources/Chopsic.otf -------------------------------------------------------------------------------- /EvilBot/resources/Evil.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xhrvan/EvilBot/23d3f6f3c3245b0509fd18f39849cc72c1d78431/EvilBot/resources/Evil.jpg -------------------------------------------------------------------------------- /EvilBot/resources/Maghrib.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xhrvan/EvilBot/23d3f6f3c3245b0509fd18f39849cc72c1d78431/EvilBot/resources/Maghrib.ttf -------------------------------------------------------------------------------- /EvilBot/resources/blackbg.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xhrvan/EvilBot/23d3f6f3c3245b0509fd18f39849cc72c1d78431/EvilBot/resources/blackbg.jpg -------------------------------------------------------------------------------- /EvilBot/resources/images.jpeg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/xhrvan/EvilBot/23d3f6f3c3245b0509fd18f39849cc72c1d78431/EvilBot/resources/images.jpeg -------------------------------------------------------------------------------- /EvilBot/sample_config.py: -------------------------------------------------------------------------------- 1 | # Create a new config.py or rename this to config.py file in same dir and import, then extend this class. 2 | import json 3 | import os 4 | 5 | 6 | def get_user_list(config, key): 7 | with open("{}/EvilBot/{}".format(os.getcwd(), config), "r") as json_file: 8 | return json.load(json_file)[key] 9 | 10 | 11 | # Create a new config.py or rename this to config.py file in same dir and import, then extend this class. 12 | class Config(object): 13 | LOGGER = True 14 | # REQUIRED 15 | # Login to https://my.telegram.org and fill in these slots with the details given by it 16 | 17 | API_ID = 123456 # integer value, dont use "" 18 | API_HASH = "awoo" 19 | TOKEN = "BOT_TOKEN" # This var used to be API_KEY but it is now TOKEN, adjust accordingly. 20 | OWNER_ID = 1742353529 # If you dont know, run the bot and do /id in your private chat with it, also an integer 21 | OWNER_USERNAME = "shrvan42" 22 | SUPPORT_CHAT = "EVIL_SUPPORT_CHAT" # Your own group for support, do not add the @ 23 | JOIN_LOGGER = ( 24 | -1001236063876 25 | ) # Prints any new group the bot is added to, prints just the name and ID. 26 | EVENT_LOGS = ( 27 | -1001188058807 28 | ) # Prints information like gbans, sudo promotes, AI enabled disable states that may help in debugging and shit 29 | 30 | # RECOMMENDED 31 | SQLALCHEMY_DATABASE_URI = "something://somewhat:user@hosturl:port/databasename" # needed for any database modules 32 | LOAD = [] 33 | NO_LOAD = ["rss", "cleaner", "connection", "math"] 34 | WEBHOOK = False 35 | INFOPIC = True 36 | URL = None 37 | SPAMWATCH_API = "" # go to support.spamwat.ch to get key 38 | SPAMWATCH_SUPPORT_CHAT = "@SpamWatchSupport" 39 | 40 | # OPTIONAL 41 | ##List of id's - (not usernames) for users which have sudo access to the bot. 42 | DRAGONS = get_user_list("elevated_users.json", "sudos") 43 | ##List of id's - (not usernames) for developers who will have the same perms as the owner 44 | DEV_USERS = get_user_list("elevated_users.json", "devs") 45 | ##List of id's (not usernames) for users which are allowed to gban, but can also be banned. 46 | DEMONS = get_user_list("elevated_users.json", "supports") 47 | # List of id's (not usernames) for users which WONT be banned/kicked by the bot. 48 | TIGERS = get_user_list("elevated_users.json", "tigers") 49 | WOLVES = get_user_list("elevated_users.json", "whitelists") 50 | DONATION_LINK = None # EG, paypal 51 | CERT_PATH = None 52 | PORT = 5000 53 | DEL_CMDS = True # Delete commands that users dont have access to, like delete /ban if a non admin uses it. 54 | STRICT_GBAN = True 55 | WORKERS = ( 56 | 8 # Number of subthreads to use. Set as number of threads your processor uses 57 | ) 58 | BAN_STICKER = "" # banhammer marie sticker id, the bot will send this sticker before banning or kicking a user in chat. 59 | ALLOW_EXCL = True # Allow ! commands as well as / (Leave this to true so that blacklist can work) 60 | CASH_API_KEY = ( 61 | "awoo" # Get your API key from https://www.alphavantage.co/support/#api-key 62 | ) 63 | TIME_API_KEY = "awoo" # Get your API key from https://timezonedb.com/api 64 | WALL_API = ( 65 | "awoo" # For wallpapers, get one from https://wall.alphacoders.com/api.php 66 | ) 67 | AI_API_KEY = "awoo" # For chatbot, get one from https://coffeehouse.intellivoid.net/dashboard 68 | BL_CHATS = [] # List of groups that you want blacklisted. 69 | SPAMMERS = None 70 | 71 | class Production(Config): 72 | LOGGER = True 73 | 74 | 75 | class Development(Config): 76 | LOGGER = True 77 | -------------------------------------------------------------------------------- /EvilBot/utils/X: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /EvilBot/utils/dbfunc.py: -------------------------------------------------------------------------------- 1 | from EvilBot.mongo import db 2 | from typing import Dict, List, Union 3 | 4 | 5 | coupledb = db.couple 6 | karmadb = db.karma 7 | 8 | # Couple Chooser 9 | 10 | async def _get_lovers(chat_id: int): 11 | lovers = coupledb.find_one({"chat_id": chat_id}) 12 | if lovers: 13 | lovers = lovers["couple"] 14 | else: 15 | lovers = {} 16 | return lovers 17 | 18 | 19 | async def get_couple(chat_id: int, date: str): 20 | lovers = await _get_lovers(chat_id) 21 | if date in lovers: 22 | return lovers[date] 23 | else: 24 | return False 25 | 26 | 27 | async def save_couple(chat_id: int, date: str, couple: dict): 28 | lovers = await _get_lovers(chat_id) 29 | lovers[date] = couple 30 | coupledb.update_one( 31 | {"chat_id": chat_id}, 32 | { 33 | "$set": { 34 | "couple": lovers 35 | } 36 | }, 37 | upsert=True 38 | ) 39 | 40 | 41 | # Karma functions 42 | 43 | 44 | async def get_karmas_count() -> dict: 45 | chats = karmadb.find({"chat_id": {"$lt": 0}}) 46 | if not chats: 47 | return {} 48 | chats_count = 0 49 | karmas_count = 0 50 | for chat in await chats.to_list(length=1000000): 51 | for i in chat['karma']: 52 | karmas_count += chat['karma'][i]['karma'] 53 | chats_count += 1 54 | return { 55 | "chats_count": chats_count, 56 | "karmas_count": karmas_count 57 | } 58 | 59 | 60 | async def get_karmas(chat_id: int) -> Dict[str, int]: 61 | karma = karmadb.find_one({"chat_id": chat_id}) 62 | if karma: 63 | karma = karma['karma'] 64 | else: 65 | karma = {} 66 | return karma 67 | 68 | 69 | async def get_karma(chat_id: int, name: str) -> Union[bool, dict]: 70 | name = name.lower().strip() 71 | karmas = await get_karmas(chat_id) 72 | if name in karmas: 73 | return karmas[name] 74 | 75 | 76 | async def update_karma(chat_id: int, name: str, karma: dict): 77 | name = name.lower().strip() 78 | karmas = await get_karmas(chat_id) 79 | karmas[name] = karma 80 | karmadb.update_one( 81 | {"chat_id": chat_id}, 82 | { 83 | "$set": { 84 | "karma": karmas 85 | } 86 | }, 87 | upsert=True 88 | ) 89 | 90 | 91 | # Alpha integer 92 | 93 | async def int_to_alpha(user_id: int) -> str: 94 | alphabet = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"] 95 | text = "" 96 | user_id = str(user_id) 97 | for i in user_id: 98 | text += alphabet[int(i)] 99 | return text 100 | 101 | 102 | async def alpha_to_int(user_id_alphabet: str) -> int: 103 | alphabet = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"] 104 | user_id = "" 105 | for i in user_id_alphabet: 106 | index = alphabet.index(i) 107 | user_id += str(index) 108 | user_id = int(user_id) 109 | return user_id 110 | -------------------------------------------------------------------------------- /EvilBot/utils/errors.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import traceback 3 | from functools import wraps 4 | from EvilBot import pbot as app 5 | from pyrogram.errors.exceptions.forbidden_403 import ChatWriteForbidden 6 | 7 | LOG_GROUP_ID = int(-1001236063876) 8 | 9 | def split_limits(text): 10 | if len(text) < 2048: 11 | return [text] 12 | 13 | lines = text.splitlines(True) 14 | small_msg = '' 15 | result = [] 16 | for line in lines: 17 | if len(small_msg) + len(line) < 2048: 18 | small_msg += line 19 | else: 20 | result.append(small_msg) 21 | small_msg = line 22 | else: 23 | result.append(small_msg) 24 | 25 | return result 26 | 27 | 28 | def capture_err(func): 29 | @wraps(func) 30 | async def capture(client, message, *args, **kwargs): 31 | try: 32 | return await func(client, message, *args, **kwargs) 33 | except ChatWriteForbidden: 34 | await app.leave_chat(message.chat.id) 35 | return 36 | except Exception as err: 37 | exc_type, exc_obj, exc_tb = sys.exc_info() 38 | errors = traceback.format_exception( 39 | etype=exc_type, value=exc_obj, tb=exc_tb, 40 | ) 41 | error_feedback = split_limits( 42 | '**ERROR** | `{}` | `{}`\n\n```{}```\n\n```{}```\n'.format( 43 | 0 if not message.from_user else message.from_user.id, 44 | 0 if not message.chat else message.chat.id, 45 | message.text or message.caption, 46 | ''.join(errors), 47 | ), 48 | ) 49 | for x in error_feedback: 50 | await app.send_message( 51 | LOG_GROUP_ID, 52 | x 53 | ) 54 | raise err 55 | return capture 56 | -------------------------------------------------------------------------------- /EvilBot/utils/filter_groups.py: -------------------------------------------------------------------------------- 1 | karma_positive_group = 3 2 | karma_negative_group = 4 3 | -------------------------------------------------------------------------------- /Git_Pull.bat: -------------------------------------------------------------------------------- 1 | @echo off 2 | TITLE Github Quick-Pull 3 | 4 | :: Print the branch cause ..oooooo fancy! 5 | echo Pulling from branch: 6 | git branch 7 | echo. 8 | git pull 9 | -------------------------------------------------------------------------------- /Git_Push.bat: -------------------------------------------------------------------------------- 1 | @echo off 2 | TITLE Github Quick-pushing 3 | 4 | :: Print the branch cause people like me push to wrong branches and cry about it later. 5 | echo Pushing to branch: 6 | git branch 7 | echo. 8 | :: Take input for comment and thats about it 9 | set /p commit_title="Enter Commit title (pushes with you as author): " 10 | 11 | :: If you are reading comments to understand this part then you can go back stab yourself. 12 | echo. 13 | git pull 14 | git add * 15 | git commit -m "%commit_title%" 16 | git push 17 | 18 | 19 | :: Hail Hydra -------------------------------------------------------------------------------- /Procfile: -------------------------------------------------------------------------------- 1 | worker: python3 -m EvilBot 2 | ps:scale worker=1 3 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 |

😈EVIL BOT😈

2 | 3 | 4 | ## You can also tap the Deploy To Heroku button below to deploy straight to Heroku! 5 | 6 | [![Deploy](https://www.herokucdn.com/deploy/button.svg)](https://heroku.com/deploy?template=https://github.com/shrvan42/EvilBot)

7 |

___________

8 | 9 | ## Starting the bot. 10 | 11 | Once you've setup your database and your configuration (see below) is complete, simply run: 12 | 13 | `python3 -m EvilBot` 14 | 15 | 16 | ### Configuration 17 | 18 | There are two possible ways of configuring your bot: a config.py file, or ENV variables. 19 | 20 | 21 | If you can't have a config.py file (EG on heroku), it is also possible to use environment variables. 22 | The following env variables are supported: 23 |

24 |

25 |

___________

26 | 27 | ## Session String 28 | 29 | * [![Run on Repl.it](https://replit.com/badge/github/TeamUltroid/Ultroid)](http://generatestringsession.sandeep1709.repl.run/) 30 | 31 | ## Variables 32 | 33 | - `API HASH AND ID`: Your Api Hash And Id from [here](https://my.telegram.org). 34 | - `ENV`: Setting this to ANYTHING will enable env variables 35 | - `TOKEN`: Your bot token. 36 | - `OWNER_ID`: An integer of consisting of your owner ID 37 | - `OWNER_USERNAME`: Your username 38 | 39 | - `DATABASE_URL`: Your database URL 40 | - `MESSAGE_DUMP`: optional: a chat where your replied saved messages are stored, to stop people deleting their old 41 | - `LOAD`: Space separated list of modules you would like to load 42 | - `NO_LOAD`: Space separated list of modules you would like NOT to load 43 | - `WEBHOOK`: Setting this to ANYTHING will enable webhooks when in env mode 44 | messages 45 | - `URL`: The URL your webhook should connect to (only needed for webhook mode) 46 | 47 | - `SUDO_USERS`: A space separated list of user_ids which should be considered sudo users 48 | - `SUPPORT_USERS`: A space separated list of user_ids which should be considered support users (can gban/ungban, 49 | nothing else) 50 | - `WHITELIST_USERS`: A space separated list of user_ids which should be considered whitelisted - they can't be banned. 51 | - `DONATION_LINK`: Optional: link where you would like to receive donations. 52 | - `CERT_PATH`: Path to your webhook certificate 53 | - `PORT`: Port to use for your webhooks 54 | - `DEL_CMDS`: Whether to delete commands from users which don't have rights to use that command 55 | - `STRICT_GBAN`: Enforce gbans across new groups as well as old groups. When a gbanned user talks, he will be banned. 56 | - `WORKERS`: Number of threads to use. 8 is the recommended (and default) amount, but your experience may vary. 57 | __Note__ that going crazy with more threads wont necessarily speed up your bot, given the large amount of sql data 58 | accesses, and the way python asynchronous calls work. 59 | - `BAN_STICKER`: Which sticker to use when banning people. 60 | - `ALLOW_EXCL`: Whether to allow using exclamation marks ! for commands as well as /. 61 | 62 | -------------------------------------------------------------------------------- /Setup venv.bat: -------------------------------------------------------------------------------- 1 | TITLE Setting up virtual env 2 | :: Running it once is fine, this just sets up virtual env >> install all modules there 3 | py -m venv env && env\scripts\activate.bat && pip install -r requirements.txt 4 | 5 | :: Note to rerun the requirements.txt in case you ever add a mdoule. 6 | :: Running this multiple time will not make a mess of your setup, dont worry about that bit. 7 | -------------------------------------------------------------------------------- /_config.yml: -------------------------------------------------------------------------------- 1 | theme: jekyll-theme-architect -------------------------------------------------------------------------------- /exp.sh: -------------------------------------------------------------------------------- 1 | sudo bash -c 'echo "{ \"cgroup-parent\": \"/actions_job\",\"experimental\":true}" > /etc/docker/daemon.json' 2 | sudo systemctl restart docker.service -------------------------------------------------------------------------------- /heroku.yml: -------------------------------------------------------------------------------- 1 | build: 2 | docker: 3 | worker: Dockerfile 4 | run: 5 | worker: python3 -m EvilBot 6 | -------------------------------------------------------------------------------- /profanity_wordlist.txt: -------------------------------------------------------------------------------- 1 | 2g1c 2 | 2 girls 1 cup 3 | 4r5e 4 | anal 5 | anus 6 | arse 7 | ass 8 | asses 9 | assfucker 10 | assfukka 11 | asshole 12 | arsehole 13 | asswhole 14 | assmunch 15 | auto erotic 16 | autoerotic 17 | ballsack 18 | bastard 19 | beastial 20 | bestial 21 | bellend 22 | bdsm 23 | beastiality 24 | bestiality 25 | bitch 26 | bitches 27 | bitchin 28 | bitching 29 | bimbo 30 | bimbos 31 | blow job 32 | blowjob 33 | blowjobs 34 | blue waffle 35 | boob 36 | boobs 37 | booobs 38 | boooobs 39 | booooobs 40 | booooooobs 41 | breasts 42 | booty call 43 | brown shower 44 | brown showers 45 | boner 46 | bondage 47 | buceta 48 | bukake 49 | bukkake 50 | bullshit 51 | bull shit 52 | busty 53 | butthole 54 | carpet muncher 55 | cawk 56 | chink 57 | cipa 58 | clit 59 | clits 60 | clitoris 61 | cnut 62 | cock 63 | cocks 64 | cockface 65 | cockhead 66 | cockmunch 67 | cockmuncher 68 | cocksuck 69 | cocksucked 70 | cocksucking 71 | cocksucks 72 | cocksucker 73 | cokmuncher 74 | coon 75 | cow girl 76 | cow girls 77 | cowgirl 78 | cowgirls 79 | crap 80 | crotch 81 | cum 82 | cummer 83 | cumming 84 | cuming 85 | cums 86 | cumshot 87 | cunilingus 88 | cunillingus 89 | cunnilingus 90 | cunt 91 | cuntlicker 92 | cuntlicking 93 | cunts 94 | damn 95 | dick 96 | dickhead 97 | dildo 98 | dildos 99 | dink 100 | dinks 101 | deepthroat 102 | deep throat 103 | dog style 104 | doggie style 105 | doggiestyle 106 | doggy style 107 | doggystyle 108 | donkeyribber 109 | doosh 110 | douche 111 | duche 112 | dyke 113 | ejaculate 114 | ejaculated 115 | ejaculates 116 | ejaculating 117 | ejaculatings 118 | ejaculation 119 | ejakulate 120 | erotic 121 | erotism 122 | fag 123 | faggot 124 | fagging 125 | faggit 126 | faggitt 127 | faggs 128 | fagot 129 | fagots 130 | fags 131 | fatass 132 | femdom 133 | fingering 134 | footjob 135 | foot job 136 | fuck 137 | fucks 138 | fucker 139 | fuckers 140 | fucked 141 | fuckhead 142 | fuckheads 143 | fuckin 144 | fucking 145 | fcuk 146 | fcuker 147 | fcuking 148 | felching 149 | fellate 150 | fellatio 151 | fingerfuck 152 | fingerfucked 153 | fingerfucker 154 | fingerfuckers 155 | fingerfucking 156 | fingerfucks 157 | fistfuck 158 | fistfucked 159 | fistfucker 160 | fistfuckers 161 | fistfucking 162 | fistfuckings 163 | fistfucks 164 | flange 165 | fook 166 | fooker 167 | fucka 168 | fuk 169 | fuks 170 | fuker 171 | fukker 172 | fukkin 173 | fukking 174 | futanari 175 | futanary 176 | gangbang 177 | gangbanged 178 | gang bang 179 | gokkun 180 | golden shower 181 | goldenshower 182 | gaysex 183 | goatse 184 | handjob 185 | hand job 186 | hentai 187 | hooker 188 | hoer 189 | homo 190 | horny 191 | incest 192 | jackoff 193 | jack off 194 | jerkoff 195 | jerk off 196 | jizz 197 | knob 198 | kinbaku 199 | labia 200 | masturbate 201 | masochist 202 | mofo 203 | mothafuck 204 | motherfuck 205 | motherfucker 206 | mothafucka 207 | mothafuckas 208 | mothafuckaz 209 | mothafucked 210 | mothafucker 211 | mothafuckers 212 | mothafuckin 213 | mothafucking 214 | mothafuckings 215 | mothafucks 216 | mother fucker 217 | motherfucked 218 | motherfucker 219 | motherfuckers 220 | motherfuckin 221 | motherfucking 222 | motherfuckings 223 | motherfuckka 224 | motherfucks 225 | milf 226 | muff 227 | nigga 228 | nigger 229 | nigg 230 | nipple 231 | nipples 232 | nob 233 | nob jokey 234 | nobhead 235 | nobjocky 236 | nobjokey 237 | numbnuts 238 | nutsack 239 | nude 240 | nudes 241 | orgy 242 | orgasm 243 | orgasms 244 | panty 245 | panties 246 | penis 247 | playboy 248 | porn 249 | porno 250 | pornography 251 | pron 252 | pussy 253 | pussies 254 | rape 255 | raping 256 | rapist 257 | rectum 258 | retard 259 | rimming 260 | sadist 261 | sadism 262 | schlong 263 | scrotum 264 | sex 265 | semen 266 | shemale 267 | she male 268 | shibari 269 | shibary 270 | shit 271 | shitdick 272 | shitfuck 273 | shitfull 274 | shithead 275 | shiting 276 | shitings 277 | shits 278 | shitted 279 | shitters 280 | shitting 281 | shittings 282 | shitty 283 | shota 284 | skank 285 | slut 286 | sluts 287 | smut 288 | smegma 289 | spunk 290 | strip club 291 | stripclub 292 | tit 293 | tits 294 | titties 295 | titty 296 | titfuck 297 | tittiefucker 298 | titties 299 | tittyfuck 300 | tittywank 301 | titwank 302 | threesome 303 | three some 304 | throating 305 | twat 306 | twathead 307 | twatty 308 | twunt 309 | viagra 310 | vagina 311 | vulva 312 | wank 313 | wanker 314 | wanky 315 | whore 316 | whoar 317 | xxx 318 | xx 319 | yaoi 320 | yury 321 | sexy -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | future 2 | emoji 3 | lxml 4 | wget 5 | gtts 6 | beautifulsoup4 7 | requests==2.20.0 8 | python-telegram-bot==12.8 9 | PyDictionary==2.0.1 10 | sqlalchemy==1.3.20 11 | psycopg2-binary 12 | feedparser 13 | hachoir 14 | pynewtonmath 15 | spongemock 16 | zalgo-text 17 | geopy 18 | nltk 19 | psutil 20 | aiohttp>=2.2.5 21 | Pillow>=4.2.0 22 | CurrencyConverter 23 | #googletrans 24 | google_trans_new 25 | jikanpy 26 | speedtest-cli 27 | coffeehouse==2.2.4 28 | regex 29 | bleach 30 | git+https://github.com/starry69/python-markdown2.git 31 | wikipedia 32 | telethon 33 | telegraph 34 | heroku3 35 | spamwatch 36 | alphabet_detector 37 | pyrate-limiter 38 | cachetools 39 | ujson 40 | pretty_errors 41 | TgCrypto 42 | Pyrogram 43 | youtube-dl 44 | youtube_search_python 45 | youtube_search 46 | asyncio 47 | dateparser==1.0.0 48 | pymongo==3.11.0 49 | dnspython 50 | secureme 51 | apscheduler 52 | emoji-country-flag 53 | countryinfo 54 | html2text 55 | bs4 56 | bing_image_downloader 57 | search_engine_parser 58 | pytz 59 | nekos.py 60 | lyricsgenius 61 | tswift 62 | python-arq 63 | envparse 64 | 65 | #profanity (Credits to Julia) 66 | better_profanity 67 | textblob 68 | nudepy 69 | 70 | motor 71 | -------------------------------------------------------------------------------- /restart.bat: -------------------------------------------------------------------------------- 1 | :: starts a cmd to silently start the bat file, just another dirty way of getting things done for my env on windows 2 | start cmd.exe /c start_service.bat -------------------------------------------------------------------------------- /runtime.txt: -------------------------------------------------------------------------------- 1 | python-3.8.6 2 | -------------------------------------------------------------------------------- /start.bat: -------------------------------------------------------------------------------- 1 | @echo off 2 | TITLE Evil Xobot 3 | :: Enables virtual env mode and then starts Evil 4 | env\scripts\activate.bat && py -m EvilBott 5 | -------------------------------------------------------------------------------- /start_service.bat: -------------------------------------------------------------------------------- 1 | @echo off 2 | :: This runs the batch file as an admin - required UAC to be off 3 | :: This is just an asty hack in to get job done cause we host it on windows dedi. 4 | :: BatchGotAdmin 5 | :------------------------------------- 6 | REM --> Check for permissions 7 | >nul 2>&1 "%SYSTEMROOT%\system32\cacls.exe" "%SYSTEMROOT%\system32\config\system" 8 | 9 | REM --> If error flag set, we do not have admin. 10 | if '%errorlevel%' NEQ '0' ( 11 | echo Requesting administrative privileges... 12 | goto UACPrompt 13 | ) else ( goto gotAdmin ) 14 | 15 | :UACPrompt 16 | echo Set UAC = CreateObject^("Shell.Application"^) > "%temp%\getadmin.vbs" 17 | set params = %*:"="" 18 | echo UAC.ShellExecute "cmd.exe", "/c %~s0 %params%", "", "runas", 1 >> "%temp%\getadmin.vbs" 19 | 20 | "%temp%\getadmin.vbs" 21 | del "%temp%\getadmin.vbs" 22 | exit /B 23 | 24 | :gotAdmin 25 | pushd "%CD%" 26 | CD /D "%~dp0" 27 | :-------------------------------------- 28 | :: your commands begin from this point. 29 | :: stops the service and then starts it 30 | net stop EvilBot 31 | net start EvilBot 32 | --------------------------------------------------------------------------------