Manga_Colorizer.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "igq9PyPR0QUH"
      },
      "source": [
        "**Use GPU for better performance**\n",
        "\n",
        "\n",
        "Credits:\n",
        "\n",
        "* [qweasdd/manga-colorization-v2](https://github.com/qweasdd/manga-colorization-v2)\n",
        "\n",
        "* [Keiser04/manga-colorization-v2](https://github.com/Keiser04/manga-colorization-v2)\n",
        "\n",
        "* [xinntao/Real-ESRGAN](https://github.com/xinntao/Real-ESRGAN/)\n",
        "\n",
        "* [ai-forever/Real-ESRGAN](https://github.com/ai-forever/Real-ESRGAN)\n",
        "\n",
        "Colab By:\n",
        "\n",
        "[Swakshan/AI-Manga-Colorizer](https://github.com/Swakshan/AI-Manga-Colorizer)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QaheKXaj5KlM"
      },
      "source": [
        "#Changelogs"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "---\n",
        "> **Version 4**\n",
        "\n",
        "* ++ Added more manga providers\n",
        "* !! Rewrite manga downloader"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jKXNjSnZLUly"
      },
      "source": [
        "---\n",
        "> **Version 3**\n",
        "\n",
        "* ++ Rewrite entire project\n",
        "* ++ Merge all functions into one\n",
        "* !! Added bulk chapter download\n",
        "* !! Use manga code instead of url\n",
        "\n",
        "> **Version 3.2**\n",
        "\n",
        "* ++ Download latest chapter"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8LNoahwgf1FW"
      },
      "source": [
        "---\n",
        "> **Version 2**\n",
        "\n",
        "* ++ Download using url\n",
        "* ++ Image Compression\n",
        "\n",
        "> **Version 2.5**\n",
        "\n",
        "* !! change default generator.zip link\n",
        "* !! display size after downloading project files\n",
        "* ++ better file type checks"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ScdUHPvCQ3Gu"
      },
      "source": [
        "---\n",
        "> **Version 1**\n",
        "\n",
        "* Initial Release\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fGgBLu-c0iDG"
      },
      "source": [
        "#Utils"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ws88UIRz0lAP",
        "outputId": "799d70fc-3d3d-4cc6-a270-b964b6037924"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "DONE: Installed Requirements\n"
          ]
        }
      ],
      "source": [
        "#@title Requirements\n",
        "from IPython.display import clear_output\n",
        "\n",
        "try:\n",
        "  !pip install patool\n",
        "  !pip install torchvision\n",
        "  !pip install opencv-python\n",
        "  !pip install python-telegram-bot\n",
        "  !pip install filetype\n",
        "  !pip install git+https://github.com/sberbank-ai/Real-ESRGAN.git\n",
        "  !pip install huggingface-hub==0.25.2\n",
        "  clear_output()\n",
        "except Exception as e:\n",
        "  print(str(e))\n",
        "print(\"DONE: Installed Requirements\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "ZaLR9dz4049A"
      },
      "outputs": [],
      "source": [
        "#@title Common\n",
        "\n",
        "import os,requests,json,shutil\n",
        "from bs4 import BeautifulSoup\n",
        "from urllib.parse import urlparse\n",
        "from IPython.display import clear_output\n",
        "from tqdm import tqdm\n",
        "from zipfile import ZipFile\n",
        "\n",
        "\n",
        "\n",
        "PROJECT_NAME = \"manga-colorization-v2\"\n",
        "\n",
        "MANGA_FOLDER = f\"/content/{PROJECT_NAME}/Manga\"\n",
        "\n",
        "\n",
        "\n",
        "def printLine():\n",
        "  print(\"--------------------------\")\n",
        "\n",
        "def downloader(path,url,hdr={}):\n",
        "  if os.path.exists(path):\n",
        "    print(f\"Exists: {path}\")\n",
        "    return True\n",
        "\n",
        "  # print(f\"Downloading {name}\")\n",
        "  r = requests.get(url,headers=hdr)\n",
        "  total = int(r.headers.get('content-length', 0))\n",
        "  if r.status_code == requests.codes.ok:\n",
        "    with open(path, 'wb') as f,tqdm(\n",
        "        desc=path,\n",
        "        total=total,\n",
        "        unit='iB',\n",
        "        unit_scale=True,\n",
        "        unit_divisor=1024,\n",
        "    )as bar:\n",
        "        for chunk in r.iter_content(chunk_size=1024):\n",
        "            if chunk: # filter out keep-alive new chunks\n",
        "                size = f.write(chunk)\n",
        "                bar.update(size)\n",
        "    print(f\"Downloaded: {path}\")\n",
        "    return\n",
        "  else:\n",
        "    print(f\"Error Downloading : {path}\")\n",
        "    return False\n",
        "\n",
        "def mkdir(path):\n",
        "  try:\n",
        "    os.makedirs(path)\n",
        "    print(f\"CREATED: {path}\")\n",
        "  except Exception as e:\n",
        "    print(str(e))\n",
        "\n",
        "def get_file_size_mb(file_path):\n",
        "    # Get the size of the file in bytes\n",
        "    size_in_bytes = os.path.getsize(file_path)\n",
        "    # Convert bytes to megabytes (1 MB = 1024 * 1024 bytes)\n",
        "    size_in_mb = size_in_bytes / (1024 * 1024)\n",
        "    # print(size_in_mb)\n",
        "    size_in_mb = round(size_in_mb,2)\n",
        "    return f\"{size_in_mb}MB\"\n",
        "\n",
        "\n",
        "def unzip(inp_dir,out_dir):\n",
        "  try:\n",
        "    with ZipFile(inp_dir, 'r') as zObject:\n",
        "        zObject.extractall(path=out_dir)\n",
        "    print(f\"UNZIPPED: {out_dir}\")\n",
        "  except Exception as e:\n",
        "    print(str(e))\n",
        "\n",
        "\n",
        "def delete(path):\n",
        "  if os.path.isdir(path):\n",
        "    shutil.rmtree(path)\n",
        "  else:\n",
        "    os.remove(path)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "#@title Manga Downloaders\n",
        "\n",
        "import requests,json,shutil\n",
        "from bs4 import BeautifulSoup as bs\n",
        "\n",
        "class Weebcentral():\n",
        "  def __init__(self,url:str=\"\",code:str=\"-1\"):\n",
        "    self.baseUrl = \"https://weebcentral.com/\"\n",
        "    if code != \"-1\" :\n",
        "      url = f\"{self.baseUrl}series/{code}\"\n",
        "    self.url = url\n",
        "    self.mangaName = \"\"\n",
        "    self.__headers = {\"Referrer\":self.baseUrl,\"User-Agent\":\"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36\"}\n",
        "    if len(self.url) > 0:\n",
        "      self.__allChapters()\n",
        "\n",
        "  def __allChapters(self):\n",
        "    c = requests.get(self.url,headers=self.__headers)\n",
        "\n",
        "    if c.status_code != requests.codes.ok:\n",
        "      raise Exception(\"Weebcentral chapters not found\")\n",
        "    ps = bs(c.text, 'html.parser')\n",
        "    self.mangaName = ps.find(\"h1\",{\"class\":\"hidden md:block text-2xl font-bold\"}).text\n",
        "\n",
        "    api = f\"{self.url}/full-chapter-list\"\n",
        "    c = requests.get(api,headers=self.__headers)\n",
        "\n",
        "    ps = bs(c.text, 'html.parser')\n",
        "    chap_list = ps.find_all(\"a\",{\"class\":\"hover:bg-base-300 flex-1 flex items-center p-2\"})\n",
        "\n",
        "    chapters = {}\n",
        "    for chap in chap_list:\n",
        "      chLink = chap['href']\n",
        "      chName = chap.find(\"span\",{\"class\":\"grow flex items-center gap-2\"}).find(\"span\").text\n",
        "      chNum = chName.split(\" \")[1] if \"Prologue\" not in chName else chName\n",
        "\n",
        "      chapters[chNum] = {\n",
        "          \"name\":chName,\n",
        "          \"url\": chLink\n",
        "      }\n",
        "\n",
        "    self.chapters = chapters\n",
        "\n",
        "  def getChapters(self,start:str,count:int=1):\n",
        "    chaps = self.chapters\n",
        "\n",
        "    chapNumbers = list(chaps.keys())\n",
        "    rd = []\n",
        "    if start == \"-1\":\n",
        "      latestChapNum = chapNumbers[0]\n",
        "      rd.append(chaps[latestChapNum])\n",
        "    else:\n",
        "      if start not in chapNumbers:\n",
        "        raise Exception(\"Manga not found\")\n",
        "\n",
        "      ind = chapNumbers.index(start)\n",
        "      for i in range(0,count):\n",
        "        chapNum = ind - i\n",
        "        if chapNum < 0: break\n",
        "        chapName = chapNumbers[chapNum]\n",
        "        rd.append(chaps[chapName])\n",
        "    return rd\n",
        "\n",
        "  def downloadChapter(self,chData={},url=\"\"):\n",
        "    chap_name = \"\"\n",
        "    link = \"\"\n",
        "\n",
        "    if len(url) > 0:\n",
        "      link = url\n",
        "    else:\n",
        "      chap_name = chData['name']\n",
        "      link = chData['url']\n",
        "    link+=\"/images?is_prev=False&current_page=1&reading_style=long_strip\"\n",
        "    c = requests.get(link,headers=self.__headers)\n",
        "\n",
        "    if c.status_code != requests.codes.ok:\n",
        "        raise Exception(\"Chapter not found\")\n",
        "\n",
        "    chapter_parser = bs(c.text, 'html.parser')\n",
        "    pages = chapter_parser.find_all('img')\n",
        "\n",
        "    if len(self.mangaName) < 1:\n",
        "      page = pages[0]['src'].split(\"/\")\n",
        "      name_list = page[4:len(page)-1]\n",
        "\n",
        "      self.mangaName = \" \".join(name_list).replace(\"-\",\" \")\n",
        "      chap_name = \"Chapter \"+page[-1].split(\"-\")[0]\n",
        "\n",
        "    downloadPath = MANGA_FOLDER+\"/\"+self.mangaName + '/' + chap_name\n",
        "    mkdir(downloadPath)\n",
        "\n",
        "    for num,page in enumerate(pages):\n",
        "      num+=1\n",
        "      img_url = page['src']\n",
        "      a = urlparse(img_url)\n",
        "      fileName,ext = os.path.splitext(a.path)\n",
        "      fileName = \"{:05d}{ext}\".format(num,ext=ext)\n",
        "      down_path = downloadPath+\"/\"+fileName\n",
        "      downloader(down_path,img_url,self.__headers)\n",
        "    clear_output()\n",
        "    return chap_name\n",
        "#-----------------\n",
        "# m = Weebcentral()\n",
        "# # ch = m.getChapters(start=\"27\")\n",
        "# m.downloadChapter(url=\"https://weebcentral.com/chapters/01J76XYYGMPHMDK8D9T38JQMBP\")\n",
        "\n",
        "class Mangapill():\n",
        "  def __init__(self,url:str=\"\",code:int=-1):\n",
        "    self.baseUrl = \"https://mangapill.com/\"\n",
        "    if code > 0 :\n",
        "      url = f\"{self.baseUrl}manga/{code}\"\n",
        "    self.url = url\n",
        "    self.mangaName = \"\"\n",
        "    if len(self.url) > 0:\n",
        "      self.__allChapters()\n",
        "\n",
        "  def __allChapters(self):\n",
        "    c = requests.get(self.url)\n",
        "\n",
        "    if c.status_code != requests.codes.ok:\n",
        "      raise Exception(\"Manga Pill chapters not found\")\n",
        "\n",
        "    ps = bs(c.text, 'html.parser')\n",
        "    self.mangaName = ps.find(\"h1\",{\"class\":\"font-bold text-lg md:text-2xl\"}).text\n",
        "\n",
        "    ps.find(\"div\",{\"class\":\"font-bold text-lg md:text-2xl\"})\n",
        "    chap_list = ps.find(\"div\",{\"id\":\"chapters\"}).find_all(\"a\")\n",
        "\n",
        "    chapters = {}\n",
        "    for chap in chap_list:\n",
        "      chLink = chap['href']\n",
        "      chName = chap.text\n",
        "      chNum = chName.split(\" \")[1]\n",
        "\n",
        "      chapters[chNum] = {\n",
        "          \"name\":chName,\n",
        "          \"url\": chLink\n",
        "      }\n",
        "\n",
        "    self.chapters = chapters\n",
        "\n",
        "  def getChapters(self,start:str,count:int=1):\n",
        "    chaps = self.chapters\n",
        "\n",
        "    chapNumbers = list(chaps.keys())\n",
        "    rd = []\n",
        "    if start == \"-1\":\n",
        "      latestChapNum = chapNumbers[0]\n",
        "      rd.append(chaps[latestChapNum])\n",
        "    else:\n",
        "      if start not in chapNumbers:\n",
        "        raise Exception(\"Manga not found\")\n",
        "\n",
        "      ind = chapNumbers.index(start)\n",
        "      for i in range(0,count):\n",
        "        chapNum = ind - i\n",
        "        if chapNum < 0: break\n",
        "        chapName = chapNumbers[chapNum]\n",
        "        rd.append(chaps[chapName])\n",
        "    return rd\n",
        "\n",
        "  def downloadChapter(self,chData={},url=\"\"):\n",
        "    chap_name = \"\"\n",
        "    link = \"\"\n",
        "    if len(url) > 0:\n",
        "      link = url\n",
        "    else:\n",
        "      chap_name = chData['name']\n",
        "      link = self.baseUrl[:-1]+chData['url']\n",
        "    hdr = {\"Referer\":self.baseUrl}\n",
        "\n",
        "    c = requests.get(link,headers=hdr)\n",
        "\n",
        "    if c.status_code != requests.codes.ok:\n",
        "        raise Exception(\"Chapter not found\")\n",
        "\n",
        "    ps = bs(c.text, 'html.parser')\n",
        "\n",
        "    if len(self.mangaName) < 1:\n",
        "      title = ps.find('h1',{'id':'top'}).text.split(\" Chapter \")\n",
        "      self.mangaName = title[0]\n",
        "      chap_name = \"Chapter \"+title[1]\n",
        "\n",
        "    downloadPath = MANGA_FOLDER+\"/\"+self.mangaName + '/' + chap_name\n",
        "    mkdir(downloadPath)\n",
        "    pages = ps.find_all('img', attrs={'class': 'js-page'})\n",
        "\n",
        "    for num,page in enumerate(pages):\n",
        "      num+=1\n",
        "      img_url = page['data-src']\n",
        "      a = urlparse(img_url)\n",
        "      fileName,ext = os.path.splitext(a.path)\n",
        "      fileName = \"{:05d}{ext}\".format(num,ext=ext)\n",
        "      down_path = downloadPath+\"/\"+fileName\n",
        "      downloader(down_path,img_url,hdr)\n",
        "    clear_output()\n",
        "    return chap_name\n",
        "\n",
        "\n",
        "# #-----------------\n",
        "# m = Mangapill()\n",
        "# # ch = m.getChapters(start=\"-1\")\n",
        "# m.downloadChapter(url=\"https://mangapill.com/chapters/1-20380000/berserk-chapter-380\")\n",
        "# print(m.mangaName)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S0GZobV91MTc",
        "outputId": "d50b0d17-ebd2-4d2a-fdfe-8dff4f911a3c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "--------------------------\n",
            "CREATED: /content/manga-colorization-v2/Manga\n",
            "DONE: manga-colorization-v2\n",
            " generator.zip - (122.99MB)\n",
            " extractor.pth - (0.09MB)\n",
            " net_rgb.pth - (3.28MB)\n",
            "\n"
          ]
        }
      ],
      "source": [
        "#@title Download Project Files\n",
        "import os\n",
        "\n",
        "#@markdown Clone Keiser04/manga-colorization-v2\n",
        "project = True # @param {type:\"boolean\"}\n",
        "generator = True # @param {type:\"boolean\"}\n",
        "generator_model_url = \"https://drive.usercontent.google.com/download?id=1qmxUEKADkEM4iYLp1fpPLLKnfZ6tcF-t&export=download&confirm=t&uuid=cf1b41fa-03b3-49bf-8373-8f5d423c775d\" # @param {type:\"string\"}\n",
        "#@markdown ---\n",
        "extractor = True # @param {type:\"boolean\"}\n",
        "extractor_model_url = \"https://drive.google.com/file/d/12cbNyJcCa1zI2EBz6nea3BXl21Fm73Bt/view?usp=sharing\" # @param {type:\"string\"}\n",
        "#@markdown ---\n",
        "denoiser = True # @param {type:\"boolean\"}\n",
        "denoiser_model_url = \"https://drive.google.com/uc?export=download&id=161oyQcYpdkVdw8gKz_MA8RD-Wtg9XDp3\" # @param {type:\"string\"}\n",
        "#@markdown ---\n",
        "\n",
        "G_PATH = f\"{PROJECT_NAME}/networks/\"\n",
        "D_PATH = f\"{PROJECT_NAME}/denoising/models/\"\n",
        "\n",
        "done_str = \"\"\n",
        "if project:\n",
        "  !git clone https://github.com/Keiser04/manga-colorization-v2.git\n",
        "  done_str+=\" \"+PROJECT_NAME+\"\\n\"\n",
        "if generator:\n",
        "  mkdir(G_PATH)\n",
        "  dPath = f\"{G_PATH}generator.zip\"\n",
        "  downloader(dPath,generator_model_url)\n",
        "  done_str=f\"{done_str} generator.zip - ({get_file_size_mb(dPath)})\\n\"\n",
        "if extractor:\n",
        "  print(extractor_model_url)\n",
        "  mkdir(G_PATH)\n",
        "  dPath = f\"{G_PATH}extractor.pth\"\n",
        "  downloader(dPath,extractor_model_url)\n",
        "  done_str=f\"{done_str} extractor.pth - ({get_file_size_mb(dPath)})\\n\"\n",
        "if denoiser:\n",
        "  mkdir(D_PATH)\n",
        "  dPath = f\"{D_PATH}net_rgb.pth\"\n",
        "  downloader(dPath,denoiser_model_url)\n",
        "  done_str=f\"{done_str} net_rgb.pth - ({get_file_size_mb(dPath)})\\n\"\n",
        "\n",
        "\n",
        "clear_output()\n",
        "\n",
        "printLine()\n",
        "os.chdir(PROJECT_NAME)\n",
        "mkdir(MANGA_FOLDER)\n",
        "print(\"DONE:\"+done_str)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "id": "7hfOJ2F03EwZ"
      },
      "outputs": [],
      "source": [
        "#@title Functions\n",
        "import torch\n",
        "from PIL import Image\n",
        "from RealESRGAN import RealESRGAN\n",
        "import matplotlib.pyplot as plt\n",
        "import filetype\n",
        "from io import BytesIO\n",
        "import patoolib\n",
        "from telegram import Bot\n",
        "from telegram.error import TelegramError\n",
        "from google.colab import drive\n",
        "import PIL\n",
        "import os\n",
        "import glob\n",
        "from colorizator import MangaColorizator\n",
        "import zipfile\n",
        "from pprint import pp\n",
        "#-----------------------------------\n",
        "#-----------------------------------\n",
        "\n",
        "CMP_FOLDER = \"compress\"\n",
        "def image_compression(PATH,QUALITY):\n",
        "  def compress(img_path,out_img_path):\n",
        "    img = Image.open(img_path)\n",
        "    img = img.convert('RGB')\n",
        "    buffer = BytesIO()\n",
        "    img.save(buffer, \"JPEG\", quality=int(QUALITY))\n",
        "\n",
        "    f = open(out_img_path, \"wb\")\n",
        "    f.write(buffer.getbuffer())\n",
        "    f.close()\n",
        "    print(f\"DONE: {out_img_path}\")\n",
        "    final_out = \"\"\n",
        "  if os.path.isfile(PATH):\n",
        "    name,ext = os.path.splitext(PATH)\n",
        "    out_img_path = f\"{name}_q{QUALITY}{ext}\"\n",
        "    compress(PATH,out_img_path)\n",
        "    final_out = out_img_path\n",
        "\n",
        "  else:\n",
        "    out_path = os.path.join(PATH,CMP_FOLDER)\n",
        "    mkdir(out_path)\n",
        "    final_out = out_path\n",
        "    # print(out_path)\n",
        "    for img_name in os.listdir(PATH):\n",
        "      img_path = os.path.join(PATH,img_name)\n",
        "      if os.path.isfile(img_path):\n",
        "        out_img_path = os.path.join(out_path,img_name)\n",
        "        if not filetype.is_image(img_path):continue\n",
        "        compress(img_path,out_img_path)\n",
        "        # clear_output()\n",
        "\n",
        "  clear_output()\n",
        "  print(f\"DONE: {final_out}\")\n",
        "\n",
        "#-----------------------------------\n",
        "#-----------------------------------\n",
        "\n",
        "def buildCBZ(IMAGES_FOLDER,ZIP_FILENAME):\n",
        "\n",
        "    output_path = os.path.join(IMAGES_FOLDER, ZIP_FILENAME)\n",
        "    if os.path.exists(output_path):\n",
        "      ch = input(f\"{ZIP_FILENAME}\\nalready exists,Delete the existsing one ? (1/0): \")\n",
        "      if (int(ch)):\n",
        "        os.remove(output_path)\n",
        "      else:\n",
        "        return\n",
        "\n",
        "    image_files = []\n",
        "    for ext in [\"jpg\", \"png\", \"jpeg\"]:\n",
        "        image_files.extend(glob.glob(os.path.join(IMAGES_FOLDER, f\"*.{ext}\")))\n",
        "\n",
        "    # # Create the zip file\n",
        "    with zipfile.ZipFile(output_path, 'w', zipfile.ZIP_DEFLATED) as zipf:\n",
        "        # Directly add the entire directory\n",
        "        for img in image_files:\n",
        "          zipf.write(img)\n",
        "    printLine()\n",
        "    rd = {\"path\":output_path,\"count\":len(image_files),\"size\": get_file_size_mb(output_path)}\n",
        "    pp(rd)\n",
        "    return rd\n",
        "\n",
        "#-----------------------------------\n",
        "#-----------------------------------\n",
        "\n",
        "async def sendTELE(BOT_TOKEN,CHANNEL_ID,DOC,CAPTION):\n",
        "  if len(BOT_TOKEN) and len(CHANNEL_ID) and len(DOC):\n",
        "    text = CAPTION\n",
        "    zip_filename = DOC\n",
        "    print(f\"SENDING: {zip_filename}\")\n",
        "\n",
        "    bot = Bot(token=BOT_TOKEN)\n",
        "    try:\n",
        "      await bot.send_document(chat_id=CHANNEL_ID, document=open(zip_filename, 'rb'),caption=text)\n",
        "      print(f'SENT: {text}')\n",
        "    except TelegramError as e:\n",
        "        print(f'Failed to send document: {e}')\n",
        "\n",
        "  else:\n",
        "    print(\"Check token and channel id and doc\")\n",
        "\n",
        "#-----------------------------------\n",
        "#-----------------------------------\n",
        "\n",
        "def send2Drive(SRC_FILE,DEST_FOLDER):\n",
        "  DRIVE = \"/content/drive/\"\n",
        "  if not os.path.exists(DRIVE):\n",
        "    drive.mount(DRIVE)\n",
        "\n",
        "  DRIVE_MANGA = os.path.join('/MyDrive/Manga/',DEST_FOLDER)\n",
        "  if not DRIVE in DEST_FOLDER:\n",
        "    DRIVE_MANGA = os.path.join(DRIVE,DRIVE_MANGA)\n",
        "  mkdir(DRIVE_MANGA)\n",
        "\n",
        "  if os.path.exists(SRC_FILE):\n",
        "    shutil.copy(SRC_FILE,DRIVE_MANGA)\n",
        "    print(f\"COPIED: to {DRIVE_MANGA}\")\n",
        "  else:\n",
        "    print(f\"FAILED: {SRC_FILE} doesnt exists\")\n",
        "\n",
        "#-----------------------------------\n",
        "#-----------------------------------\n",
        "\n",
        "CLR_FOLDER = \"colour\"\n",
        "class Colorize():\n",
        "  def __init__(self,MANGA_PATH,DEVICE,SIZE, DENOISE, DENOISE_SIGMA,GENERATOR,EXTRACTOR):\n",
        "    self.MANGA_PATH= MANGA_PATH\n",
        "    self.DEVICE= DEVICE\n",
        "    self.SIZE= SIZE\n",
        "    self.DENOISE= DENOISE\n",
        "    self.DENOISE_SIGMA= DENOISE_SIGMA\n",
        "    self.GENERATOR= GENERATOR\n",
        "    self.EXTRACTOR= EXTRACTOR\n",
        "\n",
        "  def convert_to_bw(self,img_path):\n",
        "      color_image = Image.open(img_path)\n",
        "      bw = color_image.convert('L')\n",
        "      bw.save(img_path)\n",
        "\n",
        "  def process_image(self,image, colorizator):\n",
        "      colorizator.set_image(image, self.SIZE, self.DENOISE, self.DENOISE_SIGMA)\n",
        "      return colorizator.colorize()\n",
        "\n",
        "  def color_it(self,image_path,save_path):\n",
        "    self.convert_to_bw(image_path)\n",
        "    image = plt.imread(image_path)\n",
        "    colorizer = MangaColorizator(self.DEVICE,self.GENERATOR,self.EXTRACTOR)\n",
        "    colorization = self.process_image(image, colorizer)\n",
        "    plt.imsave(save_path, colorization)\n",
        "\n",
        "  def colourize_process(self):\n",
        "    try:\n",
        "      temp_name = CLR_FOLDER\n",
        "      org_path = self.MANGA_PATH\n",
        "      if os.path.isdir(org_path):\n",
        "          SAVE_PATH = os.path.join(org_path,temp_name)\n",
        "          mkdir(SAVE_PATH)\n",
        "          num = 0\n",
        "          for img in os.listdir(org_path):\n",
        "            image_path = os.path.join(org_path,img)\n",
        "            save_path = os.path.join(SAVE_PATH,img)\n",
        "            if not os.path.isfile(image_path):continue\n",
        "            if not filetype.is_image(image_path):continue\n",
        "            if f\"_{temp_name}\" in img:continue\n",
        "            num+=1\n",
        "            self.color_it(image_path,save_path)\n",
        "            print(f\"SAVED: {save_path}\")\n",
        "          clear_output()\n",
        "          print(f\"SAVED: {SAVE_PATH} - {num} files\")\n",
        "\n",
        "      elif os.path.isfile(org_path):\n",
        "        fileName,ext = os.path.splitext(org_path)\n",
        "        save_path = f\"{fileName}_{temp_name}{ext}\"\n",
        "        self.color_it(org_path,save_path)\n",
        "        print(f\"SAVED: {save_path}\")\n",
        "      else:\n",
        "        print(\"Check the path provided..\")\n",
        "    except Exception as e:\n",
        "      print(str(e))\n",
        "\n",
        "#-----------------------------------\n",
        "#-----------------------------------\n",
        "UPSC_FOLDER = \"upscaled\"\n",
        "class Upscaler():\n",
        "  def __init__(self,device=\"cpu\",scale=2,weight=\"RealESRGAN_x4.pth\"):\n",
        "    self.scale = scale\n",
        "    device = torch.device(device)\n",
        "    self.model = RealESRGAN(device, scale=self.scale)\n",
        "    self.model.load_weights(f'weights/{weight}', download=True)\n",
        "\n",
        "  def __upscale(self,image_path):\n",
        "    og_folder,og_filename = os.path.split(image_path)\n",
        "    out_folder = os.path.join(og_folder,UPSC_FOLDER)\n",
        "    if not os.path.exists(out_folder): mkdir(out_folder)\n",
        "    name,ext = os.path.splitext(og_filename)\n",
        "    save_filename = f\"{name}_x{self.scale}{ext}\"\n",
        "    save_path = os.path.join(out_folder,save_filename)\n",
        "\n",
        "    image = Image.open(image_path).convert('RGB')\n",
        "    sr_image = self.model.predict(image)\n",
        "    sr_image.save(save_path)\n",
        "\n",
        "  def process(self,path):\n",
        "    if os.path.isfile(path):\n",
        "      self.__upscale(path)\n",
        "    else:\n",
        "      print(path)\n",
        "      for img in os.listdir(path):\n",
        "        file_path = os.path.join(path,img)\n",
        "        if os.path.isfile(file_path) and filetype.is_image(file_path):\n",
        "          self.__upscale(file_path)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i0IOBurrOnkU"
      },
      "source": [
        "# Main"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cellView": "form",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "collapsed": true,
        "id": "R9FIV4Zw8uAD",
        "outputId": "225629d4-089c-4983-d908-16d87e823bc3"
      },
      "outputs": [],
      "source": [
        "GPU = True# @param {type:\"boolean\"}\n",
        "#@markdown Manga details\n",
        "PROVIDER = \"Weebcentral\" # @param [\"Mangapill\",\"Weebcentral\"]\n",
        "IS_CHAPTER_URL = False # @param {\"type\":\"boolean\"}\n",
        "#@markdown - if IS_CHAPTER_URL is true add the chapter url\n",
        "#@markdown - if IS_CHAPTER_URL is false add the series url\n",
        "MANGA_URL = \"https://weebcentral.com/series/01J76XYCYJ0P680SKX3QZ0NQD7\" # @param {type:\"string\"}\n",
        "#@markdown - for latest chapter set CHAP_NUM = -1\n",
        "CHAP_NUM = \"-1\" # @param {type:\"string\"}\n",
        "#@markdown\n",
        "#@markdown default num of chapters = 1\n",
        "NUMBER_OF_CHAPTERS = 2# @param {\"type\":\"integer\"}\n",
        "#@markdown ---\n",
        "#@markdown Colourize Config\n",
        "GENERATOR = \"networks/generator.zip\" # @param {type:\"string\"}\n",
        "EXTRACTOR = \"networks/extractor.pth\" # @param {type:\"string\"}\n",
        "DENOISE = True# @param {type:\"boolean\"}\n",
        "DENOISE_SIGMA = 25# @param {type:\"integer\"}\n",
        "#@markdown default SIZE_FACTOR = 18\n",
        "SIZE_FACTOR = 20# @param {type:\"integer\"}\n",
        "#@markdown ---\n",
        "#@markdown ---\n",
        "#@markdown Upscaler\n",
        "#@markdown default \"SCALE_FACTOR\" = 2\n",
        "UPSCALE = True# @param {type:\"boolean\"}\n",
        "SCALE_FACTOR = \"2\" # @param [\"2\", \"3\", \"4\"]\n",
        "UPSCALER_WEIGHT = \"RealESRGAN_x4.pth\" # @param {type:\"string\"}\n",
        "#@markdown ---\n",
        "#@markdown ---\n",
        "#@markdown Compressor\n",
        "QUALITY = 60 # @param {type:\"integer\"}\n",
        "#@markdown ---\n",
        "#@markdown ---\n",
        "COPY_TO_DRIVE = False# @param {type:\"boolean\"}\n",
        "#@markdown ---\n",
        "#@markdown ---\n",
        "SEND_TO_TELEGRAM = True# @param {type:\"boolean\"}\n",
        "TELE_CHANNEL_ID = \"\" # @param {type:\"string\"}\n",
        "#@markdown Add TELE_BOT_TOKEN in secrets\n",
        "\n",
        "from google.colab import userdata\n",
        "BOT_TOKEN = userdata.get('TELE_BOT_TOKEN')\n",
        "\n",
        "DEVICE = 'cpu'\n",
        "if GPU:\n",
        "  DEVICE = 'cuda'\n",
        "\n",
        "if NUMBER_OF_CHAPTERS < 1:\n",
        "  NUMBER_OF_CHAPTERS = 1\n",
        "\n",
        "async def wholeFunction(MANGA_NAME,CHAP_NAME):\n",
        "  MANGA_PATH = f'{MANGA_FOLDER}/{MANGA_NAME}/{CHAP_NAME}'\n",
        "\n",
        "  SIZE = SIZE_FACTOR*32\n",
        "  c = Colorize(MANGA_PATH,DEVICE,SIZE, DENOISE, DENOISE_SIGMA,GENERATOR,EXTRACTOR)\n",
        "  c.colourize_process()\n",
        "  MANGA_PATH = f'{MANGA_PATH}/{CLR_FOLDER}'\n",
        "\n",
        "  if UPSCALE:\n",
        "    up = Upscaler(DEVICE,int(SCALE_FACTOR),UPSCALER_WEIGHT)\n",
        "    up.process(MANGA_PATH)\n",
        "    MANGA_PATH = f'{MANGA_PATH}/{UPSC_FOLDER}'\n",
        "\n",
        "  image_compression(MANGA_PATH,QUALITY)\n",
        "  IMAGES_FOLDER = f'{MANGA_PATH}/{CMP_FOLDER}'\n",
        "\n",
        "\n",
        "  ZIP_FILENAME = f'{CHAP_NAME}.cbz'\n",
        "  o = buildCBZ(IMAGES_FOLDER,ZIP_FILENAME)\n",
        "  #final_out.append(o)\n",
        "\n",
        "  DOC = f'{MANGA_PATH}/{CMP_FOLDER}/{ZIP_FILENAME}'\n",
        "  if COPY_TO_DRIVE:\n",
        "    send2Drive(DOC,MANGA_NAME)\n",
        "\n",
        "  if SEND_TO_TELEGRAM:\n",
        "    CAPTION = f'{MANGA_NAME} - {CHAP_NAME}'\n",
        "    await sendTELE(BOT_TOKEN,TELE_CHANNEL_ID,DOC,CAPTION)\n",
        "\n",
        "  return o\n",
        "\n",
        "\n",
        "CHAPS = []\n",
        "manga_url = MANGA_URL\n",
        "if IS_CHAPTER_URL:\n",
        "  manga_url = \"\"\n",
        "\n",
        "m = None\n",
        "if PROVIDER == \"Mangapill\":\n",
        "  m = Mangapill(url=manga_url)\n",
        "else:\n",
        "  m = Weebcentral(url=manga_url)\n",
        "\n",
        "out = []\n",
        "if IS_CHAPTER_URL:\n",
        "  chap_name = m.downloadChapter(url=MANGA_URL)\n",
        "  manga_name = m.mangaName\n",
        "  rd = await wholeFunction(manga_name,chap_name)\n",
        "  out.append(rd)\n",
        "else:\n",
        "  CHAPS = m.getChapters(CHAP_NUM,NUMBER_OF_CHAPTERS)\n",
        "  for CHAP in CHAPS:\n",
        "    chap_name = m.downloadChapter(chData=CHAP)\n",
        "    manga_name = m.mangaName\n",
        "    rd = await wholeFunction(manga_name,chap_name)\n",
        "    out.append(rd)\n",
        "\n",
        "clear_output()\n",
        "# print(f\"Downloaded : {out}\")\n",
        "pp(out)#"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "cellView": "form",
        "id": "FupHTDEHKPk_"
      },
      "outputs": [],
      "source": [
        "import shutil\n",
        "# @title remove folder\n",
        "folder_path = \"/content/manga-colorization-v2/Manga/Kagurabachi\" # @param {type:\"string\"}\n",
        "\n",
        "shutil.rmtree(folder_path)"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "T4",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}