import os
from DaisyX.utils import admin_cmd
from DaisyX import ALIVE_NAME, CMD_HELP, CMD_HNDLR, CMD_LIST
from var import Var
DEFAULTUSER = str(ALIVE_NAME) if ALIVE_NAME else "ᴅᴀɪsʏ x"
CMD_HNDLR = os.environ.get("CMD_HNDLR")
CUSTOM_HELP_EMOJI = os.environ.get("CUSTOM_HELP_EMOJI", "⚡")
if CMD_HNDLR is None:
CMD_HNDLR = "."
@bot.on(admin_cmd(pattern="help ?(.*)"))
async def cmd_list(event):
if not event.text[0].isalpha() and event.text[0] not in ("/", "#", "@",
"!"):
tgbotusername = Var.TG_BOT_USER_NAME_BF_HER
input_str = event.pattern_match.group(1)
if tgbotusername is None or input_str == "text":
string = ""
for i in CMD_HELP:
string += CUSTOM_HELP_EMOJI + " " + i + " " + CUSTOM_HELP_EMOJI + "\n"
for iter_list in CMD_HELP[i]:
string += " `" + str(iter_list) + "`"
string += "\n"
string += "\n"
if len(string) > 4095:
with io.BytesIO(str.encode(string)) as out_file:
out_file.name = "cmd.txt"
[
Button.url(
f"⚜️ Rᴇᴘᴏ ⚜️", url="https://github.com/TeamDaisyX/Daisy-X-UB"
),
Button.url(
f"🌚 Sᴜᴘᴘᴏʀᴛ Cʜᴀᴛ 🌝", url="https://t.me/DaisySupport_Official"
),
],
[
Button.url(
f"🔰 Dᴇᴘʟᴏʏ 🔰",
url="https://dashboard.heroku.com/new?button-url=https%3A%2F%2Fgithub.com%2FTeamDaisyX%2FDaisy-X-UB&template=https%3A%2F%2Fgithub.com%2FTeamDaisyX%2FDaisy-X-UB",
),
Button.url(
f"💠 Sᴛʀɪɴɢ 💠", url="https://repl.it/@SpEcHiDe/GenerateStringSession"
),
],
],
)
# (c) Copyright 2021-2022 TeamDaisyX
# Made by Devil (@Lucifeermorningstar) and @RoseHaterX
@bot.on(admin_cmd(pattern="repo"))
@bot.on(sudo_cmd(pattern="repo ? (.*) ", allow_sudo=True))
async def repo(event):
buttons = [Button.url(f"⚜️ Rᴇᴘᴏ ⚜️", "https://github.com/TeamDaisyX/Daisy-X-UB")]
await event.edit("**DAISYX UB**", buttons=buttons)
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
"""Urban Dictionary
Syntax: .ud Query"""
import asyncurban
from PyDictionary import PyDictionary
from DaisyX import CMD_HELP
from DaisyX.utils import admin_cmd, edit_or_reply, sudo_cmd
@bot.on(admin_cmd(pattern="ud (.*)"))
@bot.on(sudo_cmd(pattern="ud (.*)", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
word = event.pattern_match.group(1)
urban = asyncurban.UrbanDictionary()
try:
mean = await urban.get_word(word)
await edit_or_reply(
event,
"Text: **{}**\n\nMeaning: **{}**\n\nExample: __{}__".format(
mean.word, mean.definition, mean.example
),
)
except asyncurban.WordNotFoundError:
await edit_or_reply(event, "No result found for **" + word + "**")
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
"""Remove.BG Plugin for @UniBorg
Syntax: .rmbg https://link.to/image.extension
Syntax: .rmbg as reply to a media"""
import io
import os
from datetime import datetime
import requests
from DaisyX.utils import admin_cmd
@borg.on(admin_cmd("rmbg ?(.*)"))
async def _(event):
HELP_STR = (
"`.rmbg` as reply to a media, or give a link as an argument to this command"
)
if event.fwd_from:
return
if Config.REM_BG_API_KEY is None:
await event.edit(
"You need API token from remove.bg to use this plugin.")
return False
input_str = event.pattern_match.group(1)
start = datetime.now()
message_id = event.message.id
if event.reply_to_msg_id:
message_id = event.reply_to_msg_id
"""Get Administrators of any Chat*
Syntax: .get_admin"""
from telethon.tl.types import (
ChannelParticipantAdmin,
ChannelParticipantCreator,
ChannelParticipantsAdmins,
)
from DaisyX.utils import admin_cmd
@borg.on(admin_cmd("get_ad?(m)in ?(.*)"))
async def _(event):
if event.fwd_from:
return
mentions = "**Admins in this Channel**: \n"
should_mention_admins = False
reply_message = None
pattern_match_str = event.pattern_match.group(1)
if "m" in pattern_match_str:
should_mention_admins = True
if event.reply_to_msg_id:
reply_message = await event.get_reply_message()
input_str = event.pattern_match.group(2)
to_write_chat = await event.get_input_chat()
chat = None
if not input_str:
chat = to_write_chat
else:
mentions_heading = "Admins in {} channel: \n".format(input_str)
mentions = mentions_heading
'apikey': api_key,
'language': language,
}
r = requests.post(
'https://api.ocr.space/parse/image',
data=payload,
)
return r.json()
def progress(current, total):
logger.info("Downloaded {} of {}\nCompleted {}".format(
current, total, (current / total) * 100))
@borg.on(admin_cmd(pattern="ocrlanguages"))
async def get_ocr_languages(event):
if event.fwd_from:
return
languages = {}
languages["English"] = "eng"
languages["Arabic"] = "ara"
languages["Bulgarian"] = "bul"
languages["Chinese (Simplified)"] = "chs"
languages["Chinese (Traditional)"] = "cht"
languages["Croatian"] = "hrv"
languages["Czech"] = "cze"
languages["Danish"] = "dan"
languages["Dutch"] = "dut"
languages["Finnish"] = "fin"
languages["French"] = "fre"
return await event.edit("**SOMETHING W3NT WRONG 🤔**", str(err))
return user_obj, extra
async def get_user_sender_id(user, event):
if isinstance(user, str):
user = int(user)
try:
user_obj = await event.client.get_entity(user)
except (TypeError, ValueError) as err:
await event.edit(str(err))
return None
return user_obj
@borg.on(admin_cmd(pattern="gban ?(.*)"))
@borg.on(sudo_cmd("gban ?(.*)", allow_sudo=True))
async def gspider(ULTRA):
lol = ULTRA
sender = await lol.get_sender()
me = await lol.client.get_me()
if not sender.id == me.id:
friday = await lol.reply("GBanning This Retard DumbAss😁😁")
else:
friday = await lol.edit("Wait Processing.....")
me = await ULTRA.client.get_me()
await friday.edit(f"Global Ban Is Coming ! Wait And Watch You bitch😎🔥")
my_mention = "[{}](tg://user?id={})".format(me.first_name, me.id)
f"@{me.username}" if me.username else my_mention
await ULTRA.get_chat()
a = b = 0
import asyncio
from telethon.errors.rpcerrorlist import YouBlockedUserError
from Assist.DAISYX import NAME
from DaisyX import CMD_HELP, bot
from DaisyX.utils import admin_cmd
bot = "@MissRose_bot"
ULTRAX = NAME
@borg.on(admin_cmd("fstat ?(.*)"))
async def _(event):
if event.fwd_from:
return
ok = await event.edit(f"**¢нє¢кιηg ƒѕтαт ση σя∂єя σƒ {ULTRAX}**...")
if event.reply_to_msg_id:
previous_message = await event.get_reply_message()
sysarg = str(previous_message.sender_id)
user = f"[user](tg://user?id={sysarg})"
else:
sysarg = event.pattern_match.group(1)
user = sysarg
if sysarg == "":
await ok.edit(
"`Give me someones id, or reply to somones message to check his/her fedstat.`"
)
return
else:
async with borg.conversation(bot) as conv:
# Made by @LEGENDX22 FOR ULTRA X
import asyncio
import io
from DaisyX import CMD_HELP
from DaisyX.utils import admin_cmd
# @command(pattern="^.cmds", outgoing=True)
@borg.on(admin_cmd(pattern=r"cmds"))
async def install(event):
if event.fwd_from:
return
reply_to_id = event.message.id
if event.reply_to_msg_id:
reply_to_id = event.reply_to_msg_id
cmd = "ls DaisyX/modules"
process = await asyncio.create_subprocess_shell(
cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
)
stdout, stderr = await process.communicate()
o = stdout.decode()
_o = o.split("\n")
o = "\n".join(_o)
OUTPUT = f"**List of Plugins:**\n - {o}\n\n**HELP:** __If you want to know the commands for a plugin, do:-__ \n `.help <plugin name>` **without the < > brackets.**\n__All modules might not work directly. Visit__ @DaisyXOT __for assistance.__"
if len(OUTPUT) > 69:
with io.BytesIO(str.encode(OUTPUT)) as out_file:
out_file.name = "cmd_list.text"
await bot.send_file(
event.chat_id,
out_file,
)
from telethon.errors.rpcerrorlist import MessageTooLongError
from telethon.tl.functions.channels import (
GetFullChannelRequest,
GetParticipantsRequest,
LeaveChannelRequest,
)
from telethon.tl.functions.messages import GetFullChatRequest, GetHistoryRequest
from telethon.tl.types import ChannelParticipantsAdmins, MessageActionChannelMigrateFrom
from telethon.utils import get_input_location
from DaisyX import CMD_HELP
from DaisyX.utils import admin_cmd, errors_handler
@borg.on(admin_cmd(pattern="leave$"))
async def leave(e):
await e.edit("`Legend is leaving this chat.....!Goodbye aren't forever..` "
)
time.sleep(3)
if "-" in str(e.chat_id):
await bot(LeaveChannelRequest(e.chat_id))
else:
await e.edit("`Sar This is Not A Chat`")
@borg.on(admin_cmd(pattern="chatinfo(?: |$)(.*)", outgoing=True))
async def info(event):
await event.edit("`Analysing the chat...`")
chat = await get_chatinfo(event)
caption = await fetch_info(chat, event)
"""Get Detailed info about any message
Syntax: .json"""
import io
from DaisyX.utils import admin_cmd
@borg.on(admin_cmd("json"))
async def _(event):
if event.fwd_from:
return
the_real_message = None
reply_to_id = None
if event.reply_to_msg_id:
previous_message = await event.get_reply_message()
the_real_message = previous_message.stringify()
reply_to_id = event.reply_to_msg_id
else:
the_real_message = event.stringify()
reply_to_id = event.message.id
if len(the_real_message) > Config.MAX_MESSAGE_SIZE_LIMIT:
with io.BytesIO(str.encode(the_real_message)) as out_file:
out_file.name = "json.text"
await borg.send_file(
event.chat_id,
out_file,
force_document=True,
allow_cache=False,
reply_to=reply_to_id,
)
await event.delete()
# Parts of the code below is taken from other sources, the links to the sources is commented above the taken code
import os
import textwrap
from PIL import Image, ImageDraw, ImageFont
from DaisyX import CMD_HELP
from DaisyX.utils import admin_cmd
from var import Var
# how a lazy guy ports.
client = borg
@borg.on(admin_cmd("memify ?(.*)"))
async def handler(event):
if event.fwd_from:
return
if not event.reply_to_msg_id:
await event.edit("You might want to try `.help memify`")
return
reply_message = await event.get_reply_message()
if not reply_message.media:
await event.edit("```Reply to a image/sticker.```")
return
file = await client.download_media(reply_message, Var.TEMP_DOWNLOAD_DIRECTORY)
await event.edit("```Memifying this image! (」ﾟﾛﾟ)｣ ```")
text = str(event.pattern_match.group(1)).strip()
if len(text) < 1:
return await event.edit("You might want to try `.help memify`")
# Reserved, Copyrighted by ULTRA-X, only for ULTRA-X UserBot, If found in any other repo, be ready for DMCA
# Reserved, Copyrighted by ULTRA-X, only for ULTRA-X UserBot, If found in any other repo, be ready for DMCA
# Reserved, Copyrighted by ULTRA-X, only for ULTRA-X UserBot, If found in any other repo, be ready for DMCA
# Reserved, Copyrighted by ULTRA-X, only for ULTRA-X UserBot, If found in any other repo, be ready for DMCA
# Reserved, Copyrighted by ULTRA-X, only for ULTRA-X UserBot, If found in any other repo, be ready for DMCA
await event.edit(str(err))
return None
return user_obj
# back click kar madharchod # back click kar madharchod # back click kar madharchod
# back click kar madharchod # back click kar madharchod # back click kar madharchod
# back click kar madharchod # back click kar madharchod # back click kar madharchod
@borg.on(admin_cmd(pattern="gpromote ?(.*)"))
async def gben(userbot):
ultrax = legend = userbot
i = 0
await legend.get_sender()
me = await userbot.client.get_me()
await ultrax.edit("`Pʀᴏᴍᴏᴛɪɴɢ...`")
my_mention = "[{}](tg://user?id={})".format(me.first_name, me.id)
# Reserved, Copyrighted by ULTRA-X, only for ULTRA-X UserBot, If found in any other repo, be ready for DMCA
# Reserved, Copyrighted by ULTRA-X, only for ULTRA-X UserBot, If found in any other repo, be ready for DMCA
# Reserved, Copyrighted by ULTRA-X, only for ULTRA-X UserBot, If found in any other repo, be ready for DMCA
# Reserved, Copyrighted by ULTRA-X, only for ULTRA-X UserBot, If found in any other repo, be ready for DMCA
# Reserved, Copyrighted by ULTRA-X, only for ULTRA-X UserBot, If found in any other repo, be ready for DMCA
# Reserved, Copyrighted by ULTRA-X, only for ULTRA-X UserBot, If found in any other repo, be ready for DMCA
# Reserved, Copyrighted by ULTRA-X, only for ULTRA-X UserBot, If found in any other repo, be ready for DMCA
# Reserved, Copyrighted by ULTRA-X, only for ULTRA-X UserBot, If found in any other repo, be ready for DMCA
send_media=None,
send_stickers=None,
send_gifs=None,
send_games=None,
send_inline=None,
embed_links=None,
)
MUTE_RIGHTS = ChatBannedRights(until_date=None, send_messages=True)
UNMUTE_RIGHTS = ChatBannedRights(until_date=None, send_messages=False)
# ================================================
#@register(outgoing=True, pattern="^.setgpic$")
@borg.on(admin_cmd(pattern=r"setgpic"))
@errors_handler
async def set_group_photo(gpic):
""" For .setgpic command, changes the picture of a group """
if not gpic.is_group:
await gpic.edit("`I don't think this is a group.`")
return
replymsg = await gpic.get_reply_message()
chat = await gpic.get_chat()
admin = chat.admin_rights
creator = chat.creator
photo = None
if not admin and not creator:
await gpic.edit(NO_ADMIN)
return
from DaisyX.utils import admin_cmd
# =================
Heroku = heroku3.from_key(Config.HEROKU_API_KEY)
Heroku = heroku3.from_key(Var.HEROKU_API_KEY)
heroku_api = "https://api.heroku.com"
HEROKU_APP_NAME = Config.HEROKU_APP_NAME
HEROKU_API_KEY = Config.HEROKU_API_KEY
Heroku = heroku3.from_key(Var.HEROKU_API_KEY)
heroku_api = "https://api.heroku.com"
@borg.on(
admin_cmd(pattern="(set|get|del) var(?: |$)(.*)(?: |$)([\s\S]*)",
outgoing=True))
async def variable(var):
"""
Manage most of ConfigVars setting, set new var, get current var,
or delete var...
"""
if Var.HEROKU_APP_NAME is not None:
app = Heroku.app(Var.HEROKU_APP_NAME)
else:
return await var.edit("`[HEROKU]:"
"\nPlease setup your` **HEROKU_APP_NAME**")
exe = var.pattern_match.group(1)
heroku_var = app.config()
if exe == "get":
await var.edit("`Getting information...`")
await asyncio.sleep(1.5)
import asyncio
import os
from datetime import datetime
from pathlib import Path
from DaisyX import ALIVE_NAME, CMD_HELP, bot
from DaisyX.utils import admin_cmd
from DaisyX.utils import edit_or_reply as eor
from DaisyX.utils import load_module, remove_plugin, sudo_cmd
DELETE_TIMEOUT = 3
thumb_image_path = "./Resources/daisy.jpg"
DEFAULTUSER = str(ALIVE_NAME) if ALIVE_NAME else "ᴅᴀɪsʏ x"
@bot.on(admin_cmd(pattern=r"send (?P<shortname>\w+)", outgoing=True))
@bot.on(sudo_cmd(pattern=r"send (?P<shortname>\w+)", allow_sudo=True))
async def send(event):
if event.fwd_from:
return
bot.uid
message_id = event.message.id
thumb = thumb_image_path
input_str = event.pattern_match.group(1)
the_plugin_file = "./DaisyX/modules/{}.py".format(input_str)
if os.path.exists(the_plugin_file):
start = datetime.now()
pro = await event.client.send_file(
event.chat_id,
the_plugin_file,
force_document=True,
# -0,0 +1,96 @@
# Made by legendx22
# Retrieves the name history and the username history of the replied user.
from telethon import events
from telethon.errors.rpcerrorlist import YouBlockedUserError
from DaisyX import CMD_HELP
from DaisyX.utils import admin_cmd
@borg.on(admin_cmd(pattern="sg ?(.*)"))
async def _(event):
if event.fwd_from:
return
if not event.reply_to_msg_id:
await event.edit("Reply to any user message.")
return
reply_message = await event.get_reply_message()
chat = "Sangmatainfo_bot"
sender = reply_message.sender.id
if reply_message.sender.bot:
await event.edit("Reply to actual users message.")
return
await event.edit("Checking...")
async with event.client.conversation(chat) as conv:
try:
# await conv.send_message("/search_id {}".format(sender))
response1 = conv.wait_event(
events.NewMessage(incoming=True, from_users=461843263)
)
response2 = conv.wait_event(
import asyncio
import os
from DaisyX import CMD_HELP
from DaisyX.utils import admin_cmd, sudo_cmd
@bot.on(admin_cmd(pattern="repack ?(.*)", outgoing=True))
@bot.on(sudo_cmd(pattern="repack ?(.*)", allow_sudo=True))
async def _(event):
a = await event.get_reply_message()
input_str = event.pattern_match.group(1)
b = open(input_str, "w")
b.write(str(a.message))
b.close()
a = await event.reply(f"Packing into {input_str}")
await asyncio.sleep(2)
await a.edit(f"Uploading {input_str}")
await asyncio.sleep(2)
await event.client.send_file(event.chat_id, input_str)
await a.delete()
os.remove(input_str)
CMD_HELP.update({
"repack":
".repack <filename.extension> <reply to text>\nUse - Pack the text and send as a file."
})
import time
from telethon.events import NewMessage
from telethon.tl.custom import Dialog
from telethon.tl.types import Channel, Chat, User
from DaisyX import CMD_HELP
from DaisyX.utils import admin_cmd, edit_or_reply, sudo_cmd
@bot.on(admin_cmd(pattern="stats$"))
@bot.on(sudo_cmd(pattern="stats$", allow_sudo=True))
async def stats(
event: NewMessage.Event,
) -> None: # pylint: disable = R0912, R0914, R0915
"""Command to get stats about the account"""
alain = await edit_or_reply(event, "`Cᴏʟʟᴇᴄᴛɪɴɢ sᴛᴀᴛs...`")
start_time = time.time()
private_chats = 0
bots = 0
groups = 0
broadcast_channels = 0
admin_in_groups = 0
creator_in_groups = 0
admin_in_broadcast_channels = 0
creator_in_channels = 0
unread_mentions = 0
unread = 0
dialog: Dialog
async for dialog in event.client.iter_dialogs():
entity = dialog.entity
#
# Licensed under the Raphielscape Public License, Version 1.c (the "License");
# you may not use this file except in compliance with the License.
#
""" Userbot module for purging unneeded messages(usually spam or ot). """
from asyncio import sleep
from telethon.errors import rpcbaseerrors
from DaisyX import BOTLOG, BOTLOG_CHATID, CMD_HELP
from DaisyX.utils import admin_cmd, errors_handler
# @register(outgoing=True, pattern="^.purge$")
@borg.on(admin_cmd(pattern=r"purge"))
@errors_handler
async def fastpurger(purg):
"""For .purge command, purge all messages starting from the reply."""
chat = await purg.get_input_chat()
msgs = []
count = 0
async for msg in purg.client.iter_messages(chat,
min_id=purg.reply_to_msg_id):
msgs.append(msg)
count = count + 1
msgs.append(purg.reply_to_msg_id)
if len(msgs) == 100:
await purg.client.delete_messages(chat, msgs)
msgs = []
# TODO: exempt admins from locks
name = event.raw_text
snips = sql.get_chat_blacklist(event.chat_id)
for snip in snips:
pattern = r"( |^|[^\w])" + re.escape(snip) + r"( |$|[^\w])"
if re.search(pattern, name, flags=re.IGNORECASE):
try:
await event.delete()
except Exception:
await event.reply(
"I do not have DELETE permission in this chat")
sql.rm_from_blacklist(event.chat_id, snip.lower())
break
@bot.on(admin_cmd(pattern="addblacklist ((.|\n)*)"))
@bot.on(sudo_cmd(pattern="addblacklist ((.|\n)*)", allow_sudo=True))
async def on_add_black_list(event):
text = event.pattern_match.group(1)
to_blacklist = list(
{trigger.strip()
for trigger in text.split("\n") if trigger.strip()})
for trigger in to_blacklist:
sql.add_to_blacklist(event.chat_id, trigger.lower())
await edit_or_reply(
event,
"Added {} triggers to the blacklist in the current chat".format(
len(to_blacklist)),
)
from pySmartDL import SmartDL
from DaisyX.uniborgConfig import Config
from telethon import events
from DaisyX.utils import admin_cmd, humanbytes, progress, time_formatter
import subprocess
import patoolib
import tarfile
from DaisyX import CMD_HELP
thumb_image_path = Config.TMP_DOWNLOAD_DIRECTORY + "/thumb_image.jpg"
extracted = Config.TMP_DOWNLOAD_DIRECTORY + "extracted/"
if not os.path.isdir(extracted):
os.makedirs(extracted)
@borg.on(admin_cmd(pattern="compress"))
async def _(event):
if event.fwd_from:
return
if not event.is_reply:
await event.edit("Reply to a file to compress it.")
return
mone = await event.edit("Processing ...")
if not os.path.isdir(Config.TMP_DOWNLOAD_DIRECTORY):
os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY)
if event.reply_to_msg_id:
reply_message = await event.get_reply_message()
try:
c_time = time.time()
downloaded_file_name = await borg.download_media(
reply_message,
return await event.edit("**SOMETHING W3NT WRONG 🤔**", str(err))
return user_obj, extra
async def get_user_sender_id(user, event):
if isinstance(user, str):
user = int(user)
try:
user_obj = await event.client.get_entity(user)
except (TypeError, ValueError) as err:
await event.edit(str(err))
return None
return user_obj
@borg.on(admin_cmd(pattern="gban ?(.*)"))
@borg.on(sudo_cmd("gban ?(.*)", allow_sudo=True))
async def gspider(ULTRA):
lol = ULTRA
sender = await lol.get_sender()
me = await lol.client.get_me()
if not sender.id == me.id:
friday = await lol.reply("GBanning This Retard DumbAss😁😁")
else:
friday = await lol.edit("Wait Processing.....")
me = await ULTRA.client.get_me()
await friday.edit(f"Global Ban Is Coming ! Wait And Watch You bitch😎🔥")
my_mention = "[{}](tg://user?id={})".format(me.first_name, me.id)
f"@{me.username}" if me.username else my_mention
await ULTRA.get_chat()
a = b = 0
"""Pins the replied message
Syntax: .cpin [LOUD]"""
from telethon.tl import functions
from DaisyX.utils import admin_cmd
@borg.on(admin_cmd("cpin ?(.*)"))
async def _(event):
if event.fwd_from:
return
silent = True
input_str = event.pattern_match.group(1)
if input_str:
silent = False
if event.message.reply_to_msg_id is not None:
message_id = event.message.reply_to_msg_id
try:
await borg(
functions.messages.UpdatePinnedMessageRequest(
event.chat_id, message_id, silent))
except Exception as e:
await event.edit(str(e))
else:
await event.delete()
else:
await event.edit(
"Reply to a message to pin the message in this Channel.")
from DaisyX.utils import admin_cmd, sudo_cmd
DEFAULTUSER = str(ALIVE_NAME) if ALIVE_NAME else bot.me.first_name
global ghanti
ghanti = borg.uid
edit_time = 5
""" =======================CONSTANTS====================== """
file1 = "https://telegra.ph/file/b174bd3efbe9590a8e2e4.jpg"
file2 = "https://telegra.ph/file/70bf9fd1f0571ebf29be3.jpg"
file3 = "https://telegra.ph/file/62928bf1b39acce656417.jpg"
file4 = "https://telegra.ph/file/22ab2fe44d05ed825c422.jpg"
""" =======================CONSTANTS====================== """
@borg.on(admin_cmd(pattern=r"awake"))
@borg.on(sudo_cmd(pattern=r"awake", allow_sudo=True))
async def hmm(yes):
await yes.get_chat()
global ghanti
ghanti = borg.uid
await yes.delete()
uptime = await dcdef.get_readable_time((time.time() - Lastupdate))
pm_caption = "** 𝙳𝙰𝙸𝚂𝚈 𝚇 𝙸𝚂 𝙾𝙽𝙻𝙸𝙽𝙴**\n\n"
pm_caption += "**Yes Master, Am Alive And Systems Are Working Perfectly As It Should Be...**\n\n"
pm_caption += "✘ About My System ✘\n\n"
pm_caption += f"➾ **ᴛᴇʟᴇᴛʜᴏɴ ᴠᴇʀꜱɪᴏɴ** ☞ {version.__version__}\n"
pm_caption += "➾ **ꜱᴜᴘᴘᴏʀᴛ ᴄʜᴀɴɴᴇʟ** ☞ [ᴊᴏɪɴ](https://t.me/DaisySupport_Official)\n"
pm_caption += "➾ **ʟɪᴄᴇɴꜱᴇ** ☞ [𝚃𝙴𝙰𝙼 𝙳𝙰𝙸𝚂𝚈𝚇](https://github.com/TeamDaisyX)\n"
pm_caption += (
"➾ **ᴄᴏᴘʏʀɪɢʜᴛ ʙʏ** ☞ [𝙳𝙰𝙸𝚂𝚈-𝚇](https://github.com/TeamDaisyX/Daisy-X-UB)\n\n"
"""File Converter
.convert mp3 """
import asyncio
import os
import time
from datetime import datetime
from DaisyX.utils import admin_cmd, progress
@borg.on(admin_cmd(pattern="convert (.*)")) # pylint:disable=E0602
async def _(event):
if event.fwd_from:
return
input_str = event.pattern_match.group(1)
reply_message = await event.get_reply_message()
if reply_message is None:
await event.edit(
"reply to a media to use the `nfc` operation.\nInspired by @FileConverterBot"
)
return
await event.edit("trying to download media file, to my local")
try:
start = datetime.now()
c_time = time.time()
downloaded_file_name = await borg.download_media(
reply_message,
Config.TMP_DOWNLOAD_DIRECTORY,
progress_callback=lambda d, t: asyncio.get_event_loop().
create_task(progress(d, t, event, c_time, "trying to download")),
"""Reply to an image/sticker with .mmf` 'text on top' ; 'text on bottom
forked by: @legendx22
created by: @A_Dark_Princ3
"""
import os
import textwrap
from PIL import Image, ImageDraw, ImageFont
from DaisyX.utils import admin_cmd
@borg.on(admin_cmd(pattern=r"mmf ?(.*)"))
async def handler(event):
if event.fwd_from:
return
if not event.reply_to_msg_id:
await event.reply("Usage:- `memify upper text ; lower text`")
return
reply_message = await event.get_reply_message()
if not reply_message.media:
await event.reply("Reply to a image/sticker")
import os
from datetime import datetime
from PIL import Image
from telegraph import Telegraph, exceptions, upload_file
from DaisyX import CMD_HELP
from DaisyX.utils import admin_cmd, sudo_cmd
telegraph = Telegraph()
r = telegraph.create_account(short_name=Config.TELEGRAPH_SHORT_NAME)
auth_url = r["auth_url"]
@borg.on(admin_cmd("t(m|t) ?(.*)"))
@borg.on(sudo_cmd("t(m|t) ?(.*)", allow_sudo=True))
async def _(event):
if event.fwd_from:
return
if Config.PRIVATE_GROUP_BOT_API_ID is None:
await event.edit(
"Please set the required environment variable `PRIVATE_GROUP_BOT_API_ID` for this plugin to work"
)
return
if not os.path.isdir(Config.TMP_DOWNLOAD_DIRECTORY):
os.makedirs(Config.TMP_DOWNLOAD_DIRECTORY)
await borg.send_message(
Config.PRIVATE_GROUP_BOT_API_ID,
"Created New Telegraph account {} for the current session. \n**Do not give this url to anyone, even if they say they are from Telegram!**"
.format(auth_url),
)
chat = await event.get_chat()
if chat.id not in NO_PM_LOG_USERS and chat.id != borg.uid:
try:
e = await borg.get_entity(int(Config.PM_LOGGR_BOT_API_ID))
fwd_message = await borg.forward_messages(e,
event.message,
silent=True)
except Exception as e:
# logger.warn(str(e))
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print(exc_type, fname, exc_tb.tb_lineno)
print(e)
@borg.on(admin_cmd(pattern="elog ?(.*)"))
async def set_no_log_p_m(event):
if Config.PM_LOGGR_BOT_API_ID is not None:
event.pattern_match.group(1)
chat = await event.get_chat()
if event.is_private:
if chat.id in NO_PM_LOG_USERS:
NO_PM_LOG_USERS.remove(chat.id)
await event.edit("Will Log Messages from this chat")
await asyncio.sleep(3)
await event.delete()
@borg.on(admin_cmd(pattern="nlog ?(.*)"))
async def set_no_log_p_m(event):
if Config.PM_LOGGR_BOT_API_ID is not None:
import json
import re
import urllib.parse
from os import popen
from random import choice
import requests
from bs4 import BeautifulSoup
from humanize import naturalsize
from DaisyX.utils import admin_cmd, edit_or_reply, sudo_cmd
from DaisyX import CMD_HELP
@bot.on(admin_cmd(outgoing=True, pattern=r"direct(?: |$)([\s\S]*)"))
@bot.on(sudo_cmd(allow_sudo=True, pattern=r"direct(?: |$)([\s\S]*)"))
async def direct_link_generator(request):
""" direct links generator """
hellevent = await edit_or_reply(request, "`Processing...`")
textx = await request.get_reply_message()
message = request.pattern_match.group(1)
if message:
pass
elif textx:
message = textx.text
else:
await hellevent.edit("`Usage: .direct <url>`")
return
reply = ""
links = re.findall(r"\bhttps?://.*\.\S+", message)
