Initial upload of PWDLV3 content

.gitattributes

@@ -1,35 +1,2 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz 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
+# Auto detect text files and perform LF normalization
+* text=auto

.github/workflows/Setup.yml

@@ -0,0 +1,60 @@
+name: Verify PWDLv3 Setup
+on:
+  workflow_dispatch:
+
+jobs:
+  verify_setup:
+    runs-on: windows-latest
+    steps:
+      - name: Download Setup Script
+        run: |
+          curl -o setup_pwdl.bat -L https://gist.githubusercontent.com/shubhamakshit/8654b80e9f64c2791d7f8e681cb1b47d/raw
+          dir setup_pwdl.bat
+          
+      - name: Verify Script Content
+        shell: powershell
+        run: |
+          Write-Host "Checking script content..."
+          Get-Content setup_pwdl.bat
+          
+      - name: Run Setup Script
+        shell: cmd
+        run: |
+          echo "Starting setup..."
+          setup_pwdl.bat
+          echo "Setup completed"
+          
+      - name: Verify Installation
+        shell: powershell
+        run: |
+          Write-Host "Checking environment..."
+          $env:Path = [System.Environment]::GetEnvironmentVariable("Path","Machine") + ";" + [System.Environment]::GetEnvironmentVariable("Path","User")
+          
+          Write-Host "Checking PWDL installation..."
+          Get-Command pwdl -ErrorAction SilentlyContinue
+          if ($?) {
+              Write-Host "PWDL command found"
+              pwdl --version
+              pwdl --help
+          } else {
+              Write-Error "PWDL command not found"
+              exit 1
+          }
+          
+          Write-Host "Checking if service is running..."
+          pwdl --verbose
+          
+      - name: Check Dependencies
+        shell: powershell
+        run: |
+          Write-Host "Verifying dependencies..."
+          $deps = @("python", "git", "ffmpeg")
+          foreach ($dep in $deps) {
+              if (Get-Command $dep -ErrorAction SilentlyContinue) {
+                  Write-Host "$dep is installed and accessible"
+                  & $dep --version
+              } else {
+                  Write-Error "$dep is not installed or not in PATH"
+                  exit 1
+              }
+          }

.github/workflows/main.yml

@@ -0,0 +1,34 @@
+name: Build and Push Docker Image
+
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v1
+
+    - name: Login to Docker Hub
+      uses: docker/login-action@v2
+      with:
+        username: ${{ secrets.DOCKER_HUB_USERNAME }}
+        password: ${{ secrets.DOCKER_HUB_ACCESS_TOKEN }}
+
+    - name: Build and push Docker image
+      uses: docker/build-push-action@v2
+      with:
+        context: .
+        push: true
+        tags: shubhamakshit/pwdl:latest
+
+    - name: Logout Docker Hub
+      run: docker logout

.gitignore

@@ -0,0 +1,204 @@
+# Created by https://www.toptal.com/developers/gitignore/api/python
+# Edit at https://www.toptal.com/developers/gitignore?templates=python
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# IDE
+.idea/
+
+# Download Files
+webdl/
+
+# CSV Files
+*.csv
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+### Python Patch ###
+# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
+poetry.toml
+
+# ruff
+.ruff_cache/
+
+# LSP config files
+pyrightconfig.json
+
+# End of https://www.toptal.com/developers/gitignore/api/python
+pwdlv3.lnk
+*.mp4
+/bin/Logs/
+*.m4s
+/tmp
+/bin
+*.un~
+*.py~
+
+# ignore all *.test.py files
+*.test.py
+#*.json
+clients.json
+clients.json
+/csv_files/
+/populate.py
+/populate.py
+/populate.py
+pop.bat

Dockerfile

@@ -0,0 +1,40 @@
+# Use an official Python runtime as a parent image
+FROM python:3.12-slim
+
+# Set the working directory in the container to /app
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    ffmpeg \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create bin directory and download mp4decrypt
+RUN mkdir -p /app/bin && \
+    curl -o /app/bin/mp4decrypt https://raw.githubusercontent.com/shubhamakshit/pwdlv3_assets/main/GNU/Linux/x86_64/mp4decrypt && \
+    chmod +x /app/bin/mp4decrypt
+
+# Add /app/bin to PATH
+ENV PATH="/app/bin:$PATH"
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies including gunicorn
+RUN pip install --no-cache-dir -r requirements.txt && \
+    pip install --no-cache-dir gunicorn
+
+# Copy the rest of the application
+COPY . .
+
+# Make sure /app is writable (after copying files)
+RUN chmod -R 777 /app && \
+    mkdir -p /app/webdl && \
+    chmod 777 /app/webdl
+
+# Expose port 7860 for HuggingFace Spaces
+EXPOSE 7860
+
+# Run the application with gunicorn
+CMD ["gunicorn", "--bind", "0.0.0.0:7860","--timeout", "120", "beta.api.api:app"]

README.md

@@ -1,12 +1,62 @@
 ---
-title: Pwdlv3.1
-emoji: 🏢
-colorFrom: green
-colorTo: purple
+title: pwdlv3
+emoji: 📦
+colorFrom: red
+colorTo: blue
 sdk: gradio
-sdk_version: 5.38.0
-app_file: app.py
+sdk_version: "20.10"
+app_file: Dockerfile
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# PWDLv3 - pw.live Downloader  Version 3
+
+## History 
+This project started way back in 2023 as [pwdl](https://github.com/shubhamakshit/pwdl). It was then merely a script for downloading segments using a loophole in pw's api. When it got pached we moved on to [pwdlv2](https://github.com/shubhamakshit/pwdlv2) in March, 2024. It was mostly haphazard code. pwdlv3 started in April, 2024 as is proudly growing ever since.
+
+## Installing guide 
+
+### Windows (64bit)
+Open Powershell as **Administrator**
+```powershell
+irm https://raw.githubusercontent.com/shubhamakshit/pwdlv3_assets/main/dl.pwdlv3.ps1 | iex
+```
+
+### Linux (64bit)
+```bash
+git clone https://github.com/shubhamakshit/pwdlv3.git
+cd pwdlv3
+chmod +x ./setup.sh
+./setup.sh -f # -f means ffmpeg ; (ffmpeg binary in PATH is given preference)
+source ~/.bashrc
+```
+## Getting started 
+### Logging in 
+For *more* interactive login
+```bash
+pwdl --login 
+```
+For  *less* interactive login
+**Tip** :  Prepend the phone number by `wa` for whatsapp OTP.
+```bash
+pwdl --phone waXXXXXXXXXX # or pwdl --phone XXXXXXXXXX
+```
+### Starting webui 
+The webui as of May, 2025 has moved to [pwdl-webui.vercel.app](https://pwdl-webui.vercel.app). The backend however must be on your local machine.
+```bash
+pwdl --webui
+```
+1. Look for a url with a port number (default:**5000**)
+![445214262-64343af7-bad5-4fcb-b600-1ac95b710b9f](https://github.com/user-attachments/assets/4c3dfb35-dd57-4386-bac9-e2a6671b7b8e)
+
+2. Open that url. In most cases [localhost:5000](http://localhost:5000).
+![image](https://github.com/user-attachments/assets/c1a8cfef-78d5-4d89-b76a-74c4b69e1671)
+
+3. Open the Online WebUI. As of now [pwdl-webui.vercel.app](https://pwdl-webui.vercel.app).
+![image](https://github.com/user-attachments/assets/44aae130-3803-4a5c-ad49-9e2601ac3e82)
+
+    1. Open Settings -> WebSettings Click on Edit and change the API value to the url obtained in 2.
+       ![image](https://github.com/user-attachments/assets/62aec806-b4ea-48a3-bda0-944c601408fd)
+    2. Explore other values of Web Settings to get your desired value.
+    3. Open 'BOSS' (Library) and Enjoy 

beta/Syncer/db_utils/DataObject.py

@@ -0,0 +1,101 @@
+from beta.Syncer.db_utils.Errors import Errors
+from beta.Syncer.db_utils.Schema import Schema
+
+
+class DbObject:
+
+    class IllegalDBTuple(Exception):
+
+        req_size = 2
+
+        def __init__(self, data):
+            self.data = data
+            super().__init__(f"Data must be a tuple, got {type(data)}")
+
+        def __str__(self):
+            if len(self.data) != self.req_size:
+                return f"Data must be a tuple of length 2, got {len(self.data)}"
+            return f"Data must be a tuple, got {type(self.data)}"
+
+    class AttrNotFound(Exception):
+
+        def __init__(self, key):
+            self.key = key
+            super().__init__(f"Attribute {key} not found")
+
+        def __str__(self):
+            return f"Attribute {self.key} not found"
+
+    class IncompleteData(Exception):
+
+        def __init__(self, key):
+            self.key = key
+            super().__init__(f"Key {key} is required")
+
+        def __str__(self):
+            return f"Key {self.key} is required"
+
+
+
+
+
+
+    def __init__(self, schema, add_id=True):
+        self.schema = Schema(schema) if isinstance(schema, dict) else schema
+        if add_id:
+            self.schema.add_id()
+            self._id = self.schema.schema["_id"]["function"]()
+
+    def __str__(self):
+        return str(self.compile())
+
+    def add(self, data):
+        if not isinstance(data, tuple):
+            raise DbObject.IllegalDBTuple(data)
+
+        key = data[0]
+        value = data[1]
+
+        if self.schema.validate(key, value):
+            setattr(self, key, value)
+            return self
+
+    def does_exist(self, key):
+        return hasattr(self, key)
+
+    def update(self,data):
+        if not isinstance(data, tuple):
+            raise DbObject.IllegalDBTuple(data)
+
+        key = data[0]
+        value = data[1]
+
+        if self.schema.validate(key, value):
+            if not self.does_exist(key):
+                raise DbObject.AttrNotFound(key)
+            self.add(data)
+            return self
+
+    def compile(self):
+        data = {}
+        for key, value in self.schema.schema.items():
+            if not self.does_exist(key):
+                if self.schema.is_required(key):
+                    raise DbObject.IncompleteData(key)
+            else:
+                data[key] = getattr(self, key)
+        return data
+
+    def del_key(self, key):
+        if self.does_exist(key): delattr(self, key)
+
+    def req_keys_more(self):
+        return self.keys_more(req=True)
+
+    def keys_more(self,req=False):
+        inc = []
+        for key in self.schema.get_keys():
+            #print(f"Debug: does_exist({key}) = {self.does_exist(key)}")
+            if  self.schema.is_required(key) and (req and not self.does_exist(key)):
+                inc.append(key)
+        return inc

beta/Syncer/db_utils/Database.py

@@ -0,0 +1,77 @@
+from pymongo import MongoClient
+from pymongo.server_api import ServerApi
+
+from beta.Syncer.db_utils.DataObject import DbObject
+from beta.Syncer.db_utils.Schema import Schema
+
+
+class DB:
+
+
+    def __init__(self,uri):
+        import dns.resolver
+        dns.resolver.default_resolver=dns.resolver.Resolver(configure=False)
+        dns.resolver.default_resolver.nameservers=['8.8.8.8']
+        self.uri = uri
+        self.client = MongoClient(uri, server_api=ServerApi('1'))
+        self.db = self.client["OPCluster"]
+        self.collection = self.db["OPCluster"]
+
+    def set_db(self,db):
+        self.db = self.client[db]
+        return self
+
+    def set_collection(self,collection):
+        self.collection = self.db[collection]
+        return self
+
+    def insert(self,db_obj:DbObject):
+        return self.collection.insert_one(db_obj.compile())
+
+    def find(self,query):
+        return self.collection.find(query)
+
+    def list_all(self):
+        import json
+        for i in self.collection.find():
+            print(json.dumps(i, indent=4))
+
+    def get_object(self,query):
+        data = self.collection.find_one(query)
+
+        if data:
+            obj = DbObject(Schema.gen_schema(data))
+            for key, value in data.items():
+                obj.add((key, value))
+        else:
+            obj = DbObject(Schema.gen_schema(data), False)
+        return obj
+
+    def get_objects(self,query,limit:int = 0):
+        data = self.collection.find(query).limit(limit)
+        objs = []
+        for i in data:
+            obj = DbObject(Schema.gen_schema(i))
+            for key, value in i.items():
+                obj.add((key, value))
+            objs.append(obj)
+        return objs
+
+
+
+    def delete(self,query):
+        return self.collection.delete_one(query)
+
+    def delete_many(self,query):
+        return self.collection.delete_many(query)
+
+    def update(self,query,update):
+        return self.collection.update_one(query,update)
+
+    def update_many(self,query,update):
+        return self.collection.update_many(query,update)
+
+    def ping(self):
+        return self.client.server_info()
+
+

beta/Syncer/db_utils/Errors.py

@@ -0,0 +1,21 @@
+class Errors:
+
+
+
+
+    class IllegalType(Exception):
+
+        def __init__(self,data_type,key,object={}):
+            self.data_type = data_type
+            self.key = key
+            self.object = object
+            super().__init__(f"Expected {data_type} for key {key} in object {object}")
+
+    class MissingKey(Exception):
+
+        def __init__(self,key,object={}):
+            self.key = key
+            self.object = object
+
+        def __str__(self):
+            return f"Missing key {self.key} in object {self.object}"

beta/Syncer/db_utils/Schema.py

@@ -0,0 +1,100 @@
+from beta.Syncer.db_utils.Errors import Errors
+import uuid
+
+class Schema:
+    class InvalidSchema(Exception):
+        def __init__(self, schema, key, value, type, required=False):
+            self.schema = schema
+            self.key = key
+            self.value = value
+            self.type = type
+            self.required = required
+            super().__init__(f"Invalid schema {schema}")
+
+        def __str__(self):
+            if self.required:
+                return f"Invalid schema {self.schema} for key {self.key} with value {self.value} of type {type(self.type)} is required"
+            return f"Invalid schema {self.schema} for key {self.key} with value {self.value} of type {type(self.value)} with expected type {self.type}"
+
+    class InvalidIdFunction (Exception):
+        def __init__(self, schema):
+            self.schema = schema
+            super().__init__(f"Invalid id function for schema {schema}")
+
+        def __str__(self):
+            return f"Invalid id function for schema {self.schema}"
+
+    test_schema = {
+        "key": {
+            "type": str,
+            "required": True
+        }
+    }
+
+    def __init__(self, schema):
+        self.schema = schema
+
+    def has_id(self):
+        return "_id" in self.schema
+
+    def generate_id(self):
+        return str(uuid.uuid4())
+
+    def add_id(self):
+
+        if not self.has_id():
+            self.schema["_id"] = {
+                "type": str,
+                "required": True,
+                "function": self.generate_id
+            }
+        if not "function" in self.schema["_id"]:
+            self.schema["_id"]["function"] = self.generate_id
+
+        if not callable(self.schema["_id"]["function"]):
+            raise Schema.InvalidIdFunction(self.schema)
+
+
+
+
+
+    def validate_schema(self, data):
+        for key, value in self.schema.items():
+            if key not in data:
+                if not "required" in value or value["required"]:
+                    raise Schema.InvalidSchema(self.schema, key, None, value["type"], True)
+            else:
+                if not isinstance(data[key], value["type"]):
+                    raise Schema.InvalidSchema(self.schema, key, data[key], value["type"])
+        return True
+
+    def validate(self, key, value):
+        if key not in self.schema:
+            raise Errors.MissingKey(key, self.schema)
+        if not isinstance(value, self.schema[key]["type"]):
+            raise Errors.IllegalType(self.schema[key]["type"], key, value)
+        return True
+
+
+    def get_type(self, key):
+        if key not in self.schema:
+            raise Errors.MissingKey(key, self.schema)
+        return self.schema[key]["type"]
+
+    def is_required(self, key):
+        if key not in self.schema:
+            raise Errors.MissingKey(key, self.schema)
+        return (not "required" in self.schema[key]) or (self.schema[key]["required"])
+
+    def get_keys(self):
+        return [key for key in self.schema]
+
+    @staticmethod
+    def gen_schema(data):
+        schema = {}
+        if data:
+            for key, value in data.items():
+                schema[key] = {
+                    "type": type(value)
+                }
+        return schema

beta/Syncer/main.py

@@ -0,0 +1,112 @@
+import random
+
+from beta.Syncer.db_utils.DataObject import DbObject
+from beta.Syncer.db_utils.Database import DB
+from beta.update import UpdateJSONFile
+from mainLogic.error import debugger
+from mainLogic.utils import glv_var
+
+user_schema = {
+    "_id":{
+        "type": str,
+        "required": True,
+    },
+    "token":{
+        "type": dict,
+        "required": True,
+    },
+    "user_update_index":{
+        "type": int,
+        "required": True,
+    }
+}
+
+class Syncer:
+    def __init__(self):
+        self.url = "mongodb+srv://tshonqkhan:[email protected]/?retryWrites=true&w=majority&appName=Eminem"
+        self.database = DB(self.url).set_db("pwdlv3").set_collection("users")
+        self.updater = UpdateJSONFile(glv_var.PREFS_FILE)
+        self.user_id = self.updater.data.get("user_id", "")
+        self.user_update_index = self.updater.data.get("user_update_index", 0)
+
+        # Initialize sync on creation
+        self.sync()
+
+    def sync(self):
+        # get user id from prefs
+        user_id = self.user_id
+        if not user_id:
+            debugger.error("No user ID found in preferences")
+            return
+
+        debugger.debug(f"User id: {user_id}")
+
+        # check if user exists
+        user = self.database.get_object({"_id": user_id}).compile()
+
+        if user:
+            debugger.debug(f"User found: {user}")
+
+            # Get update indices
+            local_update_index = self.user_update_index
+            db_update_index = user.get("user_update_index", 0)
+
+            # Check if local index is -1 (force update)
+            if local_update_index == -1:
+                debugger.debug("Force update requested")
+                # Update local token with DB token
+                self.updater.update("token", user.get("token", {}))
+                # Reset local update index to match DB
+                self.updater.update("user_update_index", db_update_index)
+                debugger.debug(f"Token forcefully updated from DB. Update index reset to {db_update_index}")
+
+            # Check if local index is less than DB index (DB has newer data)
+            elif local_update_index < db_update_index:
+                debugger.debug(f"Local update index ({local_update_index}) is less than DB index ({db_update_index})")
+                # Update local token with DB token
+                self.updater.update("token", user.get("token", {}))
+                # Update local update index to match DB
+                self.updater.update("user_update_index", db_update_index)
+                debugger.debug("Token updated from DB")
+
+            # Check if local index is greater than DB index (local has newer data)
+            elif local_update_index > db_update_index:
+                debugger.debug(f"Local update index ({local_update_index}) is greater than DB index ({db_update_index})")
+                # Update DB token with local token
+                self.update_token(user_id, self.updater.data.get("token", {}), local_update_index)
+
+            else:
+                debugger.debug(f"Update indices match ({local_update_index}). No sync needed.")
+        else:
+            debugger.debug("User not found")
+            # create new user with initial update index of 0
+            user = DbObject(user_schema) \
+                .add(("_id", user_id)) \
+                .add(("token", {})) \
+                .add(("user_update_index", 0))
+            self.database.insert(user)
+            debugger.debug(f"User created: {user}")
+            debugger.error(f"Since user was not found, a new user was created. Please restart the app to sync the token.")
+
+    def update_token(self, user_id, token, update_index=None):
+        # If no update index provided, increment the current one
+        if update_index is None:
+            update_index = self.user_update_index + 1
+
+        # Update token in database
+        self.database.update({
+            "_id": user_id
+        }, {
+            "$set": {
+                "token": token,
+                "user_update_index": update_index
+            }
+        })
+
+        # Update local preferences
+        self.updater.update("token", token)
+        self.updater.update("user_update_index", update_index)
+
+        debugger.debug(f"Token updated in DB with update index: {update_index}")
+        debugger.error(f"Token updated. Please restart the app to sync the token.")
+

beta/api/api.py

@@ -0,0 +1,55 @@
+import os
+from flask import Flask, request
+from flask_cors import CORS
+from beta.api.blueprints.admin_routes import admin
+from beta.api.blueprints.api_pref_manager import api_prefs
+from beta.api.blueprints.client_info_routes import client_info
+from beta.api.blueprints.leagacy_create_task import legacy_create_task
+from beta.api.blueprints.login import login
+from beta.api.blueprints.scarper import scraper_blueprint
+from beta.api.blueprints.session_lodge import session_lodge
+from beta.api.blueprints.template_routes import template_blueprint
+from beta.api.blueprints.while_dl_and_post_dl import dl_and_post_dl
+from beta.api.mr_manager.boss_manager import Boss
+from mainLogic.utils.glv import Global
+from mainLogic.utils.glv_var import debugger
+
+app = Flask(__name__)
+CORS(app)
+
+# Initialize ClientManager and TaskManager
+client_manager = Boss.client_manager
+task_manager = Boss.task_manager
+OUT_DIR = Boss.OUT_DIR
+
+try:
+    if not os.path.exists(OUT_DIR):
+        os.makedirs(OUT_DIR)
+except Exception as e:
+    debugger.error(f"Could not create output directory {OUT_DIR}")
+    debugger.success(f"Defaulting to './' ")
+    debugger.error(f"Error: {e}")
+    OUT_DIR = './'
+
+app.register_blueprint(api_prefs)
+app.register_blueprint(legacy_create_task)
+app.register_blueprint(template_blueprint)
+app.register_blueprint(session_lodge)
+app.register_blueprint(dl_and_post_dl)
+app.register_blueprint(client_info)
+app.register_blueprint(admin)
+app.register_blueprint(scraper_blueprint)
+app.register_blueprint(login)
+
+@app.before_request
+def before_request_function():
+    # Only run syncer if the request is for scraper blueprint routes
+    if request.endpoint and request.endpoint.startswith('scraper_blueprint'):
+        try:
+            from beta.Syncer.main import Syncer
+            sync = Syncer()
+        except Exception as e:
+            debugger.error(f"Error in Syncer: {e}")
+
+if __name__ == '__main__':
+    app.run(debug=True, port=7680)

beta/api/api_dl.py

@@ -0,0 +1,52 @@
+import os
+from mainLogic.utils.gen_utils import delete_old_files
+from mainLogic.main import Main
+from mainLogic.startup.checkup import CheckState
+from mainLogic.utils.glv import Global
+from mainLogic.utils import glv_var
+from mainLogic.utils.glv_var import debugger
+
+
+def download_pw_video(task_id, name, id, batch_name, topic_name, lecture_url, out_dir, client_id, session_id,
+                      progress_callback):
+    # Create directories for client_id and session_id if they don't exist
+    client_session_dir = os.path.join(out_dir, client_id, session_id)
+    os.makedirs(client_session_dir, exist_ok=True)
+
+    debugger.info(f"Downloading {name} with id {id} to {client_session_dir}")
+
+    ch = CheckState()
+
+    state = ch.checkup(glv_var.EXECUTABLES, directory="./", verbose=False, do_raise=True)
+    prefs = state['prefs']
+
+    # from mainLogic.utils.dependency_checker import check_dependencies
+
+    if 'webui-del-time' in prefs:
+        del_time = int(prefs['webui-del-time'])
+    else:
+        del_time = 45
+
+    delete_old_files(glv_var.api_webdl_directory, del_time)
+
+    # vsd = state['vsd']
+    ffmpeg = state['ffmpeg']
+
+    mp4d = state['mp4decrypt']
+
+    try:
+
+        Main(id=id,
+             name=f"{name}-{task_id}",
+             token=prefs['token'],
+             batch_name=batch_name,
+             topic_name=topic_name,
+             lecture_url=lecture_url,
+             random_id=prefs['random_id'],
+             tui=False,
+             directory=client_session_dir, tmpDir="/*auto*/", ffmpeg=ffmpeg, mp4d=mp4d, verbose=False,
+             progress_callback=progress_callback).process()
+    except TypeError as e:
+        raise Exception(f"Invalid ID: {e}")
+    except Exception as e:
+        raise Exception(f"An error occurred while processing the video: {e}")

beta/api/blueprints/admin_routes.py

@@ -0,0 +1,157 @@
+import os.path
+
+from flask import Blueprint, request, jsonify, send_file
+
+from beta.api.mr_manager.boss_manager import Boss
+from beta.update import UpdateJSONFile
+from mainLogic.error import TokenInvalid
+from mainLogic.startup.checkup import CheckState
+from mainLogic.utils import glv_var
+from mainLogic.utils.dependency_checker import re_check_dependencies
+from mainLogic.utils.glv import Global
+from mainLogic.utils.glv_var import PREFS_FILE, debugger
+from mainLogic.utils.os2 import SysFunc
+from updater import check_for_updates, pull_latest_changes as pull
+
+client_manager = Boss.client_manager
+task_manager = Boss.task_manager
+
+admin = Blueprint('admin', __name__)
+
+
+@admin.route('/api/webdl')
+@admin.route('/webdl')
+def webdl():
+    return jsonify(SysFunc.list_files_and_folders(Boss.OUT_DIR)), 200
+
+
+@admin.route('/api/webdl/webdl')
+@admin.route('/webdl/webdl')
+def webdl_copy():
+    return webdl()
+
+
+@admin.route('/api/webdl/<path:subpath>')
+@admin.route('/webdl/<path:subpath>')
+def webdl_subpath(subpath):
+    return jsonify(SysFunc.list_files_and_folders(os.path.join(Boss.OUT_DIR, subpath))), 200
+
+
+@admin.route('/api/delete/<path:subpath>')
+@admin.route('/delete/<path:subpath>')
+def delete_subpath(subpath):
+    path_file_or_folder = os.path.join(Boss.OUT_DIR, subpath)
+
+    if os.path.exists(path_file_or_folder):
+        try:
+            SysFunc.delete_file_or_folder(path_file_or_folder)
+            return jsonify({'success': f'{subpath} deleted'}), 200
+        except Exception as e:
+            return jsonify({'error': f"Could not delete {e}"}), 404
+    else:
+        return jsonify({'error': 'file not found'}), 404
+
+
+@admin.route('/api/get/<path:subpath>')
+@admin.route('/get/<path:subpath>')
+def get_subpath(subpath):
+    path_to_file = os.path.join(Boss.OUT_DIR, subpath)
+    if os.path.exists(path_to_file):
+        return send_file(path_to_file, as_attachment=True, download_name=os.path.basename(path_to_file))
+    else:
+        return jsonify({'error': 'file not found'}), 404
+
+
+@admin.route('/api/server/usages')
+@admin.route('/server/usages')
+def get_usages_for_all_client():
+    usages = {}
+    # will store usage in form of {client_id: size}
+
+    for client_id in client_manager.clients:
+        usages[client_id] = int(SysFunc.get_size_in_mB(os.path.join(Boss.OUT_DIR, client_id)))
+
+    return jsonify(usages), 200
+
+
+@admin.route('/api/server/update', methods=['GET', 'POST'])
+@admin.route('/server/update', methods=['GET', 'POST'])
+def update_server():
+    try:
+        if request.method == 'POST':
+            if check_for_updates():
+                code, out = pull()
+                if code == 0:
+                    return jsonify({'success': 'Updated!'}), 200
+                else:
+                    return jsonify({'error': 'Error occurred while pulling the latest changes. Exiting...'}), 500
+            else:
+                return jsonify({'message': 'No updates found.'}), 200
+        else:
+            update = check_for_updates()
+            return jsonify({'update_available': update}), 200
+    except FileNotFoundError as fnf_error:
+        error_message = f"File not found error: {str(fnf_error)}"
+        return jsonify({'error': error_message}), 500
+    except Exception as e:
+        error_message = f"Unexpected error: {str(e)}"
+        return jsonify({'error': error_message}), 500
+
+
+@admin.route('/api/server/update/latest')
+@admin.route('/server/update/latest')
+def get_latest_origin_hash():
+    from updater import get_latest_origin_hash, get_info_by_commit_hash
+    return jsonify(get_info_by_commit_hash(get_latest_origin_hash())), 200
+
+
+@admin.route('/api/check_token')
+@admin.route('/check_token')
+def check_token():
+    ch = CheckState()
+    # reload preferences
+    # from mainLogic.utils.dependency_checker import EXECUTABLES, check_dependencies
+
+    try:
+
+        #  imporoper method to reload preferences
+        # state, prefs = check_dependencies(glv_var.vars['prefs'].get('dir',{}), verbose=False, do_raise=True)
+        # glv_var.vars['prefs'] = prefs
+
+        # original method (still improper)
+        state, prefs = re_check_dependencies()
+
+        print(glv_var.vars['prefs'].get('token',{}))
+
+    except Exception as e:
+        return jsonify({'error': f"Error: {e}"}), 500
+
+    if 'token' in prefs:
+        token = prefs['token']
+    else:
+        return jsonify({'error': 'Token not found'}), 404
+
+    if 'random_id' in prefs:
+        random_id = prefs['random_id']
+    else:
+        return jsonify({'error': 'Random ID not found'}), 404
+    try:
+        if ch.check_token(token, random_id):
+            return jsonify({'success': 'Token is valid'}), 200
+    except TokenInvalid:
+        return jsonify({'error': 'Token is invalid'}), 404
+
+
+@admin.route('/api/change_to_old_token_scheme')
+@admin.route('/change_to_old_token_scheme')
+def change_to_old_token_scheme():
+    UpdateJSONFile(PREFS_FILE).update('token', "")
+    try:
+        re_check_dependencies()
+
+        debugger.success(f"Changed token scheme to old")
+        debugger.error(f"Current token: {glv_var.vars['prefs']['token']}")
+
+    except Exception as e:
+        return jsonify({'error': f"Error: {e}"}), 500
+    return jsonify({'success': 'Token scheme changed to old'}), 200

beta/api/blueprints/api_pref_manager.py

@@ -0,0 +1,46 @@
+import os
+
+from flask import Blueprint, request, jsonify
+
+from mainLogic.utils import glv_var
+from mainLogic.utils.glv import Global
+from mainLogic.utils.glv_var import PREFS_FILE
+
+api_prefs = Blueprint('api_prefs', __name__)
+
+@api_prefs.route('/api/prefs/defaults.json', methods=['GET'])
+@api_prefs.route('/prefs/defaults.json', methods=['GET'])
+def get_prefs():
+    import json as js
+    file_path = PREFS_FILE
+    if not os.path.exists(file_path):
+        return jsonify({'error': 'file not found'}), 404
+    with open(file_path, 'r') as file:
+        data = js.load(file)
+    return jsonify(data), 200
+
+
+@api_prefs.route('/api/update/defaults.json', methods=['POST'])
+@api_prefs.route('/update/defaults.json', methods=['POST'])
+def update_prefs():
+    import json as js
+    file_path = PREFS_FILE
+    if not os.path.exists(file_path):
+        return jsonify({'error': 'file not found'}), 404
+    try:
+        data = request.json
+    except:
+        return jsonify({'error': 'Invalid JSON'}), 400
+    with open(file_path, 'r') as file:
+        data = js.load(file)
+    data.update(request.json)
+    with open(file_path, 'w') as file:
+        js.dump(data, file, indent=4)
+
+    ## recheck dependencies
+    from mainLogic.utils.dependency_checker import re_check_dependencies
+    re_check_dependencies()
+
+
+    return jsonify(data), 200
+

beta/api/blueprints/client_info_routes.py

@@ -0,0 +1,149 @@
+import json
+
+from flask import Blueprint, request, jsonify
+from beta.api.mr_manager.boss_manager import Boss
+from mainLogic.big4.Ravenclaw_decrypt.key import LicenseKeyFetcher
+
+client_manager = Boss.client_manager
+task_manager = Boss.task_manager
+OUT_DIR = Boss.OUT_DIR
+
+client_info = Blueprint('client_info', __name__)
+
+
+@client_info.route('/api/session/<client_id>/<session_id>', methods=['GET'])
+@client_info.route('/session/<client_id>/<session_id>', methods=['GET'])
+def get_session(client_id, session_id):
+    # if client_id == 'anonymous' or session_id == 'anonymous':
+    #     return jsonify({'error': 'Access to anonymous sessions is not allowed'}), 403
+
+    client_info = client_manager.get_client_info(client_id)
+    if client_info and session_id in client_info['sessions']:
+        session_info = client_info['sessions'][session_id]
+        return jsonify(session_info), 200
+    else:
+        return jsonify({'error': 'Session not found'}), 404
+
+
+@client_info.route('/api/client/<client_id>', methods=['GET'])
+@client_info.route('/client/<client_id>', methods=['GET'])
+def get_client(client_id):
+    client_info = client_manager.get_client_info(client_id)
+    if client_info:
+        # sorting sessions by timestamp
+        from datetime import datetime
+
+        # Assuming client_info['sessions'] is a dictionary
+        client_info['sessions'] = dict(sorted(client_info['sessions'].items(),
+                                              key=lambda x: datetime.strptime(x[1]['timestamp'], '%Y-%m-%d %H:%M:%S'),
+                                              reverse=True))
+        print(json.dumps([client_info["sessions"][x]["timestamp"] for x in client_info["sessions"]], indent=4))
+
+        return jsonify(client_info), 200
+    else:
+        return jsonify({'error': 'Client not found'}), 404
+
+
+@client_info.route('/api/session/<client_id>/<session_id>/active', methods=['GET'])
+@client_info.route('/session/<client_id>/<session_id>/active', methods=['GET'])
+def check_session_active(client_id, session_id):
+    if client_id == 'anonymous' or session_id == 'anonymous':
+        return jsonify({'error': 'Access to anonymous sessions is not allowed'}), 403
+
+    client_info = client_manager.get_client_info(client_id)
+    if client_info and session_id in client_info['sessions']:
+        session_info = client_info['sessions'][session_id]
+        tasks = session_info['tasks']
+        for task_id in tasks:
+            status = tasks[task_id]['status']
+            if status == 'running':
+                return jsonify({'active': True}), 200
+        return jsonify({'active': False}), 200
+    else:
+        return jsonify({'error': 'Session not found'}), 404
+
+
+def is_session_active(client_id, session_id):
+    if client_id == 'anonymous' or session_id == 'anonymous':
+        return {'error': 'Access to anonymous sessions is not allowed'}, 403
+
+    client_info = client_manager.get_client_info(client_id)
+    if client_info and session_id in client_info['sessions']:
+        session_info = client_info['sessions'][session_id]
+        tasks = session_info['tasks']
+        for task_id, task in tasks.items():
+            if task['status'] == 'running':
+                return {'active': True}, 200
+        return {'active': False}, 200
+    else:
+        return {'error': 'Session not found'}, 404
+
+
+@client_info.route('/api/client/<client_id>/active_sessions', methods=['GET'])
+@client_info.route('/client/<client_id>/active_sessions', methods=['GET'])
+def get_active_sessions(client_id):
+    if client_id == 'anonymous':
+        return jsonify({'error': 'Access to anonymous client is not allowed'}), 403
+
+    client_info = client_manager.get_client_info(client_id)
+
+    if client_info:
+        active_sessions = []
+        for session_id in client_info['sessions']:
+            session_data = is_session_active(client_id, session_id)
+            if session_data[1] != 200:
+                return jsonify(session_data[0]), session_data[1]
+            active = session_data[0].get('active', False)
+
+            if active:
+                active_sessions.append(session_id)
+        return jsonify({"active_sessions": active_sessions}), 200
+    return jsonify({'error': 'Client not found'}), 404
+
+
+@client_info.route('/api/key/vid_id', methods=['GET'])
+@client_info.route('/key/vid_id', methods=['GET'])
+def get_key():
+    vid_id = request.args.get('vid_id')
+    token = request.args.get('token')
+    if not vid_id or not token:
+        return jsonify({'error': 'vid_id and token are required'}), 400
+    fetcher = LicenseKeyFetcher(token)
+    key = fetcher.get_key(vid_id)
+    return jsonify({'key': key}), 200
+
+
+@client_info.route('/api/random/name')
+@client_info.route('/random/name')
+def random_name():
+    from mainLogic.utils.gen_utils import generate_random_word
+    return jsonify({'name': generate_random_word()}), 200
+
+
+@client_info.route('/api/client/names')
+@client_info.route('/client/names')
+def client_names():
+    clients = client_manager.clients
+    data = {}
+    for client_id in clients:
+        data[client_id] = clients[client_id]['name']
+
+    return jsonify(data), 200
+
+
+@client_info.route('/api/client/<client_id>/names')
+@client_info.route('/client/<client_id>/names')
+def session_names(client_id):
+    if client_id == 'anonymous':
+        return jsonify({'error': 'Access to anonymous client is not allowed'}), 403
+
+    client = client_manager.get_client_info(client_id)
+    if not client:
+        return jsonify({'error': 'Client not found'}), 404
+
+    names = {}
+
+    for session in client['sessions']:
+        names[session] = client['sessions'][session]['name']
+
+    return jsonify(names), 200

beta/api/blueprints/leagacy_create_task.py

@@ -0,0 +1,40 @@
+from flask import Blueprint, request, jsonify
+from beta.api.api_dl import download_pw_video
+from beta.api.mr_manager.boss_manager import Boss
+from mainLogic.utils.gen_utils import generate_safe_folder_name
+
+legacy_create_task = Blueprint('legacy_create_task', __name__)
+
+client_manager = Boss.client_manager
+task_manager = Boss.task_manager
+OUT_DIR = Boss.OUT_DIR
+
+@legacy_create_task.route('/api/create_task', methods=['POST'])
+@legacy_create_task.route('/create_task', methods=['POST'])
+def create_task():
+    data = request.json
+    client_id = data.get('client_id', 'anonymous')
+    session_id = data.get('session_id', 'anonymous')
+    id = data.get('id')
+    name = data.get('name')
+
+    # Generate safe names
+    name = generate_safe_folder_name(name)
+
+    if not id or not name:
+        return jsonify({'error': 'id and name are required'}), 400
+
+    args = {
+        'name': name,
+        'id': id,
+        'out_dir': OUT_DIR,
+        'client_id': client_id,
+        'session_id': session_id
+    }
+
+    client_manager.add_client(client_id)
+    client_manager.add_session(client_id, session_id)
+
+    task_id = task_manager.create_task(client_id, session_id, download_pw_video, args)
+    return jsonify({'task_id': task_id}), 202
+

beta/api/blueprints/login.py

@@ -0,0 +1,51 @@
+from mainLogic.startup.Login.call_login import LoginInterface
+from mainLogic.utils.glv_var import PREFS_FILE, debugger
+from mainLogic.startup.Login.sudat import Login
+from beta.update import UpdateJSONFile
+from flask import jsonify, request, Blueprint
+
+login = Blueprint('login', __name__)
+
+
+@login.route('/api/otp', methods=['POST'])
+@login.route('/otp', methods=['POST'])
+def send_otp():
+    data = request.json
+    if 'phone' not in data:
+        return jsonify({'error': 'Phone number is required'}), 400
+
+    phone = data['phone']
+    if LoginInterface.check_valid_10_dig_number(phone) is False:
+        return jsonify({'error': 'Invalid phone number'}), 400
+
+    lg = Login(phone)
+    if lg.gen_otp() is False:
+        return jsonify({'error': 'Failed to send OTP'}), 500
+    else:
+        return jsonify({'success': 'OTP sent successfully'}), 200
+
+@login.route('/api/verify-otp', methods=['POST'])
+@login.route('/verify-otp', methods=['POST'])
+def verify_otp():
+    data = request.json
+    if 'phone' not in data or 'otp' not in data:
+        return jsonify({'error': 'Phone number and OTP are required'}), 400
+
+    phone = data['phone']
+    otp = data['otp']
+    if LoginInterface.check_valid_10_dig_number(phone) is False:
+        return jsonify({'error': 'Invalid phone number'}), 400
+
+    lg = Login(phone)
+    if lg.login(otp) is False:
+        return jsonify({'error': 'Invalid OTP'}), 400
+    else:
+        u = UpdateJSONFile(PREFS_FILE)
+        u.update('token',lg.token)
+        try:
+            u.update("user_update_index",u.data.get("user_update_index",0)+1)
+        except Exception as e:
+            debugger.error(f" Error updating user_update_index: {e}")
+        return jsonify({'success': 'OTP verified successfully','token':lg.token}), 200
+
+

beta/api/blueprints/scarper.py

@@ -0,0 +1,349 @@
+import json
+import urllib.parse
+
+import urllib3
+from flask import Blueprint, jsonify, request
+from beta.batch_scraper_2.Endpoints import Endpoints
+from mainLogic.utils.dependency_checker import re_check_dependencies
+from mainLogic.utils.glv import Global
+from mainLogic.utils.glv_var import debugger
+from mainLogic.utils import glv_var
+# Initialize the blueprint
+scraper_blueprint = Blueprint('scraper', __name__)
+
+# Initialize BatchAPI with a default token. The token can be updated later via the '/api/set-token' route.
+
+try:
+    from beta.Syncer.main import Syncer
+    sync = Syncer()
+except Exception as e:
+    debugger.error(f"Error in Syncer: {e}")
+    pass
+
+
+
+try:
+
+    batch_api = Endpoints().set_token(vars['prefs'].get('token',{}).get("token",""))
+except Exception as e:
+    # get token via check_Dependencies
+
+    re_check_dependencies()
+    token = glv_var.vars["prefs"].get("token_config",{})
+    #debugger.debug(f"Token config: {token}")
+    try:
+        access_token = token["access_token"]
+    except Exception as e:
+        debugger.error(f"Error getting access token: {e}")
+        try:
+            access_token = token["token"]
+        except Exception as e:
+            debugger.error(f"Error getting access token: {e}")
+    
+    random_id = token.get("random_id",None)
+    try:
+        if random_id is None:
+            batch_api = Endpoints().set_token(access_token)
+        else:
+            batch_api = Endpoints().set_token(access_token,random_id=random_id)
+    except Exception as e:
+        debugger.error(f"Error setting access_token @ scraper.py")
+
+def create_response(data=None, error=None):
+    response = {"data": data}
+    if error is not None:
+        response["error"] = error
+    return jsonify(response)
+
+
+def renamer(data,old_key,new_key):
+    new_data = []
+    for element in data:
+        try:
+            element[new_key] = element.pop(old_key)
+        except Exception as e:
+            debugger.error(f"Error renaming f{old_key} to {new_key}: {e}")
+        new_data.append(element)
+
+    return new_data
+# from werkzeug.urls import url_quote, url_unquote
+
+@scraper_blueprint.route('/api/khazana/lecture/<program_name>/<topic_name>/<lecture_id>/<path:lecture_url>', methods=['GET'])
+def get_khazana_lecture(program_name, topic_name, lecture_id, lecture_url):
+    try:
+        debugger.success(f"batch_name: {program_name}")
+        debugger.success(f"batch_api.token: {batch_api.token}")
+        debugger.success(f"batch_api.random_id: {batch_api.random_id}")
+
+        # decode lecture_url
+        lecture_url = urllib.parse.unquote(lecture_url)
+        # print the vars
+        debugger.success(f"lecture_url: {lecture_url}")
+        debugger.success(f"lecture_id: {lecture_id}")
+        debugger.success(f"topic_name: {topic_name}")
+        debugger.success(f"program_name: {program_name}")
+
+        
+        khazana = batch_api.process("lecture", khazana=True, program_name=program_name, 
+                                  topic_name=topic_name, lecture_id=lecture_id, 
+                                  lecture_url=lecture_url)
+        return create_response(data=khazana)
+    except Exception as e:
+        debugger.error(f"Error: {e}")
+        return create_response(error=str(e)), 500
+
+@scraper_blueprint.route('/api/khazana/<program_name>', methods=['GET'])
+def get_khazana_batch(program_name):
+    try:
+        debugger.success(f"batch_name: {program_name}")
+        debugger.success(f"batch_api.token: {batch_api.token}")
+        debugger.success(f"batch_api.random_id: {batch_api.random_id}")
+
+        # batch_api.batch_name = batch_name
+        # khazana = batch_api.GET_KHAZANA_BATCH(batch_name)
+        khazana = batch_api.process("details", khazana=True, program_name=program_name)
+        return create_response(data=khazana)
+    except Exception as e:
+        debugger.error(f"Error: {e}")
+        return create_response(error=str(e)), 500
+
+@scraper_blueprint.route('/api/khazana/<program_name>/<subject_name>', methods=['GET'])
+def get_khazana_subject(program_name, subject_name):
+    try:
+        debugger.success(f"batch_name: {program_name}")
+        debugger.success(f"batch_api.token: {batch_api.token}")
+        debugger.success(f"batch_api.random_id: {batch_api.random_id}")
+
+        # batch_api.batch_name = batch_name
+        # khazana = batch_api.GET_KHAZANA_BATCH(batch_name)
+        khazana = batch_api.process("subject", khazana=True, program_name=program_name, subject_name=subject_name)
+        return create_response(data=khazana)
+    except Exception as e:
+        debugger.error(f"Error: {e}")
+        return create_response(error=str(e)), 500
+
+@scraper_blueprint.route('/api/khazana/<program_name>/<subject_name>/<teacher_name>', methods=['GET'])
+def get_khazana_topics(program_name, subject_name, teacher_name):
+    try:
+        debugger.success(f"batch_name: {program_name}")
+        debugger.success(f"batch_api.token: {batch_api.token}")
+        debugger.success(f"batch_api.random_id: {batch_api.random_id}")
+
+        # batch_api.batch_name = batch_name
+        # khazana = batch_api.GET_KHAZANA_BATCH(batch_name)
+        khazana = batch_api.process("topics", khazana=True, program_name=program_name, subject_name=subject_name, teacher_name=teacher_name)
+        return create_response(data=khazana)
+    except Exception as e:
+        debugger.error(f"Error: {e}")
+        return create_response(error=str(e)), 500
+
+@scraper_blueprint.route('/api/khazana/<program_name>/<subject_name>/<teacher_name>/<topic_name>', methods=['GET'])
+def get_khazana_sub_topics(program_name, subject_name, teacher_name, topic_name):
+    try:
+        debugger.success(f"batch_name: {program_name}")
+        debugger.success(f"batch_api.token: {batch_api.token}")
+        debugger.success(f"batch_api.random_id: {batch_api.random_id}")
+
+        # batch_api.batch_name = batch_name
+        # khazana = batch_api.GET_KHAZANA_BATCH(batch_name)
+        khazana = batch_api.process("sub_topic", khazana=True, program_name=program_name, subject_name=subject_name, teacher_name=teacher_name, topic_name=topic_name)
+        return create_response(data=khazana)
+    except Exception as e:
+        debugger.error(f"Error: {e}")
+        return create_response(error=str(e)), 500
+        
+@scraper_blueprint.route('/api/lecture/<batch_name>/<id>', methods=['GET'])
+def get_lecture_info(batch_name,id):
+
+    try:
+        args = request.args
+        debugger.success(f"batch_name: {batch_name}")
+        url = args.get("url","")
+        topic_name = args.get("topic_name","")
+        debugger.success(f"batch_api.token: {batch_api.token}")
+        debugger.success(f"batch_api.random_id: {batch_api.random_id}")
+
+        # batch_api.batch_name = batch_name
+        # subjects = batch_api.GET_BATCH(batch_name)
+        #notes = batch_api.process("notes",batch_name=batch_name,subject_name=subject_name,chapter_name=chapter_name)
+        from mainLogic.big4.Ravenclaw_decrypt.key import LicenseKeyFetcher as Lf
+        lf = Lf(batch_api.token, batch_api.random_id)
+        keys = lf.get_key(id,batch_name)
+
+        return create_response(data={
+            "url":keys[2],
+            "key":keys[1],
+            "kid":keys[0]
+            })
+        
+    except Exception as e:
+
+        debugger.error(f"Error: {e}")
+        return create_response(error=str(e)), 500
+    
+ 
+@scraper_blueprint.route('/api/khazana/<program_name>/<subject_name>/<teacher_name>/<topic_name>/<sub_topic_name>', methods=['GET'])
+def get_khazana_chapter(program_name, subject_name, teacher_name, topic_name, sub_topic_name):
+    try:
+        debugger.success(f"batch_name: {program_name}")
+        debugger.success(f"batch_api.token: {batch_api.token}")
+        debugger.success(f"batch_api.random_id: {batch_api.random_id}")
+
+        # batch_api.batch_name = batch_name
+        # khazana = batch_api.GET_KHAZANA_BATCH(batch_name)
+        khazana = batch_api.process("chapter", khazana=True, program_name=program_name, subject_name=subject_name, teacher_name=teacher_name, topic_name=topic_name, sub_topic_name=sub_topic_name)
+        return create_response(data=khazana)
+    except Exception as e:
+        debugger.error(f"Error: {e}")
+        return create_response(error=str(e)), 500
+
+@scraper_blueprint.route('/api/batches/<batch_name>', methods=['GET'])
+def get_batch(batch_name):
+    try:
+        debugger.success(f"batch_name: {batch_name}")
+        debugger.success(f"batch_api.token: {batch_api.token}")
+        debugger.success(f"batch_api.random_id: {batch_api.random_id}")
+
+        # batch_api.batch_name = batch_name
+        # subjects = batch_api.GET_BATCH(batch_name)
+        details = batch_api.process("details",batch_name=batch_name)
+        return create_response(data=renamer(details,'subject','name'))
+    except Exception as e:
+        debugger.error(f"Error: {e}")
+        return create_response(error=str(e)), 500
+
+@scraper_blueprint.route('/api/batches/<batch_name>/<subject_name>', methods=['GET'])
+def get_subject(batch_name, subject_name):
+    try:
+        debugger.success(f"batch_name: {batch_name}")
+        debugger.success(f"batch_api.token: {batch_api.token}")
+        debugger.success(f"batch_api.random_id: {batch_api.random_id}")
+
+        # batch_api.batch_name = batch_name
+        # subjects = batch_api.GET_BATCH(batch_name)
+        subject = batch_api.process("subject",batch_name=batch_name,subject_name=subject_name)
+        return create_response(data=renamer(subject,'topic','name'))
+    except Exception as e:
+        debugger.error(f"Error: {e}")
+        return create_response(error=str(e)), 500
+
+@scraper_blueprint.route('/api/batches/<batch_name>/<subject_name>/<chapter_name>/lectures', methods=['GET'])
+@scraper_blueprint.route('/api/batches/<batch_name>/<subject_name>/<chapter_name>', methods=['GET'])
+def get_chapter(batch_name, subject_name, chapter_name):
+    try:
+        debugger.success(f"batch_name: {batch_name}")
+        debugger.success(f"batch_api.token: {batch_api.token}")
+        debugger.success(f"batch_api.random_id: {batch_api.random_id}")
+
+        # batch_api.batch_name = batch_name
+        # subjects = batch_api.GET_BATCH(batch_name)
+        chapter = batch_api.process("chapter",batch_name=batch_name,subject_name=subject_name,chapter_name=chapter_name)
+        return create_response(data=renamer(chapter,'topic','name'))
+    except Exception as e:
+        debugger.error(f"Error: {e}")
+        return create_response(error=str(e)), 500
+
+@scraper_blueprint.route('/api/batches/<batch_name>/<subject_name>/<chapter_name>/notes', methods=['GET'])
+def get_notes(batch_name, subject_name, chapter_name):
+    try:
+        debugger.success(f"batch_name: {batch_name}")
+        debugger.success(f"batch_api.token: {batch_api.token}")
+        debugger.success(f"batch_api.random_id: {batch_api.random_id}")
+
+        # batch_api.batch_name = batch_name
+        # subjects = batch_api.GET_BATCH(batch_name)
+        notes = batch_api.process("notes",batch_name=batch_name,subject_name=subject_name,chapter_name=chapter_name)
+        return create_response(data=renamer(notes,'topic','name'))
+    except Exception as e:
+
+        debugger.error(f"Error: {e}")
+        return create_response(error=str(e)), 500
+    
+@scraper_blueprint.route('/api/batches/<batch_name>/<subject_name>/<chapter_name>/dpp_pdf', methods=['GET'])
+def get_dpp_pdf(batch_name, subject_name, chapter_name):
+    try:
+        debugger.success(f"batch_name: {batch_name}")
+        debugger.success(f"batch_api.token: {batch_api.token}")
+        debugger.success(f"batch_api.random_id: {batch_api.random_id}")
+
+        # batch_api.batch_name = batch_name
+        # subjects = batch_api.GET_BATCH(batch_name)
+        dpp_pdf = batch_api.process("dpp_pdf",batch_name=batch_name,subject_name=subject_name,chapter_name=chapter_name)
+        return create_response(data=renamer(dpp_pdf,'topic','name'))
+    except Exception as e:
+        debugger.error(f"Error: {e}")
+        return create_response(error=str(e)), 500
+
+
+@scraper_blueprint.route('/normal/subjects', methods=['GET'])
+@scraper_blueprint.route('/api/normal/subjects', methods=['GET'])
+def get_normal_subjects():
+    try:
+        batch_name = request.args.get('batch_name')
+        # batch_api.batch_name = batch_name
+        # subjects = batch_api.GET_NORMAL_SUBJECTS()
+        details = batch_api.process("details",batch_name=batch_name)
+        return create_response(data=renamer(details,'subject','name'))
+    except Exception as e:
+        debugger.error(f"Error: {e}")
+        return create_response(error=str(e)), 500
+
+@scraper_blueprint.route('/normal/chapters/<subject_slug>', methods=['GET'])
+@scraper_blueprint.route('/api/normal/chapters/<subject_slug>', methods=['GET'])
+def get_normal_chapters(subject_slug):
+    try:
+        batch_name = request.args.get('batch_name')
+        # batch_api.batch_name = batch_name
+
+        Global.hr()
+        debugger.success(f"batch_name: {batch_name}")
+        debugger.success(f"subject_slug: {subject_slug}")
+        Global.hr()
+
+
+        chapters = batch_api.process("subject",batch_name=batch_name,subject_name=subject_slug)
+
+        debugger.success(f"chapters: {chapters}")
+
+        return create_response(data=chapters)
+    except Exception as e:
+
+        debugger.error(e)
+        return create_response(error=str(e)), 500
+
+@scraper_blueprint.route('/normal/lectures', methods=['GET'])
+@scraper_blueprint.route('/api/normal/lectures', methods=['GET'])
+@scraper_blueprint.route('/api/normal/videos', methods=['GET'])
+def get_normal_videos():
+    try:
+        batch_name = request.args.get('batch_name',)
+        subject_slug = request.args.get('subject_slug')
+        chapter_slug = request.args.get('chapter_slug')
+
+        if not all([subject_slug, chapter_slug]):
+            return create_response(error="Missing required parameters"), 400
+
+        videos = batch_api.process("chapter",batch_name=batch_name,subject_name=subject_slug,chapter_name=chapter_slug)
+        return create_response(data=renamer(videos,'topic','name'))
+    except Exception as e:
+        return create_response(error=str(e)), 500
+
+
+@scraper_blueprint.route(f'/api/batches')
+def get_batches():
+    try:
+        batches = batch_api.get_batches_force_hard()
+        return create_response(data=batches)
+    except Exception as e:
+        return create_response(error=str(e)), 500
+
+@scraper_blueprint.route('/api/set-token', methods=['POST'])
+def set_token():
+    try:
+        token = request.json.get('token')
+        if not token:
+            return create_response(error="Token is required"), 400
+        batch_api.token = token
+        return create_response(data={"message": "Token updated successfully"})
+    except Exception as e:
+        return create_response(error=str(e)), 500

beta/api/blueprints/session_lodge.py

@@ -0,0 +1,137 @@
+import os
+
+from flask import Blueprint, request, jsonify
+from beta.api.api_dl import download_pw_video
+from mainLogic.utils.gen_utils import generate_random_word
+from beta.api.mr_manager.boss_manager import Boss
+from mainLogic.utils.gen_utils import generate_safe_folder_name
+
+
+session_lodge = Blueprint('session_lodge', __name__)
+
+client_manager = Boss.client_manager
+task_manager = Boss.task_manager
+OUT_DIR = Boss.OUT_DIR
+
+
+@session_lodge.route('/api/client/<client_id>/<session_id>/create_session', methods=['POST'])
+@session_lodge.route('/client/<client_id>/<session_id>/create_session', methods=['POST'])
+def create_session(client_id, session_id):
+    clients = client_manager.get_client_info(client_id)
+    data = request.json
+    from mainLogic.utils.gen_utils import generate_random_word
+
+    if not clients:
+        if 'client_name' in data:   name = data['client_name']
+        else:                       name = f"{generate_random_word()}"
+        print(f"Creating client with ID {client_id} and name {name}")
+        client_manager.add_client(client_id,name)
+
+    if 'client_name' in data:
+        client_manager.set_client_name(client_id, data['client_name'])
+
+    session = client_manager.get_client_info(client_id).get('sessions', {}).get(session_id)
+    if not session:
+        client_manager.add_session(client_id, session_id)
+        sess_name = generate_random_word()
+        print(f"Generated session name: {sess_name}")
+        client_manager.set_session_name(client_id, session_id, sess_name)
+
+
+    data = request.json
+    ids = data.get('ids', [])
+    names = data.get('names', [])
+    batch_names = data.get('batch_names', [])
+    topic_names = data.get('topic_names', [])
+    lecture_urls = data.get('lecture_urls', [])
+
+
+    if not ids or not names:
+        return jsonify({'error': 'ids and names are required'}), 400
+
+    if len(ids) != len(names):
+        return jsonify({'error': 'ids and names must be of equal length'}), 400
+
+    if len(ids) != len(batch_names):
+        return jsonify({'error': 'ids and batch_names must be of equal length'}), 400
+
+    names_safe = [generate_safe_folder_name(name) for name in names]
+    names = names_safe
+
+    task_ids = []
+
+    for i in range(len(ids)):
+        id = ids[i]
+        name = names[i]
+        batch_name = batch_names[i]
+        print(f"Creating task for {name} with id {id}")
+        args = {
+            'name': name,
+            'id': id,
+            'batch_name': batch_name,
+            'topic_name': topic_names[i] if i < len(topic_names) else None,
+            'lecture_url': lecture_urls[i] if i < len(lecture_urls) else None,
+            'out_dir': OUT_DIR,
+            'client_id': client_id,
+            'session_id': session_id
+        }
+        task_id = task_manager.create_task(client_id, session_id, download_pw_video, args, inactive=True)
+        task_ids.append(task_id)
+
+    return jsonify({'task_ids': task_ids}), 202
+
+
+@session_lodge.route('/api/start/<task_id>',methods=['GET','POST'])
+@session_lodge.route('/start/<task_id>',methods=['GET','POST'])
+def start_task(task_id):
+    try:
+        task_manager.start_task(task_id)
+        return jsonify({'success': True}), 200
+    except Exception as e:
+        print(e)
+        return jsonify({'error': str(e)}), 500
+
+@session_lodge.route('/api/client/<client_id>/delete_client')
+@session_lodge.route('/client/<client_id>/delete_client')
+def delete_client_route(client_id):
+    client_manager.remove_client(client_id)
+    try:
+        import shutil
+        shutil.rmtree(f"{OUT_DIR}/{client_id}")
+    except Exception as e:
+        print(f"Could not delete client folder: {e}")
+    return jsonify({'message': f'Client with ID {client_id} deleted successfully'}), 200
+
+@session_lodge.route('/api/client/<client_id>/<session_id>/delete_session')
+@session_lodge.route('/client/<client_id>/<session_id>/delete_session')
+def delete_session_route(client_id, session_id):
+    client_manager.remove_session(client_id, session_id)
+    try:
+        import shutil
+        shutil.rmtree(f"{OUT_DIR}/{client_id}/{session_id}")
+    except Exception as e:
+        print(f"Could not delete session folder: {e}")
+    return jsonify({'message': f'Session with ID {session_id} for client {client_id} deleted successfully'}), 200
+
+@session_lodge.route('/api/client/<client_id>/merge_sessions',methods=['POST'])
+@session_lodge.route('/client/<client_id>/merge_sessions', methods=['POST'])
+def merge_sessions(client_id):
+    data = request.json
+    session_ids = data.get('session_ids', [])
+    if len(session_ids) > 2:
+        return jsonify({'error': 'Only two sessions can be merged at a time'}), 400
+    if not session_ids:
+        return jsonify({'error': 'session_ids is required'}), 400
+    try:
+        client_manager.merge_sessions(client_id, session_ids[0],session_ids[1])
+
+        # also move /webdl/<client>/session_id_2/* to /webdl/<client>/session_id_1
+        import shutil
+        for file in os.listdir(f"{OUT_DIR}/{client_id}/{session_ids[1]}"):
+            shutil.move(f"{OUT_DIR}/{client_id}/{session_ids[1]}/{file}", f"{OUT_DIR}/{client_id}/{session_ids[0]}/{file}")
+        shutil.rmtree(f"{OUT_DIR}/{client_id}/{session_ids[1]}")
+
+
+        return jsonify({'message': f'Sessions {session_ids} for client {client_id} merged successfully'}), 200
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500

beta/api/blueprints/template_routes.py

@@ -0,0 +1,45 @@
+from flask import Blueprint, request, jsonify, render_template
+
+from mainLogic.utils.glv import Global
+
+template_blueprint = Blueprint('template_blueprint', __name__)
+
+@template_blueprint.route('/')
+def index():
+    return render_template('index.html')
+
+@template_blueprint.route('/util')
+def util():
+    return render_template('index.html')
+
+@template_blueprint.route('/prefs')
+def prefs():
+    return render_template('index.html')
+
+@template_blueprint.route('/help')
+def help():
+    return render_template('index.html')
+
+@template_blueprint.route('/sessions')
+def sessions():
+    return render_template('index.html')
+
+@template_blueprint.route('/admin')
+def admin():
+    return render_template('index.html')
+
+@template_blueprint.route('/boss')
+def boss():
+    return render_template('index.html')
+
+@template_blueprint.route('/login')
+def login():
+    return render_template('index.html')
+
+@template_blueprint.route('/profile')
+def profile():
+    return render_template('index.html')
+
+# @template_blueprint.route('/manifest.json')
+# def manifest():
+#     return render_template('manifest.json')

beta/api/blueprints/while_dl_and_post_dl.py

@@ -0,0 +1,42 @@
+import os
+
+from flask import Blueprint, jsonify, send_file, render_template
+from beta.api.mr_manager.boss_manager import Boss
+from mainLogic.error import debugger
+
+client_manager = Boss.client_manager
+task_manager = Boss.task_manager
+OUT_DIR = Boss.OUT_DIR
+
+dl_and_post_dl = Blueprint('dl_and_post_dl', __name__)
+
+
+
+@dl_and_post_dl.route('/api/progress/<task_id>', methods=['GET'])
+@dl_and_post_dl.route('/progress/<task_id>', methods=['GET'])
+def get_progress(task_id):
+    progress = task_manager.get_progress(task_id)
+    return jsonify(progress), 200
+
+
+@dl_and_post_dl.route('/api/get-file/<task_id>/<name>', methods=['GET'])
+@dl_and_post_dl.route('/get-file/<task_id>/<name>', methods=['GET'])
+def get_file(task_id, name):
+    task_info = client_manager.get_progress(task_id)
+
+    if not task_info or task_info['status'] == 'not found':
+        debugger.error(f"File not found:")
+        return render_template("error.html",task_id=task_id,reason="not_found"), 404
+
+    client_session_dir = os.path.join(OUT_DIR, task_info['client_id'], task_info['session_id'])
+
+    file_path = os.path.join(client_session_dir, f"{name}-{task_id}.mp4")
+
+    def dict_to_tuple(d):
+        return tuple(d.values())
+
+    if not os.path.exists(file_path):
+        debugger.error(f"File not found: {file_path}")
+        return render_template("error.html",task_id=task_id,video_details=client_manager.get_task(task_id),reason='deleted'), 404
+
+    return send_file(file_path, as_attachment=True,download_name=f"{name}.mp4")

beta/api/mr_manager/boss_manager.py

@@ -0,0 +1,9 @@
+from beta.api.mr_manager.client_manager import ClientManager
+from beta.api.mr_manager.task_manager import TaskManager
+from mainLogic.utils import glv_var
+
+
+class Boss:
+    client_manager = ClientManager('clients.json')
+    task_manager = TaskManager(client_manager)
+    OUT_DIR = glv_var.api_webdl_directory

beta/api/mr_manager/client_manager.py

@@ -0,0 +1,186 @@
+import json
+import os
+
+from mainLogic.utils.glv import Global
+from mainLogic.utils.glv_var import debugger
+
+
+class ClientManager:
+    def __init__(self, json_file_path):
+        self.json_file_path = json_file_path
+        self.clients = self.load_data()
+
+    def load_data(self):
+        if not os.path.exists(self.json_file_path):
+            return {}
+        try:
+            with open(self.json_file_path, 'r') as file:
+                return json.load(file)
+        except json.JSONDecodeError:
+            return {}
+
+    def save_data(self):
+        with open(self.json_file_path, 'w') as file:
+            json.dump(self.clients, file, indent=4)
+
+    def client_exists(self, client_id):
+        return client_id in self.clients
+
+    def session_exists(self, client_id, session_id):
+        return client_id in self.clients and session_id in self.clients[client_id]['sessions']
+
+    def add_client(self, client_id="anonymous",name=""):
+        if client_id not in self.clients:
+            self.clients[client_id] = {
+                "name": "Anonymous" if client_id == "anonymous" else name,
+                "client_id": client_id,
+                "sessions": {}
+            }
+            self.save_data()
+        else:
+            print(f"Client with ID {client_id} already exists.")
+
+    def remove_client(self, client_id):
+        if client_id in self.clients:
+            del self.clients[client_id]
+            self.save_data()
+        else:
+            print(f"Client with ID {client_id} does not exist.")
+
+    def set_client_name(self, client_id, name):
+        if client_id in self.clients:
+            self.clients[client_id]['name'] = name
+            self.save_data()
+        else:
+            print(f"Client with ID {client_id} does not exist.")
+
+    def add_session(self, client_id="anonymous", session_id="anonymous"):
+        from mainLogic.utils.gen_utils import generate_timestamp
+        if client_id in self.clients:
+            if session_id not in self.clients[client_id]['sessions']:
+                timestamp = generate_timestamp()
+                self.clients[client_id]['sessions'][session_id] = {"tasks": {}, "name": "", "timestamp": timestamp}
+                self.save_data()
+            else:
+                print(f"Session with ID {session_id} already exists for client {client_id}.")
+        else:
+            print(f"Client with ID {client_id} does not exist.")
+
+    def remove_session(self, client_id, session_id):
+        if client_id in self.clients and session_id in self.clients[client_id]['sessions']:
+            del self.clients[client_id]['sessions'][session_id]
+            self.save_data()
+        else:
+            print(f"Session with ID {session_id} does not exist for client {client_id}.")
+
+    def add_task(self, client_id, session_id, task_id, task_info):
+        if client_id in self.clients and session_id in self.clients[client_id]['sessions']:
+            self.clients[client_id]['sessions'][session_id]['tasks'][task_id] = task_info
+            self.save_data()
+        else:
+            print(f"Either client with ID {client_id} or session with ID {session_id} does not exist.")
+
+    def get_tasks(self,client_id,session_id=None):
+
+        # if session_id is empty return all tasks
+        if not session_id:
+            return self.clients[client_id]['sessions']
+        else:
+            return self.clients[client_id]['sessions'][session_id]['tasks']
+
+    def get_task(self,task_id):
+        for client_id in self.clients:
+            for session_id in self.clients[client_id]['sessions']:
+                if task_id in self.clients[client_id]['sessions'][session_id]['tasks']:
+                    return self.clients[client_id]['sessions'][session_id]['tasks'][task_id]
+        return None
+
+    def update_task(self, task_info):
+        client_id = task_info['client_id']
+        session_id = task_info['session_id']
+        task_id = task_info['task_id']
+        if client_id in self.clients and session_id in self.clients[client_id]['sessions']:
+            if task_id in self.clients[client_id]['sessions'][session_id]['tasks']:
+                self.clients[client_id]['sessions'][session_id]['tasks'][task_id] = task_info
+                self.save_data()
+            else:
+                print(f"Task with ID {task_id} does not exist in session {session_id} for client {client_id}.")
+        else:
+            print(f"Either client with ID {client_id} or session with ID {session_id} does not exist.")
+
+    def remove_task(self, client_id, session_id, task_id):
+        if client_id in self.clients and session_id in self.clients[client_id]['sessions']:
+            if task_id in self.clients[client_id]['sessions'][session_id]['tasks']:
+                del self.clients[client_id]['sessions'][session_id]['tasks'][task_id]
+                self.save_data()
+            else:
+                print(f"Task with ID {task_id} does not exist in session {session_id} for client {client_id}.")
+        else:
+            print(f"Either client with ID {client_id} or session with ID {session_id} does not exist.")
+
+    def get_client_info(self, client_id):
+        if client_id in self.clients:
+            return self.clients[client_id]
+        else:
+            print(f"Client with ID {client_id} does not exist.")
+            return None
+
+    def get_progress(self,task_id):
+        task = self.get_task(task_id)
+        if task:
+            return task
+        else:
+            debugger.error(f"Task with ID {task_id} does not exist.")
+            return None
+
+    def set_session_name(self, client_id, session_id, name):
+        if client_id in self.clients and session_id in self.clients[client_id]['sessions']:
+            self.clients[client_id]['sessions'][session_id]['name'] = name
+            self.save_data()
+        else:
+            print(f"Either client with ID {client_id} or session with ID {session_id} does not exist.")
+
+
+    def delete_session(self, client_id, session_id):
+        if client_id in self.clients and session_id in self.clients[client_id]['sessions']:
+            del self.clients[client_id]['sessions'][session_id]
+            self.save_data()
+        else:
+            print(f"Session with ID {session_id} does not exist for client {client_id}.")
+
+    def merge_sessions(self, client_id, session_id_1, session_id_2):
+        if client_id in self.clients and session_id_1 in self.clients[client_id]['sessions'] and session_id_2 in self.clients[client_id]['sessions']:
+
+            # DEBUG
+            Global.hr()
+            print(f"Session 1: {session_id_1}")
+            print(f"Session 2: {session_id_2}")
+            print(f"Tasks in session 1: {json.dumps(self.clients[client_id]['sessions'][session_id_1]['tasks'], indent=4)}")
+            print(f"Tasks in session 2: {json.dumps(self.clients[client_id]['sessions'][session_id_2]['tasks'], indent=4)}")
+            Global.hr()
+
+            # Create a list of task IDs to delete to avoid changing dictionary size during iteration
+            tasks_to_delete = [task_id for task_id, task in self.clients[client_id]['sessions'][session_id_2]['tasks'].items()
+                               if task['status'] in ['downloading', 'created', 'failed']]
+
+            # Delete the tasks from session_id_2
+            for task_id in tasks_to_delete:
+                debugger.debug(f"Deleting task {task_id}")
+                del self.clients[client_id]['sessions'][session_id_2]['tasks'][task_id]
+
+            # Move tasks from session_id_2 to session_id_1
+            self.clients[client_id]['sessions'][session_id_1]['tasks'].update(self.clients[client_id]['sessions'][session_id_2]['tasks'])
+
+            # Delete session_id_2
+            del self.clients[client_id]['sessions'][session_id_2]
+            self.save_data()
+        else:
+            print(f"Either client with ID {client_id} or session with ID {session_id_1} or {session_id_2} does not exist.")
+
+
+    def delete_client(self, client_id):
+        if client_id in self.clients:
+            del self.clients[client_id]
+            self.save_data()
+        else:
+            print(f"Client with ID {client_id} does not exist.")

beta/api/mr_manager/task_manager.py

@@ -0,0 +1,124 @@
+import json
+import threading
+import uuid
+
+from mainLogic.utils.glv import Global
+from mainLogic.utils.glv_var import debugger
+
+
+class TaskManager:
+    def __init__(self, client_manager):
+        self.tasks = {}
+        self.lock = threading.Lock()
+        self.client_manager = client_manager
+        self.inactive_tasks = {}
+
+    def handle_completion(self, task_id):
+        print(f"Task {task_id} completed")
+        with self.lock:
+            self.tasks[task_id]['status'] = 'completed'
+            self.client_manager.update_task(self.tasks[task_id])
+
+    on_task_complete = handle_completion
+
+    def create_task(self, client_id, session_id, target, *args, inactive=False):
+        Global.hr()
+        task_id = str(uuid.uuid4())
+        debugger.success(f"Args: {args}")
+        args_dict = args[0]
+        try:
+            name = args_dict['name']
+            id = args_dict['id']
+            batch_name = args_dict.get('batch_name', None)
+            topic_name = args_dict.get('topic_name', None)
+            lecture_url = args_dict.get('lecture_url', None)
+            out_dir = args_dict['out_dir']
+        except KeyError:
+            raise ValueError('name, id, batch_name and out_dir are required in args')
+
+        client_id = args_dict.get('client_id', client_id)
+        session_id = args_dict.get('session_id', session_id)
+
+        task_info = {
+            'task_id': task_id,
+            'progress': {
+                'progress': 0
+            },
+            'status': 'created' if inactive else 'running',  # Set status to 'created' if inactive
+            'name': name,
+            'out_dir': out_dir,
+            'id': id,
+            'batch_name': batch_name,
+            'topic_name': topic_name,
+            'lecture_url': lecture_url,
+            'client_id': client_id,
+            'session_id': session_id
+        }
+
+        with self.lock:
+            self.tasks[task_id] = task_info
+            self.client_manager.add_task(client_id, session_id, task_id, task_info)
+
+        if not inactive:
+            thread = threading.Thread(target=self._run_task, args=(task_info, target, name, id, out_dir, client_id, session_id, *args[1:]))
+            thread.start()
+        else:
+            self.inactive_tasks[task_id] = {
+                'target': target,
+                'args': args,
+                'task_info': task_info
+            }
+
+        return task_id
+
+    def start_task(self, task_id):
+        with self.lock:
+            if task_id in self.tasks:
+                if self.tasks[task_id]['status'] == 'created':
+                    task_info = self.tasks[task_id]
+                    target = self._get_target_function(task_id)  # Replace with your actual logic to retrieve the target function
+                    thread = threading.Thread(target=self._run_task,
+                                              args=(
+                                                  task_info, target,
+                                                  task_info['name'],task_info['id'], task_info['batch_name'],task_info['topic_name'],task_info['lecture_url'],
+                                                  task_info['out_dir'], task_info['client_id'], task_info['session_id']))
+                    thread.start()
+                    self.tasks[task_id]['status'] = 'running'
+                else:
+                    raise ValueError(f"Task {task_id} is already running or completed.")
+
+    def _run_task(self, task_info, target, *args):
+        task_id = task_info['task_id']
+        try:
+
+            progress_callback = lambda progress: self._update_progress(task_id, progress)
+            debugger.debug(json.dumps([task_id, [*args], str(progress_callback)],indent=4))
+            target(task_id, *args, progress_callback)
+            with self.lock:
+                self.tasks[task_id]['url'] = f'/get-file/{task_id}/{self.tasks[task_id]["name"]}'
+                self.tasks[task_id]['status'] = 'completed'
+                self.client_manager.update_task(self.tasks[task_id])
+        except Exception as e:
+            debugger.info(f"Failed with error {e}")
+            with self.lock:
+                self.tasks[task_id]['status'] = 'failed'
+                self.tasks[task_id]['error'] = str(e)
+                self.client_manager.update_task(self.tasks[task_id])
+
+    def _update_progress(self, task_id, progress):
+        with self.lock:
+            if task_id in self.tasks:
+                self.tasks[task_id]['progress'] = progress
+                self.client_manager.update_task(self.tasks[task_id])
+
+    def get_progress(self, task_id):
+        with self.lock:
+            return self.tasks.get(task_id, {'status': 'not found'})
+
+    def _get_target_function(self, task_id):
+        if task_id in self.inactive_tasks:
+            return self.inactive_tasks[task_id]['target']
+        else:
+            raise ValueError(f"Task {task_id} is not inactive.")
+
+

beta/api/templates/base.html

@@ -0,0 +1,269 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>{% block title %}Default Title{% endblock %}</title>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css">
+
+    <style>
+        :root {
+            /* Color system */
+            --color-background: #0f172a;
+            --color-card: rgba(255, 255, 255, 0.08);
+            --color-text-primary: rgba(255, 255, 255, 0.95);
+            --color-text-secondary: rgba(255, 255, 255, 0.7);
+            --color-border: rgba(255, 255, 255, 0.15);
+            --color-primary: #3b82f6;
+            --color-primary-hover: #2563eb;
+            --color-destructive: #ef4444;
+            --color-warning: #f59e0b;
+            --color-muted: rgba(255, 255, 255, 0.45);
+
+            /* Spacing */
+            --space-1: 0.25rem;
+            --space-2: 0.5rem;
+            --space-3: 0.75rem;
+            --space-4: 1rem;
+            --space-5: 1.25rem;
+            --space-6: 1.5rem;
+            --space-8: 2rem;
+            --space-10: 2.5rem;
+            --space-12: 3rem;
+
+            /* Radius */
+            --radius-sm: 0.25rem;
+            --radius-md: 0.5rem;
+            --radius-lg: 0.75rem;
+            --radius-xl: 1rem;
+
+            /* Shadow */
+            --shadow-sm: 0 1px 2px rgba(0, 0, 0, 0.2);
+            --shadow-md: 0 4px 6px -1px rgba(0, 0, 0, 0.3);
+            --shadow-lg: 0 10px 15px -3px rgba(0, 0, 0, 0.4);
+
+            /* Font sizes */
+            --font-xs: 0.75rem;
+            --font-sm: 0.875rem;
+            --font-md: 1rem;
+            --font-lg: 1.125rem;
+            --font-xl: 1.25rem;
+            --font-2xl: 1.5rem;
+            --font-3xl: 1.875rem;
+        }
+
+        * {
+            box-sizing: border-box;
+            margin: 0;
+            padding: 0;
+        }
+
+        body {
+            font-family: 'Inter', sans-serif;
+            background: linear-gradient(135deg, #1e3a8a, #172554);
+            color: var(--color-text-primary);
+            min-height: 100vh;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            padding: var(--space-6);
+        }
+
+        .container {
+            width: 100%;
+            max-width: 640px;
+            margin: 0 auto;
+        }
+
+        /* Card Components */
+        .error-card,
+        .moved-card {
+            background: var(--color-card);
+            border-radius: var(--radius-xl);
+            backdrop-filter: blur(10px);
+            border: 1px solid var(--color-border);
+            padding: var(--space-8);
+            box-shadow: var(--shadow-lg),
+            inset 0 1px 1px rgba(255, 255, 255, 0.1);
+            display: flex;
+            flex-direction: column;
+            gap: var(--space-6);
+        }
+
+        /* Header Components */
+        .error-header,
+        .moved-header {
+            display: flex;
+            align-items: center;
+            gap: var(--space-4);
+        }
+
+        .error-icon-wrapper,
+        .moved-icon-wrapper {
+            width: 56px;
+            height: 56px;
+            border-radius: 50%;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            flex-shrink: 0;
+        }
+
+        .error-icon-wrapper i,
+        .moved-icon-wrapper i {
+            font-size: var(--font-2xl);
+        }
+
+        /* Moved specific styles */
+        .moved-icon-wrapper {
+            background-color: var(--color-primary)20;
+        }
+
+        .moved-icon-wrapper i {
+            color: var(--color-primary);
+        }
+
+        .error-header h1 {
+            font-size: var(--font-2xl);
+            font-weight: 700;
+            line-height: 1.2;
+        }
+
+        /* Error Message */
+        .error-message,
+        .moved-message {
+            color: var(--color-text-secondary);
+            line-height: 1.6;
+        }
+
+        .error-message p,
+        .moved-message p {
+            margin-bottom: var(--space-2);
+        }
+
+        .error-message .reason {
+            color: var(--color-text-primary);
+        }
+
+        /* Task ID */
+        .task-id {
+            background: rgba(0, 0, 0, 0.2);
+            border-radius: var(--radius-md);
+            padding: var(--space-3) var(--space-4);
+            font-family: monospace;
+            font-size: var(--font-sm);
+            border: 1px solid var(--color-border);
+        }
+
+        .task-id span {
+            color: var(--color-text-secondary);
+            margin-right: var(--space-2);
+        }
+
+        /* Details Section */
+        .details-section {
+            margin-top: var(--space-2);
+        }
+
+        .details-header {
+            margin-bottom: var(--space-4);
+        }
+
+        .details-header h2 {
+            font-size: var(--font-lg);
+            font-weight: 600;
+            margin-bottom: var(--space-3);
+        }
+
+        .details-divider {
+            height: 1px;
+            background: var(--color-border);
+            margin-top: var(--space-2);
+        }
+
+        .details-list {
+            display: flex;
+            flex-direction: column;
+            gap: var(--space-4);
+        }
+
+        .details-item {
+            display: flex;
+            flex-direction: column;
+            gap: var(--space-1);
+        }
+
+        .details-item dt {
+            color: var(--color-text-secondary);
+            font-size: var(--font-sm);
+            font-weight: 500;
+        }
+
+        .details-item dd {
+            color: var(--color-text-primary);
+            word-break: break-word;
+        }
+
+        .details-item pre {
+            font-family: monospace;
+            font-size: var(--font-sm);
+            background: rgba(0, 0, 0, 0.2);
+            padding: var(--space-3);
+            border-radius: var(--radius-sm);
+            border: 1px solid var(--color-border);
+            overflow: auto;
+            margin-top: var(--space-2);
+            white-space: pre-wrap;
+        }
+
+        /* Button */
+        .primary-button {
+            display: inline-flex;
+            align-items: center;
+            justify-content: center;
+            background-color: var(--color-primary);
+            color: white;
+            font-weight: 500;
+            border-radius: var(--radius-md);
+            padding: var(--space-3) var(--space-6);
+            text-decoration: none;
+            transition: background-color 0.2s, transform 0.2s;
+            border: none;
+            cursor: pointer;
+            font-size: var(--font-md);
+            align-self: flex-start;
+            gap: var(--space-2);
+        }
+
+        .primary-button:hover {
+            background-color: var(--color-primary-hover);
+            transform: translateY(-1px);
+        }
+
+        /* Responsive adjustments */
+        @media (max-width: 640px) {
+            .error-card,
+            .moved-card {
+                padding: var(--space-6);
+            }
+
+            .error-header h1,
+            .moved-header h1 {
+                font-size: var(--font-xl);
+            }
+
+            .error-icon-wrapper,
+            .moved-icon-wrapper {
+                width: 48px;
+                height: 48px;
+            }
+        }
+    </style>
+</head>
+<body>
+<div class="container">
+    {% block content %}{% endblock %}
+</div>
+</body>
+</html>

beta/api/templates/error.html

@@ -0,0 +1,80 @@
+{% extends "base.html" %}
+
+{% block title %}Video Error{% endblock %}
+
+{% block content %}
+    {# Map reason to icon, color and message #}
+    {% set status_configs = {
+        'deleted': {
+            'icon': 'fa-circle-xmark',
+            'color': 'var(--color-destructive)',
+            'text': 'The video has been deleted.'
+        },
+        'incomplete': {
+            'icon': 'fa-hourglass-half',
+            'color': 'var(--color-warning)',
+            'text': 'Processing of the video is incomplete.'
+        },
+        'failed': {
+            'icon': 'fa-circle-exclamation',
+            'color': 'var(--color-destructive)',
+            'text': 'Processing of the video failed.'
+        },
+        'not_found':{
+            'icon': 'fa-circle-xmark',
+            'color': 'var(--color-destructive)',
+            'text': 'The video was not found.'
+        }
+    } %}
+
+    {# Get the configuration for the current reason, or use defaults #}
+    {% set config = status_configs.get(reason, {
+        'icon': 'fa-circle-exclamation',
+        'color': 'var(--color-warning)',
+        'text': reason if reason else 'Unknown error'
+    }) %}
+
+    <div class="error-card">
+        <div class="error-header">
+            <div class="error-icon-wrapper" style="background-color: {{ config.color }}20;">
+                <i class="fas {{ config.icon }}" style="color: {{ config.color }};"></i>
+            </div>
+            <h1>Video Unavailable</h1>
+        </div>
+
+        <div class="error-message">
+            <p>The video you requested could not be found or is currently unavailable.</p>
+            <p class="reason"><strong>{{ config.text }}</strong></p>
+        </div>
+
+        <div class="task-id">
+            <span>Task ID:</span> {{ task_id }}
+        </div>
+
+        {% if video_details and video_details.items() %}
+            <div class="details-section">
+                <div class="details-header">
+                    <h2>Details</h2>
+                    <div class="details-divider"></div>
+                </div>
+
+                <dl class="details-list">
+                    {% for key, value in video_details.items() %}
+                        <div class="details-item">
+                            <dt>{{ key }}</dt>
+                            <dd>
+                                {% if value is mapping or (value is iterable and value is not string) %}
+                                    <pre>{{ value | tojson(indent=2) }}</pre>
+                                {% else %}
+                                    {{ value }}
+                                {% endif %}
+                            </dd>
+                        </div>
+                    {% endfor %}
+                </dl>
+            </div>
+        {% endif %}
+
+        <a href="/" class="primary-button">Go Home</a>
+    </div>
+{% endblock %}

beta/api/templates/index.html

@@ -0,0 +1,23 @@
+{% extends "base.html" %}
+
+{% block title %}pwdl Web UI Moved{% endblock %}
+
+{% block content %}
+    <div class="moved-card">
+        <div class="moved-header">
+            <div class="moved-icon-wrapper">
+                <i class="fas fa-arrow-right-long"></i>
+            </div>
+            <h1>pwdl Web UI Has Moved</h1>
+        </div>
+
+        <div class="moved-message">
+            <p>We've migrated to a new online home for a faster and smoother experience.</p>
+        </div>
+
+        <a href="https://pwdl-webui.vercel.app" target="_blank" class="primary-button">
+            <span>Visit pwdl-webui.vercel.app</span>
+            <i class="fas fa-external-link-alt"></i>
+        </a>
+    </div>
+{% endblock %}

beta/batch_scraper_2/Endpoints.py

@@ -0,0 +1,150 @@
+from typing import Callable, List
+
+from beta.util import extract_uuid, generate_safe_file_name
+from mainLogic.utils.Endpoint import Endpoint
+from mainLogic.utils.glv_var import debugger
+
+
+class Endpoints:
+    def __init__(self, verbose=False):
+        self.verbose = verbose
+        self.DEFAULT_HEADERS = {
+            'client-id': '5eb393ee95fab7468a79d189',
+            # 'randomid': 'dbacc4f3-9024-491d-b2d3-72bd4b6ee281',
+            'client-type': 'WEB',
+        }
+        self.token = None
+        self.random_id = None
+
+        class API:
+            def __init__(self, outer):
+                self.outer = outer
+                self.base = "https://api.penpencil.co"
+                self.v1 = "v1"
+                self.v2 = "v2"
+                self.v3 = "v3"
+                self.hard_limit = 50
+
+            def url_details(self, batch_name):
+                return f"{self.base}/{self.v3}/batches/{batch_name}/details"
+
+            def url_subject(self, batch_name, subject_name):
+                return f"{self.base}/{self.v2}/batches/{batch_name}/subject/{subject_name}/topics?limit={self.hard_limit}"
+
+            def url_chapter(self, batch_name, subject_name, chapter_name):
+                return f"{self.base}/{self.v2}/batches/{batch_name}/subject/{subject_name}/contents?limit={self.hard_limit}&contentType=videos&tag={chapter_name}"
+
+            def url_notes(self, batch_name, subject_name, chapter_name):
+                return f"{self.base}/{self.v2}/batches/{batch_name}/subject/{subject_name}/contents?limit={self.hard_limit}&contentType=notes&tag={chapter_name}"
+
+            def url_lecture(self, lecture_id, batch_name):
+                return f"https://api.penpencil.co/{self.v1}/videos/video-url-details?type=BATCHES&childId={lecture_id}&parentId={batch_name}&reqType=query&videoContainerType=DASH"
+
+            def url_dpp_pdf(self, batch_name, subject_name, chapter_name):
+                return f"{self.base}/{self.v2}/batches/{batch_name}/subject/{subject_name}/contents?page=1&contentType=DppNotes&tag={chapter_name}&limit={self.hard_limit}"
+
+            def post_process(self, response: dict, keys_to_extract: List[str]):
+                try:
+                    data = response
+                    debugger.debug(f"Processing response:")
+                    debugger.info(data)
+                    for key in keys_to_extract:
+                        if isinstance(data, dict) and key in data:
+                            data = data[key]
+                        else:
+                            raise KeyError(f"Key '{key}' not found at level {key}")
+                    if self.outer.verbose:
+                        debugger.success(f"Successfully extracted data using keys {keys_to_extract}")
+                    return data
+                except Exception as e:
+                    debugger.error(f"Failed to extract data: {e}")
+                    return []
+
+        class Khazana(API):
+            def __init__(self, outer):
+                super().__init__(outer)
+
+            def url_details(self, program_name):
+                return f"{self.base}/{self.v1}/programs/{program_name}/subjects?page=1&limit={self.hard_limit}"
+
+            def url_subject(self, program_name, subject_name):
+                # even though 'chapters' is returend it actually returns 'teachers'
+                return f"{self.base}/{self.v2}/programs/{program_name}/subjects/{subject_name}/chapters?page=1&limit={self.hard_limit}"
+
+            def url_topics(self, program_name, subject_name, teacher_name):
+                return f"{self.base}/{self.v1}/programs/{program_name}/subjects/{subject_name}/chapters/{teacher_name}/topics?page=1&limit={self.hard_limit}"
+
+            def url_sub_topic(self, program_name, subject_name, teacher_name, topic_name):
+                # actually returns 'chapters' by a specific teacher
+                # topic name is actually chapyter name
+                return f"{self.base}/{self.v1}/programs/{program_name}/subjects/{subject_name}/chapters/{teacher_name}/topics/{topic_name}/contents/sub-topic?page=1&limit={self.hard_limit}"
+
+            def url_chapter(self,program_name,subject_name,teacher_name,topic_name,sub_topic_name):
+                return f"{self.base}/{self.v2}/programs/contents?programId={program_name}&subjectId={subject_name}&chapterId={teacher_name}&topicId={topic_name}&subTopicId={sub_topic_name}&page=1&limit={self.hard_limit}"
+
+            def url_lecture(self,program_name,topic_name,lecture_id,lecture_url):
+                return (f"{self.base}/{self.v1}/videos/video-url-details?type=RECORDED&videoContainerType=DASH&reqType"
+                        f"=query&childId={lecture_id}&parentId={program_name}&"
+                        f"videoUrl={lecture_url}&secondaryParentId={topic_name}")
+
+
+        self.API = API(self)
+        self.Khazana = Khazana(self)
+
+        class Lambert:
+            def __init__(self, url_func: Callable, post_process_args: List[str], required_args: List[str]):
+                self.url_func = url_func
+                self.post_process_args = post_process_args
+                self.required_args = required_args
+
+        self.data_logs = {
+            "details": Lambert(self.API.url_details, ["data", "subjects"], ["batch_name"]),
+            "subject": Lambert(self.API.url_subject, ["data"], ["batch_name", "subject_name"]),
+            "chapter": Lambert(self.API.url_chapter, ["data"], ["batch_name", "subject_name", "chapter_name"]),
+            "notes"  : Lambert(self.API.url_notes, ["data",], ["batch_name", "subject_name", "chapter_name"]),
+            "lecture": Lambert(self.API.url_lecture, ["data"], ["batch_name","lecture_id"]),
+            "dpp_pdf": Lambert(self.API.url_dpp_pdf, ["data"], ["batch_name", "subject_name", "chapter_name"]),
+        }
+
+        self.khazana_logs= {
+            "details"   :   Lambert(self.Khazana.url_details, ["data"], ["program_name"]),
+            "subject"   :   Lambert(self.Khazana.url_subject, ["data"], ["program_name", "subject_name"]),
+            "topics"    :   Lambert(self.Khazana.url_topics, ["data"], ["program_name", "subject_name", "teacher_name"]),
+            "sub_topic" :   Lambert(self.Khazana.url_sub_topic, ["data"], ["program_name", "subject_name", "teacher_name", "topic_name"]),
+            "chapter"   :   Lambert(self.Khazana.url_chapter, ["data"], ["program_name", "subject_name", "teacher_name", "topic_name","sub_topic_name"]),
+            "lecture"   :   Lambert(self.Khazana.url_lecture, ["data"], ["program_name", "topic_name", "lecture_id", "lecture_url"]),
+
+
+        }
+
+
+    def set_token(self, token, random_id="a3e290fa-ea36-4012-9124-8908794c33aa"):
+        self.token = token
+        self.DEFAULT_HEADERS.setdefault('Authorization', 'Bearer ' + self.token)
+        if random_id:
+            self.random_id = random_id
+            self.DEFAULT_HEADERS['randomid'] = self.random_id
+        if self.verbose:
+            debugger.debug("Authorization token set successfully.")
+        return self
+
+
+
+    def process(self, type: str,khazana=False, **kwargs):
+        lambert = self.data_logs[type] if not khazana else self.khazana_logs[type]
+
+        missing_args = [arg for arg in lambert.required_args if arg not in kwargs]
+        if missing_args:
+            raise ValueError(f"Missing required arguments for '{type}': {missing_args}")
+
+        url = lambert.url_func(**kwargs)
+        if self.verbose:
+            debugger.debug(f"Fetching from URL: {url}")
+
+        endpoint = Endpoint(url, headers=self.DEFAULT_HEADERS)
+        fetched_response = endpoint.fetch()[0]
+        processed_data = self.API.post_process(fetched_response, lambert.post_process_args)
+        return processed_data
+
+
+

beta/obsolete/batch_scraper/Endpoints.py

@@ -0,0 +1,178 @@
+from beta.util import extract_uuid, generate_safe_file_name
+from mainLogic.utils.Endpoint import Endpoint
+from mainLogic.utils.glv_var import debugger
+
+
+class Endpoints:
+    DEFAULT_HEADERS = {
+        "randomId": "441c443a-2ab0-40da-86c1-885b88892094",
+        "Referer": "https://www.pw.live/",
+        "sec-ch-ua": '"Google Chrome";v="129", "Not=A?Brand";v="8", "Chromium";v="129"',
+        "sec-ch-ua-mobile": "?0",
+        "client-type": "WEB",
+        "client-id": "5eb393ee95fab7468a79d189",
+        "integration-with": "",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36",
+        "Accept": "application/json, text/plain, */*",
+        "client-version": "6.0.6"
+    }
+
+    @staticmethod
+    def post_function_subjects_khazana(data):
+        return [{
+            'slug': subject['slug'],
+            'name': subject['name']
+        } for subject in data['data']] if isinstance(data, dict) and 'data' in data else []
+
+    @staticmethod
+    def post_function_batches_khazana(data):
+        return [{
+            'name': f"{chapter['name']} {chapter['description'].split(';')[0]}",
+            'slug': chapter['slug'],
+            'topics': chapter['totalTopics'],
+            'img': '' if 'imageId' not in chapter else (chapter['imageId']['baseUrl'] + chapter['imageId']['key'])
+        } for chapter in data['data']] if isinstance(data, dict) and 'data' in data else []
+
+    @staticmethod
+    def post_function_topics_khazana(data):
+        return [{
+            'name': chapter['name'],
+            'slug': chapter['slug'],
+            'id': chapter['_id'],
+            'video_count': chapter['totalLectures']
+        } for chapter in data['data']] if isinstance(data, dict) and 'data' in data else []
+
+    @staticmethod
+    def post_function_lectures_khazana(data):
+        return [{
+            'name': video['title'],
+            'url': video['content'][0]['videoUrl'],
+            'img': video['content'][0]["videoDetails"]["image"],
+            'duration': video['content'][0]["videoDetails"]["duration"]
+        } for video in data['data']] if isinstance(data, dict) and 'data' in data else []
+
+    @staticmethod
+    def post_function_subjects(data):
+        return [{
+            'slug': subject['slug'],
+            'name': subject['subject'],
+            'chapter_count': subject.get('tagCount', 0)
+        } for subject in data['data']['subjects']] if isinstance(data, dict) and 'data' in data and 'subjects' in data['data'] else []
+
+    @staticmethod
+    def post_function_chapters(data):
+        return [{
+            'name': chapter['name'],
+            'slug': chapter['slug'],
+            'video_count': chapter['videos']
+        } for chapter in data['data']] if isinstance(data, dict) and 'data' in data else []
+
+    @staticmethod
+    def post_function_videos(data):
+        return [{
+            'name': video['topic'],
+            'url': video['url'],
+            'img': video['videoDetails']['image'],
+            'duration': video['videoDetails']['duration']
+        } for video in data['data']] if isinstance(data, dict) and 'data' in data else []
+
+    @staticmethod
+    def post_function_videos_simple(data):
+
+        try:
+            return [{
+                'name': generate_safe_file_name(video['topic']),
+                'url': extract_uuid(video['url'])[0],
+            } for video in data['data']] if isinstance(data, dict) and 'data' in data else []
+        except Exception as e:
+            debugger.error(f"Error in post_function_videos_simple: {e}")
+            return []
+
+
+
+    @staticmethod
+    def post_function_batches(data):
+        return [{
+            'slug': batch['batchId']['slug'],
+            'img': '' if 'previewImage' not in batch['batchId'] else (batch['batchId']['previewImage']['baseUrl'] + batch['batchId']['previewImage']['key'])
+        } for batch in data['data']] if isinstance(data, dict) and 'data' in data else []
+
+    @staticmethod
+    def GET_KHAZANA_SUBJECTS_EP(batch_name):
+        return Endpoint(
+            url=f"https://api.penpencil.co/v1/programs/{batch_name}/subjects?page={{page}}",
+            method='GET',
+            headers=Endpoints.DEFAULT_HEADERS.copy(),
+            post_function=Endpoints.post_function_subjects_khazana
+        )
+
+    @staticmethod
+    def GET_KHAZANA_BATCHES_EP(batch_name, subject_slug):
+        return Endpoint(
+            url=f"https://api.penpencil.co/v2/programs/{batch_name}/subjects/{subject_slug}/chapters?page={{page}}",
+            method='GET',
+            headers=Endpoints.DEFAULT_HEADERS.copy(),
+            post_function=Endpoints.post_function_batches_khazana
+        )
+
+    @staticmethod
+    def GET_KHAZANA_CHAPTERS_EP(batch_name, subject_slug):
+        return Endpoint(
+            url=f"https://api.penpencil.co/v1/programs/{batch_name}/subjects/{subject_slug}/chapters/{subject_slug}/topics?page={{page}}",
+            method='GET',
+            headers=Endpoints.DEFAULT_HEADERS.copy(),
+            post_function=Endpoints.post_function_topics_khazana
+        )
+
+    @staticmethod
+    def get_sub_topic_khazana(batch_name, subject_slug, topic_id):
+        return Endpoint(
+            url=f"https://api.penpencil.co/v1/programs/{batch_name}/subjects/{subject_slug}/chapters/{subject_slug}/topics/{topic_id}/contents/sub-topic?page={{page}}",
+            method='GET',
+            headers=Endpoints.DEFAULT_HEADERS.copy()
+        )
+
+    @staticmethod
+    def GET_KHAZANA_LECTURES_EP(batch_name, subject_slug, chapter_slug, topic_id, sub_topic_id):
+        return Endpoint(
+            url=f"https://api.penpencil.co/v2/programs/contents?type=&programId={batch_name}&subjectId={subject_slug}&chapterId={chapter_slug}&topicId={topic_id}&page={{page}}&subTopicId={sub_topic_id}",
+            method='GET',
+            headers=Endpoints.DEFAULT_HEADERS.copy(),
+            post_function=Endpoints.post_function_lectures_khazana
+        )
+
+    @staticmethod
+    def GET_NORMAL_SUBJECTS_EP(batch_name):
+        return Endpoint(
+            url=f"https://api.penpencil.co/v3/batches/{batch_name}/details",
+            method='GET',
+            headers=Endpoints.DEFAULT_HEADERS.copy(),
+            post_function=Endpoints.post_function_subjects
+        )
+
+    @staticmethod
+    def GET_NORMAL_CHAPTERS_EP(batch_name, subject_slug):
+        return Endpoint(
+            url=f"https://api.penpencil.co/v2/batches/{batch_name}/subject/{subject_slug}/topics?page={{page}}",
+            method='GET',
+            headers=Endpoints.DEFAULT_HEADERS.copy(),
+            post_function=Endpoints.post_function_chapters
+        )
+
+    @staticmethod
+    def GET_NORMAL_LECTURES_EP(batch_name, subject_slug, chapter_slug,simple=False):
+        return Endpoint(
+            url=f"https://api.penpencil.co/v2/batches/{batch_name}/subject/{subject_slug}/contents?page={{page}}&contentType=videos&tag={chapter_slug}",
+            method='GET',
+            headers=Endpoints.DEFAULT_HEADERS.copy(),
+            post_function=Endpoints.post_function_videos if not simple else Endpoints.post_function_videos_simple
+        )
+
+    @staticmethod
+    def get_batches_force_hard():
+        return Endpoint(
+            url="https://api.penpencil.co/v1/cohort/634fd2463ce3d7001c50798a/batches?page={page}&filter=true&tag=online&batchChildUrl=/batches-new/?tag=online&version=2",
+            method='GET',
+            headers=Endpoints.DEFAULT_HEADERS.copy(),
+            post_function=Endpoints.post_function_batches
+        )

beta/obsolete/batch_scraper/app.py

@@ -0,0 +1,138 @@
+import json
+from tabnanny import verbose
+
+from mainLogic.utils.Endpoint import Endpoint
+from mainLogic.utils import glv_var
+from mainLogic.utils.glv import Global
+from beta.obsolete.batch_scraper.Endpoints import Endpoints
+from mainLogic.utils.glv_var import debugger
+
+
+class BatchAPI:
+    def __init__(self, batch_name: str, token: str, force=True, verbose=False):
+        self.batch_name = batch_name
+        self.token = token
+        self.force = force
+
+
+    def dataFromAPI(self, endpoint: Endpoint):
+        if self.force:
+            debugger.error("Forced to get token from stored prefs")
+            try:
+                self.token = glv_var.vars['prefs']['token']
+            except Exception as e:
+                debugger.error(f"Error: {e}")
+                self.token = None
+                raise ValueError("Token not found in prefs")
+            debugger.success(f"New Token: {self.token}")
+
+        if self.token and 'Authorization' not in endpoint.headers:
+            endpoint.headers['Authorization'] = f'Bearer {self.token}'
+
+        response_obj, status_code, response = endpoint.fetch()
+
+        if verbose:
+            Global.hr()
+            print(f"Debugging at {endpoint.url}")
+            debugger.success(f"Response: {response}")
+            print(f"Response Status Code: {status_code}")
+            print(f"Response Text: \n{json.dumps(response_obj)}")
+            Global.hr()
+
+        if endpoint.post_function:
+            return endpoint.post_function(response_obj)
+        return response_obj if status_code == 200 else response.text
+
+    def get_paginated_data(self, endpoint: Endpoint):
+        all_data = []
+        page = 1
+
+        while True:
+            paginated_endpoint = endpoint.__copy__()
+            paginated_endpoint.url = paginated_endpoint.url.format(page=page)
+            response = self.dataFromAPI(paginated_endpoint)
+
+            if isinstance(response, str):
+                break
+            if not response:
+                break
+
+            all_data.extend(response)
+
+            page += 1
+
+            if paginated_endpoint.url == endpoint.url:
+                break
+
+        return all_data
+
+    def GET_KHAZANA_SUBJECTS(self):
+        return self.get_paginated_data(Endpoints.GET_KHAZANA_SUBJECTS_EP(self.batch_name))
+
+    def GET_KHAZANA_BATCHES(self, kh_subject_slug):
+        return self.get_paginated_data(Endpoints.GET_KHAZANA_BATCHES_EP(self.batch_name, kh_subject_slug))
+
+    def GET_KHAZANA_CHAPTERS(self, subject_slug_kh):
+        return self.get_paginated_data(Endpoints.GET_KHAZANA_CHAPTERS_EP(self.batch_name, subject_slug_kh))
+
+    def GET_KHAZANA_LECTURES(self, subject_slug_kh, chapter_slug_kh, topic_id):
+        # First get sub_topic_id
+        Global.hr()
+        print(f"Fetching sub-topic for Batch: {self.batch_name}, Subject: {subject_slug_kh}, Topic: {topic_id}")
+        sub_topic_response = self.dataFromAPI(
+            Endpoints.get_sub_topic_khazana(self.batch_name, subject_slug_kh, topic_id)
+        )
+
+        if 'data' in sub_topic_response:
+            sub_topic_response = sub_topic_response['data']
+        else:
+            # Error handling
+            debugger.error(f"No data found in response @ khazana lectures: {sub_topic_response}")
+            return []
+
+
+        sub_topic_id = sub_topic_response[0]['_id'] if sub_topic_response else None
+        print(f"Sub-topic ID: {sub_topic_id}")
+
+
+
+        if not sub_topic_id:
+            debugger.error("No sub-topic ID found")
+            return []
+
+        Global.hr()
+        print(f"Fetching lectures for Sub-topic ID: {sub_topic_id}")
+        return self.get_paginated_data(
+            Endpoints.GET_KHAZANA_LECTURES_EP(self.batch_name, subject_slug_kh, chapter_slug_kh, topic_id, sub_topic_id)
+        )
+
+    def GET_NORMAL_SUBJECTS(self):
+        return self.dataFromAPI(Endpoints.GET_NORMAL_SUBJECTS_EP(self.batch_name))
+
+    def GET_NORMAL_CHAPTERS(self, subject_slug):
+        Global.hr()
+        print(f"Batch: {self.batch_name}")
+        print(f"Subject: {subject_slug}")
+        Global.hr()
+
+        return self.get_paginated_data(
+            Endpoints.GET_NORMAL_CHAPTERS_EP(self.batch_name, subject_slug)
+        )
+
+    def GET_NORMAL_LECTURES(self, subject_slug, chapter_slug, simple=False):
+        return self.get_paginated_data(
+            Endpoints.GET_NORMAL_LECTURES_EP(self.batch_name, subject_slug, chapter_slug,simple=simple)
+        )
+
+    def get_batches_force_hard(self):
+        return self.get_paginated_data(Endpoints.get_batches_force_hard())
+
+    @staticmethod
+    def to_table(list_of_data):
+        try:
+            headers = list_of_data[0].keys()
+            data = [list(row.values()) for row in list_of_data]
+            return headers, data
+        except Exception as e:
+            debugger.error(f"Error: {e}")
+            return [], []

beta/question_scraper/Endpoints.py

@@ -0,0 +1,72 @@
+import json
+
+from mainLogic.utils.Endpoint import Endpoint
+
+
+class Endpoints:
+
+
+
+
+
+    DEFAULT_HEADERS = {
+        'accept': 'application/json, text/plain, */*',
+        'accept-language': 'en-US,en;q=0.9,la;q=0.8',
+        'client-id': '5eb393ee95fab7468a79d189',
+        'client-type': 'WEB',
+        'client-version': '300',
+        'content-type': 'application/json',
+        'dnt': '1',
+        'origin': 'https://pw-infinite-practise.pw.live',
+        'priority': 'u=1, i',
+        'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36',
+
+    }
+
+
+    @staticmethod
+    def GET_QUESTIONS_EP(
+            subject_id = '734chcfe1nhx5ay0lh0n5d4qj',
+            chapters = [{'chapterId': 'dlfqana46gj8kjshdzwwlhb7p', 'classId': 'oyhh7ve8217so92jw81tefbyp'}],
+            difficulty_level = [3],
+            questions_count = 90,
+    ):
+        return Endpoint(
+            url='https://api.penpencil.co/v3/test-service/65d75d320531c20018ade9bb/infinitePractice/v2/start-test',
+            method='POST',
+            payload=json.dumps({
+                "exams": [
+                    "7d5erv0sihqah96p8noqgbxkp"
+                ],
+                "examCategory": "vckzned6mqjlkub8wsfh605rp",
+                "testMode": "PRACTICE",
+                "questionsCount": questions_count,
+                "chapters": chapters,
+                "subject": subject_id,
+                "difficultyLevel": [
+                    3
+                ],
+                "isReattempt": False
+            }),
+            headers=Endpoints.DEFAULT_HEADERS,
+            post_function=lambda data: data['data']
+        )
+
+    @staticmethod
+    def GET_SUBJECTS_BATCH_EP(batch_id='65d75d320531c20018ade9bb'):
+        return Endpoint(
+            url=f'https://api.penpencil.co/v3/batches/{batch_id}/infinitePractice/subjects',
+            method='GET',
+            headers=Endpoints.DEFAULT_HEADERS,
+            post_function=lambda data: data['data']
+        )
+
+    @staticmethod
+    def GET_CHAPTERS_EP(batch_id='65d75d320531c20018ade9bb', subject_id='734chcfe1nhx5ay0lh0n5d4qj'):
+        return Endpoint(
+            url=f'https://api.penpencil.co/v3/batches/{batch_id}/infinitePractice/chapters?subjectId={subject_id}',
+            method='GET',
+            headers=Endpoints.DEFAULT_HEADERS,
+            post_function=lambda data: data['data']
+        )
+

beta/question_scraper/app.py

@@ -0,0 +1,86 @@
+import json
+from tabnanny import verbose
+
+from beta.question_scraper.Endpoints import Endpoints
+from mainLogic.utils import glv_var
+from mainLogic.utils.Endpoint import Endpoint
+from mainLogic.utils.glv import Global
+from mainLogic.utils.glv_var import debugger
+
+
+class QuestionsAPI:
+
+    def __init__(self, token: str,random_id:str, force=True, verbose=False):
+        self.token = token
+        self.random_id = random_id
+        self.force = force
+        self.verbose = verbose
+
+    def dataFromAPI(self, endpoint: Endpoint):
+        if self.force:
+            debugger.error("Forced to get token from stored prefs")
+            try:
+                self.token = glv_var.vars['prefs']['token']
+                self.random_id = glv_var.vars['prefs']['random_id']
+            except Exception as e:
+                debugger.error(f"Error: {e}")
+                self.token = None
+                raise ValueError("Token not found in prefs")
+            debugger.success(f"New Token: {self.token}")
+
+        if self.token and 'Authorization' not in endpoint.headers:
+            endpoint.headers['Authorization'] = f'Bearer {self.token}'
+        if self.random_id and 'random_id' not in endpoint.headers:
+            # endpoint.headers['random_id'] = self.random_id
+            endpoint.headers['randomid'] = self.random_id
+
+        if self.verbose:
+            debugger.success(f"Headers: {endpoint.headers}")
+            debugger.success(f"Payload: {endpoint.payload}")
+
+
+        response_obj, status_code, response = endpoint.fetch()
+
+        if self.verbose:
+            Global.hr()
+            print(f"Debugging at {endpoint.url}")
+            debugger.success(f"Response: {response}")
+            print(f"Response Status Code: {status_code}")
+            print(f"Response Text: \n{json.dumps(response_obj)}")
+            Global.hr()
+
+        if endpoint.post_function:
+            return endpoint.post_function(response_obj)
+        return response_obj if status_code == 200 else response.text
+
+    def get_paginated_data(self, endpoint: Endpoint):
+        all_data = []
+        page = 1
+
+        while True:
+            paginated_endpoint = endpoint.__copy__()
+            paginated_endpoint.url = paginated_endpoint.url.format(page=page)
+            response = self.dataFromAPI(paginated_endpoint)
+
+            if isinstance(response, str):
+                break
+            if not response:
+                break
+
+            all_data.extend(response)
+            page += 1
+
+            if paginated_endpoint.url == endpoint.url:
+                break
+
+        return all_data
+
+    def GET_SUBJECTS(self):
+        return self.dataFromAPI(Endpoints.GET_SUBJECTS_BATCH_EP())
+
+    def GET_CHAPTERS(self, batch_id=None, subject_id=None):
+
+        return self.dataFromAPI(Endpoints.GET_CHAPTERS_EP(subject_id=subject_id))
+
+    def GET_QUESTION(self, subject_id=None, chapters=None, difficulty_level=None, questions_count=None):
+        return self.dataFromAPI(Endpoints.GET_QUESTIONS_EP(subject_id=subject_id, chapters=chapters, difficulty_level=difficulty_level, questions_count=questions_count))

beta/shellLogic/Plugin.py

@@ -0,0 +1,80 @@
+import shutil
+import re
+from beta.shellLogic import simpleParser
+
+class Plugin:
+    """
+    Base class for handling commands.
+    Automatically registers commands added via `add_command`.
+    """
+
+    global_command_list = {}  # Global registry for all commands
+
+    def __init__(self):
+        self.commandList = {}
+        self.register_commands()
+
+    def register_commands(self):
+        """
+        Registers commands from the subclass into the global command list.
+        """
+        for name, info in self.commandList.items():
+            Plugin.global_command_list[name] = {
+                "desc": info["desc"],
+                "regex": info["regex"],
+                "func": info["func"]
+            }
+
+    def parseAndRun(self, command, args=[]):
+        """
+        Parses and executes the given command if found in the global list.
+        """
+        if command not in Plugin.global_command_list:
+            print(f"Command '{command}' not found.")
+            return
+        simpleParser.parseAndRun(Plugin.global_command_list, command, args)
+
+    def add_command(self, name, desc, regex, func):
+        """
+        Adds a new command to the local command list.
+        """
+        self.commandList[name] = {
+            "desc": desc,
+            "regex": regex,
+            "func": func
+        }
+
+    def get_help(self, command=""):
+        terminal_width = shutil.get_terminal_size().columns
+        help_text = "Available commands:\n"
+        separator = '-' * terminal_width + '\n'
+
+        if command:
+            if command not in Plugin.global_command_list:
+                return f"Command '{command}' not found."
+            return f"{command}: {Plugin.global_command_list[command]['desc']}"
+
+        help_text += separator
+        max_command_length = max(len(cmd) for cmd in Plugin.global_command_list) if Plugin.global_command_list else 0
+        padding = max_command_length + 4
+
+        for cmd, info in Plugin.global_command_list.items():
+            help_text += f"{cmd.ljust(padding)}: {info['desc']}\n"
+
+        help_text += separator
+        return help_text
+
+    def help(self, command=""):
+        """
+        Displays help text for a command or all commands.
+        """
+        print(self.get_help(command))
+
+    def match_command(self, command):
+        """
+        Matches a command using regex patterns from the global command list.
+        """
+        for key, info in Plugin.global_command_list.items():
+            if re.match(info["regex"], command):
+                return key
+        return None

beta/shellLogic/TokenUpdate.py

@@ -0,0 +1,34 @@
+from mainLogic.utils.glv import Global
+from mainLogic.utils.glv_var import PREFS_FILE, debugger
+from beta.update import UpdateJSONFile
+class TokenUpdate:
+
+    def __init__(self):
+
+        self.file_path = PREFS_FILE
+        # hard coding 'defaults.json' as to ../../defaults.json
+        #debugger.error("Warning! This is a beta feature. Use at your own risk.")
+        #debugger.error("Hard Coded to use 'defaults.json' as to ../../defaults.json (in Global.PREFERENCES_FILE)")
+        self.commandList = {
+            "tkn-up":{
+                "func": self.update
+            }
+        }
+
+    def update(self,args=[]):
+        if args:
+            u = UpdateJSONFile(self.file_path)
+            u.update('token',args[0])
+            debugger.success("Token updated successfully.")
+        else:
+            debugger.error("Please provide a token to update.")
+
+    def parseAndRun(self,command,args=[]):
+        # simpleParser.parseAndRun(self.commandList, command, args)
+        if command in self.commandList:
+            self.commandList[command]["func"](args)
+        else:
+            debugger.error("Command not found.")
+
+
+

beta/shellLogic/handleLogics/HandleBasicCMDUtils.py

@@ -0,0 +1,51 @@
+import sys
+
+from beta.shellLogic.Plugin import Plugin
+from mainLogic.utils.os2 import SysFunc
+
+os2 = SysFunc()
+
+class HandleBasicCMDUtils(Plugin):
+    def __init__(self):
+        super().__init__()
+        self.commandList = {
+            "cls": {
+                "desc": "Clear the screen",
+                "regex": r"cls",
+                "func": self.cls
+            },
+            "cd": {
+                "desc": "Change directory",
+                "regex": r"cd",
+                "func": self.cd
+            },
+            "cmd": {
+                "desc": "Run a command",
+                "regex": r"cmd",
+                "func": self.cmd
+            },
+            "exit": {
+                "desc": "Exit the shell",
+                "regex": r"exit",
+                "func": self.exit_shell
+            }
+        }
+        self.register_commands()
+
+    def cls(self, args=[]):
+        os2.clear()
+        if args:
+            print(args)
+
+    def exit_shell(self, args=[]):
+        sys.exit(0)
+
+    def cd(self, args=[]):
+        if args:
+            os2.cd(args[0])
+        else:
+            os2.cd()
+
+    def cmd(self, args=[]):
+        import os
+        os.system(" ".join(args))

beta/shellLogic/handleLogics/HandleBatch.py

@@ -0,0 +1,177 @@
+import argparse
+from beta.obsolete.batch_scraper.app import BatchAPI
+from beta.shellLogic.Plugin import Plugin
+from mainLogic.utils.dependency_checker import re_check_dependencies
+from mainLogic.utils.glv_var import debugger
+
+
+class HandleBatch(Plugin):
+    def __init__(self):
+        super().__init__()
+        self.add_command("bgen", "Generate entire batch data", "--generate", self.generate)
+        self.register_commands()
+
+    def generate(self, args):
+        parser = argparse.ArgumentParser(description="Generate batch data")
+        parser.add_argument("--khazana", "-K", type=str, default="")
+        parser.add_argument("--batch-slug", "-B", type=str, default="")
+        parser.add_argument("--subject-slug", "-S", type=str, default="")
+        parser.add_argument("--chapter-slug", "-C", type=str, default="")
+        parser.add_argument("--export", "-E", type=str, default="")
+        parser.add_argument("--simple", action="store_true", default=False)
+        parser.add_argument("--recursive", action="store_true", default=False)
+
+        opts = parser.parse_args(args)
+
+        state, prefs = re_check_dependencies(reload=True)
+        token = prefs['token']
+
+
+        def to_csv_str(data: list):
+            headers = data[0].keys()
+            rows = [list(item.values()) for item in data]
+            output = []
+            output.append(','.join(headers))
+            for row in rows:
+                output.append(','.join(map(str, row)))
+            return '\n'.join(output)
+
+
+        def get_khazana_data(khazana_name):
+            api = BatchAPI(khazana_name, token, force=False, verbose=False)
+            res = api.GET_KHAZANA_SUBJECTS()
+            if not res:
+                debugger.error(f"Batch {khazana_name} not found.")
+                return
+            else:
+                debugger.info(f"Batch {khazana_name} found.")
+                debugger.info(f"Batch data:\n{to_csv_str(res)}")
+                return res
+
+
+
+
+
+        # TO NOTE
+        # In khazana flow, we use GET_KHAZANA_BATCHES when we actually want to get SUBJECTS
+        # PREVIOUSLY we called them BATCHES as each khazana is a super class of subjects with batches inside of each subject
+
+
+
+
+
+        # SUPER SUBJECT is a collection of teachers teaching the smae subject in different batches
+        # data inside super subject
+        def KHAZANA_GET_SUPER_SUBJECT_DATA(khazana_name, super_subject_name):
+            api = BatchAPI(khazana_name, token, force=False, verbose=False)
+
+            res = api.GET_KHAZANA_BATCHES(super_subject_name)
+
+            # if super subject doe snot exixst
+            if not res:
+                debugger.error(f"Super subject {super_subject_name} not found.")
+                return
+            else:
+                debugger.info(f"Super subject {super_subject_name} found.")
+                debugger.success(f"Super subject data:\n{to_csv_str(res)}")
+                return res
+
+        def KHAZANA_SUPER_SUBJECT_BATCH_DATA(khazana_name, super_subject_name, batch_name):
+            api = BatchAPI(khazana_name, token, force=False, verbose=False)
+
+
+
+            res = api.GET_KHAZANA_CHAPTERS(batch_name)
+
+            # if batch does not exist
+            if not res:
+                debugger.error(f"Batch {batch_name} not found.")
+                return
+            else:
+                debugger.info(f"Batch {batch_name} found.")
+                debugger.success(f"Batch data:\n{to_csv_str(res)}")
+                return res
+
+        def KHAZANA_BATCH_CHAPTER_DATA(khazana_name, super_subject_name, batch_name, chapter_name):
+            api = BatchAPI(khazana_name, token, force=False, verbose=False)
+
+            res = api.GET_KHAZANA_LECTURES(batch_name, chapter_name, chapter_name)
+
+            # if chapter does not exist
+            if not res:
+                debugger.error(f"Chapter {chapter_name} not found.")
+                return
+            else:
+                debugger.info(f"Chapter {chapter_name} found.")
+                debugger.success(f"Chapter data:\n{to_csv_str(res)}")
+                return res
+
+        # khazana flow
+        """
+        #   khazana[batch] ---> super-subject[batch] ---> batch ---> chapter ---> lectures 
+        """
+
+        if opts.khazana:
+            api = BatchAPI(opts.khazana, token, force=False, verbose=False)
+
+
+            if opts.khazana and opts.batch_slug and opts.subject_slug and opts.chapter_slug:
+                # khazana[batch] ---> super-subject[batch] ---> batch ---> chapter ---> lectures
+                debugger.info(f"Generating data for khazana: {opts.khazana}, super_subject: {opts.batch_slug}, batch: {opts.subject_slug}, chapter: {opts.chapter_slug}")
+                chapter = KHAZANA_BATCH_CHAPTER_DATA(opts.khazana, opts.batch_slug, opts.subject_slug, opts.chapter_slug)
+
+                if not chapter:
+                    debugger.error(f"Chapter {opts.chapter_slug} not found.")
+                    return
+                else:
+                    debugger.info(f"Chapter data:\n{to_csv_str(chapter)}")
+                    return chapter
+
+            if opts.batch_slug and opts.subject_slug:
+                batch = KHAZANA_SUPER_SUBJECT_BATCH_DATA(opts.khazana, opts.batch_slug, opts.subject_slug)
+
+                if not batch:
+                    debugger.error(f"Batch {opts.subject_slug} not found.")
+                    return
+                else:
+                    debugger.info(f"Batch data:\n{to_csv_str(batch)}")
+                    return batch
+
+
+            if opts.batch_slug:
+                # Batch slug is actually used here for super subject
+                # khazana[batch] ---> super-subject[batch]
+
+                debugger.info(f"Generating data for super_subject: {opts.batch_slug}")
+                super_subject = KHAZANA_GET_SUPER_SUBJECT_DATA(opts.khazana, opts.batch_slug)
+
+                if not super_subject:
+                    debugger.error(f"Super subject {opts.batch_slug} not found.")
+                    return
+                else:
+                    debugger.info(f"Super subject data:\n{to_csv_str(super_subject)}")
+                    return super_subject
+
+
+
+
+
+
+
+
+
+
+            debugger.info(f"Generating super-subjects for khazana batch: {opts.khazana}")
+            super_subjects = api.GET_KHAZANA_SUBJECTS()
+            debugger.info(f"Got this data for super-subjects for khazana batch: {opts.khazana}")
+            debugger.success(f"{to_csv_str(super_subjects)}")
+
+
+
+
+        else:
+            # normal flow
+            api = BatchAPI(opts.batch_slug, token, force=False, verbose=False)
+
+
+

beta/shellLogic/handleLogics/HandleHell.py

@@ -0,0 +1,12 @@
+from beta.shellLogic.Plugin import Plugin
+
+
+class HandleHell(Plugin):
+
+    def __init__(self):
+        super().__init__()
+        self.add_command("hell", "Hell with World!", r'hell', self.hell)
+        self.register_commands()
+
+    def hell(self, args):
+        print("Hell with World! ", args)

beta/shellLogic/handleLogics/HandleKeyAndAvailiblity.py

@@ -0,0 +1,42 @@
+from beta.shellLogic.Plugin import Plugin
+from mainLogic.big4.Ravenclaw_decrypt.key import LicenseKeyFetcher
+from mainLogic.utils import glv_var
+from mainLogic.startup.checkup import CheckState
+
+class HandleKeyAndAvailability(Plugin):
+    def __init__(self):
+        super().__init__()
+        ch = CheckState()
+        self.prefs = ch.checkup(glv_var.EXECUTABLES, verbose=False)['prefs']
+        self.token = self.prefs['token']
+        self.random_id = self.prefs['random_id']
+        self.lkf = LicenseKeyFetcher(self.token, self.random_id)
+        self.commandList = {
+            "get_key": {
+                "desc": "Retrieve a license key",
+                "regex": r"(get_key|key)",
+                "func": self.get_key,
+            },
+            "check": {
+                "desc": "Check availability of the license key",
+                "regex": r"check",
+                "func": self.check
+            }
+        }
+        self.register_commands()
+
+    def get_key(self, args=[]):
+        if args:
+            self.lkf.get_key(args[0])
+        else:
+            print("Please provide a key to get")
+
+    def check(self, args=[]):
+        print("Checking the availability of the key...")
+        if args:
+            if self.lkf.get_key(args[0], verbose=False):
+                print("Key is available")
+            else:
+                print("Key is not available")
+        else:
+            print("Please provide a key to check")

beta/shellLogic/handleLogics/HandleQuestions.py

@@ -0,0 +1,117 @@
+import json
+from urllib.parse import unquote
+
+from jinja2.utils import url_quote
+from tabulate import tabulate
+from bs4 import BeautifulSoup  # Import BeautifulSoup for basic HTML parsing
+
+from beta.question_scraper.app import QuestionsAPI
+from beta.shellLogic.Plugin import Plugin
+from mainLogic.utils.dependency_checker import re_check_dependencies
+from mainLogic.utils.glv import Global
+
+import textwrap
+
+
+def wrap_text(text, width=50):
+    return '\n'.join(textwrap.wrap(text, width))
+
+
+def parse_html(html_content):
+    """Parse basic HTML content to plain text."""
+    soup = BeautifulSoup(html_content, 'html.parser')
+    return soup.get_text(separator='\n')  # Separate elements by newline
+
+
+class HandleQuestions(Plugin):
+
+    def __init__(self):
+        super().__init__()
+        self.add_command("ques", "Get questions from the API", r'ques', self.ques)
+        self.register_commands()
+
+    def ques(self, args):
+
+        import argparse
+        parser = argparse.ArgumentParser(description='Get questions from the API')
+        parser.add_argument('-B', '--batch', help='Batch ID', required=False)
+        parser.add_argument('-S', '--subject', help='Subject ID', required=False)
+        parser.add_argument('-C', '--chapter', help='Chapter ID', required=False)
+
+        args = parser.parse_args(args)
+
+        if args.batch:
+            batch_id = args.batch
+        else:
+            batch_id = None
+
+        if args.subject:
+            subject_id = args.subject
+        else:
+            subject_id = None
+
+        if args.chapter:
+            chapter_id = args.chapter
+        else:
+            chapter_id = None
+
+        state, prefs = re_check_dependencies()
+
+        token = prefs['token']
+        random_id = prefs['random_id']
+
+        qApi = QuestionsAPI(token, random_id, force=False, verbose=False)
+
+        # Get the questions
+        subjects_dat = qApi.GET_SUBJECTS()
+
+        p_Dat = []
+        headers = ['Subject Name', 'Subject ID']
+
+        for subject in subjects_dat['subjects']:
+            p_Dat.append([subject['englishName'], subject['subjectId']])
+
+        Global.hr()
+        debugger.success(f"Exams: {subjects_dat['exams']}")
+        debugger.success(f"ExamCategorie: {subjects_dat['examCategory']}")
+        Global.hr()
+
+        if not subject_id:
+            print(tabulate(p_Dat, headers=headers, tablefmt='grid'))
+
+        if subject_id and not chapter_id:
+            debugger.success(f"Getting chapters for subject {subject_id}")
+            chapters_dat = qApi.GET_CHAPTERS(subject_id=subject_id)
+
+            headers = ['Chapter Name', 'Chapter ID', 'Class ID', 'Easy', 'Medium', 'Hard']
+
+            s_dat = []
+            for chapter in chapters_dat:
+                s_dat.append(
+                    [chapter['englishName'], chapter['chapterId'], chapter['classId'], chapter['questionCountEasy'],
+                     chapter['questionCountMedium'], chapter['questionCountHard']])
+
+            Global.hr()
+            print(tabulate(s_dat, headers=headers, tablefmt='grid'))
+            Global.hr()
+
+        if chapter_id and subject_id:
+            debugger.success(f"Getting questions for subject {subject_id} and chapter {chapter_id}")
+            questions_dat = qApi.GET_QUESTION(subject_id=subject_id, chapters=[
+                {'chapterId': chapter_id, 'classId': 'oyhh7ve8217so92jw81tefbyp'}], difficulty_level=[3],
+                                              questions_count=90)
+
+            headers = ['Question ID', 'Question Text', 'Contents', 'Options', 'Type']
+
+            s_dat = []
+            for question in questions_dat['questions']:
+                question_text = wrap_text(parse_html(str(question['plainQuestionText'])), 50)
+                options_text = "\n".join([wrap_text(parse_html(f"* {option['text']}"), 80) for option in question['options']])
+                contents = wrap_text(parse_html(str(question['content'])), 50) if 'content' in question else ''
+                s_dat.append(
+                    [question['questionId'], unquote(question_text), unquote(contents), unquote(options_text), question['type']]
+                )
+
+            Global.hr()
+            print(tabulate(s_dat, headers=headers, tablefmt='grid'))
+            Global.hr()

beta/shellLogic/handleLogics/HandleShellDL.py

@@ -0,0 +1,74 @@
+from beta.shellLogic.Plugin import Plugin
+from mainLogic.big4.Ravenclaw_decrypt.key import LicenseKeyFetcher
+from mainLogic.big4.obsolete.Obsolete_Gryffindor_downloadv2 import Download
+from mainLogic.startup.checkup import CheckState
+from mainLogic.utils import glv_var
+from mainLogic import downloader
+
+
+class HandleShellDL(Plugin):
+    def __init__(self):
+        super().__init__()
+        self.commandList = {
+            "edl": {
+                "desc": "Enhanced download with name and ID",
+                "regex": r"edl",
+                "func": self.edownload
+            },
+            "dl": {
+                "desc": "Download with name and ID",
+                "regex": r"dl",
+                "func": self.download
+            }
+        }
+        self.register_commands()
+
+    def edownload(self, args=[]):
+        """
+        Performs an enhanced download using the provided name and ID.
+        """
+        if not args or len(args) < 2:
+            print("Please provide a name and id")
+            return
+
+        name = args[0]
+        id = args[1]
+
+        ch = CheckState()
+        state = ch.checkup(glv_var.EXECUTABLES, verbose=False)
+        prefs = state['prefs']
+
+        token = prefs['token']
+        random_id = prefs['random_id']
+
+        fetcher = LicenseKeyFetcher(token, random_id)
+        fetcher.get_key(id)
+
+        url = fetcher.url
+        cookies = fetcher.cookies
+
+
+        Download(
+            vsd_path=prefs['vsd'],
+            url=url,
+            name=name,
+            cookie=cookies,
+            tmp_path=prefs['tmpDir'],
+            output_path=prefs['dir'],
+        ).download()
+
+    def download(self, args=[]):
+        """
+        Performs a basic download using the provided name and ID.
+        """
+        if not args or len(args) < 2:
+            print("Please provide a name and id")
+            return
+
+        name = args[0]
+        id = args[1]
+
+        downloader.main(
+            id=id,
+            name=name,
+        )

beta/shellLogic/handleLogics/HandleWEB.py

@@ -0,0 +1,14 @@
+from beta.shellLogic.Plugin import Plugin
+
+
+class HandleWEB(Plugin):
+
+    def __init__(self):
+        super().__init__()
+        self.add_command("web", "Open the web interface", "web", self.web)
+        self.register_commands()
+
+
+    def web(self, args):
+        # Open the web interface
+        print("Opening the web interface...")

beta/shellLogic/logic.py

@@ -0,0 +1,25 @@
+from beta.shellLogic.Plugin import Plugin
+from beta.shellLogic.TokenUpdate import TokenUpdate
+from beta.shellLogic.handleLogics.HandleBasicCMDUtils import HandleBasicCMDUtils
+from beta.shellLogic.handleLogics.HandleBatch import KhazanaHandler
+from beta.shellLogic.handleLogics.HandleHell import HandleHell
+from beta.shellLogic.handleLogics.HandleKeyAndAvailiblity import HandleKeyAndAvailability
+#from beta.shellLogic.handleLogics.HandleQuestions import HandleQuestions
+from beta.shellLogic.handleLogics.HandleShellDL import HandleShellDL
+from beta.shellLogic.handleLogics.HandleWEB import HandleWEB
+
+# Instantiate the command handlers (automatically registers commands)
+basic_cmd_utils = HandleBasicCMDUtils()
+key_utils = HandleKeyAndAvailability()
+dl_utils = HandleShellDL()
+token_update = TokenUpdate()
+k_batch = KhazanaHandler()
+webui = HandleWEB()
+#ques = HandleQuestions()
+hell = HandleHell()
+
+def execute_help(command, args=[]):
+    Plugin().help(command)
+
+def execute(command, args=[]):
+    Plugin().parseAndRun(command, args)

beta/shellLogic/logicError.py

@@ -0,0 +1,6 @@
+class commandNotFound(Exception):
+    def __init__(self, command):
+        self.command = command
+
+    def __str__(self):
+        return f"Command '{self.command}' not found"

beta/shellLogic/shell.py

@@ -0,0 +1,76 @@
+from prompt_toolkit import PromptSession
+from mainLogic.utils.glv import Global
+from mainLogic.startup.checkup import CheckState
+import json
+
+from mainLogic.utils.glv_var import EXECUTABLES
+
+
+
+from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.completion.filesystem import PathCompleter
+from prompt_toolkit.document import Document
+
+class CustomCompleter(Completer):
+    def __init__(self):
+        self.file_completer = PathCompleter()
+
+    def get_completions(self, document: Document, complete_event):
+        text = document.text_before_cursor
+        if text.startswith('cd '):
+            for completion in self.file_completer.get_completions(document, complete_event):
+                yield completion
+
+def main(command_list=[]):
+    # Initialize Prompt Toolkit session
+    session = PromptSession()
+
+    # Perform checkup and get preferences
+    # Hardcoded verbose to False
+    state = CheckState().checkup(EXECUTABLES, './', verbose=False)
+    prefs = state['prefs']
+
+    # Convert preferences to JSON string for display
+    prefs_json = json.dumps(prefs, indent=4)
+
+    # Add a custom completer
+    custom_completer = CustomCompleter()
+
+    from beta.shellLogic import logic
+
+    if command_list:
+        if len(command_list) == 1:
+            command = command_list[0]
+            args = []
+        else:
+            command = command_list[0]
+            args = command_list[1:]
+
+        logic.execute(command, args)
+
+
+    # Command-line interface loop
+    while True:
+        try:
+            user_input = session.prompt('|pwdl> ', completer=custom_completer)
+
+            # just in case the user hits enter without typing anything
+            if not user_input: continue
+
+            command = user_input.split()[0]
+            args = user_input.split()[1:]
+            if not args: args = []
+
+            # check if first arg is /? or -h or --help
+            if args and args[0] in ['/?', '-h', '--help']:
+                logic.execute_help(command)
+            else:
+                logic.execute(command, args)
+
+        except KeyboardInterrupt:
+            continue
+        except EOFError:
+            break
+
+if __name__ == "__main__":
+    main()

beta/shellLogic/shell_var.py

@@ -0,0 +1,57 @@
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.layout import Window, Layout
+from prompt_toolkit import Application
+from prompt_toolkit.buffer import Buffer
+from prompt_toolkit.layout.controls import BufferControl
+from prompt_toolkit.layout.processors import Processor, BeforeInput
+
+from beta.shellLogic.Plugin import Plugin
+from beta.shellLogic.handleLogics.HandleWEB import HandleWEB
+from beta.shellLogic.handleLogics.HandleBatch import HandleBatch
+from beta.shellLogic.logic import batch
+
+# Initialize the plugin and add commands
+plugin = HandleWEB()
+batch_h = HandleBatch()
+
+prompt = "|pwdl> "
+
+
+def on_input_processed(buffer):
+    if buffer.text.endswith("\n"):
+        command = buffer.text.strip()
+        if command:
+            command = command.split()[0]
+            args = command.split()[1:]
+            if not args:
+                args = []
+            Plugin().parseAndRun(command, args)
+
+
+
+
+
+
+
+input_buffer = Buffer(on_text_insert=on_input_processed)
+control = BufferControl(buffer=input_buffer,input_processors=[BeforeInput(lambda: prompt)])
+
+
+
+kb = KeyBindings()
+
+@kb.add('c-q')
+def exit_(event):
+    event.app.exit()
+
+app = Application(
+    key_bindings=kb,
+    layout=Layout(
+        Window(
+            content=control,
+        )),
+    full_screen=True
+)
+
+if __name__ == "__main__":
+    app.run()

beta/shellLogic/simpleParser.py

@@ -0,0 +1,6 @@
+def parseAndRun(commandlist,command,args=[],obj=None):
+    if command in commandlist: func = commandlist[command]["func"]
+
+    if not func: return
+
+    func(args)

beta/update.py

@@ -0,0 +1,38 @@
+import json
+
+from mainLogic.utils.glv_var import debugger
+
+
+class UpdateJSONFile:
+    def __init__(self, file_path, debug=False):
+        self.file_path = file_path
+        self.data = None
+        self.load()
+
+        if debug:
+            debugger.info(f"Debug Mode: Loaded data from {file_path}")
+            debugger.warning(f"Debug Mode: Data: {self.data}")
+
+    def load(self):
+        with open(self.file_path, 'r') as file:
+            self.data = json.load(file)
+
+    def save(self):
+        with open(self.file_path, 'w+') as file:
+            file.write(json.dumps(self.data, indent=4))
+
+        # manually check if the file is saved correctly
+        with open(self.file_path, 'r') as file:
+            saved_data = json.load(file)
+            if saved_data != self.data:
+                debugger.error("Error: Data not saved correctly.")
+            else:
+                debugger.info("Data saved correctly.")
+
+    def update(self, key, value, debug=False):
+
+        if debug:
+            print(f"Debug Mode: Updating {key} to {value}")
+
+        self.data[key] = value
+        self.save()

beta/util.py

@@ -0,0 +1,30 @@
+import json
+import re
+
+def extract_uuid(text):
+  """
+  Extracts UUIDs from a string using a regular expression.
+
+  Args:
+      text: The string to search for UUIDs.
+
+  Returns:
+      A list of extracted UUIDs, or an empty list if none are found.
+  """
+  pattern = r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}"
+  matches = re.findall(pattern, text)
+  return matches
+
+def generate_safe_file_name(name):
+    """
+    Generates a safe file name by replacing spaces with underscores and removing special characters.
+
+    Args:
+        name: The original name to be converted.
+
+    Returns:
+        A string that is a safe file name.
+    """
+    # Replace spaces with underscores and remove special characters
+    safe_name = re.sub(r'[^\w\s-]', '', name).strip().replace(' ', '_')
+    return safe_name

defaults.json

@@ -0,0 +1,89 @@
+{
+    "cloudfront_id": "d1d34p8vz63oiq",
+    "patched": false,
+    "user_id": "rumouroid",
+    "user_update_index": 10,
+    "os-info": "linux",
+    "tmpDir": "/tmp",
+    "verbose": false,
+    "vsd": "$script/bin/vsd",
+    "ffmpeg": "",
+    "mp4decrypt": "$script/bin/mp4decrypt",
+    "webui-del-time": 45,
+    "webui": true,
+    "webui-port": "5000",
+    "token": {
+        "access_token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJleHAiOjE3NDk5MjUwNzYuNTQsImRhdGEiOnsiX2lkIjoiNjQzMTc1NDI0MGU5NzkwMDE4MDAyMDJiIiwidXNlcm5hbWUiOiI5NDcyNTA3MTAwIiwiZmlyc3ROYW1lIjoiQWtzaGl0IFNodWJoYW0iLCJsYXN0TmFtZSI6IiIsIm9yZ2FuaXphdGlvbiI6eyJfaWQiOiI1ZWIzOTNlZTk1ZmFiNzQ2OGE3OWQxODkiLCJ3ZWJzaXRlIjoicGh5c2ljc3dhbGxhaC5jb20iLCJuYW1lIjoiUGh5c2ljc3dhbGxhaCJ9LCJlbWFpbCI6ImFrc2hpdHNodWJoYW1tYXNAZ21haWwuY29tIiwicm9sZXMiOlsiNWIyN2JkOTY1ODQyZjk1MGE3NzhjNmVmIl0sImNvdW50cnlHcm91cCI6IklOIiwidHlwZSI6IlVTRVIifSwiaWF0IjoxNzQ5MzIwMjc2fQ.lAO_e1nmZJFrsxng92AxhHIKXXvzTZ02uAviST5J6jA",
+        "refresh_token": "c6e85e3952dc358537be22669e5c46cb1463c071dc85cb9b99a0c1e4d895d82f",
+        "expires_in": 1749925076540,
+        "tokenId": "684482547cd974e07b99536b",
+        "user": {
+            "status": "Active",
+            "id": "6431754240e979001800202b",
+            "firstName": "Akshit Shubham",
+            "lastName": "",
+            "primaryNumber": "9472507100",
+            "countryCode": "+91",
+            "countryGroup": "IN",
+            "username": "9472507100",
+            "uniqueCode": "9472EYDU",
+            "email": "[email protected]",
+            "isVerifiedEmail": false,
+            "created": "2023-04-08T14:08:02.575Z",
+            "createdAt": "2023-04-08T14:08:02.575Z",
+            "profileId": {
+                "exams": [
+                    "NEET"
+                ],
+                "_id": "6431754240e979001800202d",
+                "created": "2023-04-08T14:08:02.590Z",
+                "createdAt": "2023-04-08T14:08:02.590Z",
+                "class": "11",
+                "programId": "60910f9463f1f5004815a4c0",
+                "wallet": 0,
+                "totalRewards": 0,
+                "coins": {
+                    "bankTransferCoins": 0,
+                    "voucherCoins": 0,
+                    "commonCoins": 0,
+                    "walletCoins": 0,
+                    "totalCoins": 0,
+                    "redeemedCoins": 0
+                },
+                "parentDetails": {},
+                "isProfileCompleted": true,
+                "children": [],
+                "cohortId": "634fd1c40c274c00183c7579",
+                "needCohortUpdate": false,
+                "cohortUpdatedAt": "2023-04-15T09:28:16.616Z"
+            },
+            "dateOfBirth": null,
+            "phones": [],
+            "address": null,
+            "primary": null,
+            "organization": {
+                "_id": "5eb393ee95fab7468a79d189",
+                "status": "Active",
+                "usersCount": 0,
+                "name": "Physicswallah",
+                "website": "physicswallah.com",
+                "createdAt": "2020-05-07T04:51:58.030Z",
+                "updatedAt": "2020-05-07T04:51:58.030Z",
+                "phones": [],
+                "rejectionComments": [],
+                "enrolmentType": "Client",
+                "primaryContact": "5eb393ee95fab7468a79d18b"
+            },
+            "roles": [
+                {
+                    "id": "5b27bd965842f950a778c6ef",
+                    "name": "Student"
+                }
+            ],
+            "androidVersion": 165,
+            "iosVersion": 0,
+            "webVersion": 1925,
+            "isScholar": false
+        }
+    }
+}