firsty

.dockerignore

@@ -0,0 +1,8 @@
+fly.toml
+.git/
+*.sqlite3
+frontend/node_modules
+frontend/src
+venv
+credentials.txt
+

.expo/README.md

@@ -0,0 +1,15 @@
+> Why do I have a folder named ".expo" in my project?
+
+The ".expo" folder is created when an Expo project is started using "expo start" command.
+
+> What do the files contain?
+
+- "devices.json": contains information about devices that have recently opened this project. This is used to populate the "Development sessions" list in your development builds.
+- "packager-info.json": contains port numbers and process PIDs that are used to serve the application to the mobile device/simulator.
+- "settings.json": contains the server configuration that is used to serve the application manifest.
+
+> Should I commit the ".expo" folder?
+
+No, you should not share the ".expo" folder. It does not contain any information that is relevant for other developers working on the project, it is specific to your machine.
+
+Upon project creation, the ".expo" folder is already added to your ".gitignore" file.

.expo/settings.json

@@ -0,0 +1,8 @@
+{
+  "hostType": "lan",
+  "lanType": "ip",
+  "dev": true,
+  "minify": false,
+  "urlRandomness": null,
+  "https": false
+}

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.ttf filter=lfs diff=lfs merge=lfs -text
+*.ttc filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,57 @@
+frontend/node_modules
+frontend/static/frontend
+venv/
+frontend/.git
+.env
+.cache
+.git
+*.sqlite3
+
+frontend/android/
+log/
+temp/
+media/
+storage/
+backend/module/utils/image_translator/models/
+
+backend/module/utils/image_translator/result
+backend/module/utils/image_translator/*.ckpt
+backend/module/utils/image_translator/*.pt
+backend/module/utils/image_translator/.vscode
+backend/module/utils/image_translator/*.onnx
+backend/module/utils/image_translator/__pycache__
+backend/module/utils/image_translator/ocrs
+backend/module/utils/image_translator/Manga
+backend/module/utils/image_translator/Manga-translated
+backend/module/utils/image_translator//models
+backend/module/utils/image_translator/.env
+backend/module/utils/image_translator/*.local
+backend/module/utils/image_translator/*.local.*
+backend/module/utils/image_translator/test/testdata
+backend/module/utils/image_translator/.idea
+backend/module/utils/image_translator/pyvenv.cfg
+backend/module/utils/image_translator/Scripts
+backend/module/utils/image_translator/Lib
+backend/module/utils/image_translator/include
+backend/module/utils/image_translator/share
+
+# Distribution / packaging
+backend/module/utils/image_translator/.Python
+backend/module/utils/image_translator/build/
+backend/module/utils/image_translator/develop-eggs/
+backend/module/utils/image_translator/dist/
+backend/module/utils/image_translator/downloads/
+backend/module/utils/image_translator/eggs/
+backend/module/utils/image_translator/.eggs/
+backend/module/utils/image_translator/lib/
+backend/module/utils/image_translator/lib64/
+backend/module/utils/image_translator/parts/
+backend/module/utils/image_translator/sdist/
+backend/module/utils/image_translator/var/
+backend/module/utils/image_translator/wheels/
+backend/module/utils/image_translator/share/python-wheels/
+backend/module/utils/image_translator/*.egg-info/
+backend/module/utils/image_translator/.installed.cfg
+backend/module/utils/image_translator/*.egg
+backend/module/utils/image_translator/MANIFEST
+backend/module/utils/image_translator/.history

Dockerfile

@@ -0,0 +1,42 @@
+ARG PYTHON_VERSION=3.12-slim-bullseye
+
+FROM python:${PYTHON_VERSION}
+
+ENV PYTHONDONTWRITEBYTECODE 1
+ENV PYTHONUNBUFFERED 1
+
+# install psycopg2 dependencies.
+RUN apt-get update && apt-get install -y \
+    libpq-dev \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN mkdir -p /code
+
+WORKDIR /code
+
+COPY requirements.txt /tmp/requirements.txt
+RUN set -ex && \
+    pip install --upgrade pip && \
+    pip install -r /tmp/requirements.txt && \
+    rm -rf /root/.cache/
+COPY . /code
+
+
+RUN python manage.py makemigrations
+RUN python manage.py migrate --database=default
+RUN python manage.py migrate --database=cache
+RUN python manage.py migrate --database=DB1
+RUN python manage.py migrate --database=DB2
+
+
+
+EXPOSE 8000
+
+# CMD ["gunicorn", "--bind", ":8000", "--workers", "1", "--worker-class", "gevent", "core.wsgi:application"]
+# CMD ["daphne", "-u", "/tmp/daphne.sock", "core.asgi:application"]
+CMD ["daphne", "-b", "0.0.0.0", "-p", "7860", "core.asgi:application"]
+
+# CMD ["gunicorn", "--bind", ":8000", "--workers", "1", "--worker-class", "uvicorn.workers.UvicornWorker", "core.asgi:application"]
+
+

README.md

@@ -1,10 +1,8 @@
----
-title: ComicMTL
-emoji: 🚀
-colorFrom: green
-colorTo: purple
-sdk: docker
-pinned: false
----
+# ComicMTL
+App that translate whole manga into prefer languages. Currently In development.
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+Project Status: https://github.com/GoodDay360/ComicMTL/projects?query=is%3Aopen
+
+### Utilities that used for this project:
+- [Translator](https://github.com/zyddnys/manga-image-translator)

backend/admin.py

@@ -0,0 +1,3 @@
+from django.contrib import admin
+
+# Register your models here.

backend/api/__init__.py

@@ -0,0 +1,4 @@
+import backend.invoke_worker
+
+
+

backend/api/cloudflare_turnstile.py

@@ -0,0 +1,36 @@
+
+import requests, environ, json
+from django.http import JsonResponse, HttpResponseBadRequest
+
+from backend.models.model_cache import CloudflareTurnStileCache
+
+from django_ratelimit.decorators import ratelimit
+from django.views.decorators.csrf import csrf_exempt
+from ipware import get_client_ip
+
+env = environ.Env()
+
+@csrf_exempt
+@ratelimit(key='ip', rate='60/m')
+def verify(request):
+    if request.method != "POST": return HttpResponseBadRequest('Allowed POST request only!', status=400)
+    client_ip, is_routable = get_client_ip(request)
+    payload = json.loads(request.body)
+    token = payload.get("token")
+    form_data = {
+        "secret": env("CLOUDFLARE_TURNSTILE_SECRET"),
+        "response": token,
+        "remoteip": client_ip
+    }
+    req = requests.post(
+        url="https://challenges.cloudflare.com/turnstile/v0/siteverify", 
+        data=form_data, 
+    )
+    result = req.json()
+    status = result.get("success")
+    if (status): 
+       
+        queryset = CloudflareTurnStileCache.objects.create(token=token)
+        queryset.refresh_from_db()
+        return JsonResponse(result)
+    else: return HttpResponseBadRequest('Cloudflare turnstile token verificaion failed!', status=511)

backend/api/queue.py

@@ -0,0 +1,109 @@
+
+import json, environ, requests, os, subprocess
+import asyncio, uuid
+
+from django.http import HttpResponse, JsonResponse, HttpResponseBadRequest
+from django_ratelimit.decorators import ratelimit
+from django.views.decorators.csrf import csrf_exempt
+from asgiref.sync import sync_to_async
+
+from backend.module import web_scrap
+from backend.module.utils import manage_image
+from backend.models.model_cache import SocketRequestChapterQueueCache, ComicStorageCache
+from core.settings import BASE_DIR
+from backend.module.utils import cloudflare_turnstile
+
+
+env = environ.Env()
+
+
+@csrf_exempt
+@ratelimit(key='ip', rate='60/m')
+def request_chapter(request):
+    try:
+        if request.method != "POST": return HttpResponseBadRequest('Allowed POST request only!', status=400)
+        token = request.META.get('HTTP_X_CLOUDFLARE_TURNSTILE_TOKEN')
+        if not cloudflare_turnstile.check(token): return HttpResponseBadRequest('Cloudflare turnstile token not existed or expired!', status=511)
+        
+        payload = json.loads(request.body)
+        source = payload.get("source")
+        comic_id = payload.get("comic_id")
+        chapter_id = payload.get("chapter_id")
+        chapter_idx = payload.get("chapter_idx")
+        socket_id = payload.get("socket_id")
+        channel_name = payload.get("channel_name")
+        options = payload.get("options") or {}
+        
+        options["translate"]["target"] = options.get("translate").get("target") if options.get("translate").get("state") else ""
+        query_count = ComicStorageCache.objects.filter(
+            source=source, 
+            comic_id=comic_id, 
+            chapter_id=chapter_id,
+            chapter_idx=chapter_idx,
+            colorize=options.get("colorize"),
+            translate=options.get("translate").get("state"),
+            target_lang = options.get("translate").get("target")
+        ).count()
+        
+        if query_count: return JsonResponse({"status":"ready"})
+        else:
+            SocketRequestChapterQueueCache(
+                socket_id=socket_id, 
+                channel_name=channel_name, 
+                source=source, 
+                comic_id=comic_id,
+                chapter_id=chapter_id, 
+                chapter_idx=chapter_idx,
+                options=options
+            ).save()
+            return JsonResponse({"status":"queue"})
+    except Exception as e: 
+        print(e)
+        return HttpResponseBadRequest('Internal Error.', status=500)
+
+
+@csrf_exempt
+@ratelimit(key='ip', rate='60/m')
+def request_info(request):
+    try:
+        if request.method != "POST": return HttpResponseBadRequest('Allowed POST request only!', status=400)
+        token = request.META.get('HTTP_X_CLOUDFLARE_TURNSTILE_TOKEN')
+        if not cloudflare_turnstile.check(token): return HttpResponseBadRequest('Cloudflare turnstile token not existed or expired!', status=511)
+
+        payload = json.loads(request.body)
+        socket_id = payload.get("socket_id")
+        source = payload.get("source")
+        comic_id = payload.get("comic_id")
+        chapter_requested = payload.get("chapter_requested")
+        
+        
+        result_request = {}
+        for chapter in chapter_requested:
+            options = chapter.get("options")
+            query_count = SocketRequestChapterQueueCache.objects.filter(socket_id=socket_id, source=source, comic_id=comic_id, chapter_id=chapter.get("chapter_id")).count()
+            if query_count: result_request[chapter.get("chapter_id")] =  {"state":"queue","chapter_idx":chapter.get("chapter_idx"),"options":options}
+            else:
+                query_result = ComicStorageCache.objects.filter(
+                    source=source, 
+                    comic_id=comic_id, 
+                    chapter_id=chapter.get("chapter_id"),
+                    chapter_idx=chapter.get("chapter_idx"),
+                    colorize=options.get("colorize"),
+                    translate=options.get("translate").get("state"),
+                    target_lang = options.get("translate").get("target") if options.get("translate").get("state") else ""
+                ).first()
+                
+                if query_result:
+                    file_path = query_result.file_path
+                    if os.path.exists(file_path): 
+                        result_request[chapter.get("chapter_id")] = {"state":"ready","chapter_idx":chapter.get("chapter_idx"),"options":options}
+                    else:
+                        ComicStorageCache.objects.filter(id=query_result.id).delete()
+                        result_request[chapter.get("chapter_id")] = {"state":"unkown","chapter_idx":chapter.get("chapter_idx"),"options":options}
+                else:
+                    result_request[chapter.get("chapter_id")] = {"state":"unkown","chapter_idx":chapter.get("chapter_idx"),"options":options}
+        return JsonResponse(result_request)
+        
+    except Exception as e: 
+        print(e)
+        return HttpResponseBadRequest('Internal Error.', status=500)

backend/api/stream_file.py

@@ -0,0 +1,53 @@
+from django.http import StreamingHttpResponse, HttpResponseBadRequest
+from core.settings import BASE_DIR
+from django_ratelimit.decorators import ratelimit
+from django.views.decorators.csrf import csrf_exempt
+from backend.module.utils import cloudflare_turnstile
+from backend.models.model_cache import SocketRequestChapterQueueCache, ComicStorageCache
+
+import os, json, sys
+
+@csrf_exempt
+@ratelimit(key='ip', rate='60/m')
+def download_chapter(request):
+    if request.method != "POST": return HttpResponseBadRequest('Allowed POST request only!', status=400)
+    token = request.META.get('HTTP_X_CLOUDFLARE_TURNSTILE_TOKEN')
+    if not cloudflare_turnstile.check(token): return HttpResponseBadRequest('Cloudflare turnstile token not existed or expired!', status=511)
+    try:
+        payload = json.loads(request.body)
+        source = payload.get("source")
+        comic_id = payload.get("comic_id")
+        chapter_id = payload.get("chapter_id")
+        chapter_idx = payload.get("chapter_idx")
+        options = payload.get("options")
+        
+        query_result = ComicStorageCache.objects.filter(
+            source=source, 
+            comic_id=comic_id, 
+            chapter_id=chapter_id,
+            chapter_idx=chapter_idx,
+            colorize=options.get("colorize"),
+            translate=options.get("translate").get("state"),
+            target_lang = options.get("translate").get("target") if options.get("translate").get("state") else ""
+        ).first()
+        
+        
+        file_path = query_result.file_path
+        file_name = os.path.basename(file_path)
+        chunk_size = 8192
+
+        def file_iterator():
+            with open(file_path, 'rb') as f:
+                while chunk := f.read(chunk_size):
+                    yield chunk
+
+        response = StreamingHttpResponse(file_iterator())
+        response['Content-Type'] = 'application/octet-stream'
+        response['Content-Length'] = os.path.getsize(file_path)
+        response['Content-Disposition'] = f'attachment; filename="{file_name}"'
+        return response
+    except Exception as e: 
+        exc_type, exc_obj, exc_tb = sys.exc_info()
+        line_number = exc_tb.tb_lineno
+        print(f"Error on line {line_number}: {e}")
+        return HttpResponseBadRequest('Internal Error.', status=500)

backend/api/test.py

@@ -0,0 +1,17 @@
+
+import json, environ, requests, os
+
+from django.core.files.uploadedfile import TemporaryUploadedFile
+from django.http import HttpResponse, JsonResponse, HttpResponseBadRequest
+from django_ratelimit.decorators import ratelimit
+
+from core.settings import BASE_DIR
+
+from backend.module import web_scrap
+
+env = environ.Env()
+
+
+@ratelimit(key='ip', rate='60/m')
+def run_1(request):
+   pass

backend/api/web_scrap.py

@@ -0,0 +1,111 @@
+
+import json, environ, requests, os, subprocess
+import asyncio, uuid
+
+from django.http import HttpResponse, JsonResponse, HttpResponseBadRequest
+from django_ratelimit.decorators import ratelimit
+from django.views.decorators.csrf import csrf_exempt
+from asgiref.sync import sync_to_async
+
+from backend.module import web_scrap
+from backend.module.utils import manage_image
+from backend.models.model_cache import RequestCache
+from core.settings import BASE_DIR
+from backend.module.utils import cloudflare_turnstile
+
+
+env = environ.Env()
+
+
+@csrf_exempt
+@ratelimit(key='ip', rate='60/m')
+def get_list(request):
+    if request.method != "POST": return HttpResponseBadRequest('Allowed POST request only!', status=400)
+    token = request.META.get('HTTP_X_CLOUDFLARE_TURNSTILE_TOKEN')
+    if not cloudflare_turnstile.check(token): return HttpResponseBadRequest('Cloudflare turnstile token not existed or expired!', status=511)
+    
+    payload = json.loads(request.body)
+    search = payload.get("search")
+    page = payload.get("page")
+    source = payload.get("source")
+    
+    if search.get("text"): DATA = web_scrap.source_control[source].search.scrap(search=search,page=page)
+    else: DATA = web_scrap.source_control["colamanga"].get_list.scrap(page=page)
+
+    return JsonResponse({"data":DATA}) 
+
+
+@ratelimit(key='ip', rate='60/m')
+def search(request):
+    # if request.method != "POST": return HttpResponseBadRequest('Allowed POST request only!', status=400)
+    try:
+        DATA = web_scrap.source_control["colamanga"].search.scrap(search="妖")
+        return JsonResponse({"data":DATA}) 
+    except Exception as e:
+        return HttpResponseBadRequest(str(e), status=500)
+    
+
+
+@csrf_exempt
+@ratelimit(key='ip', rate='60/m')
+def get(request):
+    if request.method != "POST": return HttpResponseBadRequest('Allowed POST request only!', status=400)
+    token = request.META.get('HTTP_X_CLOUDFLARE_TURNSTILE_TOKEN')
+    if not cloudflare_turnstile.check(token): return HttpResponseBadRequest('Cloudflare turnstile token not existed or expired!', status=511)
+    
+    payload = json.loads(request.body)
+    id = payload.get("id")
+    source = payload.get("source")
+    
+    try:
+        DATA = web_scrap.source_control[source].get.scrap(id=id)
+        return JsonResponse({"data":DATA}) 
+    except Exception as e:
+
+        return HttpResponseBadRequest(str(e), status=500)
+
+
+@ratelimit(key='ip', rate='60/m')
+def get_cover(request,source,id,cover_id):
+    token = request.META.get('HTTP_X_CLOUDFLARE_TURNSTILE_TOKEN')
+    if not cloudflare_turnstile.check(token): return HttpResponseBadRequest('Cloudflare turnstile token not existed or expired!', status=511)
+    
+    try:
+        DATA = web_scrap.source_control[source].get_cover.scrap(id=id,cover_id=cover_id)
+        if not DATA: HttpResponseBadRequest('Image Not found!', status=404)
+        response = HttpResponse(DATA, content_type="image/png")
+        response['Content-Disposition'] = f'inline; filename="{id}-{cover_id}.png"'
+        return response
+    except Exception as e:
+        return HttpResponseBadRequest(str(e), status=500)
+
+    
+def get_chapter(request):
+    try:
+        id = "manga-lo816008/1/410.html"
+        job = web_scrap.source_control["colamanga"].get_chapter.scrap(id=id,output_dir=os.path.join(BASE_DIR,"media"))
+        if job.get("status") == "success":
+            chapter_id = id.split("/")[-1].split(".")[0]
+            input_dir = os.path.join(BASE_DIR,"media",id.split("/")[0],chapter_id,"original")
+            merged_output_dir =  os.path.join(BASE_DIR,"media",id.split("/")[0],chapter_id,"merged")
+            os.makedirs(merged_output_dir,exist_ok=True)
+            
+            manage_image.merge_images_vertically(input_dir=input_dir,output_dir=merged_output_dir,max_size=10*1024*1024)
+
+            translated_merged_output_dir = os.path.join(BASE_DIR,"media",id.split("/")[0],chapter_id,"merged_translated")
+            os.makedirs(translated_merged_output_dir,exist_ok=True)
+        
+        
+            subprocess.run(
+                ["python", "-m", "manga_translator", "-v", "--manga2eng", "--translator=m2m100_big", "-l", "ENG", "-i", f"{merged_output_dir}", "-o", f"{translated_merged_output_dir}"],
+                cwd=os.path.join(BASE_DIR,"backend","module","utils","image_translator"), shell=True, check=True
+            )
+            
+            translated_splited_output_dir = os.path.join(BASE_DIR,"media",id.split("/")[0],chapter_id,"translated")
+            
+            os.makedirs(translated_splited_output_dir,exist_ok=True)
+            manage_image.split_image_vertically(input_dir=translated_merged_output_dir,output_dir=translated_splited_output_dir)
+    except Exception as e:
+        print(e)
+            
+    return JsonResponse({})

backend/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class BackendConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'backend'

backend/invoke_worker/__init__.py

@@ -0,0 +1,11 @@
+from core.settings import DEBUG
+import sys
+
+if len(sys.argv) > 1 and not (sys.argv[1] in ['migrate', "makemigrations", "clear_all_sessions"]):
+    print("[Worker] Starting Thread...")
+    from backend.invoke_worker import (
+        session,
+        chapter_queue,
+    )
+    print("[Worker] Thread Started!")
+

backend/invoke_worker/chapter_queue.py

@@ -0,0 +1,266 @@
+from django_thread import Thread
+from time import sleep
+from backend.module.utils import date_utils
+from django.db import connections
+from backend.models.model_cache import SocketRequestChapterQueueCache, ComicStorageCache
+from core.settings import BASE_DIR
+from backend.module import web_scrap
+from backend.module.utils import manage_image
+from backend.module.utils.directory_info import GetDirectorySize
+
+from channels.layers import get_channel_layer
+from asgiref.sync import async_to_sync
+
+from django.db.models import Count
+
+import requests, environ, os, subprocess, shutil, zipfile, uuid
+
+env = environ.Env()
+
+# os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
+
+STORAGE_DIR = os.path.join(BASE_DIR,"storage")
+LOG_DIR = os.path.join(BASE_DIR, "log")
+if not os.path.exists(LOG_DIR): os.makedirs(LOG_DIR)
+
+MAX_STORAGE_SIZE = 20 * 1024**3
+
+class Job(Thread):
+    def run(self):
+        while True: 
+            input_dir = ""
+            managed_output_dir = ""
+            try:
+                
+                query_result = SocketRequestChapterQueueCache.objects.order_by("datetime").first()
+                while True:
+                    if (GetDirectorySize(STORAGE_DIR) >= MAX_STORAGE_SIZE):
+                        query_result_2 = ComicStorageCache.objects.order_by("datetime").first()
+                        if (query_result_2):
+                            file_path = query_result_2.file_path
+                            if os.path.exists(file_path): os.remove(file_path)
+                        ComicStorageCache.objects.filter(id=query_result_2.id).delete()
+                    else: break
+                
+                if (query_result):
+                    socket_id = query_result.socket_id
+                    channel_name = query_result.channel_name
+                    source = query_result.source
+                    comic_id = query_result.comic_id
+                    chapter_id = query_result.chapter_id   
+                    chapter_idx = query_result.chapter_idx
+                    options = query_result.options
+                    if (options.get("translate").get("state")): 
+                        target_lang = options.get("translate").get("target")
+                    else: target_lang = ""
+                            
+                    stored = ComicStorageCache.objects.filter(
+                        source=source,
+                        comic_id=comic_id,
+                        chapter_id=chapter_id,
+                        chapter_idx=chapter_idx,
+                        colorize= options.get("colorize"),
+                        translate= options.get("translate").get("state"),
+                        target_lang= target_lang,
+                    ).first()
+                    if (stored):
+                        SocketRequestChapterQueueCache.objects.filter(id=query_result.id).delete()
+                        connections['cache'].close()
+                    else:
+                        connections['cache'].close()
+                        
+                        script = []
+                        
+                        input_dir = os.path.join(STORAGE_DIR,source,comic_id,str(chapter_idx),"temp")
+                        
+                        if (options.get("translate").get("state") and options.get("colorize")):
+                            
+                            managed_output_dir = os.path.join(STORAGE_DIR,source,comic_id,str(chapter_idx),f"{options.get("translate").get("target")}_translated_colorized")
+                            script = ["python", "-m", "manga_translator", "-v", "--overwrite", "--attempts=3", "--ocr=mocr", "--no-text-lang-skip", "--det-auto-rotate", "--det-gamma-correct", "--colorize=mc2", "--translator=m2m100_big", "-l", f"{options.get("translate").get("target")}", "-i", f"{input_dir}", "-o", f"{managed_output_dir}"]
+                        elif (options.get("translate").get("state") and not options.get("colorize")):
+                            
+                            managed_output_dir = os.path.join(STORAGE_DIR,source,comic_id,str(chapter_idx),f"{options.get("translate").get("target")}_translated")
+                            script = ["python", "-m", "manga_translator", "-v", "--overwrite", "--attempts=3", "--ocr=mocr", "--no-text-lang-skip", "--det-auto-rotate", "--det-gamma-correct", "--translator=m2m100_big", "-l", f"{options.get("translate").get("target")}", "-i", f"{input_dir}", "-o", f"{managed_output_dir}"]
+                        elif (options.get("colorize") and not options.get("translate").get("state")):
+                            
+                            managed_output_dir = os.path.join(STORAGE_DIR,source,comic_id,str(chapter_idx),"colorized")
+                            script = ["python", "-m", "manga_translator", "-v", "--overwrite", "--attempts=3", "--detector=none", "--translator=original", "--colorize=mc2", "--colorization-size=-1", "-i", f"{input_dir}", "-o", f"{managed_output_dir}"]
+
+                        if target_lang == "ENG": script.append("--manga2eng")
+                            
+                        
+                        
+                        if (options.get("colorize") or options.get("translate").get("state")):
+                            if os.path.exists(input_dir): shutil.rmtree(input_dir)
+                            if os.path.exists(managed_output_dir): shutil.rmtree(managed_output_dir)
+                            
+                            job = web_scrap.source_control[source].get_chapter.scrap(comic_id=comic_id,chapter_id=chapter_id,output_dir=input_dir)
+                            if job.get("status") == "success":
+                                with open(os.path.join(LOG_DIR,"image_translator_output.log"), "w") as file:
+                                    result = subprocess.run(
+                                        script,
+                                        cwd=os.path.join(BASE_DIR, "backend", "module", "utils", "image_translator"),
+                                        shell=True,
+                                        check=True,
+                                        stdout=file,
+                                        stderr=file,
+                                        text=True,
+                                    )
+                                if result.returncode != 0: raise Exception("Image Translator Execution error!")
+                                os.makedirs(managed_output_dir,exist_ok=True)
+                                shutil.rmtree(input_dir)
+                                
+                                with zipfile.ZipFile(managed_output_dir + '.zip', 'w') as zipf:
+                                    for foldername, subfolders, filenames in os.walk(managed_output_dir):
+                                        for filename in filenames:
+                                            if filename.endswith(('.png', '.jpg', '.jpeg')):
+                                                file_path = os.path.join(foldername, filename)
+                                                zipf.write(file_path, os.path.basename(file_path))
+                                shutil.rmtree(managed_output_dir)
+                                
+                                
+                                ComicStorageCache(
+                                    source = source,
+                                    comic_id = comic_id,
+                                    chapter_id = chapter_id,
+                                    chapter_idx = chapter_idx,
+                                    file_path = managed_output_dir + ".zip",
+                                    colorize = options.get("colorize"),
+                                    translate = options.get("translate").get("state"),
+                                    target_lang = target_lang,
+                                    
+                                ).save()
+                                
+                                
+                                query_result_3 = SocketRequestChapterQueueCache.objects.filter(id=query_result.id).first()
+                                channel_name = query_result_3.channel_name if query_result_3 else ""
+                                channel_layer = get_channel_layer()
+                                async_to_sync(channel_layer.send)(channel_name, {
+                                    'type': 'event_send',
+                                    'data': {
+                                        "type": "chapter_ready_to_download",
+                                        "data": {
+                                            "source": source,
+                                            "comic_id": comic_id,
+                                            "chapter_id": chapter_id,
+                                            "chapter_idx": chapter_idx
+                                        }
+                                    }
+                                })
+                                SocketRequestChapterQueueCache.objects.filter(id=query_result.id).delete()
+                        else:
+                            input_dir = os.path.join(STORAGE_DIR,source,comic_id,str(chapter_idx),"original")
+                            if os.path.exists(input_dir): shutil.rmtree(input_dir)
+                            
+                            job = web_scrap.source_control["colamanga"].get_chapter.scrap(comic_id=comic_id,chapter_id=chapter_id,output_dir=input_dir)
+                        
+                            with zipfile.ZipFile(input_dir + '.zip', 'w') as zipf:
+                                for foldername, subfolders, filenames in os.walk(input_dir):
+                                    for filename in filenames:
+                                        if filename.endswith(('.png', '.jpg', '.jpeg')):
+                                            file_path = os.path.join(foldername, filename)
+                                            zipf.write(file_path, os.path.basename(file_path))
+                            shutil.rmtree(input_dir)
+                            
+                            ComicStorageCache(
+                                    source = source,
+                                    comic_id = comic_id,
+                                    chapter_id = chapter_id,
+                                    chapter_idx = chapter_idx,
+                                    file_path = input_dir + '.zip',
+                                    colorize = False,
+                                    translate = False,
+                                    target_lang = "",
+                                    
+                            ).save()
+                            query_result_3 = SocketRequestChapterQueueCache.objects.filter(id=query_result.id).first()
+                            channel_name = query_result_3.channel_name if query_result_3 else ""
+                            channel_layer = get_channel_layer()
+                            async_to_sync(channel_layer.send)(channel_name, {
+                                'type': 'event_send',
+                                'data': {
+                                    "type": "chapter_ready_to_download",
+                                    "data": {
+                                        "source": source,
+                                        "comic_id": comic_id,
+                                        "chapter_id": chapter_id,
+                                        "chapter_idx": chapter_idx
+                                    }
+                                }
+                            })
+                            SocketRequestChapterQueueCache.objects.filter(id=query_result.id).delete() 
+                        
+                        connections['cache'].close()
+                else:
+                    connections['cache'].close()
+                    sleep(5)
+            except Exception as e: 
+                print("[Error] Chapter Queue Socket:", e) 
+                if (input_dir): 
+                    if os.path.exists(input_dir): shutil.rmtree(input_dir) 
+                if (managed_output_dir):
+                    if os.path.exists(managed_output_dir): shutil.rmtree(managed_output_dir)
+                query_result_3 = SocketRequestChapterQueueCache.objects.filter(id=query_result.id).first()
+                channel_name = query_result_3.channel_name if query_result_3 else ""
+                channel_layer = get_channel_layer()
+                async_to_sync(channel_layer.send)(channel_name, {
+                    'type': 'event_send',
+                    'data': {
+                        "type": "chapter_ready_to_download",
+                        "data": {"state":"error"}
+                    }
+                })
+                
+                SocketRequestChapterQueueCache.objects.filter(id=query_result.id).delete() 
+                connections['cache'].close()
+                sleep(10)
+
+thread = Job()
+thread.daemon = True
+thread.start()
+
+class UpdateSocketQueue(Thread):
+    def run(self):
+        while True:
+            try:
+                queue = 0
+                MAX_QUEUE = SocketRequestChapterQueueCache.objects.count()
+                
+                if (MAX_QUEUE):
+                    query_result = list(set(SocketRequestChapterQueueCache.objects.order_by("datetime").values_list('socket_id', flat=True).distinct()))
+                    for socket_id in query_result:
+                        object = {}
+                        query_result_2 = SocketRequestChapterQueueCache.objects.filter(socket_id=socket_id).order_by("datetime").values("source","comic_id","chapter_idx")
+                        
+                        for item in query_result_2:
+                            source = item.get("source")
+                            comic_id = item.get("comic_id")
+                            chapter_idx = item.get("chapter_idx")
+                            
+                            object[f"{source}-{comic_id}-{chapter_idx}"] = queue
+                            
+                            queue += 1
+                        
+                        query_result_3 = SocketRequestChapterQueueCache.objects.filter(socket_id=socket_id).first()
+                        if (query_result_3):
+                            channel_layer = get_channel_layer()
+                            async_to_sync(channel_layer.send)(query_result_3.channel_name, {
+                                'type': 'event_send',
+                                'data': {
+                                    "type": "chapter_queue_info",
+                                    "chapter_queue": {
+                                        "queue": object,
+                                        "max_queue": MAX_QUEUE,
+                                    }
+                                }
+                            })
+                else:
+                    pass
+            except Exception as e:
+                print(e)
+                
+            connections['cache'].close()
+            sleep(10)
+thread = UpdateSocketQueue()
+thread.daemon = True
+thread.start()

backend/invoke_worker/session.py

@@ -0,0 +1,24 @@
+from django_thread import Thread
+from time import sleep
+from backend.module.utils import date_utils
+import requests, environ
+from core import settings
+
+env = environ.Env()
+
+class Delete(Thread):
+    def run(self):
+        while True: 
+            try:
+                requests.post(f'{settings.WORKER_SERVED_SCOPE}/worker/session/delete_outdated/', headers={"Worker-Token": env("WORKER_TOKEN")})
+                print('[Worker] All expired sessions have been cleared successfully.')
+                sleep(1.5 * 60 * 60)
+            except Exception as e: 
+                print(e) 
+                sleep(10)
+
+thread = Delete()
+thread.daemon = True
+thread.start()
+
+

backend/management/commands/clear_all_sessions.py

@@ -0,0 +1,11 @@
+from django.core.management.base import BaseCommand
+from django.contrib.sessions.models import Session
+from django.db import connections
+
+class Command(BaseCommand):
+    help = 'Clear all sessions'
+
+    def handle(self, *args, **options):
+        for db in connections.databases:
+            Session.objects.using(db).all().delete()
+        self.stdout.write('All sessions have been cleared.')