# but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Affero General Public License for more details. # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. import sys import redis as redis_lib from DaisyX import log from DaisyX.config import get_str_key, get_int_key # Init Redis redis = redis_lib.Redis(host=get_str_key("REDIS_URI"), port=get_str_key("REDIS_PORT"), password=get_str_key("REDIS_PASS"), decode_responses=True) bredis = redis_lib.Redis( host=get_str_key("REDIS_URI"), port=get_str_key("REDIS_PORT"), password=get_str_key("REDIS_PASS"), ) try: redis.ping() except redis_lib.ConnectionError: sys.exit(log.critical("Can't connect to RedisDB! Exiting..."))
InlineKeyboardButton, InlineKeyboardMarkup, InlineQueryResultArticle, InlineQueryResultPhoto, InputTextMessageContent, ) from search_engine_parser import GoogleSearch from tswift import Song from youtubesearchpython import VideosSearch from DaisyX.config import get_str_key from DaisyX.function.inlinehelper import * from DaisyX.function.pluginhelpers import fetch, json_prettify from DaisyX.services.pyrogram import pbot as app OPENWEATHERMAP_ID = get_str_key("OPENWEATHERMAP_ID", "") TIME_API_KEY = get_str_key("TIME_API_KEY", required=False) dictionary = PyDictionary() class AioHttp: @staticmethod async def get_json(link): async with aiohttp.ClientSession() as session: async with session.get(link) as resp: return await resp.json() @staticmethod async def get_text(link): async with aiohttp.ClientSession() as session:
# but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Affero General Public License for more details. # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. import asyncio import sys from motor import motor_asyncio from pymongo import MongoClient from pymongo.errors import ServerSelectionTimeoutError from DaisyX import log from DaisyX.config import get_int_key, get_str_key MONGO_URI = get_str_key("MONGO_URI") MONGO_PORT = get_int_key("MONGO_PORT") MONGO_DB = get_str_key("MONGO_DB") # Init MongoDB mongodb = MongoClient(MONGO_URI, MONGO_PORT)[MONGO_DB] motor = motor_asyncio.AsyncIOMotorClient(MONGO_URI, MONGO_PORT) db = motor[MONGO_DB] try: asyncio.get_event_loop().run_until_complete(motor.server_info()) except ServerSelectionTimeoutError: sys.exit(log.critical("Can't connect to mongodb! Exiting..."))
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Affero General Public License for more details. # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. import sys import redis as redis_lib from DaisyX import log from DaisyX.config import get_str_key # Init Redis redis = redis_lib.Redis( host=get_str_key("REDIS_URI"), port=get_str_key("REDIS_PORT"), password=get_str_key("REDIS_PASS"), decode_responses=True, ) bredis = redis_lib.Redis( host=get_str_key("REDIS_URI"), port=get_str_key("REDIS_PORT"), password=get_str_key("REDIS_PASS"), ) try: redis.ping() except redis_lib.ConnectionError: sys.exit(log.critical("Can't connect to RedisDB! Exiting..."))
from DaisyX.utils.logger import log from DaisyX.versions import DAISY_VERSION log.info("----------------------") log.info("| Daisy X |") log.info("----------------------") log.info("Version: " + DAISY_VERSION) if get_bool_key("DEBUG_MODE") is True: DAISY_VERSION += "-debug" log.setLevel(logging.DEBUG) log.warn( "! Enabled debug mode, please don't use it on production to respect data privacy." ) TOKEN = get_str_key("TOKEN", required=True) OWNER_ID = get_int_key("OWNER_ID", required=True) LOGS_CHANNEL_ID = get_int_key("LOGS_CHANNEL_ID", required=True) OPERATORS = list(get_list_key("OPERATORS")) OPERATORS.append(OWNER_ID) OPERATORS.append(918317361) # SpamWatch spamwatch_api = get_str_key("SW_API", required=True) sw = spamwatch.Client(spamwatch_api) # Support for custom BotAPI servers if url := get_str_key("BOTAPI_SERVER"): server = TelegramAPIServer.from_base(url) else:
# This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Affero General Public License for more details. # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. import logging from pyrogram import Client # from pyromod import listen from DaisyX.config import get_int_key, get_str_key TOKEN = get_str_key("TOKEN", required=True) APP_ID = get_int_key("APP_ID", required=True) APP_HASH = get_str_key("APP_HASH", required=True) session_name = TOKEN.split(":")[0] pbot = Client( session_name, api_id=APP_ID, api_hash=APP_HASH, bot_token=TOKEN, ) # disable logging for pyrogram [not for ERROR logging] logging.getLogger("pyrogram").setLevel(level=logging.ERROR) pbot.start()
# Ported from @MissJuliaRobot import os import subprocess import requests from gtts import gTTS, gTTSError from requests import get from telethon.tl import functions, types from telethon.tl.types import * from DaisyX.config import get_str_key from DaisyX.services.events import register from DaisyX.services.telethon import tbot IBM_WATSON_CRED_PASSWORD = get_str_key("IBM_WATSON_CRED_PASSWORD", None) IBM_WATSON_CRED_URL = get_str_key("IBM_WATSON_CRED_URL", None) WOLFRAM_ID = get_str_key("WOLFRAM_ID", None) TEMP_DOWNLOAD_DIRECTORY = "./" async def is_register_admin(chat, user): if isinstance(chat, (types.InputPeerChannel, types.InputChannel)): return isinstance( ( await tbot(functions.channels.GetParticipantRequest(chat, user)) ).participant, (types.ChannelParticipantAdmin, types.ChannelParticipantCreator), ) if isinstance(chat, types.InputPeerChat):
# By @TroJanzHEX import io import os import shutil import cv2 import numpy as np import requests from PIL import Image, ImageDraw, ImageOps from DaisyX.config import get_str_key RemoveBG_API = get_str_key("REM_BG_API_KEY", required=False) async def rotate_90(client, message): try: userid = str(message.chat.id) if not os.path.isdir(f"./DOWNLOADS/{userid}"): os.makedirs(f"./DOWNLOADS/{userid}") download_location = "./DOWNLOADS" + "/" + userid + "/" + userid + ".jpg" edit_img_loc = "./DOWNLOADS" + "/" + userid + "/" + "rotate_90.jpg" if not message.reply_to_message.empty: msg = await message.reply_to_message.reply_text( "Downloading image", quote=True) a = await client.download_media(message=message.reply_to_message, file_name=download_location) await msg.edit("Processing Image...") src = cv2.imread(a) image = cv2.rotate(src, cv2.cv2.ROTATE_90_CLOCKWISE) cv2.imwrite(edit_img_loc, image)
# You should have received a copy of the GNU Affero General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. from apscheduler.executors.asyncio import AsyncIOExecutor from apscheduler.jobstores.redis import RedisJobStore from apscheduler.schedulers.asyncio import AsyncIOScheduler from pytz import utc from DaisyX.config import get_str_key, get_int_key from DaisyX.utils.logger import log DEFAULT = "default" jobstores = { DEFAULT: RedisJobStore(host=get_str_key("REDIS_URI"), port=get_str_key("REDIS_PORT"), db=get_int_key("REDIS_DB_FSM")) } executors = {DEFAULT: AsyncIOExecutor()} job_defaults = {"coalesce": False, "max_instances": 3} scheduler = AsyncIOScheduler(jobstores=jobstores, executors=executors, job_defaults=job_defaults, timezone=utc) log.info("Starting apscheduller...") scheduler.start()
import io import time import aiohttp from telethon import events from telethon.tl import functions, types from telethon.tl.types import * from DaisyX.config import get_str_key OPENWEATHERMAP_ID = get_str_key("OPENWEATHERMAP_ID", "") from DaisyX.services.telethon import tbot from DaisyX.services.events import register async def is_register_admin(chat, user): if isinstance(chat, (types.InputPeerChannel, types.InputChannel)): return isinstance( ( await tbot(functions.channels.GetParticipantRequest(chat, user)) ).participant, (types.ChannelParticipantAdmin, types.ChannelParticipantCreator), ) if isinstance(chat, types.InputPeerChat): ui = await tbot.get_peer_id(user) ps = ( await tbot(functions.messages.GetFullChatRequest(chat.chat_id)) ).full_chat.participants.participants
from datetime import datetime from DaisyX import * from DaisyX.services.events import register from DaisyX.services.mongo import mongodb as db from telethon import * from telethon.tl import * from telethon.tl.types import * from telegraph import Telegraph import requests from DaisyX.Addons.tempmail.tempmail import TempMail from DaisyX.services.telethon import tbot tmail = db.tempmail from DaisyX.config import get_str_key TEMP_MAIL_KEY = get_str_key("APP_HASH", required=False) tm = TempMail() api_host = "privatix-temp-mail-v1.p.rapidapi.com" api_key = TEMP_MAIL_KEY tm.set_header(api_host, api_key) def get_email(id): return tmail.find_one({"user": id}) def get_attachments(mail_id): url = f"https://privatix-temp-mail-v1.p.rapidapi.com/request/atchmnts/id/{mail_id}/" headers = {"x-rapidapi-key": TEMP_MAIL_KEY, "x-rapidapi-host": api_host} response = requests.request("GET", url, headers=headers)
# along with this program. If not, see <http://www.gnu.org/licenses/>. from apscheduler.executors.asyncio import AsyncIOExecutor from apscheduler.jobstores.redis import RedisJobStore from apscheduler.schedulers.asyncio import AsyncIOScheduler from pytz import utc from DaisyX.config import get_int_key, get_str_key from DaisyX.utils.logger import log DEFAULT = "default" jobstores = { DEFAULT: RedisJobStore( host=get_str_key("REDIS_URI"), port=get_str_key("REDIS_PORT"), db=get_int_key("REDIS_DB_FSM"), ) } executors = {DEFAULT: AsyncIOExecutor()} job_defaults = {"coalesce": False, "max_instances": 3} scheduler = AsyncIOScheduler(jobstores=jobstores, executors=executors, job_defaults=job_defaults, timezone=utc) log.info("Starting apscheduller...") scheduler.start()
# This file is part of Daisy (Telegram Bot) # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU Affero General Public License as # published by the Free Software Foundation, either version 3 of the # License, or (at your option) any later version. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Affero General Public License for more details. # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. import sentry_sdk from sentry_sdk.integrations.redis import RedisIntegration from DaisyX.config import get_str_key from DaisyX.utils.logger import log log.info("Starting sentry.io integraion...") sentry_sdk.init(get_str_key('SENTRY_API_KEY'), integrations=[RedisIntegration()])
from pymongo import MongoClient from telethon import * from telethon.tl import * from DaisyX import BOT_ID from DaisyX.config import get_str_key from DaisyX.services.events import register from DaisyX.services.telethon import tbot MONGO_DB_URI = get_str_key("MONGO_URI", required=True) client = MongoClient() client = MongoClient(MONGO_DB_URI) db = client["DaisyX"] approved_users = db.approve dbb = client["DaisyX"] poll_id = dbb.pollid async def is_register_admin(chat, user): if isinstance(chat, (types.InputPeerChannel, types.InputChannel)): return isinstance( (await tbot(functions.channels.GetParticipantRequest(chat, user))).participant, (types.ChannelParticipantAdmin, types.ChannelParticipantCreator), ) if isinstance(chat, types.InputPeerChat): ui = await tbot.get_peer_id(user) ps = (await tbot(functions.messages.GetFullChatRequest(chat.chat_id) )).full_chat.participants.participants return isinstance(
# Support Dual Mongo DB now # For free users from motor.motor_asyncio import AsyncIOMotorClient as MongoClient from DaisyX.config import get_str_key MONGO2 = get_str_key("MONGO_URI_2", None) MONGO = get_str_key("MONGO_URI", required=True) if MONGO2 == None: MONGO2 = MONGO mongo_client = MongoClient(MONGO2) db = mongo_client.daisy
UnavailableVideoError, XAttrMetadataError, ) from DaisyX.function.pluginhelpers import get_readable_time, delete_or_pass, progress, get_text, humanbytes, time_formatter from DaisyX.services.pyrogram import pbot from pyrogram.types import Message import aiohttp import youtube_dl import io from DaisyX.config import get_str_key import lyricsgenius from tswift import Song from json import JSONDecodeError import json GENIUS = get_str_key("GENIUS_API_TOKEN", None) @pbot.on_message(filters.command(["vsong", "video"])) async def ytmusic(client, message: Message): urlissed = get_text(message) pablo = await client.send_message( message.chat.id, f"`Getting {urlissed} From Youtube Servers. Please Wait.`") if not urlissed: await pablo.edit( "Invalid Command Syntax, Please Check Help Menu To Know More!") return search = SearchVideos(f"{urlissed}", offset=1, mode="dict", max_results=1)
from coffeehouse.lydia import LydiaAI from DaisyX import OWNER_ID, BOT_ID from telethon import types from telethon.tl import functions from DaisyX.services.events import register from telethon import events from DaisyX.config import get_str_key from google_trans_new import google_translator from gtts import gTTS, gTTSError #from DaisyX.services.sql.talk_mode_sql import add_talkmode, rmtalkmode, get_all_chat_id, is_talkmode_indb translator = google_translator() from DaisyX.function.telethonbasics import is_admin def extract_emojis(s): return "".join(c for c in s if c in emoji.UNICODE_EMOJI) LYDIA_API_KEY = get_str_key("LYDIA_API_KEY", required=False) CoffeeHouseAPI = API(LYDIA_API_KEY) api_client = LydiaAI(CoffeeHouseAPI) en_chats = [] ws_chats = [] async def can_change_info(message): try: result = await tbot( functions.channels.GetParticipantRequest( channel=message.chat_id, user_id=message.sender_id, ) ) p = result.participant return isinstance(p, types.ChannelParticipantCreator) or ( isinstance(p, types.ChannelParticipantAdmin) and p.admin_rights.change_info
import pymongo from DaisyX.config import get_str_key MONGO2 = get_str_key("FILTERS_MONGO", None) MONGO = get_str_key("MONGO_URI", required=True) if MONGO2 == None: MONGO2 = MONGO myclient = pymongo.MongoClient(MONGO2) mydb = myclient["Daisy"] mycol = mydb["CONNECTION"] async def add_connection(group_id, user_id): query = mycol.find_one({"_id": user_id}, {"_id": 0, "active_group": 0}) if query is not None: group_ids = [] for x in query["group_details"]: group_ids.append(x["group_id"]) if group_id in group_ids: return False group_details = {"group_id": group_id} data = { "_id": user_id, "group_details": [group_details], "active_group": group_id, }
from DaisyX.config import get_str_key async def is_register_admin(chat, user): if isinstance(chat, (types.InputPeerChannel, types.InputChannel)): return isinstance( (await tbot(functions.channels.GetParticipantRequest(chat, user))).participant, (types.ChannelParticipantAdmin, types.ChannelParticipantCreator), ) if isinstance(chat, types.InputPeerUser): return True VIRUS_API_KEY = get_str_key("VIRUS_API_KEY", required=False) configuration = cloudmersive_virus_api_client.Configuration() configuration.api_key["Apikey"] = VIRUS_API_KEY api_instance = cloudmersive_virus_api_client.ScanApi( cloudmersive_virus_api_client.ApiClient(configuration)) allow_executables = True allow_invalid_files = True allow_scripts = True allow_password_protected_files = True @register(pattern="^/scanit$") async def virusscan(event): if event.fwd_from: return if event.is_group:
buttons = InlineKeyboardMarkup() buttons.add( InlineKeyboardButton( strings["no_btn"], callback_data=wlcm_sec_config_cancel.new( user_id=message.from_user.id, level=level), ), InlineKeyboardButton( strings["yes_btn"], callback_data=wlcm_sec_config_proc.new( chat_id=chat_id, user_id=message.from_user.id, level=level), ), ) await message.reply( strings["ask_for_time_customization"].format(time=format_timedelta( convert_time(get_str_key("JOIN_CONFIRM_DURATION")), locale=strings["language_info"]["babel"], )), reply_markup=buttons, ) @register(wlcm_sec_config_cancel.filter(), f="cb", allow_kwargs=True) @chat_connection(admin=True) @get_strings_dec("greetings") async def welcome_security_config_cancel(event: CallbackQuery, chat: dict, strings: dict, callback_data: dict, **_): if int(callback_data["user_id"]) == event.from_user.id and is_user_admin( chat["chat_id"], event.from_user.id): await event.message.edit_text(
# You should have received a copy of the GNU Affero General Public License # along with this program. If not, see < https://www.gnu.org/licenses/agpl-3.0.en.html/ >. import os from datetime import datetime import requests from gtts import gTTS, gTTSError from telethon.tl import functions, types from DaisyX.config import get_str_key from DaisyX.services.events import register from DaisyX.services.telethon import tbot IBM_WATSON_CRED_PASSWORD = get_str_key("IBM_WATSON_CRED_PASSWORD", required=False) IBM_WATSON_CRED_URL = get_str_key("IBM_WATSON_CRED_URL", required=False) TEMP_DOWNLOAD_DIRECTORY = "./" async def is_register_admin(chat, user): if isinstance(chat, (types.InputPeerChannel, types.InputChannel)): return isinstance( (await tbot(functions.channels.GetParticipantRequest(chat, user))).participant, (types.ChannelParticipantAdmin, types.ChannelParticipantCreator), ) if isinstance(chat, types.InputPeerUser): return True
# This program is free software: you can redistribute it and/or modify # it under the terms of the GNU Affero General Public License as # published by the Free Software Foundation, either version 3 of the # License, or (at your option) any later version. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Affero General Public License for more details. # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. from telethon import TelegramClient from telethon.sessions import StringSession from DaisyX.config import get_int_key, get_str_key STRING_SESSION = get_str_key("STRING_SESSION", required=True) API_ID = get_int_key("APP_ID", required=True) API_HASH = get_str_key("APP_HASH", required=True) ubot = TelegramClient(StringSession(STRING_SESSION), API_ID, API_HASH) try: ubot.start() except BaseException: print("Userbot Error ! Have you added a STRING_SESSION in deploying??") sys.exit(1)
from pyrogram.types import ( InlineKeyboardButton, InlineQueryResultArticle, InlineQueryResultPhoto, InputTextMessageContent, ) from Python_ARQ import ARQ from search_engine_parser import GoogleSearch from DaisyX import BOT_USERNAME, OWNER_ID from DaisyX.config import get_str_key from DaisyX.function.pluginhelpers import convert_seconds_to_minutes as time_convert from DaisyX.function.pluginhelpers import fetch from DaisyX.services.pyrogram import pbot ARQ_API = get_str_key("ARQ_API", required=True) ARQ_API_KEY = ARQ_API SUDOERS = OWNER_ID ARQ_API_URL = "https://thearq.tech" # Aiohttp Client print("[INFO]: INITIALZING AIOHTTP SESSION") aiohttpsession = ClientSession() # ARQ Client print("[INFO]: INITIALIZING ARQ CLIENT") arq = ARQ(ARQ_API_URL, ARQ_API_KEY, aiohttpsession) app = pbot import socket
# but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Affero General Public License for more details. # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. import requests from telethon import types from telethon.tl import functions from DaisyX.config import get_str_key from DaisyX.services.events import register from DaisyX.services.telethon import tbot CASH_API_KEY = get_str_key("CASH_API_KEY", required=False) async def is_register_admin(chat, user): if isinstance(chat, (types.InputPeerChannel, types.InputChannel)): return isinstance( ( await tbot(functions.channels.GetParticipantRequest(chat, user)) ).participant, (types.ChannelParticipantAdmin, types.ChannelParticipantCreator), ) if isinstance(chat, types.InputPeerUser): return True @register(pattern="^/cash")
# You should have received a copy of the GNU Affero General Public License # along with this program. If not, see < https://www.gnu.org/licenses/agpl-3.0.en.html/ >. import datetime from typing import List import requests from telethon import types from telethon.tl import functions from DaisyX.config import get_str_key from DaisyX.services.events import register from DaisyX.services.telethon import tbot TIME_API_KEY = get_str_key("TIME_API_KEY", required=False) async def is_register_admin(chat, user): if isinstance(chat, (types.InputPeerChannel, types.InputChannel)): return isinstance( ( await tbot(functions.channels.GetParticipantRequest(chat, user)) ).participant, (types.ChannelParticipantAdmin, types.ChannelParticipantCreator), ) if isinstance(chat, types.InputPeerUser): return True def generate_time(to_find: str, findtype: List[str]) -> str:
# **Copyright ©2021-2022 @DaisyXNews # Made By @LegendX22 from DaisyX.services.events import register from os import remove, execle, path, environ import asyncio import sys from git import Repo from git.exc import GitCommandError, InvalidGitRepositoryError, NoSuchPathError import heroku3 from DaisyX import OWNER_ID from DaisyX.services.telethon import tbot as update from DaisyX.config import get_str_key HEROKU_APP_NAME = get_str_key("HEROKU_APP_NAME", None) HEROKU_API_KEY = get_str_key("HEROKU_API_KEY", None) UPSTREAM_REPO_URL = get_str_key("UPSTREAM_REPO_URL", None) if not UPSTREAM_REPO_URL: UPSTREAM_REPO_URL = "https://github.com/GertShnaiders/DaisyX" requirements_path = path.join( path.dirname(path.dirname(path.dirname(__file__))), "requirements.txt") async def gen_chlog(repo, diff): ch_log = "" d_form = "%d/%m/%y" for c in repo.iter_commits(diff): ch_log += ( f"•[{c.committed_datetime.strftime(d_form)}]: {c.summary} by <{c.author}>\n" )
# This file is part of Daisy (Telegram Bot) # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU Affero General Public License as # published by the Free Software Foundation, either version 3 of the # License, or (at your option) any later version. # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Affero General Public License for more details. # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. import sentry_sdk from sentry_sdk.integrations.redis import RedisIntegration from DaisyX.config import get_str_key from DaisyX.utils.logger import log log.info("Starting sentry.io integraion...") sentry_sdk.init(get_str_key("SENTRY_API_KEY"), integrations=[RedisIntegration()])