Exemple #1
0
async def anime_view_more(bot: Amime, callback: CallbackQuery):
    message = callback.message
    user = callback.from_user
    lang = callback._lang

    anime_id = int(callback.matches[0].group(1))
    user_id = int(callback.matches[0].group(2))

    if user_id != user.id:
        return

    async with anilist.AsyncClient() as client:
        anime = await client.get(anime_id, "anime")

        buttons = [
            (lang.description_button,
             f"anime description {anime_id} {user_id} 1"),
            (lang.characters_button, f"anime characters {anime_id} {user_id}"),
            (lang.studios_button, f"anime studios {anime_id} {user_id}"),
        ]

        if hasattr(anime, "trailer"):
            if hasattr(anime.trailer, "url"):
                buttons.append((lang.trailer_button, anime.trailer.url, "url"))

        buttons.append(("🐢 Anilist", anime.url, "url"))

        keyboard = array_chunk(buttons, 2)

        keyboard.append([(lang.back_button, f"anime {anime_id} {user_id}")])

        await message.edit_text(
            lang.view_more_text,
            reply_markup=ikb(keyboard),
        )
Exemple #2
0
async def sudoers_interface(cq):
    lang = cq._lang
    c = cq._client
    text = lang.setting_sudoers_text + "\n"
    buttons = []
    added = []
    for user_id in sudoers:
        try:
            user_obj = await c.get_users(user_id)
        except:
            import traceback
            traceback.print_exc()
            user_obj = None
        id = user_obj.id if user_obj else user_id
        if id in added:
            continue
        added.append(id)

        mention = user_id
        if user_obj:
            mention = f'@{user_obj.username}' if user_obj.username else user_obj.first_name
        text += f"\n👤 {mention}"

        if id not in ['me', user.me.id, cq.from_user.id]:
            buttons.append((f"🗑 {mention}", f'remove_sudoer {user_id}'))

    lines = array_chunk(buttons, 2)
    if bot.me.username:
        lines.append([
            (lang.add_sudoer,
             f"https://t.me/{bot.me.username}?start=add_sudoer", 'url')
        ])
    lines.append([(lang.back, 'settings')])
    keyboard = ikb(lines)
    return text, keyboard
Exemple #3
0
async def request_episodes(bot: Amime, callback: CallbackQuery):
    message = callback.message
    user = callback.from_user
    lang = callback._lang

    anime_id = int(callback.matches[0].group(1))
    language = callback.matches[0].group(2)

    buttons = []
    for code, obj in lang.strings.items():
        text, data = ((f"✅ {obj['LANGUAGE_NAME']}",
                       "noop") if code == language else (
                           obj["LANGUAGE_NAME"],
                           f"request episodes {anime_id} {code}",
                       ))
        buttons.append((text, data))

    keyboard = array_chunk(buttons, 2)

    keyboard.append([
        (lang.confirm_button,
         f"request episodes confirm {anime_id} {language}"),
        (lang.back_button, f"anime {anime_id} {user.id}"),
    ])

    await message.edit_text(
        lang.request_content_text,
        reply_markup=ikb(keyboard),
    )
Exemple #4
0
async def manga_view_more(bot: Amime, callback: CallbackQuery):
    message = callback.message
    user = callback.from_user
    lang = callback._lang

    manga_id = int(callback.matches[0].group(1))
    user_id = int(callback.matches[0].group(2))

    if user_id != user.id:
        return

    async with anilist.AsyncClient() as client:
        manga = await client.get(manga_id, "manga")

        buttons = [
            (lang.description_button,
             f"manga description {manga_id} {user_id} 1"),
            (lang.characters_button, f"manga characters {manga_id} {user_id}"),
            (lang.studios_button, f"manga studios {manga_id} {user_id}"),
        ]

        buttons.append(("🐢 Anilist", manga.url, "url"))

        keyboard = array_chunk(buttons, 2)

        keyboard.append([(lang.back_button, f"manga {manga_id} {user_id}")])

        await message.edit_text(
            lang.view_more_text,
            reply_markup=ikb(keyboard),
        )
Exemple #5
0
async def on_setting_language(c, cq):
    lang = cq._lang
    buttons = []
    for code, obj in lang.strings.items():
        text, data = ((f"✅ {obj['NAME']}",
                       "noop") if obj["LANGUAGE_CODE"] == lang.code else
                      (obj["NAME"], f"set_language {obj['LANGUAGE_CODE']}"))
        buttons.append((text, data))
    lines = array_chunk(buttons, 2)
    lines.append([(lang.back, "settings")])
    keyboard = ikb(lines)
    await cq.edit(lang.choose_language, keyboard)
Exemple #6
0
async def anime_season(bot: Amime, callback: CallbackQuery):
    message = callback.message
    lang = callback._lang

    anime_id = int(callback.matches[0].group(1))
    season = int(callback.matches[0].group(2))
    subtitled = bool(int(callback.matches[0].group(3)))
    language = callback.matches[0].group(4)
    page = int(callback.matches[0].group(5))

    episodes = await Episodes.filter(anime=anime_id,
                                     language=language,
                                     subtitled=subtitled)
    episodes = sorted(episodes, key=lambda episode: episode.number)

    seasons = [0]
    for episode in episodes:
        if episode.season not in seasons:
            seasons.append(episode.season)

    seasons.sort()
    if season not in seasons:
        seasons.append(season)

    keyboard = [
        [(
            lang.add_button,
            f"manage anime {anime_id} {seasons[-1] + 1} {int(subtitled)} {language} 1",
        )],
    ]

    buttons = []
    for _season in seasons:
        text = ("✅" if _season == season else "") + f" {_season}"
        data = (
            "noop" if _season == season else
            f"manage anime season {anime_id} {_season} {int(subtitled)} {language} 1"
        )
        buttons.append((text, data))

    keyboard += array_chunk(buttons, 2)

    keyboard.append([(
        lang.back_button,
        f"manage anime {anime_id} {season} {int(subtitled)} {language} {page}",
    )])

    await message.edit_text(
        lang.season_text,
        reply_markup=ikb(keyboard),
    )
Exemple #7
0
async def on_setting_env(c, cq):
    if cq.message:
        cq.message.chat.cancel_listener()
    lang = cq._lang
    buttons = []
    async for row in Config.all():
        btn = (f'👁‍🗨 {row.key}', f'view_env {row.key}')
        if cq.message and cq.message.from_user.id == bot.me.id:
            btn = (f'📝 {row.key}', f'edit_env {row.key}')
        buttons.append(btn)
    lines = array_chunk(buttons, 2)
    lines.append([(lang.back, 'settings')])
    keyboard = ikb(lines)
    await cq.edit(lang.settings_env_text, keyboard)
Exemple #8
0
async def on_set_language(c, cq):
    lang = cq._lang
    match = cq.matches[0]
    lang = lang.get_language(match["code"])
    await Config.get(key="LANGUAGE").update(value=lang.code)
    os.environ["LANGUAGE"] = lang.code
    buttons = []
    for code, obj in lang.strings.items():
        text, data = ((f"✅ {obj['NAME']}",
                       "noop") if obj["LANGUAGE_CODE"] == lang.code else
                      (obj["NAME"], f"set_language {obj['LANGUAGE_CODE']}"))
        buttons.append((text, data))
    lines = array_chunk(buttons, 2)
    lines.append([(lang.back, "settings")])
    keyboard = ikb(lines)
    await cq.edit(lang.choose_language, keyboard,
                  {"text": lang.language_chosen})
Exemple #9
0
async def episodes_season(bot: Amime, callback: CallbackQuery):
    message = callback.message
    chat = message.chat
    user = callback.from_user
    lang = callback._lang

    anime_id = int(callback.matches[0].group(1))
    season = int(callback.matches[0].group(2))
    page = int(callback.matches[0].group(3))

    user_db = await Users.get(id=user.id)
    language = user_db.language_anime

    episodes = await Episodes.filter(anime=anime_id, language=language)
    episodes = sorted(episodes, key=lambda episode: episode.number)

    seasons = []
    for episode in episodes:
        if episode.season not in seasons:
            seasons.append(episode.season)

    seasons.sort()

    buttons = []
    for _season in seasons:
        text = ("✅" if _season == season else "") + f" {_season}"
        data = ("noop" if _season == season else
                f"episodes season {anime_id} {_season} 1")
        buttons.append((text, data))

    keyboard = array_chunk(buttons, 2)

    keyboard.append([(lang.back_button, f"episodes {anime_id} {season} {page}")
                     ])

    await message.edit_text(
        lang.season_text,
        reply_markup=ikb(keyboard),
    )
Exemple #10
0
async def user_collaborator(bot: Amime, callback: CallbackQuery):
    message = callback.message
    lang = callback._lang

    user = await bot.get_users(callback.matches[0].group(1))

    buttons = []
    for code, obj in lang.strings.items():
        in_language = await Collaborators.get_or_none(user=user.id, language=code)
        text = ("✅ " if in_language is not None else "") + obj["LANGUAGE_NAME"]
        data = f"user collaborator edit {user.id} {code}"
        buttons.append((text, data))

    keyboard = array_chunk(buttons, 2)

    text = f"<b>{user.mention()}</b>"
    text += f"\n{lang.language_text}"

    await message.edit_text(
        text,
        reply_markup=ikb(keyboard),
    )
Exemple #11
0
async def anime_manage(bot: Amime, callback: CallbackQuery):
    message = callback.message
    chat = message.chat
    user = callback.from_user
    lang = callback._lang

    anime_id = int(callback.matches[0].group(1))
    season = int(callback.matches[0].group(2))
    subtitled = bool(int(callback.matches[0].group(3)))
    language = callback.matches[0].group(4)
    page = int(callback.matches[0].group(5))

    if str(user.id) in VIDEOS.keys() and str(anime_id) in VIDEOS[str(
            user.id)].keys():
        chat.cancel_listener()
        del VIDEOS[str(user.id)][str(anime_id)]

    buttons = [
        (
            f"{lang.language_button}: {lang.strings[language]['LANGUAGE_NAME']}",
            f"manage anime language {anime_id} {season} {int(subtitled)} {language} {page}",
        ),
        (
            f"{lang.season_button}: {season}",
            f"manage anime season {anime_id} {season} {int(subtitled)} {language} {page}",
        ),
        (
            f"{lang.subtitled_button}: {lang.yes if subtitled else lang.no}",
            f"manage anime {anime_id} {season} {int(not subtitled)} {language} {page}",
        ),
        (
            lang.add_button,
            f"manage episode {anime_id} {season} -1 {int(subtitled)} {language} {page}",
        ),
    ]

    episodes = await Episodes.filter(anime=anime_id,
                                     season=season,
                                     language=language,
                                     subtitled=subtitled)
    episodes = sorted(episodes, key=lambda episode: episode.number)

    if len(episodes) >= 2:
        buttons.append((
            lang.del_season_button,
            f"manage episode delete {anime_id} {season} -1 {int(subtitled)} {language} {page}",
        ))
    else:
        if page > 0:
            page -= 1
            matches = re.search(
                r"(\d+) (\d+) (\d+) (\w+) (\d+)",
                f"{anime_id} {season} {int(subtitled)} {language} {page}",
            )
            callback.matches = [matches]
            await anime_manage(bot, callback)
            return

    buttons.append((
        lang.add_in_batch_button,
        f"manage episode batch {anime_id} {season} {int(subtitled)} {language} {page}",
    ))

    notifications = await Notifications.filter(
        item=anime_id,
        type="anime",
        language=language,
    )
    if len(notifications) > 0:
        buttons.append((
            lang.notify_users_button,
            f"notify episodes {anime_id} {season} {int(subtitled)} {language} {page}",
        ))

    keyboard = array_chunk(buttons, 2)

    layout = Pagination(
        episodes,
        item_data=lambda i, pg:
        f"manage episode {i.anime} {i.season} {i.number} {int(subtitled)} {language} {pg}",
        item_title=lambda i, pg: f"📝 {i.number}",
        page_data=lambda pg:
        f"manage anime {anime_id} {season} {int(subtitled)} {language} {pg}",
    )

    lines = layout.create(page, lines=5, columns=3)

    if len(lines) > 0:
        keyboard += lines

    keyboard.append([(lang.back_button, f"anime {anime_id}")])

    if bool(message.photo):
        await message.edit_text(
            lang.manage_anime_text,
            reply_markup=ikb(keyboard),
        )
    else:
        await callback.edit_message_media(
            InputMediaPhoto(
                f"https://img.anili.st/media/{anime_id}",
                caption=lang.manage_anime_text,
            ),
            reply_markup=ikb(keyboard),
        )
Exemple #12
0
async def anime_episode(bot: Amime, callback: CallbackQuery):
    message = callback.message
    chat = message.chat
    user = callback.from_user
    lang = callback._lang

    anime_id = int(callback.matches[0].group(1))
    season = int(callback.matches[0].group(2))
    number = int(callback.matches[0].group(3))
    subtitled = bool(int(callback.matches[0].group(4)))
    language = callback.matches[0].group(5)
    page = int(callback.matches[0].group(6))

    if str(user.id) not in EPISODES.keys():
        EPISODES[str(user.id)] = {}
    if str(anime_id) not in EPISODES[str(user.id)].keys():
        EPISODES[str(user.id)][str(anime_id)] = {}

    chat.cancel_listener()

    episode = EPISODES[str(user.id)][str(anime_id)]

    episode_db = await Episodes.get_or_none(
        anime=anime_id,
        season=season,
        number=number,
        language=language,
        subtitled=subtitled,
    )
    if episode_db is not None:
        if not ("id" in episode.keys() and episode["id"] == episode_db.id):
            episode["id"] = episode_db.id
            episode["video"] = episode_db.file_id
            episode["name"] = episode_db.name
            episode["notes"] = episode_db.notes
            episode["duration"] = episode_db.duration
            episode["unified_until"] = episode_db.unified_until

            EPISODES[str(user.id)][str(anime_id)] = episode
    elif number == -1:
        EPISODES[str(user.id)][str(anime_id)] = {}
        episode = EPISODES[str(user.id)][str(anime_id)]

        episodes = await Episodes.filter(
            anime=anime_id,
            season=season,
            language=language,
            subtitled=subtitled,
        )
        episodes = sorted(episodes, key=lambda episode: episode.number)
        if len(episodes) > 0:
            number = episodes[-1].number + 1
        else:
            number = 1

    episode["subtitled"] = subtitled

    async with anilist.AsyncClient() as client:
        anime = await client.get(anime_id, "anime")

        if anime is None:
            return

        logger.debug(
            "%s is editing/adding episode %s of the anime %s (%s)",
            user.first_name,
            number,
            anime_id,
            language,
        )

        text = lang.manage_episode_text
        text += f"\n<b>{anime.title.romaji}</b> (<code>{anime.title.native}</code>)\n"

        buttons = []

        if "name" in episode.keys() and len(episode["name"]) > 0:
            text += f"\n<b>{lang.name}</b>: <code>{episode['name']}</code>"
            buttons.append((
                f"✏️ {lang.name}",
                f"manage episode edit name {anime_id} {season} {number} {int(subtitled)} {language} {page}",
            ))
        else:
            buttons.append((
                f"➕ {lang.name}",
                f"manage episode edit name {anime_id} {season} {number} {int(subtitled)} {language} {page}",
            ))

        if season > 0:
            text += f"\n<b>{lang.season}</b>: <code>{season}</code>"

        if number != -1:
            episode_number = str(number)
            if "unified_until" in episode.keys() and int(
                    episode["unified_until"]) > 0:
                episode_number += f"-{episode['unified_until']}"
            text += f"\n<b>{lang.episode}</b>: <code>{episode_number}</code>"
            buttons.append((
                f"✏️ {lang.episode}",
                f"manage episode edit number {anime_id} {season} {number} {int(subtitled)} {language} {page}",
            ))
        else:
            buttons.append((
                f"➕ {lang.episode}",
                f"manage episode edit number {anime_id} {season} {number} {int(subtitled)} {language} {page}",
            ))

        if "video" in episode.keys():
            buttons.append((
                f"✏️ {lang.video}",
                f"manage episode edit video {anime_id} {season} {number} {int(subtitled)} {language} {page}",
            ))
        else:
            buttons.append((
                f"➕ {lang.video}",
                f"manage episode edit video {anime_id} {season} {number} {int(subtitled)} {language} {page}",
            ))

        if "duration" in episode.keys():
            text += f"\n<b>{lang.duration}</b>: <code>{episode['duration']}m</code>"
            buttons.append((
                f"✏️ {lang.duration}",
                f"manage episode edit duration {anime_id} {season} {number} {int(subtitled)} {language} {page}",
            ))
        else:
            buttons.append((
                f"➕ {lang.duration}",
                f"manage episode edit duration {anime_id} {season} {number} {int(subtitled)} {language} {page}",
            ))

        text += f"\n<b>{lang.language}</b>: <code>{lang.strings[language]['LANGUAGE_NAME']}</code>"

        if "notes" in episode.keys() and len(episode["notes"]) > 0:
            text += f"\n<b>{lang.notes}</b>: <i>{episode['notes']}</i>"
            buttons.append((
                f"✏️ {lang.notes}",
                f"manage episode edit notes {anime_id} {season} {number} {int(subtitled)} {language} {page}",
            ))
        else:
            buttons.append((
                f"➕ {lang.notes}",
                f"manage episode edit notes {anime_id} {season} {number} {int(subtitled)} {language} {page}",
            ))

        keyboard = array_chunk(buttons, 2)

        buttons = []
        if number != -1 and "video" in episode.keys():
            episode["number"] = number
            buttons.append((
                lang.confirm_button,
                f"manage episode save {anime_id} {season} {int(subtitled)} {language} {page}",
            ))

        if "id" in episode.keys():
            buttons.append((
                lang.del_button,
                f"manage episode delete {anime_id} {season} {number} {int(subtitled)} {language} {page}",
            ))

        buttons.append((
            lang.back_button,
            f"manage anime {anime_id} {season} {int(subtitled)} {language} {page}",
        ))

        keyboard += array_chunk(buttons, 2)

        if "video" in episode.keys():
            file_id = False
            if isinstance(episode["video"], str) and len(episode["video"]) > 0:
                file_id = episode["video"]
            elif isinstance(episode["video"], Video):
                file_id = episode["video"].file_id

            if file_id is not False:
                try:
                    await callback.edit_message_media(
                        InputMediaVideo(
                            file_id,
                            caption=text,
                        ),
                        reply_markup=ikb(keyboard),
                    )
                    return
                except BaseException:
                    pass
        await callback.edit_message_media(
            InputMediaPhoto(
                f"https://img.anili.st/media/{anime_id}",
                caption=text,
            ),
            reply_markup=ikb(keyboard),
        )
Exemple #13
0
async def anime_view(bot: Amime, union: Union[CallbackQuery, Message]):
    is_callback = isinstance(union, CallbackQuery)
    message = union.message if is_callback else union
    chat = message.chat
    user = union.from_user
    lang = union._lang

    is_private = await filters.private(bot, message)
    is_collaborator = await filters.collaborator(
        bot, union) or await filters.sudo(bot, union)

    query = union.matches[0].group(1)

    if is_callback:
        user_id = union.matches[0].group(2)
        if user_id is not None:
            user_id = int(user_id)

            if user_id != user.id:
                return

        to_delete = union.matches[0].group(3)
        if bool(to_delete) and not is_private:
            await message.delete()

    if not bool(query):
        return

    async with anilist.AsyncClient() as client:
        if not query.isdecimal():
            results = await client.search(query, "anime", 10)
            if results is None:
                await asyncio.sleep(0.5)
                results = await client.search(query, "anime", 10)

            if results is None:
                return

            if len(results) == 1:
                anime_id = results[0].id
            else:
                keyboard = []
                for result in results:
                    keyboard.append([(result.title.romaji,
                                      f"anime {result.id} {user.id} 1")])
                await message.reply_text(
                    lang.search_results_text(query=query, ),
                    reply_markup=ikb(keyboard),
                )
                return
        else:
            anime_id = int(query)

        anime = await client.get(anime_id, "anime")

        if anime is None:
            return

        user_db = await Users.get(id=user.id)
        language = user_db.language_anime

        episodes = await Episodes.filter(anime=anime.id)
        episodes = sorted(episodes, key=lambda episode: episode.number)
        episodes = [
            *filter(lambda episode: len(episode.file_id) > 0, episodes)
        ]

        text = f"<b>{anime.title.romaji}</b>"
        if hasattr(anime.title, "native"):
            text += f" (<code>{anime.title.native}</code>)"
        text += f"\n\n<b>ID</b>: <code>{anime.id}</code>"
        if hasattr(anime, "score"):
            if hasattr(anime.score, "average"):
                text += f"\n<b>{lang.score}</b>: <code>{anime.score.average}</code>"
        text += f"\n<b>{lang.status}</b>: <code>{anime.status}</code>"
        if hasattr(anime, "genres"):
            text += f"\n<b>{lang.genres}</b>: <code>{', '.join(anime.genres)}</code>"
        if hasattr(anime, "studios"):
            text += f"\n<b>{lang.studios}</b>: <code>{', '.join(anime.studios)}</code>"
        text += f"\n<b>{lang.format}</b>: <code>{anime.format}</code>"
        if hasattr(anime, "duration"):
            text += f"\n<b>{lang.duration}</b>: <code>{anime.duration}m</code>"
        if not anime.format.lower() == "movie" and hasattr(anime, "episodes"):
            text += f"\n<b>{lang.episode}s</b>: <code>{anime.episodes}</code>"
        if not anime.status.lower() == "not_yet_released":
            text += f"\n<b>{lang.start_date}</b>: <code>{anime.start_date.day if hasattr(anime.start_date, 'day') else 0}/{anime.start_date.month if hasattr(anime.start_date, 'month') else 0}/{anime.start_date.year if hasattr(anime.start_date, 'year') else 0}</code>"
        if not anime.status.lower() in ["not_yet_released", "releasing"]:
            text += f"\n<b>{lang.end_date}</b>: <code>{anime.end_date.day if hasattr(anime.end_date, 'day') else 0}/{anime.end_date.month if hasattr(anime.end_date, 'month') else 0}/{anime.end_date.year if hasattr(anime.end_date, 'year') else 0}</code>"

        buttons = [
            (lang.view_more_button, f"anime more {anime.id} {user.id}"),
        ]

        if is_private:
            buttons.append(await get_favorite_button(lang, user, "anime",
                                                     anime.id))

        if len(episodes) > 0:
            if is_private:
                if anime.format.lower() == "movie":
                    buttons.append(
                        (lang.watch_button, f"episode {anime.id} 0 1"))
                else:
                    buttons.append((
                        lang.watch_button,
                        f"episodes {anime.id} {episodes[0].season} 1",
                    ))
            else:
                buttons.append((
                    lang.watch_button,
                    f"https://t.me/{bot.me.username}/?start=anime_{anime.id}",
                    "url",
                ))

        buttons.append(await
                       get_notify_button(lang, user if is_private else chat,
                                         "anime", anime.id))

        if is_private and is_collaborator:
            buttons.append((
                lang.manage_button,
                f"manage anime {anime.id} 0 1 {language} 1",
            ))

        if is_private and not anime.status.lower() == "not_yet_released":
            button = (
                lang.request_content_button,
                f"request episodes {anime.id} {language}",
            )
            if anime.status.lower() == "releasing":
                if hasattr(anime, "next_airing"):
                    next_episode = anime.next_airing.episode
                    if len(episodes) < (next_episode - 1):
                        buttons.append(button)
                else:
                    buttons.append(button)
            elif hasattr(anime, "episodes"):
                if len(episodes) < anime.episodes:
                    buttons.append(button)

        keyboard = array_chunk(buttons, 2)

        photo = f"https://img.anili.st/media/{anime.id}"

        if bool(message.video) and is_callback:
            await union.edit_message_media(
                InputMediaPhoto(
                    photo,
                    caption=text,
                ),
                reply_markup=ikb(keyboard),
            )
        elif bool(message.photo) and not bool(message.via_bot):
            await message.edit_text(
                text,
                reply_markup=ikb(keyboard),
            )
        else:
            await message.reply_photo(
                photo,
                caption=text,
                reply_markup=ikb(keyboard),
            )
Exemple #14
0
async def anime_episodes(bot: Amime, callback: CallbackQuery):
    message = callback.message
    user = callback.from_user
    lang = callback._lang

    anime_id = int(callback.matches[0].group(1))
    season = int(callback.matches[0].group(2))
    page = int(callback.matches[0].group(3))

    user_db = await Users.get(id=user.id)
    language = user_db.language_anime
    subtitled = user_db.subtitled_anime

    buttons = [
        (
            f"{lang.language_button}: {lang.strings[language]['LANGUAGE_NAME']}",
            f"episodes language {anime_id} {season} {language} {page}",
        ),
    ]

    if season > 0:
        buttons.append((
            f"{lang.season_button}: {season}",
            f"episodes season {anime_id} {season} {page}",
        ))

    buttons.append((
        f"{lang.subtitled_button}: {lang.yes if subtitled else lang.no}",
        f"episodes subtitled {anime_id} {season} {page}",
    ))

    keyboard = array_chunk(buttons, 2)

    episodes = await Episodes.filter(anime=anime_id,
                                     season=season,
                                     language=language,
                                     subtitled=subtitled)
    episodes = sorted(episodes, key=lambda episode: episode.number)
    episodes = [*filter(lambda episode: len(episode.file_id) > 0, episodes)]

    for index, episode in enumerate(
            sorted(episodes, key=lambda episode: episode.number,
                   reverse=True)):
        if await Watched.get_or_none(user=user.id,
                                     episode=episode.id) is not None:
            episode = episodes[-index]

            if index == 0:
                break

            if math.ceil(episode.number / (5 * 3)) != page:
                keyboard.append([(
                    f"{lang.next_episode_button}: {lang.episode[0]}{episode.number}",
                    f"episode {anime_id} {episode.season} {episode.number}",
                )])
            break

    episodes_list = []
    for episode in episodes:
        viewed = bool(await Viewed.get_or_none(user=user.id, item=episode.id))
        watched = bool(await Watched.get_or_none(user=user.id,
                                                 episode=episode.id))
        episodes_list.append((episode, viewed, watched))

    layout = Pagination(
        episodes_list,
        item_data=lambda i, pg:
        f"episode {i[0].anime} {i[0].season} {i[0].number}",
        item_title=lambda i, pg: ("✅" if i[2] else "👁️"
                                  if i[1] else "🙈") + f" {i[0].number}" +
        (f"-{i[0].unified_until}" if i[0].unified_until > 0 else ""),
        page_data=lambda pg: f"episodes {anime_id} {season} {pg}",
    )

    lines = layout.create(page, lines=5, columns=3)

    if len(lines) > 0:
        keyboard += lines

    keyboard.append([(lang.back_button, f"anime {anime_id}")])

    await callback.edit_message_media(
        InputMediaPhoto(
            f"https://img.anili.st/media/{anime_id}",
            caption=lang.watch_list_anime_text,
        ),
        reply_markup=ikb(keyboard),
    )
Exemple #15
0
async def report_episode(bot: Amime, callback: CallbackQuery):
    message = callback.message
    user = callback.from_user
    lang = callback._lang

    anime_id = int(callback.matches[0].group(1))
    season = int(callback.matches[0].group(2))
    number = int(callback.matches[0].group(3))
    report_type = int(callback.matches[0].group(4))

    if str(user.id) not in REPORTING.keys():
        REPORTING[str(user.id)] = {}
    if str(anime_id) not in REPORTING[str(user.id)].keys():
        REPORTING[str(user.id)][str(anime_id)] = {}

    reporting = REPORTING[str(user.id)][str(anime_id)]

    buttons = []
    for index, r_type in enumerate(REPORT_TYPES):
        text = ("✅ " if index == report_type else
                "") + lang.strings[lang.code][r_type]
        data = f"report episode {anime_id} {season} {number} {index}"
        buttons.append((text, data))

    text = lang.report_text + "\n"

    if report_type != -1:
        text += f"\n<b>{lang.type}</b>: {lang.strings[lang.code][REPORT_TYPES[report_type]]}"

    if "notes" in reporting.keys():
        text += f"\n\n<b>{lang.notes}</b>: <i>{reporting['notes']}</i>"
        buttons.append((
            f"🗑️ {lang.notes}",
            f"report episode edit notes {anime_id} {season} {number} {report_type}",
        ))
    else:
        buttons.append((
            f"➕ {lang.notes}",
            f"report episode edit notes {anime_id} {season} {number} {report_type}",
        ))

    keyboard = array_chunk(buttons, 2)

    buttons = []

    if (report_type == 3
            and "notes" in reporting.keys()) or (report_type > -1
                                                 and report_type < 3):
        buttons.append((
            lang.confirm_button,
            f"report episode confirm {anime_id} {season} {number} {report_type}",
        ))

    buttons.append((lang.back_button, f"episode {anime_id} {season} {number}"))

    keyboard += array_chunk(buttons, 2)

    await message.edit_text(
        text,
        reply_markup=ikb(keyboard),
    )
Exemple #16
0
async def manga_view(bot: Amime, union: Union[CallbackQuery, Message]):
    is_callback = isinstance(union, CallbackQuery)
    message = union.message if is_callback else union
    chat = message.chat
    user = union.from_user
    lang = union._lang

    is_private = await filters.private(bot, message)

    query = union.matches[0].group(1)

    if is_callback:
        user_id = union.matches[0].group(2)
        if user_id is not None:
            user_id = int(user_id)

            if user_id != user.id:
                return

        is_search = union.matches[0].group(3)
        if bool(is_search) and not is_private:
            await message.delete()

    if not bool(query):
        return

    async with anilist.AsyncClient() as client:
        if not query.isdecimal():
            results = await client.search(query, "manga", 10)
            if results is None:
                await asyncio.sleep(0.5)
                results = await client.search(query, "manga", 10)

            if results is None:
                return

            if len(results) == 1:
                manga_id = results[0].id
            else:
                keyboard = []
                for result in results:
                    keyboard.append([(result.title.romaji,
                                      f"manga {result.id} {user.id} 1")])
                await message.reply_text(
                    lang.search_results_text(query=query, ),
                    reply_markup=ikb(keyboard),
                )
                return
        else:
            manga_id = int(query)

        manga = await client.get(manga_id, "manga")

        if manga is None:
            return

        photo: str = ""
        if hasattr(manga, "banner"):
            photo = manga.banner
        elif hasattr(manga, "cover"):
            if hasattr(manga.cover, "extra_large"):
                photo = manga.cover.extra_large
            elif hasattr(manga.cover, "large"):
                photo = manga.cover.large
            elif hasattr(manga.cover, "medium"):
                photo = manga.cover.medium

        text = f"<b>{manga.title.romaji}</b>"
        if hasattr(manga.title, "native"):
            text += f" (<code>{manga.title.native}</code>)"
        text += f"\n\n<b>ID</b>: <code>{manga.id}</code>"
        if hasattr(manga, "score"):
            if hasattr(manga.score, "average"):
                text += f"\n<b>{lang.score}</b>: <code>{manga.score.average}</code>"
        text += f"\n<b>{lang.status}</b>: <code>{manga.status}</code>"
        if hasattr(manga, "genres"):
            text += f"\n<b>{lang.genres}</b>: <code>{', '.join(manga.genres)}</code>"
        if hasattr(manga, "volumes"):
            text += f"\n<b>{lang.volume}s</b>: <code>{manga.volumes}</code>"
        if hasattr(manga, "chapters"):
            text += f"\n<b>{lang.chapter}s</b>: <code>{manga.chapters}</code>"
        if not manga.status.lower() == "not_yet_released":
            text += f"\n<b>{lang.start_date}</b>: <code>{manga.start_date.day if hasattr(manga.start_date, 'day') else 0}/{manga.start_date.month if hasattr(manga.start_date, 'month') else 0}/{manga.start_date.year if hasattr(manga.start_date, 'year') else 0}</code>"
        if not manga.status.lower() in ["not_yet_released", "releasing"]:
            text += f"\n<b>{lang.end_date}</b>: <code>{manga.end_date.day if hasattr(manga.end_date, 'day') else 0}/{manga.end_date.month if hasattr(manga.end_date, 'month') else 0}/{manga.end_date.year if hasattr(manga.end_date, 'year') else 0}</code>"

        buttons = [
            (lang.view_more_button, f"manga more {manga.id} {user.id}"),
        ]

        if is_private:
            buttons.append(await get_favorite_button(lang, user, "manga",
                                                     manga.id))

        buttons.append(await
                       get_notify_button(lang, user if is_private else chat,
                                         "manga", manga.id))

        keyboard = array_chunk(buttons, 2)

        if bool(message.photo) and not bool(message.via_bot):
            await message.edit_text(
                text,
                reply_markup=ikb(keyboard),
            )
        else:
            await message.reply_photo(
                photo,
                caption=text,
                reply_markup=ikb(keyboard),
            )