Beispiel #1
0
    async def start(self):
        await super().start()
        result = load_cmds(ALL_PLUGINS)
        LOGGER.info(result)

        me = await self.get_me()
        LOGGER.info(f"TelePyroBot based on Pyrogram v{__version__} "
                    f"(Layer {layer}) started...\n"
                    f"Hey {me.first_name}!")
Beispiel #2
0
async def take_screen_shot(
    video_file: str, duration: int, path: str = ""
) -> Optional[str]:
    """take a screenshot."""
    ttl = duration // 2
    thumb_image_path = path or os.path.join(screen_shot, f"{basename(video_file)}.jpg")
    command = f"ffmpeg -ss {ttl} -i '{video_file}' -vframes 1 '{thumb_image_path}'"
    err = (await run_cmd(command))[1]
    if err:
        LOGGER.info(err)
    return thumb_image_path if os.path.exists(thumb_image_path) else None
Beispiel #3
0
async def covid(c: TelePyroBot, m: Message):
    if len(m.text.split()) == 1:
        await m.edit_text("`Enter a directory location`")
    elif len(m.text.split()) >= 2:
        temp_dir = m.text.split(None, 1)[1]
        if not temp_dir.endswith("/"):
            temp_dir += "/"
    sm = await m.reply_text("`Uploading Files to Telegram...`")
    if os.path.exists(temp_dir):
        files = os.listdir(temp_dir)
        files.sort()
        for file in files:
            c_time = time.time()
            required_file_name = temp_dir + file
            thumb_image_path = await is_thumb_image_exists(required_file_name)
            doc_caption = os.path.basename(required_file_name)
            LOGGER.info(
                f"Uploading <i>{required_file_name}</i> from {temp_dir} to Telegram."
            )
            await c.send_document(
                chat_id=m.chat.id,
                document=required_file_name,
                thumb=thumb_image_path,
                caption=doc_caption,
                disable_notification=True,
                progress=progress_for_pyrogram,
                progress_args=(
                    f"Trying to upload __{file}__",
                    sm,
                    c_time,
                ),
            )
    else:
        await sm.edit("Directory Not Found.")
        return
    await sm.delete()
    await m.delete()
    await m.reply_text(f"Uploaded all files from Directory `{temp_dir}`")
    LOGGER.info("Uploaded all files!")
    return
Beispiel #4
0
async def gDrive_upload_file(creds, file_path, message):
    service = build("drive", "v3", credentials=creds, cache_discovery=False)
    mime_type = guess_type(file_path)[0]
    mime_type = mime_type if mime_type else "text/plain"
    media_body = MediaFileUpload(
        file_path,
        mimetype=mime_type,
        chunksize=150 * 1024 * 1024,
        resumable=True)
    file_name = os.path.basename(file_path)
    body = {
        "name": file_name,
        "description": "Uploaded using TelePyroBot gDrive",
        "mimeType": mime_type,
    }
    u_file_obj = service.files().create(body=body, media_body=media_body)
    response = None
    display_message = ""
    while response is None:
        status, response = u_file_obj.next_chunk()
        if status:
            percentage = int(status.progress() * 100)
            progress_str = "[{0}{1}]\nProgress: {2}%\n".format(
                "".join(["●" for i in range(math.floor(percentage / 5))]),
                "".join(["○" for i in range(20 - math.floor(percentage / 5))]),
                round(percentage, 2),
            )
            current_message = (
                f"uploading to gDrive\nFile Name: {file_name}\n{progress_str}"
            )
            if display_message != current_message:
                try:
                    await m.edit_text(current_message)
                    display_message = current_message
                except Exception as e:
                    LOGGER.info(str(e))
                    pass
    file_id = response.get("id")
    return file_id
async def upload_as_document(c: TelePyroBot, m: Message):
    text = m.command[1:]
    if not text:
        await m.edit_text("`Input not found`")
        return
    s_time = 0.1
    typing_symbol = "|"
    old_text = ""
    await m.edit_text(typing_symbol)
    time.sleep(s_time)
    for character in text:
        s_t = s_time / random.randint(1, 100)
        old_text += character
        typing_text = old_text + typing_symbol
        try:
            await m.try_to_edit(typing_text, sudo=False)
            time.sleep(s_t)
            await m.try_to_edit(old_text, sudo=False)
            time.sleep(s_t)
        except FloodWait as ef:
            time.sleep(ef.x)
            LOGGER.info(str(ef))
        return
Beispiel #6
0
async def covid(c: TelePyroBot, m: Message):
    if len(m.text.split()) == 1:
        await m.edit("`Enter a directory location`")
    elif len(m.text.split()) >= 2:
        temp_dir = m.text.split(" ", 1)[1]
        if not temp_dir.endswith("/"):
            temp_dir += "/"
    status_message = await m.reply_text("`Uploading Files...`")
    if os.path.exists(temp_dir):
        files = sorted(os.listdir(temp_dir))
        await status_message.edit("`Uploading Files to Telegram...`")
        for file in files:
            c_time = time.time()
            required_file_name = temp_dir + file
            thumb_image_path = await is_thumb_image_exists(required_file_name)
            doc_caption = os.path.basename(required_file_name)
            LOGGER.info(
                f"Uploading {required_file_name} from {temp_dir} to Telegram.")
            await c.send_document(
                chat_id=m.chat.id,
                document=required_file_name,
                thumb=thumb_image_path,
                caption=doc_caption,
                parse_mode="html",
                disable_notification=True,
                progress=progress_for_pyrogram,
                progress_args=(
                    "Trying to upload multiple files...",
                    status_message,
                    c_time,
                ),
            )
    else:
        await m.edit("Directory Not Found.")
        return
    await status_message.edit(f"Uploaded all files from Directory `{temp_dir}`"
                              )
Beispiel #7
0
 async def stop(self, *args):
     await super().stop()
     LOGGER.info("TelePyroBot stopped. Bye.")
Beispiel #8
0
`{COMMAND_HAND_LER}megafind <filename>`: Find file or folder in mega drive.
`{COMMAND_HAND_LER}megaup <file location>`: Upload the file and export its link.
`{COMMAND_HAND_LER}megaupdir <folder location>`: Upload contents of folder to mega drive.
`{COMMAND_HAND_LER}megaimport <url>`: Download file from mega url to your account.
"""
mega, megaC = None, None


try:
    mega = Mega()
    if MEGANZ_EMAIL and MEGANZ_PASSWORD:
        megaC = mega.login(MEGANZ_EMAIL, MEGANZ_PASSWORD)
    else:
        megaC = mega.login()
except Exception as ef:
    LOGGER.info(ef)


@TelePyroBot.on_message(filters.command("megainfo", COMMAND_HAND_LER) & filters.me)
async def mega_info(c: TelePyroBot, m: Message):
    if (MEGANZ_EMAIL or MEGANZ_PASSWORD) is None:
        await m.edit_text(
            "Setup `MEGANZ_EMAIL` and `MEGANZ_PASSWORD` vars to use this."
        )
        return
    user = megaC.get_user()
    storage = megaC.get_storage_space(giga=True)
    details = (
        "</b>User Details:</b>\n"
        f"Name: {user['name']}\n"
        f"Email: {user['email']}\n"
Beispiel #9
0
async def down_load_media(c: TelePyroBot, m: Message):
    sm = await m.reply_text("...", quote=True)
    if not os.path.isdir(TMP_DOWNLOAD_DIRECTORY):
        os.makedirs(TMP_DOWNLOAD_DIRECTORY)
    if m.reply_to_message is not None:
        start_t = datetime.now()
        download_location = TMP_DOWNLOAD_DIRECTORY
        c_time = time.time()
        the_real_download_location = await c.download_media(
            message=m.reply_to_message,
            file_name=download_location,
            progress=progress_for_pyrogram,
            progress_args=("**__Trying to download...__**", m, c_time),
        )
        end_t = datetime.now()
        ms = (end_t - start_t).seconds
        await sm.edit(
            f"Downloaded to <code>{the_real_download_location}</code> in <u>{ms}</u> seconds",
            parse_mode="html",
        )
        await m.delete()
    elif len(m.command) > 1:
        start_t = datetime.now()
        the_url_parts = " ".join(m.command[1:])
        url = the_url_parts.strip()
        custom_file_name = os.path.basename(url)
        if "|" in the_url_parts:
            url, custom_file_name = the_url_parts.split("|")
            url = url.strip()
            custom_file_name = custom_file_name.strip()
        download_file_path = os.path.join(TMP_DOWNLOAD_DIRECTORY,
                                          custom_file_name)
        downloader = SmartDL(url, download_file_path, progress_bar=False)
        downloader.start(blocking=False)
        c_time = time.time()
        while not downloader.isFinished():
            total_length = downloader.filesize if downloader.filesize else None
            downloaded = downloader.get_dl_size()
            display_message = ""
            now = time.time()
            diff = now - c_time
            percentage = downloader.get_progress() * 100
            speed = downloader.get_speed(human=True)
            elapsed_time = round(diff) * 1000
            progress_str = "**[{0}{1}]**\n**Progress:** __{2}%__".format(
                "".join(["●" for i in range(math.floor(percentage / 5))]),
                "".join(["○" for i in range(20 - math.floor(percentage / 5))]),
                round(percentage, 2),
            )
            estimated_total_time = downloader.get_eta(human=True)
            try:
                current_message = f"__**Trying to download...**__\n"
                current_message += f"**URL:** `{url}`\n"
                current_message += f"**File Name:** `{custom_file_name}`\n"
                current_message += f"{progress_str}\n"
                current_message += (
                    f"__{humanbytes(downloaded)} of {humanbytes(total_length)}__\n"
                )
                current_message += f"**Download Speed** __{speed}__\n"
                current_message += f"**ETA:** __{estimated_total_time}__"
                if round(diff %
                         10.00) == 0 and current_message != display_message:
                    await sm.edit(disable_web_page_preview=True,
                                  text=current_message)
                    display_message = current_message
                    await asyncio.sleep(10)
            except Exception as e:
                LOGGER.info(str(e))
                pass
        if os.path.exists(download_file_path):
            end_t = datetime.now()
            ms = (end_t - start_t).seconds
            await sm.edit(
                f"Downloaded to <code>{download_file_path}</code> in <u>{ms}</u> seconds",
                parse_mode="html",
            )
    else:
        await sm.edit(
            "`Reply to a Telegram Media, to download it to local server.`")
    return
Beispiel #10
0
async def updater(c: TelePyroBot, m: Message):
    if len(m.command) == 2 and m.command[1] == "force":
        force_update = True
    else:
        force_update = False

    umsg = await m.reply_text("`Checking for Update...`")
    if HEROKU_API_KEY is None or HEROKU_APP_NAME is None:
        await umsg.edit(
            "__Please the Vars__ `HEROKU_API_KEY` __and__ `HEROKU_APP_NAME` __properly!__"
        )
        return
    if PRIVATE_GROUP_ID is None:
        await umsg.edit(
            "__**Please Set**__ `PRIVATE_GROUP_ID` **__to use updater!__**")
    try:
        repo = git.Repo()
    except git.exc.InvalidGitRepositoryError as error_one:
        LOGGER.info(str(error_one))
        repo = git.Repo.init()
        origin = repo.create_remote(REPO_REMOTE_NAME, OFFICIAL_UPSTREAM_REPO)
        origin.fetch()
        repo.create_head(IFFUCI_ACTIVE_BRANCH_NAME, origin.refs.master)
        repo.heads.master.checkout(True)

    active_branch_name = repo.active_branch.name
    LOGGER.info(active_branch_name)
    if active_branch_name != IFFUCI_ACTIVE_BRANCH_NAME:
        await umsg.edit(
            IS_SELECTED_DIFFERENT_BRANCH.format(
                branch_name=active_branch_name,
                COMMAND_HAND_LER=COMMAND_HAND_LER))
        return

    try:
        repo.create_remote(REPO_REMOTE_NAME, OFFICIAL_UPSTREAM_REPO)
    except Exception as error_two:
        LOGGER.info(str(error_two))

    temp_remote = repo.remote(REPO_REMOTE_NAME)
    temp_remote.fetch(active_branch_name)

    changelog = generate_change_log(
        repo,
        DIFF_MARKER.format(remote_name=REPO_REMOTE_NAME,
                           branch_name=active_branch_name),
    )
    LOGGER.info(changelog)

    try:
        remote_head_github = repo.head.reference
        commit_id = remote_head_github.commit.hexsha
        commit_link = f"<a href='https://github.com/SkuzzyxD/TelePyroBot/commit/{commit_id}'>{commit_id[:7]}</a>"
    except:
        commit_link = "None"

    message_one = NEW_BOT_UP_DATE_FOUND.format(branch_name=active_branch_name,
                                               changelog=changelog,
                                               commit_link=commit_link)
    message_two = NEW_UP_DATE_FOUND.format(branch_name=active_branch_name)

    if len(message_one) > MAX_MESSAGE_LENGTH:
        with open("change.log", "w+", encoding="utf8") as out_file:
            out_file.write(str(message_one))
            out_file.close()
        await m.reply_document(
            document="change.log",
            caption=message_two,
            disable_notification=True,
            reply_to_message_id=m.message_id,
        )
        os.remove("change.log")

    if not changelog and force_update == False:
        await umsg.edit("`Your userbot is already up-to-date!!`")
        return

    await umsg.edit(message_one, disable_web_page_preview=True)

    if force_update == True:
        await umsg.edit(
            "**Force-Update initiated**\n`Fetching latest version and installing it...`"
        )
        changelog = "#ForceUpdate"

    temp_remote.fetch(active_branch_name)
    repo.git.reset("--hard", "FETCH_HEAD")

    heroku = heroku3.from_key(HEROKU_API_KEY)
    heroku_app = heroku.apps()[HEROKU_APP_NAME]
    heroku_git_url = heroku_app.git_url.replace(
        "https://", f"https://*****:*****@")
    if "heroku" in repo.remotes:
        remote = repo.remote("heroku")
        remote.set_url(heroku_git_url)
    else:
        remote = repo.create_remote("heroku", heroku_git_url)
    await umsg.reply(
        f"**Update Started**\n__**Type**__ `{COMMAND_HAND_LER}alive` **__to check if I'm alive__**\n\n**It would take upto 5 minutes to update!**"
    )
    await c.send_message(
        PRIVATE_GROUP_ID,
        f"#UPDATE\n\n**__TelePyroBot Update__** {commit_link}\n\n**Changelog:**\n{changelog}",
        disable_web_page_preview=True,
    )
    remote.push(refspec=HEROKU_GIT_REF_SPEC, force=True)
    asyncio.get_event_loop().create_task(deploy_start(client))