drag

.github/workflows/codeflix

@@ -0,0 +1 @@
+

.github/workflows/dev_deploy.yml

@@ -0,0 +1,35 @@
+name: DevDeploy
+
+# Controls when the workflow will run
+on:
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+
+# A workflow run is made up of one or more jobs that can run sequentially or in parallel
+jobs:
+  DevDeploy:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    
+    - name: Set up ssh-agent
+      uses: appleboy/ssh-action@v0.1.6
+      with:
+        host: ${{ secrets.HOST }}
+        username: ${{ secrets.USERNAME }}
+        key: ${{ secrets.PRIVATE_KEY }}
+        passphrase: ${{ secrets.PASSPHRASE }}
+        script_stop: true
+        script: |
+          cd manga-bot/tg-manga-bot-dev
+          git pull origin master
+          docker container rm -f manga-bot-dev 2> /dev/null || true
+          docker build . -t manga-bot-dev
+          docker run --name manga-bot-dev --restart=always -dti \
+          --env BOT_TOKEN=${{ secrets.DEV_BOT_TOKEN }} \
+          --env API_ID=${{ secrets.API_ID }} \
+          --env API_HASH=${{ secrets.API_HASH }} \
+          --env DATABASE_URL_PRIMARY=${{ secrets.DEV_DATABASE_URI }} \
+          --env LOG_LEVEL=${{ secrets.DEV_LOG_LEVEL }} \
+          manga-bot-dev 

.github/workflows/prod_deploy.yml

@@ -0,0 +1,39 @@
+name: ProdDeploy
+
+# Controls when the workflow will run
+on:
+  # Allows you to run this workflow manually from the Actions tab
+  push:
+    branches: [ "prod" ]
+  workflow_dispatch:
+
+
+# A workflow run is made up of one or more jobs that can run sequentially or in parallel
+jobs:
+  ProdDeploy:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    
+    - name: Set up ssh-agent
+      uses: appleboy/ssh-action@v0.1.6
+      with:
+        host: ${{ secrets.HOST }}
+        username: ${{ secrets.USERNAME }}
+        key: ${{ secrets.PRIVATE_KEY }}
+        passphrase: ${{ secrets.PASSPHRASE }}
+        script_stop: true
+        script: |
+          cd manga-bot/tg-manga-bot-prod
+          git pull origin prod
+          docker container rm -f manga-bot-prod 2> /dev/null || true
+          docker build . -t manga-bot-prod
+          docker run --name manga-bot-prod --restart=always -dti \
+          --env BOT_TOKEN=${{ secrets.PROD_BOT_TOKEN }} \
+          --env API_ID=${{ secrets.API_ID }} \
+          --env API_HASH=${{ secrets.API_HASH }} \
+          --env CHANNEL=${{ secrets.PROD_CHANNEL }} \
+          --env CACHE_CHANNEL=${{ secrets.CACHE_CHANNEL }} \
+          --env DATABASE_URL_PRIMARY=${{ secrets.PROD_DATABASE_URI }} \
+          --env LOG_LEVEL=${{ secrets.PROD_LOG_LEVEL }} \
+          manga-bot-prod 

.gitignore

@@ -0,0 +1,16 @@
+## Cache
+__pycache__/
+
+##PyCharm
+.idea/
+.vscode
+
+.env
+cache
+bot.session
+bot.session-journal
+/test.db
+
+venv
+.venv
+env.json

Dockerfile

@@ -0,0 +1,21 @@
+# For more information, please refer to https://aka.ms/vscode-docker-python
+FROM python
+
+# Keeps Python from generating .pyc files in the container
+ENV PYTHONDONTWRITEBYTECODE=1
+
+# Turns off buffering for easier container logging
+ENV PYTHONUNBUFFERED=1
+
+WORKDIR /app
+
+# Install pip requirements
+COPY requirements.txt .
+RUN python -m pip install --no-cache-dir -r requirements.txt
+
+COPY . /app
+
+RUN alembic upgrade head
+
+# During debugging, this entry point will be overridden. For more information, please refer to https://aka.ms/vscode-docker-python-debug
+CMD ["bash", "start.sh"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 𝖢𝗈𝖽𝖾𝖿𝗅𝗂𝗑 𝖡𝗈𝗍𝗌
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Procfile

@@ -0,0 +1 @@
+worker: python main.py

alembic.ini

@@ -0,0 +1,110 @@
+# A generic, single database configuration.
+
+[alembic]
+# path to migration scripts
+script_location = alembic
+
+# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
+# Uncomment the line below if you want the files to be prepended with date and time
+# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file
+# for all available tokens
+# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
+
+# sys.path path, will be prepended to sys.path if present.
+# defaults to the current working directory.
+prepend_sys_path = .
+
+# timezone to use when rendering the date within the migration file
+# as well as the filename.
+# If specified, requires the python-dateutil library that can be
+# installed by adding `alembic[tz]` to the pip requirements
+# string value is passed to dateutil.tz.gettz()
+# leave blank for localtime
+# timezone =
+
+# max length of characters to apply to the
+# "slug" field
+# truncate_slug_length = 40
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+# set to 'true' to allow .pyc and .pyo files without
+# a source .py file to be detected as revisions in the
+# versions/ directory
+# sourceless = false
+
+# version location specification; This defaults
+# to alembic/versions.  When using multiple version
+# directories, initial revisions must be specified with --version-path.
+# The path separator used here should be the separator specified by "version_path_separator" below.
+# version_locations = %(here)s/bar:%(here)s/bat:alembic/versions
+
+# version path separator; As mentioned above, this is the character used to split
+# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep.
+# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas.
+# Valid values for version_path_separator are:
+#
+# version_path_separator = :
+# version_path_separator = ;
+# version_path_separator = space
+version_path_separator = os  # Use os.pathsep. Default configuration used for new projects.
+
+# set to 'true' to search source files recursively
+# in each "version_locations" directory
+# new in Alembic version 1.10
+# recursive_version_locations = false
+
+# the output encoding used when revision files
+# are written from script.py.mako
+# output_encoding = utf-8
+
+sqlalchemy.url = driver://user:pass@localhost/dbname
+
+
+[post_write_hooks]
+# post_write_hooks defines scripts or Python functions that are run
+# on newly generated revision scripts.  See the documentation for further
+# detail and examples
+
+# format using "black" - use the console_scripts runner, against the "black" entrypoint
+# hooks = black
+# black.type = console_scripts
+# black.entrypoint = black
+# black.options = -l 79 REVISION_SCRIPT_FILENAME
+
+# Logging configuration
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

alembic/README

@@ -0,0 +1 @@
+Generic single-database configuration.

alembic/codeflix

@@ -0,0 +1 @@
+

alembic/env.py

@@ -0,0 +1,83 @@
+from logging.config import fileConfig
+
+from sqlalchemy import engine_from_config
+from sqlalchemy import pool
+
+from alembic import context
+from sqlmodel import SQLModel
+
+from config import dbname
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+config.set_main_option('sqlalchemy.url', dbname)
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+# from myapp import mymodel
+# target_metadata = mymodel.Base.metadata
+from models.db import *
+target_metadata = SQLModel.metadata
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section, {}),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(
+            connection=connection, target_metadata=target_metadata
+        )
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

alembic/script.py.mako

@@ -0,0 +1,25 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision = ${repr(up_revision)}
+down_revision = ${repr(down_revision)}
+branch_labels = ${repr(branch_labels)}
+depends_on = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    ${downgrades if downgrades else "pass"}

alembic/versions/1ad8012fafa0_first_migration.py

@@ -0,0 +1,74 @@
+"""first migration
+
+Revision ID: 1ad8012fafa0
+Revises: 
+Create Date: 2023-05-21 14:48:52.387894
+
+"""
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel
+from sqlalchemy.engine import Inspector
+
+# revision identifiers, used by Alembic.
+revision = '1ad8012fafa0'
+down_revision = None
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    conn = op.get_bind()
+    inspector = Inspector.from_engine(conn)
+    tables = inspector.get_table_names()
+
+    if 'chapterfile' not in tables:
+        op.create_table('chapterfile',
+                        sa.Column('url', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+                        sa.Column('file_id', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+                        sa.Column('file_unique_id', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+                        sa.Column('cbz_id', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+                        sa.Column('cbz_unique_id', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+                        sa.Column('telegraph_url', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+                        sa.PrimaryKeyConstraint('url')
+                        )
+
+    if 'lastchapter' not in tables:
+        op.create_table('lastchapter',
+                        sa.Column('url', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+                        sa.Column('chapter_url', sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+                        sa.PrimaryKeyConstraint('url')
+                        )
+
+    if 'manganame' not in tables:
+        op.create_table('manganame',
+                        sa.Column('url', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+                        sa.Column('name', sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+                        sa.PrimaryKeyConstraint('url')
+                        )
+
+    if 'mangaoutput' not in tables:
+        op.create_table('mangaoutput',
+                        sa.Column('user_id', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+                        sa.Column('output', sa.Integer(), nullable=True),
+                        sa.PrimaryKeyConstraint('user_id')
+                        )
+
+    if 'subscription' not in tables:
+        op.create_table('subscription',
+                        sa.Column('url', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+                        sa.Column('user_id', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+                        sa.PrimaryKeyConstraint('url', 'user_id')
+                        )
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table('subscription')
+    op.drop_table('mangaoutput')
+    op.drop_table('manganame')
+    op.drop_table('lastchapter')
+    op.drop_table('chapterfile')
+    # ### end Alembic commands ###

alembic/versions/71bd610aaa43_make_chapterfile_ids_optional.py

@@ -0,0 +1,84 @@
+"""Make chapterFile ids optional
+
+Revision ID: 71bd610aaa43
+Revises: 1ad8012fafa0
+Create Date: 2023-05-28 14:30:33.114680
+
+"""
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel
+
+# revision identifiers, used by Alembic.
+revision = '71bd610aaa43'
+down_revision = '1ad8012fafa0'
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    if op.get_bind().dialect.name == 'sqlite':
+        op.create_table('chapterfile_temp',
+                        sa.Column('url', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+                        sa.Column('file_id', sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+                        sa.Column('file_unique_id', sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+                        sa.Column('cbz_id', sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+                        sa.Column('cbz_unique_id', sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+                        sa.Column('telegraph_url', sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+                        sa.PrimaryKeyConstraint('url')
+                        )
+        op.execute('INSERT INTO chapterfile_temp SELECT * FROM chapterfile')
+        op.drop_table('chapterfile')
+        op.rename_table('chapterfile_temp', 'chapterfile')
+    else:
+        op.alter_column('chapterfile', 'file_id',
+                        existing_type=sa.VARCHAR(),
+                        nullable=True)
+        op.alter_column('chapterfile', 'file_unique_id',
+                        existing_type=sa.VARCHAR(),
+                        nullable=True)
+        op.alter_column('chapterfile', 'cbz_id',
+                        existing_type=sa.VARCHAR(),
+                        nullable=True)
+        op.alter_column('chapterfile', 'cbz_unique_id',
+                        existing_type=sa.VARCHAR(),
+                        nullable=True)
+        op.alter_column('chapterfile', 'telegraph_url',
+                        existing_type=sa.VARCHAR(),
+                        nullable=True)
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    if op.get_bind().dialect.name == 'sqlite':
+        op.create_table('chapterfile_temp',
+                        sa.Column('url', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+                        sa.Column('file_id', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+                        sa.Column('file_unique_id', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+                        sa.Column('cbz_id', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+                        sa.Column('cbz_unique_id', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+                        sa.Column('telegraph_url', sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+                        sa.PrimaryKeyConstraint('url')
+                        )
+        op.execute('INSERT INTO chapterfile_temp SELECT * FROM chapterfile')
+        op.drop_table('chapterfile')
+        op.rename_table('chapterfile_temp', 'chapterfile')
+    else:
+        op.alter_column('chapterfile', 'telegraph_url',
+                        existing_type=sa.VARCHAR(),
+                        nullable=False)
+        op.alter_column('chapterfile', 'cbz_unique_id',
+                        existing_type=sa.VARCHAR(),
+                        nullable=False)
+        op.alter_column('chapterfile', 'cbz_id',
+                        existing_type=sa.VARCHAR(),
+                        nullable=False)
+        op.alter_column('chapterfile', 'file_unique_id',
+                        existing_type=sa.VARCHAR(),
+                        nullable=False)
+        op.alter_column('chapterfile', 'file_id',
+                        existing_type=sa.VARCHAR(),
+                        nullable=False)
+    # ### end Alembic commands ###

alembic/versions/c

@@ -0,0 +1 @@
+

app.json

@@ -0,0 +1,50 @@
+{
+    "name": "TG-MANGA-BOT",
+    "description": "Read manga from your favourites websites on telegram.",
+    "keywords": [
+        "manga",
+        "pyrogram",
+        "pdf",
+        "telegram",
+        "bot"
+    ],
+    "stack": "container",
+    "repository": "https://github.com/driverog/tg-manga-bot",
+    "success_url": "/welcome",
+    "env": {
+        "API_ID": {
+            "description": "Get this value from https://my.telegram.org/apps",
+            "value": "",
+            "required": true
+        },
+        "API_HASH": {
+            "description": "Get this value from https://my.telegram.org/apps",
+            "value": "",
+            "required": true
+        },
+        "BOT_TOKEN": {
+            "description": "Get this value from @BotFather in telegram",
+            "required": true
+        },
+        "CHANNEL": {
+            "description": "Channel that users must be subscribed in order to use the bot.",
+            "required": false
+        },
+        "DATABASE_URL_PRIMARY": {
+            "description": "Will be used as database url. If not given heroku database will be used instead.",
+            "required": false
+        }
+    },
+    "formation": {
+        "worker": {
+            "quantity": 1,
+            "size": "free"
+        }
+        },
+    "image": "heroku/python",
+    "addons": [
+        {
+        "plan": "heroku-postgresql"
+        }
+    ]
+}

bot.py

@@ -0,0 +1,712 @@
+import enum
+import shutil
+from ast import arg
+import asyncio
+import re
+from dataclasses import dataclass
+import datetime as dt
+import json
+
+import pyrogram.errors
+from pyrogram.types import Message, InlineKeyboardMarkup, InlineKeyboardButton, CallbackQuery, InputMediaDocument
+
+from config import env_vars, dbname
+from img2cbz.core import fld2cbz
+from img2pdf.core import fld2pdf, fld2thumb
+from img2tph.core import img2tph
+from plugins import MangaClient, ManhuaKoClient, MangaCard, MangaChapter, ManhuaPlusClient, TMOClient, MangaDexClient, \
+    MangaSeeClient, MangasInClient, McReaderClient, MangaKakalotClient, ManganeloClient, ManganatoClient, \
+    KissMangaClient, MangatigreClient, MangaHasuClient, MangaBuddyClient, AsuraScansClient, NineMangaClient, Manhwa18Client
+import os
+
+from pyrogram import Client, filters
+from typing import Dict, Tuple, List, TypedDict
+from loguru import logger
+
+from models.db import DB, ChapterFile, Subscription, LastChapter, MangaName, MangaOutput
+from pagination import Pagination
+from plugins.client import clean
+from tools.aqueue import AQueue
+from tools.flood import retry_on_flood
+
+mangas: Dict[str, MangaCard] = dict()
+chapters: Dict[str, MangaChapter] = dict()
+pdfs: Dict[str, str] = dict()
+paginations: Dict[int, Pagination] = dict()
+queries: Dict[str, Tuple[MangaClient, str]] = dict()
+full_pages: Dict[str, List[str]] = dict()
+favourites: Dict[str, MangaCard] = dict()
+language_query: Dict[str, Tuple[str, str]] = dict()
+users_in_channel: Dict[int, dt.datetime] = dict()
+locks: Dict[int, asyncio.Lock] = dict()
+
+plugin_dicts: Dict[str, Dict[str, MangaClient]] = {
+    "🇬🇧 EN": {
+        "MangaDex": MangaDexClient(),
+        "Manhuaplus": ManhuaPlusClient(),
+        "Mangasee": MangaSeeClient(),
+        "McReader": McReaderClient(),
+        "MagaKakalot": MangaKakalotClient(),
+        "Manganelo": ManganeloClient(),
+        "Manganato": ManganatoClient(),
+        "KissManga": KissMangaClient(),
+        "MangaHasu": MangaHasuClient(),
+        "MangaBuddy": MangaBuddyClient(),
+        "AsuraScans": AsuraScansClient(),
+        "NineManga": NineMangaClient(),
+        "Manhwa18": Manhwa18Client(),
+    },
+    "🇪🇸 ES": {
+        "MangaDex": MangaDexClient(language=("es-la", "es")),
+        "ManhuaKo": ManhuaKoClient(),
+        "TMO": TMOClient(),
+        "Mangatigre": MangatigreClient(),
+        "NineManga": NineMangaClient(language='es'),
+        "MangasIn": MangasInClient(),
+    }
+}
+
+cache_dir = "cache"
+if os.path.exists(cache_dir):
+    shutil.rmtree(cache_dir)
+with open("tools/help_message.txt", "r") as f:
+    help_msg = f.read()
+
+
+class OutputOptions(enum.IntEnum):
+    PDF = 1
+    CBZ = 2
+    Telegraph = 4
+
+    def __and__(self, other):
+        return self.value & other
+
+    def __xor__(self, other):
+        return self.value ^ other
+
+    def __or__(self, other):
+        return self.value | other
+
+
+disabled = ["[🇬🇧 EN] McReader", "[🇬🇧 EN] Manhuaplus", "[🇪🇸 ES] MangasIn"]
+
+plugins = dict()
+for lang, plugin_dict in plugin_dicts.items():
+    for name, plugin in plugin_dict.items():
+        identifier = f'[{lang}] {name}'
+        if identifier in disabled:
+            continue
+        plugins[identifier] = plugin
+
+# subsPaused = ["[🇪🇸 ES] TMO"]
+subsPaused = disabled + []
+
+
+def split_list(li):
+    return [li[x: x + 2] for x in range(0, len(li), 2)]
+
+
+def get_buttons_for_options(user_options: int):
+    buttons = []
+    for option in OutputOptions:
+        checked = "✅" if option & user_options else "❌"
+        text = f'{checked} {option.name}'
+        buttons.append([InlineKeyboardButton(text, f"options_{option.value}")])
+    return InlineKeyboardMarkup(buttons)
+
+
+bot = Client('bot',
+             api_id=int(env_vars.get('API_ID')),
+             api_hash=env_vars.get('API_HASH'),
+             bot_token=env_vars.get('BOT_TOKEN'),
+             max_concurrent_transmissions=3)
+
+pdf_queue = AQueue()
+
+if dbname:
+    DB(dbname)
+else:
+    DB()
+
+
+@bot.on_message(filters=~(filters.private & filters.incoming))
+async def on_chat_or_channel_message(client: Client, message: Message):
+    pass
+
+
+@bot.on_message()
+async def on_private_message(client: Client, message: Message):
+    channel = env_vars.get('CHANNEL')
+    if not channel:
+        return message.continue_propagation()
+    if in_channel_cached := users_in_channel.get(message.from_user.id):
+        if dt.datetime.now() - in_channel_cached < dt.timedelta(days=1):
+            return message.continue_propagation()
+    try:
+        if await client.get_chat_member(channel, message.from_user.id):
+            users_in_channel[message.from_user.id] = dt.datetime.now()
+            return message.continue_propagation()
+    except pyrogram.errors.UsernameNotOccupied:
+        logger.debug("Channel does not exist, therefore bot will continue to operate normally")
+        return message.continue_propagation()
+    except pyrogram.errors.ChatAdminRequired:
+        logger.debug("Bot is not admin of the channel, therefore bot will continue to operate normally")
+        return message.continue_propagation()
+    except pyrogram.errors.UserNotParticipant:
+        await message.reply("In order to use the bot you must join it's update channel.",
+                            reply_markup=InlineKeyboardMarkup(
+                                [[InlineKeyboardButton('ᴊᴏɪɴ ᴄʜᴀɴɴᴇʟ!', url=f't.me/{channel}')]]
+                            ))
+    except pyrogram.ContinuePropagation:
+        raise
+    except pyrogram.StopPropagation:
+        raise
+    except BaseException as e:
+        logger.exception(e)
+
+
+@bot.on_message(filters=filters.command(['start']))
+async def on_start(client: Client, message: Message):
+    logger.info(f"User {message.from_user.id} started the bot")
+    await message.reply("›› **__Welcome to the best manga pdf bot in telegram!!\n"
+                        "\n"
+                        "How to use? Just type the name of some manga you want to keep up to date.\n"
+                        "\n"
+                        "For example:\n"
+                        "`Fire Force`\n"
+                        "\n"
+                        "Check /help for more information.__**")
+    logger.info(f"User {message.from_user.id} finished the start command")
+
+
+@bot.on_message(filters=filters.command(['help']))
+async def on_help(client: Client, message: Message):
+    await message.reply(help_msg)
+
+
+@bot.on_message(filters=filters.command(['queue']))
+async def on_help(client: Client, message: Message):
+    await message.reply(f'Queue size: {pdf_queue.qsize()}')
+
+
+@bot.on_message(filters=filters.command(['refresh']))
+async def on_refresh(client: Client, message: Message):
+    text = message.reply_to_message.text or message.reply_to_message.caption
+    if text:
+        regex = re.compile(r'\[Read on telegraph]\((.*)\)')
+        match = regex.search(text.markdown)
+    else:
+        match = None
+    document = message.reply_to_message.document
+    if not (message.reply_to_message and message.reply_to_message.outgoing and
+            ((document and document.file_name[-4:].lower() in ['.pdf', '.cbz']) or match)):
+        return await message.reply("This command only works when it replies to a manga file that bot sent to you")
+    db = DB()
+    if document:
+        chapter = await db.get_chapter_file_by_id(document.file_unique_id)
+    else:
+        chapter = await db.get_chapter_file_by_id(match.group(1))
+    if not chapter:
+        return await message.reply("This file was already refreshed")
+    await db.erase(chapter)
+    return await message.reply("File refreshed successfully!")
+
+
+@bot.on_message(filters=filters.command(['subs']))
+async def on_subs(client: Client, message: Message):
+    db = DB()
+
+    filter_ = message.text.split(maxsplit=1)[1] if message.text.split(maxsplit=1)[1:] else ''
+    filter_list = [filter_.strip() for filter_ in filter_.split(' ') if filter_.strip()]
+
+    subs = await db.get_subs(str(message.from_user.id), filter_list)
+
+    lines = []
+    for sub in subs[:10]:
+        lines.append(f'<a href="{sub.url}">{sub.name}</a>')
+        lines.append(f'`/cancel {sub.url}`')
+        lines.append('')
+
+    if not lines:
+        if filter_:
+            return await message.reply("You have no subscriptions with that filter.")
+        return await message.reply("You have no subscriptions yet.")
+
+    text = "\n".join(lines)
+    await message.reply(f'Your subscriptions:\n\n{text}\nTo see more subscriptions use `/subs filter`', disable_web_page_preview=True)
+
+
+@bot.on_message(filters=filters.regex(r'^/cancel ([^ ]+)$'))
+async def on_cancel_command(client: Client, message: Message):
+    db = DB()
+    sub = await db.get(Subscription, (message.matches[0].group(1), str(message.from_user.id)))
+    if not sub:
+        return await message.reply("You were not subscribed to that manga.")
+    await db.erase(sub)
+    return await message.reply("You will no longer receive updates for that manga.")
+
+
+@bot.on_message(filters=filters.command(['options']))
+async def on_options_command(client: Client, message: Message):
+    db = DB()
+    user_options = await db.get(MangaOutput, str(message.from_user.id))
+    user_options = user_options.output if user_options else (1 << 30) - 1
+    buttons = get_buttons_for_options(user_options)
+    return await message.reply("Select the desired output format.", reply_markup=buttons)
+
+
+@bot.on_message(filters=filters.regex(r'^/'))
+async def on_unknown_command(client: Client, message: Message):
+    await message.reply("Unknown command")
+
+
+@bot.on_message(filters=filters.text)
+async def on_message(client, message: Message):
+    language_query[f"lang_None_{hash(message.text)}"] = (None, message.text)
+    for language in plugin_dicts.keys():
+        language_query[f"lang_{language}_{hash(message.text)}"] = (language, message.text)
+    await bot.send_message(message.chat.id, "Select search languages.", reply_markup=InlineKeyboardMarkup(
+        split_list([InlineKeyboardButton(language, callback_data=f"lang_{language}_{hash(message.text)}")
+                    for language in plugin_dicts.keys()])
+    ))
+
+
+async def options_click(client, callback: CallbackQuery):
+    db = DB()
+    user_options = await db.get(MangaOutput, str(callback.from_user.id))
+    if not user_options:
+        user_options = MangaOutput(user_id=str(callback.from_user.id), output=(2 << 30) - 1)
+    option = int(callback.data.split('_')[-1])
+    user_options.output ^= option
+    buttons = get_buttons_for_options(user_options.output)
+    await db.add(user_options)
+    return await callback.message.edit_reply_markup(reply_markup=buttons)
+
+
+async def language_click(client, callback: CallbackQuery):
+    lang, query = language_query[callback.data]
+    if not lang:
+        return await callback.message.edit("Select search languages.", reply_markup=InlineKeyboardMarkup(
+            split_list([InlineKeyboardButton(language, callback_data=f"lang_{language}_{hash(query)}")
+                        for language in plugin_dicts.keys()])
+        ))
+    for identifier, manga_client in plugin_dicts[lang].items():
+        queries[f"query_{lang}_{identifier}_{hash(query)}"] = (manga_client, query)
+    await callback.message.edit(f"Language: {lang}\n\nSelect search plugin.", reply_markup=InlineKeyboardMarkup(
+        split_list([InlineKeyboardButton(identifier, callback_data=f"query_{lang}_{identifier}_{hash(query)}")
+                    for identifier in plugin_dicts[lang].keys() if f'[{lang}] {identifier}' not in disabled]) + [
+            [InlineKeyboardButton("◀️ Back", callback_data=f"lang_None_{hash(query)}")]]
+    ))
+
+
+async def plugin_click(client, callback: CallbackQuery):
+    manga_client, query = queries[callback.data]
+    results = await manga_client.search(query)
+    if not results:
+        await bot.send_message(callback.from_user.id, "No manga found for given query.")
+        return
+    for result in results:
+        mangas[result.unique()] = result
+    await bot.send_message(callback.from_user.id,
+                           "This is the result of your search",
+                           reply_markup=InlineKeyboardMarkup([
+                               [InlineKeyboardButton(result.name, callback_data=result.unique())] for result in results
+                           ]))
+
+
+async def manga_click(client, callback: CallbackQuery, pagination: Pagination = None):
+    if pagination is None:
+        pagination = Pagination()
+        paginations[pagination.id] = pagination
+
+    if pagination.manga is None:
+        manga = mangas[callback.data]
+        pagination.manga = manga
+
+    results = await pagination.manga.client.get_chapters(pagination.manga, pagination.page)
+
+    if not results:
+        await callback.answer("Ups, no chapters there.", show_alert=True)
+        return
+
+    full_page_key = f'full_page_{hash("".join([result.unique() for result in results]))}'
+    full_pages[full_page_key] = []
+    for result in results:
+        chapters[result.unique()] = result
+        full_pages[full_page_key].append(result.unique())
+
+    db = DB()
+    subs = await db.get(Subscription, (pagination.manga.url, str(callback.from_user.id)))
+
+    prev = [InlineKeyboardButton('<<', f'{pagination.id}_{pagination.page - 1}')]
+    next_ = [InlineKeyboardButton('>>', f'{pagination.id}_{pagination.page + 1}')]
+    footer = [prev + next_] if pagination.page > 1 else [next_]
+
+    fav = [[InlineKeyboardButton(
+        "Unsubscribe" if subs else "Subscribe",
+        f"{'unfav' if subs else 'fav'}_{pagination.manga.unique()}"
+    )]]
+    favourites[f"fav_{pagination.manga.unique()}"] = pagination.manga
+    favourites[f"unfav_{pagination.manga.unique()}"] = pagination.manga
+
+    full_page = [[InlineKeyboardButton('Full Page', full_page_key)]]
+
+    buttons = InlineKeyboardMarkup(fav + footer + [
+        [InlineKeyboardButton(result.name, result.unique())] for result in results
+    ] + full_page + footer)
+
+    if pagination.message is None:
+        try:
+            message = await bot.send_photo(callback.from_user.id,
+                                           pagination.manga.picture_url,
+                                           f'{pagination.manga.name}\n'
+                                           f'{pagination.manga.get_url()}', reply_markup=buttons)
+            pagination.message = message
+        except pyrogram.errors.BadRequest as e:
+            file_name = f'pictures/{pagination.manga.unique()}.jpg'
+            await pagination.manga.client.get_cover(pagination.manga, cache=True, file_name=file_name)
+            message = await bot.send_photo(callback.from_user.id,
+                                           f'./cache/{pagination.manga.client.name}/{file_name}',
+                                           f'{pagination.manga.name}\n'
+                                           f'{pagination.manga.get_url()}', reply_markup=buttons)
+            pagination.message = message
+    else:
+        await bot.edit_message_reply_markup(
+            callback.from_user.id,
+            pagination.message.id,
+            reply_markup=buttons
+        )
+
+users_lock = asyncio.Lock()
+
+
+async def get_user_lock(chat_id: int):
+    async with users_lock:
+        lock = locks.get(chat_id)
+        if not lock:
+            locks[chat_id] = asyncio.Lock()
+        return locks[chat_id]
+
+
+async def chapter_click(client, data, chat_id):
+    await pdf_queue.put(chapters[data], int(chat_id))
+    logger.debug(f"Put chapter {chapters[data].name} to queue for user {chat_id} - queue size: {pdf_queue.qsize()}")
+
+
+async def send_manga_chapter(client: Client, chapter, chat_id):
+    db = DB()
+
+    chapter_file = await db.get(ChapterFile, chapter.url)
+    options = await db.get(MangaOutput, str(chat_id))
+    options = options.output if options else (1 << 30) - 1
+
+    error_caption = '\n'.join([
+        f'{chapter.manga.name} - {chapter.name}',
+        f'{chapter.get_url()}'
+    ])
+
+    success_caption = f'{chapter.manga.name} - {chapter.name}\n'
+
+    download = not chapter_file
+    download = download or options & OutputOptions.PDF and not chapter_file.file_id
+    download = download or options & OutputOptions.CBZ and not chapter_file.cbz_id
+    download = download or options & OutputOptions.Telegraph and not chapter_file.telegraph_url
+    download = download and options & ((1 << len(OutputOptions)) - 1) != 0
+
+    if download:
+        pictures_folder = await chapter.client.download_pictures(chapter)
+        if not chapter.pictures:
+            return await client.send_message(chat_id,
+                                          f'There was an error parsing this chapter or chapter is missing' +
+                                          f', please check the chapter at the web\n\n{error_caption}')
+        thumb_path = fld2thumb(pictures_folder)
+
+    chapter_file = chapter_file or ChapterFile(url=chapter.url)
+
+    if download and not chapter_file.telegraph_url:
+        chapter_file.telegraph_url = await img2tph(chapter, clean(f'{chapter.manga.name} {chapter.name}'))
+
+    if options & OutputOptions.Telegraph:
+        success_caption += f'[Read on telegraph]({chapter_file.telegraph_url})\n'
+    success_caption += f'[Read on website]({chapter.get_url()})'
+
+    ch_name = clean(f'{clean(chapter.manga.name, 25)} - {chapter.name}', 45)
+
+    media_docs = []
+
+    if options & OutputOptions.PDF:
+        if chapter_file.file_id:
+            media_docs.append(InputMediaDocument(chapter_file.file_id))
+        else:
+            try:
+                pdf = await asyncio.get_running_loop().run_in_executor(None, fld2pdf, pictures_folder, ch_name)
+            except Exception as e:
+                logger.exception(f'Error creating pdf for {chapter.name} - {chapter.manga.name}\n{e}')
+                return await client.send_message(chat_id, f'There was an error making the pdf for this chapter. '
+                                                       f'Forward this message to the bot group to report the '
+                                                       f'error.\n\n{error_caption}')
+            media_docs.append(InputMediaDocument(pdf, thumb=thumb_path))
+
+    if options & OutputOptions.CBZ:
+        if chapter_file.cbz_id:
+            media_docs.append(InputMediaDocument(chapter_file.cbz_id))
+        else:
+            try:
+                cbz = await asyncio.get_running_loop().run_in_executor(None, fld2cbz, pictures_folder, ch_name)
+            except Exception as e:
+                logger.exception(f'Error creating cbz for {chapter.name} - {chapter.manga.name}\n{e}')
+                return await client.send_message(chat_id, f'There was an error making the cbz for this chapter. '
+                                                       f'Forward this message to the bot group to report the '
+                                                       f'error.\n\n{error_caption}')
+            media_docs.append(InputMediaDocument(cbz, thumb=thumb_path))
+
+    if len(media_docs) == 0:
+        messages: list[Message] = await retry_on_flood(client.send_message)(chat_id, success_caption)
+    else:
+        media_docs[-1].caption = success_caption
+        messages: list[Message] = await retry_on_flood(client.send_media_group)(chat_id, media_docs)
+
+    # Save file ids
+    if download and media_docs:
+        for message in [x for x in messages if x.document]:
+            if message.document.file_name.endswith('.pdf'):
+                chapter_file.file_id = message.document.file_id
+                chapter_file.file_unique_id = message.document.file_unique_id
+            elif message.document.file_name.endswith('.cbz'):
+                chapter_file.cbz_id = message.document.file_id
+                chapter_file.cbz_unique_id = message.document.file_unique_id
+
+    if download:
+        shutil.rmtree(pictures_folder, ignore_errors=True)
+        await db.add(chapter_file)
+
+
+async def pagination_click(client: Client, callback: CallbackQuery):
+    pagination_id, page = map(int, callback.data.split('_'))
+    pagination = paginations[pagination_id]
+    pagination.page = page
+    await manga_click(client, callback, pagination)
+
+
+async def full_page_click(client: Client, callback: CallbackQuery):
+    chapters_data = full_pages[callback.data]
+    for chapter_data in reversed(chapters_data):
+        try:
+            await chapter_click(client, chapter_data, callback.from_user.id)
+        except Exception as e:
+            logger.exception(e)
+
+
+async def favourite_click(client: Client, callback: CallbackQuery):
+    action, data = callback.data.split('_')
+    fav = action == 'fav'
+    manga = favourites[callback.data]
+    db = DB()
+    subs = await db.get(Subscription, (manga.url, str(callback.from_user.id)))
+    if not subs and fav:
+        await db.add(Subscription(url=manga.url, user_id=str(callback.from_user.id)))
+    if subs and not fav:
+        await db.erase(subs)
+    if subs and fav:
+        await callback.answer("You are already subscribed", show_alert=True)
+    if not subs and not fav:
+        await callback.answer("You are not subscribed", show_alert=True)
+    reply_markup = callback.message.reply_markup
+    keyboard = reply_markup.inline_keyboard
+    keyboard[0] = [InlineKeyboardButton(
+        "Unsubscribe" if fav else "Subscribe",
+        f"{'unfav' if fav else 'fav'}_{data}"
+    )]
+    await bot.edit_message_reply_markup(callback.from_user.id, callback.message.id,
+                                        InlineKeyboardMarkup(keyboard))
+    db_manga = await db.get(MangaName, manga.url)
+    if not db_manga:
+        await db.add(MangaName(url=manga.url, name=manga.name))
+
+
+def is_pagination_data(callback: CallbackQuery):
+    data = callback.data
+    match = re.match(r'\d+_\d+', data)
+    if not match:
+        return False
+    pagination_id = int(data.split('_')[0])
+    if pagination_id not in paginations:
+        return False
+    pagination = paginations[pagination_id]
+    if not pagination.message:
+        return False
+    if pagination.message.chat.id != callback.from_user.id:
+        return False
+    if pagination.message.id != callback.message.id:
+        return False
+    return True
+
+
+@bot.on_callback_query()
+async def on_callback_query(client, callback: CallbackQuery):
+    if callback.data in queries:
+        await plugin_click(client, callback)
+    elif callback.data in mangas:
+        await manga_click(client, callback)
+    elif callback.data in chapters:
+        await chapter_click(client, callback.data, callback.from_user.id)
+    elif callback.data in full_pages:
+        await full_page_click(client, callback)
+    elif callback.data in favourites:
+        await favourite_click(client, callback)
+    elif is_pagination_data(callback):
+        await pagination_click(client, callback)
+    elif callback.data in language_query:
+        await language_click(client, callback)
+    elif callback.data.startswith('options'):
+        await options_click(client, callback)
+    else:
+        await bot.answer_callback_query(callback.id, 'This is an old button, please redo the search', show_alert=True)
+        return
+    try:
+        await callback.answer()
+    except BaseException as e:
+        logger.warning(e)
+
+
+async def remove_subscriptions(sub: str):
+    db = DB()
+
+    await db.erase_subs(sub)
+
+
+async def update_mangas():
+    logger.debug("Updating mangas")
+    db = DB()
+    subscriptions = await db.get_all(Subscription)
+    last_chapters = await db.get_all(LastChapter)
+    manga_names = await db.get_all(MangaName)
+
+    subs_dictionary = dict()
+    chapters_dictionary = dict()
+    url_client_dictionary = dict()
+    client_url_dictionary = {client: set() for client in plugins.values()}
+    manga_dict = dict()
+
+    for subscription in subscriptions:
+        if subscription.url not in subs_dictionary:
+            subs_dictionary[subscription.url] = []
+        subs_dictionary[subscription.url].append(subscription.user_id)
+
+    for last_chapter in last_chapters:
+        chapters_dictionary[last_chapter.url] = last_chapter
+
+    for manga in manga_names:
+        manga_dict[manga.url] = manga
+
+    for url in subs_dictionary:
+        for ident, client in plugins.items():
+            if ident in subsPaused:
+                continue
+            if await client.contains_url(url):
+                url_client_dictionary[url] = client
+                client_url_dictionary[client].add(url)
+
+    for client, urls in client_url_dictionary.items():
+        logger.debug(f'Updating {client.name}')
+        logger.debug(f'Urls:\t{list(urls)}')
+        new_urls = [url for url in urls if not chapters_dictionary.get(url)]
+        logger.debug(f'New Urls:\t{new_urls}')
+        to_check = [chapters_dictionary[url] for url in urls if chapters_dictionary.get(url)]
+        if len(to_check) == 0:
+            continue
+        try:
+            updated, not_updated = await client.check_updated_urls(to_check)
+        except BaseException as e:
+            logger.exception(f"Error while checking updates for site: {client.name}, err: {e}")
+            updated = []
+            not_updated = list(urls)
+        for url in not_updated:
+            del url_client_dictionary[url]
+        logger.debug(f'Updated:\t{list(updated)}')
+        logger.debug(f'Not Updated:\t{list(not_updated)}')
+
+    updated = dict()
+
+    for url, client in url_client_dictionary.items():
+        try:
+            if url not in manga_dict:
+                continue
+            manga_name = manga_dict[url].name
+            if url not in chapters_dictionary:
+                agen = client.iter_chapters(url, manga_name)
+                last_chapter = await anext(agen)
+                await db.add(LastChapter(url=url, chapter_url=last_chapter.url))
+                await asyncio.sleep(10)
+            else:
+                last_chapter = chapters_dictionary[url]
+                new_chapters: List[MangaChapter] = []
+                counter = 0
+                async for chapter in client.iter_chapters(url, manga_name):
+                    if chapter.url == last_chapter.chapter_url:
+                        break
+                    new_chapters.append(chapter)
+                    counter += 1
+                    if counter == 20:
+                        break
+                if new_chapters:
+                    last_chapter.chapter_url = new_chapters[0].url
+                    await db.add(last_chapter)
+                    updated[url] = list(reversed(new_chapters))
+                    for chapter in new_chapters:
+                        if chapter.unique() not in chapters:
+                            chapters[chapter.unique()] = chapter
+                await asyncio.sleep(1)
+        except BaseException as e:
+            logger.exception(f'An exception occurred getting new chapters for url {url}: {e}')
+
+    blocked = set()
+    for url, chapter_list in updated.items():
+        for chapter in chapter_list:
+            logger.debug(f'Updating {chapter.manga.name} - {chapter.name}')
+            for sub in subs_dictionary[url]:
+                if sub in blocked:
+                    continue
+                try:
+                    await pdf_queue.put(chapter, int(sub))
+                    logger.debug(f"Put chapter {chapter} to queue for user {sub} - queue size: {pdf_queue.qsize()}")
+                except pyrogram.errors.UserIsBlocked:
+                    logger.info(f'User {sub} blocked the bot')
+                    await remove_subscriptions(sub)
+                    blocked.add(sub)
+                except BaseException as e:
+                    logger.exception(f'An exception occurred sending new chapter: {e}')
+
+
+async def manga_updater():
+    minutes = 5
+    while True:
+        wait_time = minutes * 60
+        try:
+            start = dt.datetime.now()
+            await update_mangas()
+            elapsed = dt.datetime.now() - start
+            wait_time = max((dt.timedelta(seconds=wait_time) - elapsed).total_seconds(), 0)
+            logger.debug(f'Time elapsed updating mangas: {elapsed}, waiting for {wait_time}')
+        except BaseException as e:
+            logger.exception(f'An exception occurred during chapters update: {e}')
+        if wait_time:
+            await asyncio.sleep(wait_time)
+
+
+async def chapter_creation(worker_id: int = 0):
+    """
+    This function will always run in the background
+    It will be listening for a channel which notifies whether there is a new request in the request queue
+    :return:
+    """
+    logger.debug(f"Worker {worker_id}: Starting worker")
+    while True:
+        chapter, chat_id = await pdf_queue.get(worker_id)
+        logger.debug(f"Worker {worker_id}: Got chapter '{chapter.name}' from queue for user '{chat_id}'")
+        try:
+            await send_manga_chapter(bot, chapter, chat_id)
+        except:
+            logger.exception(f"Error sending chapter {chapter.name} to user {chat_id}")
+        finally:
+            pdf_queue.release(chat_id)

config.py

@@ -0,0 +1,14 @@
+import os
+import json
+
+env_file = "env.json"
+if os.path.exists(env_file):
+    with open(env_file) as f:
+        env_vars = json.loads(f.read())
+else:
+    env_vars = dict(os.environ)
+
+dbname = env_vars.get('DATABASE_URL_PRIMARY') or env_vars.get('DATABASE_URL') or 'sqlite:///test.db'
+
+if dbname.startswith('postgres://'):
+    dbname = dbname.replace('postgres://', 'postgresql://', 1)

heroku.yml

@@ -0,0 +1,3 @@
+build:
+  docker:
+    worker: Dockerfile

img2cbz/codeflix

@@ -0,0 +1 @@
+

img2cbz/core.py

@@ -0,0 +1,21 @@
+import re
+import zipfile
+from pathlib import Path
+from typing import List
+
+
+def fld2cbz(folder: Path, name: str):
+    cbz = folder / f'{name}.cbz'
+    files = [file for file in folder.glob(r'*') if re.match(r'.*\.(jpg|png|jpeg|webp)', file.name)]
+    files.sort(key=lambda x: x.name)
+    img2cbz(files, cbz)
+    return cbz
+
+
+def img2cbz(files: List[Path], out: Path):
+    zip_file = zipfile.ZipFile(out, 'w')  # parameter "out" must be a .zip file
+
+    for image_file in files:
+        zip_file.write(image_file, compress_type=zipfile.ZIP_DEFLATED)
+
+    zip_file.close()

img2pdf/codeflix

@@ -0,0 +1 @@
+

img2pdf/core.py

@@ -0,0 +1,103 @@
+import os
+from io import BytesIO
+from typing import List, BinaryIO
+from pathlib import Path
+from fpdf import FPDF
+import re
+
+from PIL import Image
+
+
+def fld2pdf(folder: Path, out: str):
+    
+    files = [file for file in folder.glob(r'*') if re.match(r'.*\.(jpg|png|jpeg|webp)', file.name)]
+    files.sort(key=lambda x: x.name)
+    pdf = folder / f'{out}.pdf'
+    img2pdf(files, pdf)
+    return pdf
+
+
+def new_img(path: Path) -> Image.Image:
+    img = Image.open(path)
+    if img.mode != 'RGB':
+        img = img.convert('RGB')
+    return img
+
+
+def old_img2pdf(files: List[Path], out: Path):
+    img_list = [new_img(img) for img in files]
+    img_list[0].save(out, resolution=100.0, save_all=True, append_images=img_list[1:])
+    for img in img_list:
+        img.close()
+
+
+def pil_image(path: Path) -> (BytesIO, int, int):
+    img = new_img(path)
+    width, height = img.width, img.height
+    try:
+        membuf = BytesIO()
+        img.save(membuf, format='JPEG')
+    finally:
+        img.close()
+    return membuf, width, height
+
+
+def unicode_to_latin1(s):
+    # Substitute the ' character
+    s = s.replace('\u2019', '\x92')
+    # Substitute the " character
+    s = s.replace('\u201d', '\x94')
+    # Substitute the - character
+    s = s.replace('\u2013', '\x96')
+    # Remove all other non-latin1 characters
+    s = s.encode('latin1', 'replace').decode('latin1')
+    return s
+
+
+def img2pdf(files: List[Path], out: Path):
+    pdf = FPDF('P', 'pt')
+    for imageFile in files:
+        img_bytes, width, height = pil_image(imageFile)
+        
+        pdf.add_page(format=(width, height))
+
+        pdf.image(img_bytes, 0, 0, width, height)
+
+        img_bytes.close()
+
+    pdf.set_title(unicode_to_latin1(out.stem))
+    pdf.output(out, "F")
+
+
+def fld2thumb(folder: Path):
+    files = [file for file in folder.glob(r'*') if re.match(r'.*\.(jpg|png|jpeg|webp)', file.name)]
+    files.sort(key=lambda x: x.name)
+    thumb_path = make_thumb(folder, files)
+    return thumb_path
+
+
+def make_thumb(folder, files):
+    aspect_ratio = 0.7
+    if len(files) > 1:
+        with Image.open(files[1]) as img:
+            aspect_ratio = img.width / img.height
+
+    thumbnail = Image.open(files[0]).convert('RGB')
+    tg_max_size = (300, 300)
+    thumbnail = crop_thumb(thumbnail, aspect_ratio)
+    thumbnail.thumbnail(tg_max_size)
+    thumb_path = folder / 'thumbnail' / f'thumbnail.jpg'
+    os.makedirs(thumb_path.parent, exist_ok=True)
+    thumbnail.save(thumb_path)
+    thumbnail.close()
+    return thumb_path
+
+
+def crop_thumb(thumb: Image.Image, aspect_ratio):
+    w, h = thumb.width, thumb.height
+    if w * 2 <= h:
+        b = int(h - (w / aspect_ratio))
+        if b <= 0:
+            b = w
+        thumb = thumb.crop((0, 0, w, b))
+    return thumb

img2tph/codeflix

@@ -0,0 +1 @@
+

img2tph/core.py

@@ -0,0 +1,18 @@
+from typing import List
+
+from telegraph.aio import Telegraph
+
+from plugins import MangaChapter
+
+
+async def img2tph(manga_chapter: MangaChapter, name: str):
+    lines = []
+    for img in manga_chapter.pictures:
+        a_tag = f'<img src="{img}"/>'
+        lines.append(a_tag)
+    content = '\n'.join(lines)
+
+    client = Telegraph()
+    await client.create_account('Alpha')
+    page = await client.create_page(name, author_name='AlphaBot', author_url='https://t.me/idkpythonbot', html_content=content)
+    return page['url']

logger.py

@@ -0,0 +1,6 @@
+from loguru import logger
+from config import env_vars
+import sys
+
+logger.remove(0)
+logger.add(sys.stdout, level=env_vars.get("LOG_LEVEL", "INFO"))

main.py

@@ -0,0 +1,19 @@
+import asyncio as aio
+import os
+
+from logger import logger
+from bot import bot, manga_updater, chapter_creation
+from models import DB
+
+
+async def async_main():
+    db = DB()
+    await db.connect()
+
+if __name__ == '__main__':
+    loop = aio.get_event_loop_policy().get_event_loop()
+    loop.run_until_complete(async_main())
+    loop.create_task(manga_updater())
+    for i in range(10):
+        loop.create_task(chapter_creation(i + 1))
+    bot.run()

models/__init__.py

@@ -0,0 +1 @@
+from .db import DB, ChapterFile, Subscription, LastChapter, MangaName

models/codeflix

@@ -0,0 +1 @@
+

models/db.py

@@ -0,0 +1,100 @@
+import os
+from typing import Type, List, TypeVar, Optional
+
+from sqlalchemy.ext.asyncio import create_async_engine
+from sqlmodel import SQLModel, Field, Session, select, delete
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from tools import LanguageSingleton
+
+T = TypeVar("T")
+
+
+class ChapterFile(SQLModel, table=True):
+    url: str = Field(primary_key=True)
+    file_id: Optional[str]
+    file_unique_id: Optional[str]
+    cbz_id: Optional[str]
+    cbz_unique_id: Optional[str]
+    telegraph_url: Optional[str]
+
+
+class MangaOutput(SQLModel, table=True):
+    user_id: str = Field(primary_key=True, regex=r'\d+')
+    output: int = Field
+
+
+class Subscription(SQLModel, table=True):
+    url: str = Field(primary_key=True)
+    user_id: str = Field(primary_key=True, regex=r'\d+')
+
+
+class LastChapter(SQLModel, table=True):
+    url: str = Field(primary_key=True)
+    chapter_url: str = Field
+
+
+class MangaName(SQLModel, table=True):
+    url: str = Field(primary_key=True)
+    name: str = Field
+
+
+class DB(metaclass=LanguageSingleton):
+
+    def __init__(self, dbname: str = 'sqlite+aiosqlite:///test.db'):
+        if dbname.startswith('postgres://'):
+            dbname = dbname.replace('postgres://', 'postgresql+asyncpg://', 1)
+        elif dbname.startswith('postgresql://'):
+            dbname = dbname.replace('postgresql://', 'postgresql+asyncpg://', 1)
+        elif dbname.startswith('sqlite'):
+            dbname = dbname.replace('sqlite', 'sqlite+aiosqlite', 1)
+
+        self.engine = create_async_engine(dbname)
+
+    async def connect(self):
+        async with self.engine.begin() as conn:
+            await conn.run_sync(SQLModel.metadata.create_all, checkfirst=True)
+
+    async def add(self, other: SQLModel):
+        async with AsyncSession(self.engine) as session:  # type: AsyncSession
+            async with session.begin():
+                session.add(other)
+
+    async def get(self, table: Type[T], id) -> T:
+        async with AsyncSession(self.engine) as session:  # type: AsyncSession
+            return await session.get(table, id)
+
+    async def get_all(self, table: Type[T]) -> List[T]:
+        async with AsyncSession(self.engine) as session:  # type: AsyncSession
+            statement = select(table)
+            return await session.exec(statement=statement)
+
+    async def erase(self, other: SQLModel):
+        async with AsyncSession(self.engine) as session:  # type: AsyncSession
+            async with session.begin():
+                await session.delete(other)
+
+    async def get_chapter_file_by_id(self, id: str):
+        async with AsyncSession(self.engine) as session:  # type: AsyncSession
+            statement = select(ChapterFile).where((ChapterFile.file_unique_id == id) |
+                                                  (ChapterFile.cbz_unique_id == id) |
+                                                  (ChapterFile.telegraph_url == id))
+            return (await session.exec(statement=statement)).first()
+
+    async def get_subs(self, user_id: str, filters=None) -> List[MangaName]:
+        async with AsyncSession(self.engine) as session:
+            statement = (
+                select(MangaName)
+                .join(Subscription, Subscription.url == MangaName.url)
+                .where(Subscription.user_id == user_id)
+            )
+            for filter_ in filters or []:
+                statement = statement.where(MangaName.name.ilike(f'%{filter_}%') | MangaName.url.ilike(f'%{filter_}%'))
+            return (await session.exec(statement=statement)).all()
+
+    async def erase_subs(self, user_id: str):
+        async with AsyncSession(self.engine) as session:
+            async with session.begin():
+                statement = delete(Subscription).where(Subscription.user_id == user_id)
+                await session.exec(statement=statement)
+

pagination.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+
+from pyrogram.types import Message
+
+from plugins import MangaCard
+
+
+class Pagination:
+    pagination_id: int = 0
+    
+    def __init__(self):
+        self.id = self.pagination_id
+        Pagination.pagination_id += 1
+        self.page = 1
+        self.message: Message = None
+        self.manga: MangaCard = None

plugins/__init__.py

@@ -0,0 +1,18 @@
+from .client import MangaClient, MangaCard, MangaChapter
+from .manhuako import ManhuaKoClient
+from .manhuaplus import ManhuaPlusClient
+from .tmo import TMOClient
+from .mangadex import MangaDexClient
+from .mangasee import MangaSeeClient
+from .mangasin import MangasInClient
+from .mcreader import McReaderClient
+from .mangakakalot import MangaKakalotClient
+from .manganelo import ManganeloClient
+from .manganato import ManganatoClient
+from .kissmanga import KissMangaClient
+from .mangatigre import MangatigreClient
+from .mangahasu import MangaHasuClient
+from .mangabuddy import MangaBuddyClient
+from .asurascans import AsuraScansClient
+from .ninemanga import NineMangaClient
+from .manhwa18 import Manhwa18Client

plugins/asurascans.py

@@ -0,0 +1,122 @@
+from typing import List, AsyncIterable
+from urllib.parse import urlparse, urljoin, quote, quote_plus
+
+from bs4 import BeautifulSoup
+
+from plugins.client import MangaClient, MangaCard, MangaChapter, LastChapter
+
+
+class AsuraScansClient(MangaClient):
+
+    base_url = urlparse("https://asuracomic.net/")
+    search_url = base_url.geturl()
+    search_param = 's'
+    updates_url = base_url.geturl()
+
+    pre_headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:97.0) Gecko/20100101 Firefox/97.0'
+    }
+
+    def __init__(self, *args, name="AsuraScans", **kwargs):
+        super().__init__(*args, name=name, headers=self.pre_headers, **kwargs)
+
+    def mangas_from_page(self, page: bytes):
+        bs = BeautifulSoup(page, "html.parser")
+
+        container = bs.find("div", {"class": "grid grid-cols-2 sm:grid-cols-2 md:grid-cols-5 gap-3 p-4"})
+
+        cards = container.find_all("div", {"class": "flex h-[250px] md:h-[200px] overflow-hidden relative hover:opacity-60"})
+
+        names = [containers.findChild('span', {'class': 'block text-[13.3px] font-bold'}).string.strip() for containers in container]
+        l = "https://asuracomic.net/"
+        url = [l + containers.get("href") for containers in container]
+        images = [card.findNext("img").get("src") for card in cards]
+
+        mangas = [MangaCard(self, *tup) for tup in zip(names, url, images)]
+
+        return mangas
+
+    def chapters_from_page(self, page: bytes, manga: MangaCard = None):
+        bs = BeautifulSoup(page, "html.parser")
+
+        li = bs.findAll("a", {"class": "block visited:text-themecolor"})
+
+        a = "https://asuracomic.net/series/"
+        links = [a + containers.get("href") for containers in li]
+        b = "Ch : "
+        texts = [b + (sub.split('/')[6]) for sub in links]
+
+        return list(map(lambda x: MangaChapter(self, x[0], x[1], manga, []), zip(texts, links)))
+
+    def updates_from_page(self, content):
+        bs = BeautifulSoup(content, "html.parser")
+
+        manga_items = bs.find_all("span", {"class": "text-[15px] font-medium hover:text-themecolor hover:cursor-pointer"})
+
+        urls = dict()
+
+        for manga_item in manga_items:
+            manga_url =  urljoin(self.base_url.geturl(), manga_item.findNext("a").get("href"))
+
+            if manga_url in urls:
+                continue
+
+            chapter_url = urljoin(self.base_url.geturl(), manga_item.findNext("span").findNext("a").get("href"))
+            
+            urls[manga_url] = chapter_url
+
+        return urls
+
+    async def pictures_from_chapters(self, content: bytes, response=None):
+        bs = BeautifulSoup(content, "html.parser")
+
+        container = bs.find("div", {"class": "py-8 -mx-5 md:mx-0 flex flex-col items-center justify-center"})
+
+        images_url = [quote(containers.findNext("img").get("src"), safe=':/%') for containers in container]
+
+        return images_url
+
+    async def search(self, query: str = "", page: int = 1) -> List[MangaCard]:
+        query = quote_plus(query)
+
+        request_url = self.search_url
+
+        if query:
+            request_url += f'series?page=1&name={query}'
+
+        content = await self.get_url(request_url)
+
+        return self.mangas_from_page(content)
+
+    async def get_chapters(self, manga_card: MangaCard, page: int = 1) -> List[MangaChapter]:
+
+        request_url = f'{manga_card.url}'
+
+        content = await self.get_url(request_url)
+
+        return self.chapters_from_page(content, manga_card)[(page - 1) * 20:page * 20]
+
+    async def iter_chapters(self, manga_url: str, manga_name) -> AsyncIterable[MangaChapter]:
+        manga_card = MangaCard(self, manga_name, manga_url, '')
+
+        request_url = f'{manga_card.url}'
+
+        content = await self.get_url(request_url)
+
+        for chapter in self.chapters_from_page(content, manga_card):
+            yield chapter
+
+    async def contains_url(self, url: str):
+        return url.startswith(self.base_url.geturl())
+
+    async def check_updated_urls(self, last_chapters: List[LastChapter]):
+
+        content = await self.get_url(self.updates_url)
+
+        updates = self.updates_from_page(content)
+
+        updated = [lc.url for lc in last_chapters if updates.get(lc.url) and updates.get(lc.url) != lc.chapter_url]
+        not_updated = [lc.url for lc in last_chapters if
+                       not updates.get(lc.url) or updates.get(lc.url) == lc.chapter_url]
+
+        return updated, not_updated

plugins/client.py

@@ -0,0 +1,158 @@
+import os
+from abc import abstractmethod, ABC
+from dataclasses import dataclass
+from typing import List, AsyncIterable
+
+from aiohttp import ClientSession
+from pathlib import Path
+
+from models import LastChapter
+from tools import LanguageSingleton
+
+
+@dataclass
+class MangaCard:
+    client: "MangaClient"
+    name: str
+    url: str
+    picture_url: str
+
+    def get_url(self):
+        return self.url
+
+    def unique(self):
+        return str(hash(self.url))
+
+
+@dataclass
+class MangaChapter:
+    client: "MangaClient"
+    name: str
+    url: str
+    manga: MangaCard
+    pictures: List[str]
+
+    def get_url(self):
+        return self.url
+
+    def unique(self):
+        return str(hash(self.url))
+
+
+def clean(name, length=-1):
+    while '  ' in name:
+        name = name.replace('  ', ' ')
+    name = name.replace(':', '')
+    if length != -1:
+        name = name[:length]
+    return name
+
+
+class MangaClient(ClientSession, metaclass=LanguageSingleton):
+
+    def __init__(self, *args, name="client", **kwargs):
+        if name == "client":
+            raise NotImplementedError
+        super().__init__(*args, **kwargs)
+        self.name = name
+
+    async def get_url(self, url, *args, file_name=None, cache=False, req_content=True, method='get', data=None,
+                      **kwargs):
+        def response():
+            pass
+
+        response.status = "200"
+        if cache:
+            path = Path(f'cache/{self.name}/{file_name}')
+            os.makedirs(path.parent, exist_ok=True)
+            try:
+                with open(path, 'rb') as f:
+                    content = f.read()
+            except FileNotFoundError:
+                if method == 'get':
+                    response = await self.get(url, *args, **kwargs)
+                elif method == 'post':
+                    response = await self.post(url, data=data or {}, **kwargs)
+                else:
+                    raise ValueError
+                if str(response.status).startswith('2'):
+                    content = await response.read()
+                    with open(path, 'wb') as f:
+                        f.write(content)
+        else:
+            if method == 'get':
+                response = await self.get(url, *args, **kwargs)
+            elif method == 'post':
+                response = await self.post(url, data=data or {}, **kwargs)
+            else:
+                raise ValueError
+            content = await response.read()
+        if req_content:
+            return content
+        else:
+            return response
+
+    async def set_pictures(self, manga_chapter: MangaChapter):
+        requests_url = manga_chapter.url
+
+        # Set manga url as the referer if there is one
+        headers = {**self.headers}
+        if manga_chapter.manga:
+            headers['referer'] = manga_chapter.manga.url
+
+        response = await self.get(requests_url, headers=headers)
+
+        content = await response.read()
+
+        manga_chapter.pictures = await self.pictures_from_chapters(content, response)
+
+        return manga_chapter
+
+    async def download_pictures(self, manga_chapter: MangaChapter):
+        if not manga_chapter.pictures:
+            await self.set_pictures(manga_chapter)
+
+        folder_name = f'{clean(manga_chapter.manga.name)}/{clean(manga_chapter.name)}'
+        i = 0
+        for picture in manga_chapter.pictures:
+            ext = picture.split('.')[-1].split('?')[0].lower()
+            file_name = f'{folder_name}/{format(i, "05d")}.{ext}'
+            for _ in range(3):
+                req = await self.get_picture(manga_chapter, picture, file_name=file_name, cache=True,
+                                             req_content=False)
+                if str(req.status).startswith('2'):
+                    break
+            else:
+                raise ValueError
+            i += 1
+
+        return Path(f'cache/{manga_chapter.client.name}') / folder_name
+
+    async def get_picture(self, manga_chapter: MangaChapter, url, *args, **kwargs):
+        return await self.get_url(url, *args, **kwargs)
+
+    async def get_cover(self, manga_card: MangaCard, *args, **kwargs):
+        return await self.get_url(manga_card.picture_url, *args, **kwargs)
+
+    async def check_updated_urls(self, last_chapters: List[LastChapter]):
+        return [lc.url for lc in last_chapters], []
+
+    @abstractmethod
+    async def search(self, query: str = "", page: int = 1) -> List[MangaCard]:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def get_chapters(self, manga_card: MangaCard, page: int = 1) -> List[MangaChapter]:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def contains_url(self, url: str):
+        raise NotImplementedError
+
+    @abstractmethod
+    async def iter_chapters(self, manga_url: str, manga_name: str) -> AsyncIterable[MangaChapter]:
+        raise NotImplementedError
+
+    @abstractmethod
+    async def pictures_from_chapters(self, content: bytes, response=None):
+        raise NotImplementedError

plugins/codeflix

@@ -0,0 +1 @@
+

plugins/kissmanga.py

@@ -0,0 +1,125 @@
+from typing import List, AsyncIterable
+from urllib.parse import urlparse, urljoin, quote_plus
+
+from bs4 import BeautifulSoup
+
+from plugins.client import MangaClient, MangaCard, MangaChapter, LastChapter
+
+
+class KissMangaClient(MangaClient):
+
+    base_url = urlparse("http://kissmanga.nl/")
+    search_url = urljoin(base_url.geturl(), "search")
+    search_param = 'q'
+
+    pre_headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:97.0) Gecko/20100101 Firefox/97.0'
+    }
+
+    def __init__(self, *args, name="KissManga", **kwargs):
+        super().__init__(*args, name=name, headers=self.pre_headers, **kwargs)
+
+    def mangas_from_page(self, page: bytes):
+        bs = BeautifulSoup(page, "html.parser")
+
+        cards = bs.findAll("div", {"class": "mainpage-manga"})
+
+        mangas = [card.findNext('div', {"class": "media-body"}).findNext("a") for card in cards]
+        names = [manga.get('title') for manga in mangas]
+        url = [manga.get('href') for manga in mangas]
+
+        images = [card.findNext('img').get('src') for card in cards]
+
+        mangas = [MangaCard(self, *tup) for tup in zip(names, url, images)]
+
+        return mangas
+
+    def chapters_from_page(self, page: bytes, manga: MangaCard = None):
+        bs = BeautifulSoup(page, "html.parser")
+
+        ul = bs.findAll("div", {"class": "chapter-list"})[1]
+
+        lis = ul.findAll("h4")
+
+        items = [li.findNext('a') for li in lis]
+
+        links = [item.get('href') for item in items]
+        texts: List[str] = [item.get('title').strip() for item in items]
+
+        texts = [(text if not text.startswith(manga.name) else text[len(manga.name):].strip()) for text in texts]
+
+        return list(map(lambda x: MangaChapter(self, x[0], x[1], manga, []), zip(texts, links)))
+
+    @staticmethod
+    def updates_from_page(content):
+        bs = BeautifulSoup(content, "html.parser")
+
+        manga_items = bs.find_all("div", {"class": "media-body"})
+
+        urls = dict()
+
+        for manga_item in manga_items:
+            manga_url = manga_item.findNext('a').get('href')
+
+            if manga_url in urls:
+                continue
+
+            chapter_url = manga_item.findNext('a', {'class': 'xanh'}).get('href')
+
+            urls[manga_url] = chapter_url
+
+        return urls
+
+    async def pictures_from_chapters(self, content: bytes, response=None):
+        bs = BeautifulSoup(content, "html.parser")
+
+        ul = bs.find("p", {"id": "arraydata"})
+
+        images_url = ul.text.split(',')
+
+        return images_url
+
+    async def search(self, query: str = "", page: int = 1) -> List[MangaCard]:
+        query = quote_plus(query)
+
+        request_url = f'{self.search_url}'
+
+        if query:
+            request_url += f'?{self.search_param}={query}'
+
+        content = await self.get_url(request_url)
+
+        return self.mangas_from_page(content)
+
+    async def get_chapters(self, manga_card: MangaCard, page: int = 1) -> List[MangaChapter]:
+
+        request_url = f'{manga_card.url}'
+
+        content = await self.get_url(request_url)
+
+        return self.chapters_from_page(content, manga_card)[(page - 1) * 20:page * 20]
+
+    async def iter_chapters(self, manga_url: str, manga_name) -> AsyncIterable[MangaChapter]:
+        manga_card = MangaCard(self, manga_name, manga_url, '')
+
+        request_url = f'{manga_card.url}'
+
+        content = await self.get_url(request_url)
+
+        for chapter in self.chapters_from_page(content, manga_card):
+            yield chapter
+
+    async def contains_url(self, url: str):
+        return url.startswith(self.base_url.geturl())
+
+    async def check_updated_urls(self, last_chapters: List[LastChapter]):
+
+        content = await self.get_url(self.base_url.geturl())
+
+        updates = self.updates_from_page(content)
+
+        updated = [lc.url for lc in last_chapters if updates.get(lc.url) and updates.get(lc.url) != lc.chapter_url]
+        not_updated = [lc.url for lc in last_chapters if
+                       not updates.get(lc.url) or updates.get(lc.url) == lc.chapter_url]
+
+        return updated, not_updated

plugins/mangabuddy.py

@@ -0,0 +1,145 @@
+import re
+from dataclasses import dataclass
+from typing import List, AsyncIterable
+from urllib.parse import urlparse, urljoin, quote, quote_plus
+
+from bs4 import BeautifulSoup
+
+from models import LastChapter
+from plugins.client import MangaClient, MangaCard, MangaChapter
+
+
+@dataclass
+class MangaBuddyCard(MangaCard):
+    read_url: str
+
+    def get_url(self):
+        return self.read_url
+
+
+class MangaBuddyClient(MangaClient):
+    base_url = urlparse("https://mangabuddy.com/")
+    search_url = urljoin(base_url.geturl(), "search")
+    search_param = 'q'
+    home_page = urljoin(base_url.geturl(), "home-page")
+    img_server = "https://s1.mbbcdnv1.xyz/file/img-mbuddy/manga/"
+
+    pre_headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:97.0) Gecko/20100101 Firefox/97.0'
+    }
+
+    def __init__(self, *args, name="MangaBuddy", **kwargs):
+        super().__init__(*args, name=name, headers=self.pre_headers, **kwargs)
+
+    def mangas_from_page(self, page: bytes):
+        bs = BeautifulSoup(page, "html.parser")
+
+        cards = bs.find_all("div", {"class": "book-item"})
+
+        mangas = [card.a for card in cards if card.a is not None]
+        names = [manga.get("title").strip() for manga in mangas]
+        read_url = [urljoin(self.base_url.geturl(), manga.get('href').strip()) for manga in mangas]
+        url = [f'https://mangabuddy.com/api/manga{manga.get("href").strip()}/chapters?source=detail' for manga in mangas]
+        images = [manga.find("img").get('data-src').strip() for manga in mangas]
+
+        mangas = [MangaBuddyCard(self, *tup) for tup in zip(names, url, images, read_url)]
+
+        return mangas
+
+    def chapters_from_page(self, page: bytes, manga: MangaCard = None):
+        bs = BeautifulSoup(page, "html.parser")
+
+        ul = bs.find('ul', {'id': 'chapter-list'})
+
+        lis = ul.findAll('li')
+        a_elems = [li.find('a') for li in lis]
+
+        links = [urljoin(self.base_url.geturl(), a.get('href')) for a in a_elems]
+        texts = [a.findNext('strong', {'class': 'chapter-title'}).text.strip() for a in a_elems]
+
+        return list(map(lambda x: MangaChapter(self, x[0], x[1], manga, []), zip(texts, links)))
+
+    def updates_from_page(self, page: bytes):
+        bs = BeautifulSoup(page, "html.parser")
+
+        div = bs.find('div', {'class': 'container__left'})
+
+        manga_items = div.findAll('div', {'class': 'book-item'})
+
+        urls = dict()
+
+        for manga_item in manga_items:
+
+            manga_url_part = manga_item.findNext('a').get('href')
+            manga_url = f'https://mangabuddy.com/api/manga{manga_url_part}/chapters?source=detail'
+
+            chapter_item = manga_item.findNext("div", {"class": "chap-item"})
+            if not chapter_item or not chapter_item.a:
+                continue
+            chapter_url = urljoin(self.base_url.geturl(), chapter_item.a.get('href'))
+
+            if manga_url not in urls:
+                urls[manga_url] = chapter_url
+
+        return urls
+
+    async def pictures_from_chapters(self, content: bytes, response=None):
+
+        regex = rb"var chapImages = '(.*)'"
+
+        imgs = re.findall(regex, content)[0].decode().split(',')
+
+        images_url = [img for img in imgs]
+
+        return images_url
+
+    async def search(self, query: str = "", page: int = 1) -> List[MangaCard]:
+        request_url = self.search_url
+
+        if query:
+            request_url = f'{request_url}?{self.search_param}={quote_plus(query)}'
+
+        content = await self.get_url(request_url)
+
+        return self.mangas_from_page(content)[(page - 1) * 20:page * 20]
+
+    async def get_chapters(self, manga_card: MangaCard, page: int = 1) -> List[MangaChapter]:
+
+        request_url = f'{manga_card.url}'
+
+        content = await self.get_url(request_url)
+
+        return self.chapters_from_page(content, manga_card)[(page - 1) * 20:page * 20]
+
+    async def iter_chapters(self, manga_url: str, manga_name) -> AsyncIterable[MangaChapter]:
+        manga_card = MangaCard(self, manga_name, manga_url, '')
+
+        request_url = f'{manga_card.url}'
+
+        content = await self.get_url(request_url)
+
+        for chapter in self.chapters_from_page(content, manga_card):
+            yield chapter
+
+    async def contains_url(self, url: str):
+        return url.startswith(self.base_url.geturl())
+
+    async def check_updated_urls(self, last_chapters: List[LastChapter]):
+
+        content = await self.get_url(self.home_page)
+
+        updates = self.updates_from_page(content)
+
+        updated = [lc.url for lc in last_chapters if updates.get(lc.url) and updates.get(lc.url) != lc.chapter_url]
+        not_updated = [lc.url for lc in last_chapters if not updates.get(lc.url)
+                       or updates.get(lc.url) == lc.chapter_url]
+
+        return updated, not_updated
+
+    async def get_cover(self, manga_card: MangaCard, *args, **kwargs):
+        headers = {**self.pre_headers, 'Referer': self.base_url.geturl()}
+        return await super(MangaBuddyClient, self).get_cover(manga_card, *args, headers=headers, **kwargs)
+
+    async def get_picture(self, manga_chapter: MangaChapter, url, *args, **kwargs):
+        headers = {**self.pre_headers, 'Referer': self.base_url.geturl()}
+        return await super(MangaBuddyClient, self).get_picture(manga_chapter, url, *args, headers=headers, **kwargs)

plugins/mangadex.py

@@ -0,0 +1,167 @@
+import json
+from dataclasses import dataclass
+from typing import List, AsyncIterable
+from urllib.parse import urlparse, urljoin, quote
+
+from plugins.client import MangaClient, MangaCard, MangaChapter, LastChapter
+
+
+@dataclass
+class MangaDexMangaCard(MangaCard):
+    id: str
+
+    def get_url(self):
+        return f"https://mangadex.org/title/{self.id}"
+
+
+@dataclass
+class MangaDexMangaChapter(MangaChapter):
+    id: str
+
+    def get_url(self):
+        return f"https://mangadex.org/chapter/{self.id}"
+
+
+class MangaDexClient(MangaClient):
+    base_url = urlparse("https://api.mangadex.org/")
+    search_url = urljoin(base_url.geturl(), "manga")
+    search_param = 'q'
+    latest_uploads = 'https://api.mangadex.org/chapter?limit=32&offset=0&includes[]=manga&contentRating[]=safe&contentRating[]=suggestive&contentRating[]=erotica&order[readableAt]=desc'
+
+    covers_url = urlparse("https://uploads.mangadex.org/covers")
+
+    pre_headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:97.0) Gecko/20100101 Firefox/97.0'
+    }
+
+    def __init__(self, *args, name="MangaDex", language=None, **kwargs):
+        if language is None:
+            language = ("en",)
+        super().__init__(*args, name=f'{name}-{language[0]}', headers=self.pre_headers, **kwargs)
+        self.languages = language
+        self.language_param = '&'.join([f'translatedLanguage[]={lang}' for lang in self.languages])
+
+    def mangas_from_page(self, page: bytes):
+        dt = json.loads(page.decode())
+
+        cards = dt['data']
+
+        names = [list(card['attributes']['title'].values())[0] for card in cards]
+        ids = [card["id"] for card in cards]
+
+        url = [f'https://api.mangadex.org/manga/{card["id"]}/feed?{self.language_param}' for card in cards]
+
+        cover_filename = lambda x: list(filter(lambda y: y['type'] == 'cover_art', x))[0]['attributes']['fileName']
+
+        images = [f'https://uploads.mangadex.org/covers/{card["id"]}/{cover_filename(card["relationships"])}.512.jpg'
+                  for card in cards]
+
+        mangas = [MangaDexMangaCard(self, *tup) for tup in zip(names, url, images, ids)]
+
+        return mangas
+
+    def chapters_from_page(self, page: bytes, manga: MangaCard = None):
+        dt = json.loads(page.decode())
+
+        dt_chapters = dt['data']
+
+        visited = set()
+        chapters = []
+        for chapter in dt_chapters:
+            if chapter["attributes"]["chapter"] not in visited:
+                visited.add(chapter["attributes"]["chapter"])
+                chapters.append(chapter)
+
+        def chapter_name(c):
+            if c["attributes"]["title"]:
+                return f'{c["attributes"]["chapter"]} - {c["attributes"]["title"]}'
+            return f'{c["attributes"]["chapter"]}'
+
+        ids = [chapter.get("id") for chapter in chapters]
+        links = [f'https://api.mangadex.org/at-home/server/{chapter.get("id")}?forcePort443=false' for chapter in
+                 chapters]
+        texts = [chapter_name(chapter) for chapter in chapters]
+
+        return list(map(lambda x: MangaDexMangaChapter(self, x[0], x[1], manga, [], x[2]), zip(texts, links, ids)))
+
+    async def pictures_from_chapters(self, content: bytes, response=None):
+        dt = json.loads(content)
+
+        if dt.get('result') == 'error':
+            return []
+
+        base_url = dt['baseUrl']
+        chapter_hash = dt['chapter']['hash']
+        file_names = dt['chapter']['data']
+
+        images_url = [f"{base_url}/data/{chapter_hash}/{file}" for file in file_names]
+
+        return images_url
+
+    async def search(self, query: str = "", page: int = 1) -> List[MangaCard]:
+        query = quote(query)
+
+        request_url = f'{self.search_url}?limit=20&offset={(page - 1) * 20}&includes[]=cover_art&includes[]=author&includes[' \
+                      f']=artist&contentRating[]=safe&contentRating[]=suggestive&contentRating[' \
+                      f']=erotica&title={query}&order[relevance]=desc'
+
+        content = await self.get_url(request_url)
+
+        return self.mangas_from_page(content)
+
+    async def get_chapters(self, manga_card: MangaCard, page: int = 1, count: int = 10) -> List[MangaChapter]:
+
+        request_url = f'{manga_card.url}' \
+                      f'&limit={count}&offset={(page - 1) * count}&includes[' \
+                      f']=scanlation_group&includes[]=user&order[volume]=desc&order[' \
+                      f'chapter]=desc&contentRating[]=safe&contentRating[]=suggestive&contentRating[' \
+                      f']=erotica&contentRating[]=pornographic'
+
+        content = await self.get_url(request_url)
+
+        return self.chapters_from_page(content, manga_card)
+
+    async def iter_chapters(self, manga_url: str, manga_name) -> AsyncIterable[MangaChapter]:
+        manga = MangaCard(self, manga_name, manga_url, '')
+        page = 1
+        while page > 0:
+            chapters = await self.get_chapters(manga_card=manga, page=page, count=500)
+            if not chapters:
+                break
+            for chapter in chapters:
+                yield chapter
+            page += 1
+
+    async def contains_url(self, url: str):
+        return url.startswith(self.base_url.geturl()) and url.endswith(self.language_param)
+
+    async def check_updated_urls(self, last_chapters: List[LastChapter]):
+
+        content = await self.get_url(f'{self.latest_uploads}&{self.language_param}')
+
+        data = json.loads(content)['data']
+
+        updates = {}
+        for item in data:
+            ch_id = item['id']
+            manga_id = None
+            for rel in item['relationships']:
+                if rel['type'] == 'manga':
+                    manga_id = rel['id']
+            if manga_id and not updates.get(manga_id):
+                updates[manga_id] = ch_id
+
+        updated = []
+        not_updated = []
+
+        for lc in last_chapters:
+            upd = False
+            for manga_id, ch_id in updates.items():
+                if manga_id in lc.url and not ch_id in lc.chapter_url:
+                    upd = True
+                    updated.append(lc.url)
+                    break
+            if not upd:
+                not_updated.append(lc.url)
+
+        return updated, not_updated

plugins/mangahasu.py

@@ -0,0 +1,125 @@
+from typing import List, AsyncIterable
+from urllib.parse import urlparse, urljoin, quote, quote_plus
+
+from bs4 import BeautifulSoup
+
+from models import LastChapter
+from plugins.client import MangaClient, MangaCard, MangaChapter
+
+
+class MangaHasuClient(MangaClient):
+    base_url = urlparse("https://mangahasu.se/")
+    search_url = urljoin(base_url.geturl(), "search/autosearch")
+    search_param = 'key'
+
+    pre_headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:97.0) Gecko/20100101 Firefox/97.0'
+    }
+
+    def __init__(self, *args, name="MangaHasu", **kwargs):
+        super().__init__(*args, name=name, headers=self.pre_headers, **kwargs)
+
+    def mangas_from_page(self, page: bytes):
+        bs = BeautifulSoup(page, "html.parser")
+
+        cards = bs.find_all("li")[:-1]
+
+        mangas = [card.a for card in cards]
+        names = [manga.findNext('p', {'class': 'name'}).text.strip() for manga in mangas]
+        url = [manga.get('href').strip() for manga in mangas]
+        images = [manga.find("img").get('src').strip() for manga in mangas]
+
+        mangas = [MangaCard(self, *tup) for tup in zip(names, url, images)]
+
+        return mangas
+
+    def chapters_from_page(self, page: bytes, manga: MangaCard = None):
+        bs = BeautifulSoup(page, "html.parser")
+
+        div = bs.find("div", {"class": "list-chapter"})
+
+        lis = div.findAll('tr')[1:]
+        a_elems = [li.find('a') for li in lis]
+
+        links = [a.get('href') for a in a_elems]
+        texts = [(a.text if not a.text.startswith(manga.name) else a.text[len(manga.name):]).strip() for a in a_elems]
+
+        return list(map(lambda x: MangaChapter(self, x[0], x[1], manga, []), zip(texts, links)))
+
+    def updates_from_page(self, page: bytes):
+        bs = BeautifulSoup(page, "html.parser")
+
+        div = bs.find('div', {'class': 'st_content'})
+
+        manga_items = div.find_all('div', {'class': 'info-manga'})
+
+        urls = dict()
+
+        for manga_item in manga_items:
+
+            manga_url = manga_item.findNext('a',  {"class": "name-manga"}).get('href')
+
+            chapter_item = manga_item.findNext("a", {"class": "name-chapter"})
+            if not chapter_item:
+                continue
+            chapter_url = chapter_item.get('href')
+
+            if manga_url not in urls:
+                urls[manga_url] = chapter_url
+
+        return urls
+
+    async def pictures_from_chapters(self, content: bytes, response=None):
+        bs = BeautifulSoup(content, "html.parser")
+
+        div = bs.find('div', {'class': 'img'})
+
+        imgs = div.findAll('img')
+
+        images_url = [quote(img.get('src'), safe=':/%') for img in imgs]
+
+        return images_url
+
+    async def search(self, query: str = "", page: int = 1) -> List[MangaCard]:
+        request_url = self.search_url
+
+        data = {
+            self.search_param: query
+        }
+
+        content = await self.get_url(request_url, data=data, method='post')
+
+        return self.mangas_from_page(content)
+
+    async def get_chapters(self, manga_card: MangaCard, page: int = 1) -> List[MangaChapter]:
+
+        request_url = f'{manga_card.url}'
+
+        content = await self.get_url(request_url)
+
+        return self.chapters_from_page(content, manga_card)[(page - 1) * 20:page * 20]
+
+    async def iter_chapters(self, manga_url: str, manga_name) -> AsyncIterable[MangaChapter]:
+        manga_card = MangaCard(self, manga_name, manga_url, '')
+
+        request_url = f'{manga_card.url}'
+
+        content = await self.get_url(request_url)
+
+        for chapter in self.chapters_from_page(content, manga_card):
+            yield chapter
+
+    async def contains_url(self, url: str):
+        return url.startswith(self.base_url.geturl())
+
+    async def check_updated_urls(self, last_chapters: List[LastChapter]):
+
+        content = await self.get_url(self.base_url.geturl())
+
+        updates = self.updates_from_page(content)
+
+        updated = [lc.url for lc in last_chapters if updates.get(lc.url) and updates.get(lc.url) != lc.chapter_url]
+        not_updated = [lc.url for lc in last_chapters if not updates.get(lc.url)
+                       or updates.get(lc.url) == lc.chapter_url]
+
+        return updated, not_updated

plugins/mangakakalot.py

@@ -0,0 +1,141 @@
+import json
+from typing import List, AsyncIterable
+from urllib.parse import urlparse, urljoin, quote
+import re
+
+from bs4 import BeautifulSoup
+from bs4.element import PageElement
+
+from plugins.manganato import ManganatoClient
+from plugins.client import MangaClient, MangaCard, MangaChapter, LastChapter
+
+
+class MangaKakalotClient(MangaClient):
+
+    base_url = urlparse("https://mangakakalot.com/")
+    search_url = urljoin(base_url.geturl(), 'home_json_search')
+    search_param = 'searchword'
+
+    pre_headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:97.0) Gecko/20100101 Firefox/97.0'
+    }
+
+    def __init__(self, *args, name="MangaKakalot", **kwargs):
+        super().__init__(*args, name=name, headers=self.pre_headers, **kwargs)
+
+    def mangas_from_page(self, page: bytes):
+        li = json.loads(page)
+
+        pattern = re.compile(r'<span .*?>(.+?)</span>')
+
+        names = []
+        for item in li:
+            name = item['name']
+            while '</span>' in name:
+                name = re.sub(pattern, r'\1', name)
+            names.append(name.title())
+
+        url = [item['story_link'] for item in li]
+        images = [item['image'] for item in li]
+
+        mangas = [MangaCard(self if tup[1].startswith(self.base_url.geturl()) else ManganatoClient(), *tup)
+                  for tup in zip(names, url, images)]
+
+        return mangas
+
+    def chapters_from_page(self, page: bytes, manga: MangaCard = None):
+        bs = BeautifulSoup(page, "html.parser")
+
+        ul = bs.find("div", {"class": "chapter-list"})
+
+        lis = ul.findAll("div", {"class": "row"})
+
+        items = [li.findNext('a') for li in lis]
+
+        links = [item.get('href') for item in items]
+        texts = [item.string.strip() for item in items]
+
+        return list(map(lambda x: MangaChapter(self, x[0], x[1], manga, []), zip(texts, links)))
+
+    def updates_from_page(self, page: bytes):
+        bs = BeautifulSoup(page, "html.parser")
+
+        manga_items: List[PageElement] = bs.find_all("div", {"class": "itemupdate first"})
+
+        urls = dict()
+
+        for manga_item in manga_items:
+
+            manga_url = manga_item.findNext('a').get('href')
+
+            chapter_item = manga_item.findNext("a", {"class": "sts sts_1"})
+            if not chapter_item:
+                continue
+            chapter_url = chapter_item.get('href')
+
+            urls[manga_url] = chapter_url
+
+        return urls
+
+    async def pictures_from_chapters(self, content: bytes, response=None):
+        bs = BeautifulSoup(content, "html.parser")
+
+        ul = bs.find("div", {"class": "container-chapter-reader"})
+
+        images = ul.find_all('img')
+
+        images_url = [quote(img.get('src'), safe=':/%') for img in images]
+
+        return images_url
+
+    async def get_picture(self, manga_chapter: MangaChapter, url, *args, **kwargs):
+        headers = dict(self.headers)
+        headers['Referer'] = self.base_url.geturl()
+
+        return await super(MangaKakalotClient, self).get_picture(manga_chapter, url, headers=headers, *args, **kwargs)
+
+    async def search(self, query: str = "", page: int = 1) -> List[MangaCard]:
+        query = query.lower().replace(' ', '_')
+
+        request_url = self.search_url
+
+        data = {
+            self.search_param: query
+        }
+
+        content = await self.get_url(request_url, data=data, method='post')
+
+        return self.mangas_from_page(content)
+
+    async def get_chapters(self, manga_card: MangaCard, page: int = 1) -> List[MangaChapter]:
+
+        request_url = f'{manga_card.url}'
+
+        content = await self.get_url(request_url)
+
+        return self.chapters_from_page(content, manga_card)[(page - 1) * 20:page * 20]
+
+    async def iter_chapters(self, manga_url: str, manga_name) -> AsyncIterable[MangaChapter]:
+        manga_card = MangaCard(self, manga_name, manga_url, '')
+
+        request_url = f'{manga_card.url}'
+
+        content = await self.get_url(request_url)
+
+        for chapter in self.chapters_from_page(content, manga_card):
+            yield chapter
+
+    async def contains_url(self, url: str):
+        return url.startswith(self.base_url.geturl())
+
+    async def check_updated_urls(self, last_chapters: List[LastChapter]):
+
+        content = await self.get_url(self.base_url.geturl())
+
+        updates = self.updates_from_page(content)
+
+        updated = [lc.url for lc in last_chapters if updates.get(lc.url) and updates.get(lc.url) != lc.chapter_url]
+        not_updated = [lc.url for lc in last_chapters if not updates.get(lc.url)
+                       or updates.get(lc.url) == lc.chapter_url]
+
+        return updated, not_updated

plugins/manganato.py

@@ -0,0 +1,144 @@
+import json
+from typing import List, AsyncIterable
+from urllib.parse import urlparse, urljoin, quote
+import re
+
+from bs4 import BeautifulSoup
+from bs4.element import PageElement
+
+from plugins.client import MangaClient, MangaCard, MangaChapter, LastChapter
+
+
+class ManganatoClient(MangaClient):
+
+    base_url = urlparse("https://manganato.com/")
+    search_url = urljoin(base_url.geturl(), 'getstorysearchjson')
+    search_param = 'searchword'
+    read_url = 'https://readmanganato.com/'
+    chap_url = 'https://chapmanganato.com/'
+
+    pre_headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:97.0) Gecko/20100101 Firefox/97.0'
+    }
+
+    def __init__(self, *args, name="Manganato", **kwargs):
+        super().__init__(*args, name=name, headers=self.pre_headers, **kwargs)
+
+    def mangas_from_page(self, page: bytes):
+        li = json.loads(page)
+
+        pattern = re.compile(r'<span .*?>(.+?)</span>')
+
+        items = li['searchlist']
+        names = []
+        for item in items:
+            name = item['name']
+            while '</span>' in name:
+                name = re.sub(pattern, r'\1', name)
+            names.append(name.title())
+
+        url = [item['url_story'] for item in items]
+        images = [item['image'] for item in items]
+
+        mangas = [MangaCard(self, *tup) for tup in zip(names, url, images)]
+
+        return mangas
+
+    def chapters_from_page(self, page: bytes, manga: MangaCard = None):
+        bs = BeautifulSoup(page, "html.parser")
+
+        lis = bs.find_all("li", {"class": "a-h"})
+
+        items = [li.findNext('a') for li in lis]
+
+        links = [item.get('href') for item in items]
+        texts = [item.string.strip() for item in items]
+
+        return list(map(lambda x: MangaChapter(self, x[0], x[1], manga, []), zip(texts, links)))
+
+    def updates_from_page(self, page: bytes):
+        bs = BeautifulSoup(page, "html.parser")
+
+        manga_items: List[PageElement] = bs.find_all("div", {"class": "content-homepage-item"})
+
+        urls = dict()
+
+        for manga_item in manga_items:
+
+            manga_url = manga_item.findNext('a').get('href')
+
+            chapter_item = manga_item.findNext("p", {"class": "a-h item-chapter"})
+            if not chapter_item:
+                continue
+            chapter_url = chapter_item.findNext("a").get('href')
+
+            urls[manga_url] = chapter_url
+
+        return urls
+
+    async def pictures_from_chapters(self, content: bytes, response=None):
+        bs = BeautifulSoup(content, "html.parser")
+
+        ul = bs.find("div", {"class": "container-chapter-reader"})
+
+        images = ul.find_all('img')
+
+        images_url = [quote(img.get('src'), safe=':/%') for img in images]
+
+        return images_url
+
+    async def get_picture(self, manga_chapter: MangaChapter, url, *args, **kwargs):
+        pattern = re.compile(r'(.*\.com/)')
+        match = re.match(pattern, manga_chapter.url)
+        referer = match.group(1)
+
+        headers = dict(self.headers)
+        headers['Referer'] = referer
+
+        return await super(ManganatoClient, self).get_picture(manga_chapter, url, headers=headers, *args, **kwargs)
+
+    async def search(self, query: str = "", page: int = 1) -> List[MangaCard]:
+        query = query.lower().replace(' ', '_')
+
+        request_url = self.search_url
+
+        data = {
+            self.search_param: query
+        }
+
+        content = await self.get_url(request_url, data=data, method='post')
+
+        return self.mangas_from_page(content)
+
+    async def get_chapters(self, manga_card: MangaCard, page: int = 1) -> List[MangaChapter]:
+
+        request_url = f'{manga_card.url}'
+
+        content = await self.get_url(request_url)
+
+        return self.chapters_from_page(content, manga_card)[(page - 1) * 20:page * 20]
+
+    async def iter_chapters(self, manga_url: str, manga_name) -> AsyncIterable[MangaChapter]:
+        manga_card = MangaCard(self, manga_name, manga_url, '')
+
+        request_url = f'{manga_card.url}'
+
+        content = await self.get_url(request_url)
+
+        for chapter in self.chapters_from_page(content, manga_card):
+            yield chapter
+
+    async def contains_url(self, url: str):
+        return url.startswith(self.read_url) or url.startswith(self.base_url.geturl()) or url.startswith(self.chap_url)
+
+    async def check_updated_urls(self, last_chapters: List[LastChapter]):
+
+        content = await self.get_url(self.base_url.geturl())
+
+        updates = self.updates_from_page(content)
+
+        updated = [lc.url for lc in last_chapters if updates.get(lc.url) and updates.get(lc.url) != lc.chapter_url]
+        not_updated = [lc.url for lc in last_chapters if not updates.get(lc.url)
+                       or updates.get(lc.url) == lc.chapter_url]
+
+        return updated, not_updated

plugins/manganelo.py

@@ -0,0 +1,128 @@
+from typing import List, AsyncIterable
+from urllib.parse import urlparse, urljoin, quote
+
+from bs4 import BeautifulSoup
+
+from plugins.client import MangaClient, MangaCard, MangaChapter, LastChapter
+
+
+class ManganeloClient(MangaClient):
+
+    base_url = urlparse("https://m.manganelo.com/")
+    search_url = urljoin(base_url.geturl(), "search/story/")
+    updates_url = urljoin(base_url.geturl(), "genre-all-update-latest")
+    chapter_url = "https://chapmanganelo.com/"
+
+    pre_headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:97.0) Gecko/20100101 Firefox/97.0'
+    }
+
+    def __init__(self, *args, name="Manganelo", **kwargs):
+        super().__init__(*args, name=name, headers=self.pre_headers, **kwargs)
+
+    def mangas_from_page(self, page: bytes):
+        bs = BeautifulSoup(page, "html.parser")
+
+        cards = bs.find_all("div", {"class": "search-story-item"})
+
+        mangas = [card.findNext('a') for card in cards]
+        names = [manga.get('title') for manga in mangas]
+        url = [manga.get("href") for manga in mangas]
+        images = [manga.findNext("img").get("src") for manga in mangas]
+
+        mangas = [MangaCard(self, *tup) for tup in zip(names, url, images)]
+
+        return mangas
+
+    def chapters_from_page(self, page: bytes, manga: MangaCard = None):
+        bs = BeautifulSoup(page, "html.parser")
+
+        lis = bs.find_all("li", {"class": "a-h"})
+
+        items = [li.findNext('a') for li in lis]
+
+        links = [item.get("href") for item in items]
+        texts = [item.string for item in items]
+
+        return list(map(lambda x: MangaChapter(self, x[0], x[1], manga, []), zip(texts, links)))
+
+    def updates_from_page(self, content):
+        bs = BeautifulSoup(content, "html.parser")
+
+        manga_items = bs.find_all("div", {"class": "content-genres-item"})
+
+        urls = dict()
+
+        for manga_item in manga_items:
+            manga_url = manga_item.findNext("a", {"class": "genres-item-img"}).get("href")
+
+            if manga_url in urls:
+                continue
+
+            chapter_url = manga_item.findNext('a', {'class': 'genres-item-chap'}).get('href')
+
+            urls[manga_url] = chapter_url
+
+        return urls
+
+    async def pictures_from_chapters(self, content: bytes, response=None):
+        bs = BeautifulSoup(content, "html.parser")
+
+        ul = bs.find("div", {"class": "container-chapter-reader"})
+
+        images = ul.find_all('img')
+
+        images_url = [quote(img.get('src'), safe=':/%') for img in images]
+
+        return images_url
+
+    async def search(self, query: str = "", page: int = 1) -> List[MangaCard]:
+        query = quote(query.replace(' ', '_').lower())
+
+        request_url = f'{self.search_url}'
+
+        if query:
+            request_url += f'{query}'
+
+        content = await self.get_url(request_url)
+
+        return self.mangas_from_page(content)
+
+    async def get_chapters(self, manga_card: MangaCard, page: int = 1) -> List[MangaChapter]:
+
+        request_url = f'{manga_card.url}'
+
+        content = await self.get_url(request_url)
+
+        return self.chapters_from_page(content, manga_card)[(page - 1) * 20:page * 20]
+
+    async def iter_chapters(self, manga_url: str, manga_name) -> AsyncIterable[MangaChapter]:
+        manga_card = MangaCard(self, manga_name, manga_url, '')
+
+        request_url = f'{manga_card.url}'
+
+        content = await self.get_url(request_url)
+
+        for chapter in self.chapters_from_page(content, manga_card):
+            yield chapter
+
+    def get_picture(self, manga_chapter: MangaChapter, url, *args, **kwargs):
+        headers = dict(self.headers)
+        headers['Referer'] = self.chapter_url
+
+        return self.get_url(url, headers=headers, *args, **kwargs)
+
+    async def contains_url(self, url: str):
+        return url.startswith(self.base_url.geturl()) or url.startswith(self.chapter_url)
+
+    async def check_updated_urls(self, last_chapters: List[LastChapter]):
+
+        content = await self.get_url(self.updates_url)
+
+        updates = self.updates_from_page(content)
+
+        updated = [lc.url for lc in last_chapters if updates.get(lc.url) and updates.get(lc.url) != lc.chapter_url]
+        not_updated = [lc.url for lc in last_chapters if
+                       not updates.get(lc.url) or updates.get(lc.url) == lc.chapter_url]
+
+        return updated, not_updated

plugins/mangasee.py

@@ -0,0 +1,185 @@
+import json
+import re
+from typing import List, AsyncIterable
+from urllib.parse import urlparse, urljoin, quote_plus
+
+from plugins.client import MangaClient, MangaCard, MangaChapter, LastChapter
+from .search_engine import search
+
+
+class MangaSeeClient(MangaClient):
+    base_url = urlparse("https://mangasee123.com/")
+    search_url = urljoin(base_url.geturl(), "_search.php")
+    manga_url = urljoin(base_url.geturl(), "manga")
+    chapter_url = urljoin(base_url.geturl(), "read-online")
+    cover_url = "https://cover.nep.li/cover"
+
+    pre_headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:97.0) Gecko/20100101 Firefox/97.0'
+    }
+
+    def __init__(self, *args, name="Mangasee", **kwargs):
+        super().__init__(*args, name=name, headers=self.pre_headers, **kwargs)
+
+    def mangas_from_page(self, documents: List):
+        names = [doc['s'] for doc in documents]
+        url = [f"{self.manga_url}/{doc['i']}" for doc in documents]
+        images = [f"{self.cover_url}/{doc['i']}.jpg" for doc in documents]
+
+        mangas = [MangaCard(self, *tup) for tup in zip(names, url, images)]
+
+        return mangas
+
+    def chapter_url_encode(self, chapter):
+        chapter = chapter['Chapter']
+        Index = ""
+        t = chapter[0:1]
+        if t != '1':
+            Index = "-index-" + t
+        n = int(chapter[1:-1])
+        m = ""
+        a = chapter[-1]
+        if a != '0':
+            m = "." + a
+        return "-chapter-" + str(n) + m + Index + ".html"
+
+    def chapter_display(self, chapter):
+        chapter = chapter['Chapter']
+        t = int(chapter[1:-1])
+        n = chapter[-1]
+        return t if n == '0' else str(t) + "." + n
+
+    def chapters_from_page(self, page: bytes, manga: MangaCard = None):
+
+        chap_pat = re.compile('vm.Chapters = ([\s\S]*?);')
+        chapters_str_list = chap_pat.findall(page.decode())
+        if not chapters_str_list:
+            return []
+
+        chapter_list = json.loads(chapters_str_list[0])
+
+        index_pat = re.compile('vm.IndexName = ([\s\S]*?);')
+        index_str_list = index_pat.findall(page.decode())
+        if not index_str_list:
+            return []
+
+        index_str = json.loads(index_str_list[0])
+
+        for ch in chapter_list:
+            if not ch.get('Type'):
+                ch['Type'] = 'Chapter'
+
+        links = [f"{self.chapter_url}/{index_str}{self.chapter_url_encode(ch)}" for ch in chapter_list]
+        texts = [f"{ch.get('Type')} {self.chapter_display(ch)}" for ch in chapter_list]
+
+        return list(map(lambda x: MangaChapter(self, x[0], x[1], manga, []), zip(texts, links)))
+
+    def updates_from_page(self, page: bytes):
+
+        chap_pat = re.compile(r'vm.LatestJSON = (\[[\s\S]*?]);')
+        chapters_str_list = chap_pat.findall(page.decode())
+        if not chapters_str_list:
+            return []
+
+        chapter_list = json.loads(chapters_str_list[0])
+
+        urls = [f"{self.manga_url}/{ch['IndexName']}" for ch in chapter_list]
+        chapter_urls = [f"{self.chapter_url}/{ch['IndexName']}{self.chapter_url_encode(ch)}" for ch in chapter_list]
+
+        urls = dict(zip(urls[:32], chapter_urls[:32]))
+
+        return urls
+
+    def chapterImage(self, ChapterString):
+        Chapter = ChapterString[1:-1]
+        Odd = ChapterString[-1]
+        if Odd == '0':
+            return Chapter
+        else:
+            return Chapter + "." + Odd
+
+    def pageImage(self, PageString):
+        s = "000" + str(PageString)
+        return s[-3:]
+
+    async def pictures_from_chapters(self, content: bytes, response=None):
+
+        chap_pat = re.compile('vm.CurChapter = ([\s\S]*?);')
+        chap_str_list = chap_pat.findall(content.decode())
+        if not chap_str_list:
+            return []
+
+        curChapter = json.loads(chap_str_list[0])
+
+        path_pat = re.compile('vm.CurPathName = ([\s\S]*?);')
+        path_str_list = path_pat.findall(content.decode())
+        if not path_str_list:
+            return []
+
+        curPath = json.loads(path_str_list[0])
+
+        index_pat = re.compile('vm.IndexName = ([\s\S]*?);')
+        index_str_list = index_pat.findall(content.decode())
+        if not index_str_list:
+            return []
+
+        index_str = json.loads(index_str_list[0])
+
+        pages = list(range(1, int(curChapter['Page']) + 1))
+
+        images_url = [
+            f"https://{curPath}/manga/{index_str}/{'' if curChapter['Directory'] == '' else curChapter['Directory'] + '/'}{self.chapterImage(curChapter['Chapter'])}-{self.pageImage(page)}.png"
+            for page in pages]
+
+        return images_url
+
+    async def search(self, query: str = "", page: int = 1) -> List[MangaCard]:
+        def text_from_document(doc) -> str:
+            return doc['s'] + ' ' + ' '.join(doc['a'])
+
+        def title_from_document(doc) -> str:
+            return doc['i']
+
+        request_url = self.search_url
+
+        content = await self.get_url(request_url, method="post")
+
+        documents = json.loads(content)
+
+        results = search(query, documents, title_from_document, text_from_document)[(page - 1) * 20:page * 20]
+
+        return self.mangas_from_page(results)
+
+    async def get_chapters(self, manga_card: MangaCard, page: int = 1) -> List[MangaChapter]:
+
+        request_url = f'{manga_card.url}'
+
+        content = await self.get_url(request_url)
+
+        return self.chapters_from_page(content, manga_card)[(page - 1) * 20:page * 20]
+
+    async def iter_chapters(self, manga_url: str, manga_name) -> AsyncIterable[MangaChapter]:
+
+        manga_card = MangaCard(self, manga_name, manga_url, '')
+
+        request_url = f'{manga_card.url}'
+
+        content = await self.get_url(request_url)
+
+        for ch in self.chapters_from_page(content, manga_card):
+            yield ch
+
+    async def contains_url(self, url: str):
+        return url.startswith(self.base_url.geturl())
+
+    async def check_updated_urls(self, last_chapters: List[LastChapter]):
+
+        content = await self.get_url(self.base_url.geturl())
+
+        updates = self.updates_from_page(content)
+
+        updated = [lc.url for lc in last_chapters if updates.get(lc.url) and updates.get(lc.url) != lc.chapter_url]
+        not_updated = [lc.url for lc in last_chapters if
+                       not updates.get(lc.url) or updates.get(lc.url) == lc.chapter_url]
+
+        return updated, not_updated

plugins/mangasin.py

@@ -0,0 +1,145 @@
+import re
+from typing import List, AsyncIterable
+import json
+from urllib.parse import urlparse, urljoin, quote, quote_plus
+from dataclasses import dataclass
+
+from bs4 import BeautifulSoup
+from bs4.element import PageElement
+
+from plugins.client import MangaClient, MangaCard, MangaChapter
+from models import LastChapter
+
+@dataclass
+class MangaSinMangaCard(MangaCard):
+    data: str
+
+class MangasInClient(MangaClient):
+
+    base_url = urlparse("https://mangas.in/")
+    search_url = urljoin(base_url.geturl(), "search")
+    search_param = 'q'
+
+    pre_headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:97.0) Gecko/20100101 Firefox/97.0'
+    }
+
+    def __init__(self, *args, name="MangasIn", **kwargs):
+        super().__init__(*args, name=name, headers=self.pre_headers, **kwargs)
+
+    def build_cover_url(self, data: str):
+        return f"{self.base_url.geturl()}uploads/manga/{data}/cover/cover_250x350.jpg"
+
+    def build_manga_url(self, data: str):
+        return f"{self.base_url.geturl()}manga/{data}"
+
+    def build_chapter_url(self, manga: MangaSinMangaCard, chapter: str):
+        return f"{self.base_url.geturl()}manga/{manga.data}/{chapter}"
+
+    def build_chapter_name(self, li_tag: PageElement):
+        name_div = li_tag.findNext('eee')
+        if not name_div or name_div.findPrevious('li') != li_tag:
+            name_div = li_tag.findNext('fff')
+        name = name_div.a.text
+
+        number = li_tag.findNext('a').get('data-number')
+
+        return f"{number} - {name}"
+
+    def mangas_from_page(self, page: bytes):
+        mangas = json.loads(page)
+
+        names = [manga['value'] for manga in mangas]
+        datas = [manga['data'] for manga in mangas]
+        url = [self.build_manga_url(data) for data in datas]
+        images = [self.build_cover_url(data) for data in datas]
+
+        mangas = [MangaSinMangaCard(self, *tup) for tup in zip(names, url, images, datas)]
+
+        return mangas
+
+    def chapters_from_page(self, page: bytes, manga: MangaCard = None):
+
+        regex = rb"var .*? = (.*?);"
+
+        chapters_text = max([var for var in re.findall(regex, page, re.DOTALL) if b'manga_id' in var], key=len)
+        chapters = json.loads(chapters_text)
+
+        texts = [chapter['number'] for chapter in chapters]
+        links = [f"{manga.url}/{chapter['slug']}" for chapter in chapters]
+
+        return list(map(lambda x: MangaChapter(self, x[0], x[1], manga, []), zip(texts, links)))
+
+    def updates_from_page(self, page: bytes):
+        bs = BeautifulSoup(page, "html.parser")
+
+        manga_items: List[PageElement] = bs.find_all("div", {"class": "manga-item"})
+
+        urls = dict()
+
+        for manga_item in manga_items:
+
+            manga_url = manga_item.findNext('a').findNextSibling('a').get('href')
+
+            chapter_item = manga_item.findNext("div", {"class": "manga-chapter"})
+            chapter_url = chapter_item.findNext("a").get('href')
+
+            urls[manga_url] = chapter_url
+
+        return urls
+
+    async def pictures_from_chapters(self, content: bytes, response=None):
+        bs = BeautifulSoup(content, "html.parser")
+
+        ul = bs.find("div", {"id": "all"})
+
+        images = ul.find_all('img')
+
+        images_url = [quote(img.get('data-src'), safe=':/%') for img in images]
+
+        return images_url
+
+
+    async def search(self, query: str = "", page: int = 1) -> List[MangaCard]:
+        query = quote_plus(query)
+
+        request_url = f'{self.search_url}'
+
+        if query:
+            request_url += f'?{self.search_param}={query}'
+
+        content = await self.get_url(request_url)
+
+        return self.mangas_from_page(content)[(page - 1) * 10:page * 10]
+
+    async def get_chapters(self, manga_card: MangaCard, page: int = 1) -> List[MangaChapter]:
+
+        request_url = f'{manga_card.url}'
+
+        content = await self.get_url(request_url)
+
+        return self.chapters_from_page(content, manga_card)[(page - 1) * 10:page * 10]
+
+    async def iter_chapters(self, manga_url: str, manga_name) -> AsyncIterable[MangaChapter]:
+        manga = MangaCard(self, manga_name, manga_url, '')
+
+        request_url = f'{manga.url}'
+
+        content = await self.get_url(request_url)
+
+        for chapter in self.chapters_from_page(content, manga):
+            yield chapter
+
+    async def contains_url(self, url: str):
+        return url.startswith(self.base_url.geturl())
+
+    async def check_updated_urls(self, last_chapters: List[LastChapter]):
+
+        content = await self.get_url(self.base_url.geturl())
+
+        updates = self.updates_from_page(content)
+
+        updated = [lc.url for lc in last_chapters if updates.get(lc.url) and updates.get(lc.url) != lc.chapter_url]
+        not_updated = [lc.url for lc in last_chapters if not updates.get(lc.url) or updates.get(lc.url) == lc.chapter_url]
+
+        return updated, not_updated

plugins/mangatigre.py

@@ -0,0 +1,150 @@
+import json
+from typing import List, AsyncIterable
+from urllib.parse import urlparse, urljoin, quote, quote_plus
+
+from aiohttp import ClientResponse
+from bs4 import BeautifulSoup
+from bs4.element import PageElement
+
+from plugins.client import MangaClient, MangaCard, MangaChapter, LastChapter
+
+
+class MangatigreClient(MangaClient):
+
+    base_url = urlparse("https://www.mangatigre.net/")
+    search_url = urljoin(base_url.geturl(), 'mangas/search')
+    manga_url = urljoin(base_url.geturl(), 'manga')
+    img_url = urlparse("https://i2.mtcdn.xyz/")
+    cover_url = urljoin(img_url.geturl(), "mangas")
+    search_param = 'query'
+
+    pre_headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:97.0) Gecko/20100101 Firefox/97.0'
+    }
+
+    def __init__(self, *args, name="Mangatigre", **kwargs):
+        super().__init__(*args, name=name, headers=self.pre_headers, **kwargs)
+
+    def mangas_from_page(self, page: bytes):
+        dt = json.loads(page)
+        mangas = dt['result']
+
+        names = [manga.get('name') for manga in mangas]
+        url = [f"{self.manga_url}/{manga.get('slug')}" for manga in mangas]
+        images = [f"{self.cover_url}/{manga.get('image')}" for manga in mangas]
+
+        mangas = [MangaCard(self, *tup) for tup in zip(names, url, images)]
+
+        return mangas
+
+    def chapters_from_page(self, page: bytes, manga: MangaCard = None):
+        bs = BeautifulSoup(page, "html.parser")
+
+        ul = bs.find('ul', {'class': 'list-unstyled'})
+        lis = ul.find_all("li")
+
+        items = [li.findNext('a') for li in lis]
+
+        links = [item.get('href') for item in items]
+        texts = [item.get('title').split(':')[0] for item in items]
+
+        return list(map(lambda x: MangaChapter(self, x[0], x[1], manga, []), zip(texts, links)))
+
+    def updates_from_page(self, page: bytes):
+        bs = BeautifulSoup(page, "html.parser")
+
+        manga_items: List[PageElement] = bs.find_all("article", {"class": "chapter-block"})
+
+        urls = dict()
+
+        for manga_item in manga_items:
+
+            manga_url = manga_item.findNext('a').get('href')
+
+            chapter_item = manga_item.findNext("div", {"class": "chapter"})
+            chapter_url = chapter_item.findNext("a").get('href')
+
+            urls[manga_url] = chapter_url
+
+        return urls
+
+    async def pictures_from_chapters(self, content: bytes, response: ClientResponse = None):
+        bs = BeautifulSoup(content, "html.parser")
+
+        btn = bs.find('button', {'data-read-type': 2})
+        if btn:
+            token = btn.get('data-token')
+
+            data = {
+                '_method': 'patch',
+                '_token': token,
+                'read_type': 2
+            }
+
+            content = await self.get_url(f'{response.url}/read-type', data=data, method='post')
+            bs = BeautifulSoup(content, "html.parser")
+
+        ul = bs.find("div", {"class": "display-zone"})
+
+        images = ul.find_all('img')
+        images = [f"https:{img.get('data-src') or img.get('src')}" for img in images]
+
+        images_url = [quote(img, safe=':/%') for img in images]
+
+        return images_url
+
+    async def search(self, query: str = "", page: int = 1) -> List[MangaCard]:
+        main_page = await self.get_url(self.base_url.geturl())
+
+        bs = BeautifulSoup(main_page, "html.parser")
+        div = bs.find('div', {'class': 'input-group'})
+        token = div.find('input').get('data-csrf')
+
+        request_url = self.search_url
+
+        data = {
+            self.search_param: query,
+            '_token': token
+        }
+
+        content = await self.get_url(request_url, data=data, method='post')
+
+        return self.mangas_from_page(content)[(page - 1) * 20:page * 20]
+
+    async def get_chapters(self, manga_card: MangaCard, page: int = 1) -> List[MangaChapter]:
+        chapters = [x async for x in self.iter_chapters(manga_card.url, manga_card.name)]
+        return chapters[(page - 1) * 20:page * 20]
+
+    async def iter_chapters(self, manga_url: str, manga_name) -> AsyncIterable[MangaChapter]:
+        manga_card = MangaCard(self, manga_name, manga_url, '')
+
+        request_url = f'{manga_card.url}'
+
+        chapter_page = await self.get_url(request_url)
+
+        bs = BeautifulSoup(chapter_page, "html.parser")
+        btn = bs.find('button', {'class': 'btn-load-more-chapters'})
+        token = btn.get('data-token')
+
+        data = {'_token': token}
+
+        content = await self.get_url(request_url, data=data, method='post')
+
+        chapters = self.chapters_from_page(content, manga_card)
+
+        for chapter in chapters:
+            yield chapter
+
+    async def contains_url(self, url: str):
+        return url.startswith(self.base_url.geturl())
+
+    async def check_updated_urls(self, last_chapters: List[LastChapter]):
+
+        content = await self.get_url(self.base_url.geturl())
+
+        updates = self.updates_from_page(content)
+
+        updated = [lc.url for lc in last_chapters if updates.get(lc.url) and updates.get(lc.url) != lc.chapter_url]
+        not_updated = [lc.url for lc in last_chapters if not updates.get(lc.url) or updates.get(lc.url) == lc.chapter_url]
+
+        return updated, not_updated

plugins/manhuako.py

@@ -0,0 +1,128 @@
+from typing import List, AsyncIterable
+from urllib.parse import urlparse, urljoin, quote, quote_plus
+
+from bs4 import BeautifulSoup
+from bs4.element import PageElement
+
+from plugins.client import MangaClient, MangaCard, MangaChapter, LastChapter
+
+
+class ManhuaKoClient(MangaClient):
+
+    base_url = urlparse("https://manhuako.com/")
+    search_url = urljoin(base_url.geturl(), "home/search")
+    search_param = 'mq'
+
+    pre_headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:97.0) Gecko/20100101 Firefox/97.0'
+    }
+
+    def __init__(self, *args, name="Manhuako", **kwargs):
+        super().__init__(*args, name=name, headers=self.pre_headers, **kwargs)
+
+    def mangas_from_page(self, page: bytes):
+        bs = BeautifulSoup(page, "html.parser")
+
+        cards = bs.find_all("div", {"class": "card"})
+
+        cards = [card for card in cards if card.findNext('p', {'class': 'type'}).text != "Novela"]
+
+        mangas = [card.findNext('a', {'class': 'white-text'}) for card in cards]
+        names = [manga.string for manga in mangas]
+        url = [manga.get('href') for manga in mangas]
+
+        images = [card.findNext('img').get('src') for card in cards]
+
+        mangas = [MangaCard(self, *tup) for tup in zip(names, url, images)]
+
+        return mangas
+
+    def chapters_from_page(self, page: bytes, manga: MangaCard = None):
+        bs = BeautifulSoup(page, "html.parser")
+
+        table = bs.find("table", {"class": "table-chapters"})
+        trs = table.find_all('tr')
+
+        items = [tr.findNext('a') for tr in trs]
+
+        links = [item.get('href') for item in items]
+        texts = [item.string for item in items]
+
+        return list(map(lambda x: MangaChapter(self, x[0], x[1], manga, []), zip(texts, links)))
+
+    @staticmethod
+    def updates_from_page(content):
+        bs = BeautifulSoup(content, "html.parser")
+
+        manga_items = bs.find_all("div", {"class": "card"})
+
+        urls = dict()
+
+        for manga_item in manga_items:
+            manga_url = manga_item.findNext('a', {'class': 'white-text'}).get('href')
+
+            if manga_url in urls:
+                continue
+
+            chapter_url = manga_item.findNext('a', {'class': 'chip'}).get('href')
+
+            urls[manga_url] = chapter_url
+
+        return urls
+
+    async def pictures_from_chapters(self, content: bytes, response=None):
+        bs = BeautifulSoup(content, "html.parser")
+
+        ul = bs.find("div", {"id": "pantallaCompleta"})
+
+        images = ul.find_all('img')
+
+        images_url = [quote(img.get('src'), safe=':/%') for img in images]
+
+        return images_url
+
+    async def search(self, query: str = "", page: int = 1) -> List[MangaCard]:
+        query = quote_plus(query)
+
+        request_url = f'{self.search_url}/page/{page}'
+
+        if query:
+            request_url += f'?{self.search_param}={query}'
+
+        content = await self.get_url(request_url)
+
+        return self.mangas_from_page(content)
+
+    async def get_chapters(self, manga_card: MangaCard, page: int = 1) -> List[MangaChapter]:
+
+        request_url = f'{manga_card.url}/page/{page}'
+
+        content = await self.get_url(request_url)
+
+        return self.chapters_from_page(content, manga_card)
+
+    async def iter_chapters(self, manga_url: str, manga_name) -> AsyncIterable[MangaChapter]:
+        manga = MangaCard(self, manga_name, manga_url, '')
+        page = 1
+        while page > 0:
+            chapters = await self.get_chapters(manga_card=manga, page=page)
+            if not chapters:
+                break
+            for chapter in chapters:
+                yield chapter
+            page += 1
+
+    async def contains_url(self, url: str):
+        return url.startswith(self.base_url.geturl())
+
+    async def check_updated_urls(self, last_chapters: List[LastChapter]):
+
+        content = await self.get_url(self.base_url.geturl())
+
+        updates = self.updates_from_page(content)
+
+        updated = [lc.url for lc in last_chapters if updates.get(lc.url) and updates.get(lc.url) != lc.chapter_url]
+        not_updated = [lc.url for lc in last_chapters if
+                       not updates.get(lc.url) or updates.get(lc.url) == lc.chapter_url]
+
+        return updated, not_updated

plugins/manhuaplus.py

@@ -0,0 +1,125 @@
+from typing import List, AsyncIterable
+from urllib.parse import urlparse, urljoin, quote, quote_plus
+
+from bs4 import BeautifulSoup
+from bs4.element import PageElement
+
+from plugins.client import MangaClient, MangaCard, MangaChapter, LastChapter
+
+
+class ManhuaPlusClient(MangaClient):
+
+    base_url = urlparse("https://manhuaplus.com/")
+    search_url = base_url.geturl()
+    search_param = 's'
+    chapters = 'ajax/chapters/'
+
+    pre_headers = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:97.0) Gecko/20100101 Firefox/97.0'
+    }
+
+    def __init__(self, *args, name="Manhuaplus", **kwargs):
+        super().__init__(*args, name=name, headers=self.pre_headers, **kwargs)
+
+    def mangas_from_page(self, page: bytes):
+        bs = BeautifulSoup(page, "html.parser")
+
+        cards = bs.find("div", {"class": "c-tabs-item"})
+
+        if not cards:
+            return []
+
+        mangas = cards.find_all('div', {'class': 'tab-thumb'})
+        names = [manga.a.get('title') for manga in mangas]
+        url = [manga.a.get('href') for manga in mangas]
+
+        images = [manga.findNext('img').get('data-src') for manga in mangas]
+
+        mangas = [MangaCard(self, *tup) for tup in zip(names, url, images)]
+
+        return mangas
+
+    def chapters_from_page(self, page: bytes, manga: MangaCard = None):
+        bs = BeautifulSoup(page, "html.parser")
+
+        lis = bs.find_all("li", {"class": "wp-manga-chapter"})
+
+        items = [li.findNext('a') for li in lis]
+
+        links = [item.get('href') for item in items]
+        texts = [item.string.strip() for item in items]
+
+        return list(map(lambda x: MangaChapter(self, x[0], x[1], manga, []), zip(texts, links)))
+
+    def updates_from_page(self, page: bytes):
+        bs = BeautifulSoup(page, "html.parser")
+
+        manga_items: List[PageElement] = bs.find_all("div", {"class": "page-item-detail"})
+
+        urls = dict()
+
+        for manga_item in manga_items:
+
+            manga_url = manga_item.findNext('a').get('href')
+
+            chapter_item = manga_item.findNext("div", {"class": "chapter-item"})
+            chapter_url = chapter_item.findNext("a").get('href')
+
+            urls[manga_url] = chapter_url
+
+        return urls
+
+    async def pictures_from_chapters(self, content: bytes, response=None):
+        bs = BeautifulSoup(content, "html.parser")
+
+        ul = bs.find("div", {"class": "reading-content"})
+
+        images = ul.find_all('img')
+
+        images_url = [quote(img.get('src'), safe=':/%') for img in images]
+
+        return images_url
+
+    async def search(self, query: str = "", page: int = 1) -> List[MangaCard]:
+        query = quote_plus(query)
+
+        request_url = self.search_url
+
+        if query:
+            request_url += f'?{self.search_param}={query}&post_type=wp-manga'
+
+        content = await self.get_url(request_url)
+
+        return self.mangas_from_page(content)
+
+    async def get_chapters(self, manga_card: MangaCard, page: int = 1) -> List[MangaChapter]:
+
+        request_url = f'{manga_card.url}{self.chapters}'
+
+        content = await self.get_url(request_url, method='post')
+
+        return self.chapters_from_page(content, manga_card)[(page - 1) * 20:page * 20]
+
+    async def iter_chapters(self, manga_url: str, manga_name) -> AsyncIterable[MangaChapter]:
+        manga_card = MangaCard(self, manga_name, manga_url, '')
+
+        request_url = f'{manga_card.url}{self.chapters}'
+
+        content = await self.get_url(request_url, method='post')
+
+        for chapter in self.chapters_from_page(content, manga_card):
+            yield chapter
+
+    async def contains_url(self, url: str):
+        return url.startswith(self.base_url.geturl())
+
+    async def check_updated_urls(self, last_chapters: List[LastChapter]):
+
+        content = await self.get_url(self.base_url.geturl())
+
+        updates = self.updates_from_page(content)
+
+        updated = [lc.url for lc in last_chapters if updates.get(lc.url) and updates.get(lc.url) != lc.chapter_url]
+        not_updated = [lc.url for lc in last_chapters if not updates.get(lc.url) or updates.get(lc.url) == lc.chapter_url]
+
+        return updated, not_updated