Upload folder using huggingface_hub

.gitattributes

@@ -1,5 +1,5 @@
-# Auto detect text files and perform LF normalization
-* text=auto
+# Auto detect text files and perform LF normalization
+* text=auto
 bin/mp4decrypt filter=lfs diff=lfs merge=lfs -text
 bin/nm3 filter=lfs diff=lfs merge=lfs -text
 bin/nm3.exe filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1,190 +1,190 @@
-# 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
+# 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

Dockerfile

@@ -1,34 +1,34 @@
-# 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
-
-# Add the current directory contents into the container at /app
-ADD . /app
-
-# Install ffmpeg
-RUN apt-get update && apt-get install -y ffmpeg
-
-# Create a virtual environment and activate it
-RUN python -m venv /opt/venv
-
-# Ensure the virtual environment is used
-ENV PATH="/opt/venv/bin:$PATH"
-
-# Install any needed packages specified in requirements.txt
-RUN pip install --no-cache-dir -r requirements.txt
-
-# Make port 7680 available to the world outside this container
-EXPOSE 7680
-
-COPY ./defaults.linux.json ./defaults.json
-RUN chmod +x ./bin/*
-
-RUN chmod +x ./setup.sh
-RUN ./setup.sh
-
-RUN mkdir webdl
-
-# Run gunicorn when the container launches
-CMD ["gunicorn", "-b", "0.0.0.0:7680", "beta.api.api:app"]
+# 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
+
+# Add the current directory contents into the container at /app
+ADD . /app
+
+# Install ffmpeg
+RUN apt-get update && apt-get install -y ffmpeg
+
+# Create a virtual environment and activate it
+RUN python -m venv /opt/venv
+
+# Ensure the virtual environment is used
+ENV PATH="/opt/venv/bin:$PATH"
+
+# Install any needed packages specified in requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Make port 7680 available to the world outside this container
+EXPOSE 7680
+
+COPY ./defaults.linux.json ./defaults.json
+RUN chmod +x ./bin/*
+
+RUN chmod +x ./setup.sh
+RUN ./setup.sh
+
+RUN mkdir webdl
+
+# Run gunicorn when the container launches
+CMD ["nohup","gunicorn", "-b", "0.0.0.0:7680", "beta.api.api:app", "&"]

README.md

@@ -1,102 +1,102 @@
----
-title: pwdlAPIv1
-emoji: 💻🐳
-colorFrom: gray
-colorTo: green
-sdk: docker
-pinned: false
-suggested_storage: small
-license: mit
----
-# PhysicsWallah M3u8 Parser
-
-This is a Python script that parses M3u8 files. It uses the argparse library to handle command-line arguments.
-
-## Dependencies
-
-The script requires the following executables to be available in the PATH or the user should provide the path to the executables:
-
-- [ffmpeg](https://ffmpeg.org/download.html)
-- [mp4decrypt](https://www.bento4.com/downloads/)
-- [nm3](https://github.com/nilaoda/N_m3u8DL-RE) (renamed to nm3 in the script)
-
-The script also requires the following Python libraries (which are listed in the `requirements.txt` file
-
-
-- `requests`: A library for making HTTP requests. It abstracts the complexities of making requests behind a simple API, allowing you to send HTTP/1.1 requests.
-
-- `colorama`: Makes ANSI escape character sequences work on Windows and Unix systems, allowing colored terminal text and cursor positioning.
-
-- `argparse`: Provides a way to specify command line arguments and options the program is supposed to accept.
-
-- `bs4` (BeautifulSoup4): A library for pulling data out of HTML and XML files. It provides Pythonic idioms for iterating, searching, and modifying the parse tree.
-
-- `flask`: A micro web framework written in Python. It does not require particular tools or libraries, it has no database abstraction layer, form validation, or any other components where pre-existing third-party libraries provide common functions.
-
-- `flask_socketio`: Gives Flask applications access to low latency bi-directional communications between the clients and the server. The client-side application can use any of the Socket.IO official clients libraries in Javascript, C++, Java and Swift, or any compatible client to establish a permanent connection to the server.
-
-To install these dependencies, you would typically run `pip install -r requirements.txt` in your command line.
-
-or if you want to install them individually, you can run the following commands:
-
-`pip install requests colorama argparse bs4 flask flask_socketio`
-
-## Usage
-
-You can use the script with the following command-line arguments:
-
-- `--csv-file`: Input csv file. Legacy Support too.
-- `--id`: PhysicsWallh Video Id for single usage. Incompatible with --csv-file. Must be used with --name.
-- `--name`: Name for the output file. Incompatible with --csv-file. Must be used with --url.
-- `--dir`: Output Directory.
-- `--verbose`: Verbose Output.
-- `--version`: Shows the version of the program.
-- `--simulate`: Simulate the download process. No files will be downloaded.
-
-## Example
-
-```bash
-python pwdl.py --csv-file input.csv --dir ./output --verbose
-```
-
-This will parse the M3u8 files listed in `input.csv` and save the output in the `./output` directory. The `--verbose` flag is used to enable verbose output.
-
-## Error Handling
-
-The script has built-in error handling. If an error occurs during the parsing of a file, the script will print an error message and continue with the next file. If both csv file and id (or name) is provided, the script will exit with error code 3.
-
-## User Preferences
-
-User preferences can be loaded from a `defaults.json` file. These preferences include the temporary directory (`tmpDir`), verbosity of output (`verbose`), and whether to display a horizontal rule (`hr`). If these preferences are not set in the `defaults.json` file, the script will use default values.
-
-## Simulation Mode
-
-The script includes a simulation mode, which can be enabled with the `--simulate` flag. In this mode, the script will print the files that would be processed, but no files will be downloaded.
-
-## Shell Mode
-
-Still in beta
-
-## Error Codes
-
-
-| Error Name                       | Error Code | Error Message                                         |
-|----------------------------------|------------|-------------------------------------------------------|
-| noError                          | 0          | None                                                  |
-| defaultsNotFound                 | 1          | defaults.json not found. Exiting...                   |
-| dependencyNotFound               | 2          | Dependency not found. Exiting...                      |
-| dependencyNotFoundInPrefs        | 3          | Dependency not found in default settings. Exiting...  |
-| csvFileNotFound                  | 4          | CSV file {fileName} not found. Exiting...             |
-| downloadFailed                   | 5          | Download failed for {name} with id {id}. Exiting...   |
-| cantLoadFile                     | 22         | Can't load file {fileName}                            |
-| requestFailedDueToUnknownReason  | 24         | Request failed due to unknown reason. Status Code: {status_code} |
-| keyExtractionFailed              | 25         | Key extraction failed for id -> {id}. Exiting...      |
-| keyNotProvided                   | 26         | Key not provided. Exiting...                          |
-| couldNotDownloadAudio            | 27         | Could not download audio for id -> {id} Exiting...    |
-| couldNotDownloadVideo            | 28         | Could not download video for {id} Exiting...          |
-| couldNotDecryptAudio             | 29         | Could not decrypt audio. Exiting...                   |
-| couldNotDecryptVideo             | 30         | Could not decrypt video. Exiting...                   |
-| methodPatched                    | 31         | Method is patched. Exiting...                         |
-| couldNotExtractKey               | 32         | Could not extract key. Exiting...                     |
-
+---
+title: pwdlAPIv1
+emoji: 💻🐳
+colorFrom: gray
+colorTo: green
+sdk: docker
+pinned: false
+suggested_storage: small
+license: mit
+---
+# PhysicsWallah M3u8 Parser
+
+This is a Python script that parses M3u8 files. It uses the argparse library to handle command-line arguments.
+
+## Dependencies
+
+The script requires the following executables to be available in the PATH or the user should provide the path to the executables:
+
+- [ffmpeg](https://ffmpeg.org/download.html)
+- [mp4decrypt](https://www.bento4.com/downloads/)
+- [nm3](https://github.com/nilaoda/N_m3u8DL-RE) (renamed to nm3 in the script)
+
+The script also requires the following Python libraries (which are listed in the `requirements.txt` file
+
+
+- `requests`: A library for making HTTP requests. It abstracts the complexities of making requests behind a simple API, allowing you to send HTTP/1.1 requests.
+
+- `colorama`: Makes ANSI escape character sequences work on Windows and Unix systems, allowing colored terminal text and cursor positioning.
+
+- `argparse`: Provides a way to specify command line arguments and options the program is supposed to accept.
+
+- `bs4` (BeautifulSoup4): A library for pulling data out of HTML and XML files. It provides Pythonic idioms for iterating, searching, and modifying the parse tree.
+
+- `flask`: A micro web framework written in Python. It does not require particular tools or libraries, it has no database abstraction layer, form validation, or any other components where pre-existing third-party libraries provide common functions.
+
+- `flask_socketio`: Gives Flask applications access to low latency bi-directional communications between the clients and the server. The client-side application can use any of the Socket.IO official clients libraries in Javascript, C++, Java and Swift, or any compatible client to establish a permanent connection to the server.
+
+To install these dependencies, you would typically run `pip install -r requirements.txt` in your command line.
+
+or if you want to install them individually, you can run the following commands:
+
+`pip install requests colorama argparse bs4 flask flask_socketio`
+
+## Usage
+
+You can use the script with the following command-line arguments:
+
+- `--csv-file`: Input csv file. Legacy Support too.
+- `--id`: PhysicsWallh Video Id for single usage. Incompatible with --csv-file. Must be used with --name.
+- `--name`: Name for the output file. Incompatible with --csv-file. Must be used with --url.
+- `--dir`: Output Directory.
+- `--verbose`: Verbose Output.
+- `--version`: Shows the version of the program.
+- `--simulate`: Simulate the download process. No files will be downloaded.
+
+## Example
+
+```bash
+python pwdl.py --csv-file input.csv --dir ./output --verbose
+```
+
+This will parse the M3u8 files listed in `input.csv` and save the output in the `./output` directory. The `--verbose` flag is used to enable verbose output.
+
+## Error Handling
+
+The script has built-in error handling. If an error occurs during the parsing of a file, the script will print an error message and continue with the next file. If both csv file and id (or name) is provided, the script will exit with error code 3.
+
+## User Preferences
+
+User preferences can be loaded from a `defaults.json` file. These preferences include the temporary directory (`tmpDir`), verbosity of output (`verbose`), and whether to display a horizontal rule (`hr`). If these preferences are not set in the `defaults.json` file, the script will use default values.
+
+## Simulation Mode
+
+The script includes a simulation mode, which can be enabled with the `--simulate` flag. In this mode, the script will print the files that would be processed, but no files will be downloaded.
+
+## Shell Mode
+
+Still in beta
+
+## Error Codes
+
+
+| Error Name                       | Error Code | Error Message                                         |
+|----------------------------------|------------|-------------------------------------------------------|
+| noError                          | 0          | None                                                  |
+| defaultsNotFound                 | 1          | defaults.json not found. Exiting...                   |
+| dependencyNotFound               | 2          | Dependency not found. Exiting...                      |
+| dependencyNotFoundInPrefs        | 3          | Dependency not found in default settings. Exiting...  |
+| csvFileNotFound                  | 4          | CSV file {fileName} not found. Exiting...             |
+| downloadFailed                   | 5          | Download failed for {name} with id {id}. Exiting...   |
+| cantLoadFile                     | 22         | Can't load file {fileName}                            |
+| requestFailedDueToUnknownReason  | 24         | Request failed due to unknown reason. Status Code: {status_code} |
+| keyExtractionFailed              | 25         | Key extraction failed for id -> {id}. Exiting...      |
+| keyNotProvided                   | 26         | Key not provided. Exiting...                          |
+| couldNotDownloadAudio            | 27         | Could not download audio for id -> {id} Exiting...    |
+| couldNotDownloadVideo            | 28         | Could not download video for {id} Exiting...          |
+| couldNotDecryptAudio             | 29         | Could not decrypt audio. Exiting...                   |
+| couldNotDecryptVideo             | 30         | Could not decrypt video. Exiting...                   |
+| methodPatched                    | 31         | Method is patched. Exiting...                         |
+| couldNotExtractKey               | 32         | Could not extract key. Exiting...                     |
+
 Please note that the `{fileName}`, `{name}`, `{id}`, and `{status_code}` in the Error Message column are placeholders and will be replaced with actual values when the error occurs.

beta/api/api.py

@@ -1,68 +1,68 @@
-import os
-import time
-from flask import Flask, jsonify, request, send_from_directory, send_file
-from beta.api.task_manager import TaskManager  # Assuming the TaskManager class is in task_manager.py
-from mainLogic.main import Main
-from mainLogic.startup.checkup import CheckState
-from mainLogic.utils.glv import Global
-from mainLogic.utils.basicUtils import BasicUtils
-
-app = Flask(__name__)
-task_manager = TaskManager()
-
-OUT_DIR = Global.api_webdl_directory
-
-try:
-    if not os.path.exists(OUT_DIR): os.makedirs(OUT_DIR)
-except Exception as e:
-    Global.errprint(f"Could not create output directory {OUT_DIR}")
-    Global.sprint(f"Defaulting to './' ")
-    Global.errprint(f"Error: {e}")
-    OUT_DIR = './'
-
-def setup_directory():
-    pass
-def download_pw_video(task_id, id, name, out_dir, progress_callback):
-
-    print(f"Downloading {name} with id {id} to {out_dir}")
-
-    ch = CheckState()
-    prefs = ch.checkup(Global.EXECUTABLES, directory="./", verbose=True)
-    nm3 = prefs['nm3']
-    ffmpeg = prefs['ffmpeg']
-    mp4d = prefs['mp4decrypt']
-    verbose = True
-    Main(id=id, name=f"{name}-{task_id}", directory=out_dir, tmpDir="/*auto*/", nm3Path=nm3, ffmpeg=ffmpeg, mp4d=mp4d, verbose=verbose, progress_callback=progress_callback).process()
-
-
-@app.route('/create_task', methods=['POST'])
-def create_task():
-    data = request.json
-    id = data.get('id')
-    name = data.get('name')
-
-    if not id or not name:
-        return jsonify({'error': 'id and name are required'}), 400
-
-    task_id = task_manager.create_task(download_pw_video, id, name, OUT_DIR)
-    return jsonify({'task_id': task_id}), 202
-
-@app.route('/progress/<task_id>', methods=['GET'])
-def get_progress(task_id):
-    progress = task_manager.get_progress(task_id)
-    return jsonify(progress), 200
-
-@app.route('/get-file/<task_id>/<name>', methods=['GET'])
-def get_file(task_id,name):
-    file = BasicUtils.abspath(f"{OUT_DIR}/{name}-{task_id}.mp4")
-    if not os.path.exists(file):
-        return jsonify({'error': 'file not found'}), 404
-    return send_file( f"{file}", as_attachment=True), 200
-
-
-@app.route('/', methods=['GET'])
-def index():
-    return jsonify({'message': 'Hello, World!'}), 200
-
-# if __name__ == '__main__':
-#     app.run(debug=True)
+import os
+import time
+from flask import Flask, jsonify, request, send_from_directory, send_file
+from beta.api.task_manager import TaskManager  # Assuming the TaskManager class is in task_manager.py
+from mainLogic.main import Main
+from mainLogic.startup.checkup import CheckState
+from mainLogic.utils.glv import Global
+from mainLogic.utils.basicUtils import BasicUtils
+
+app = Flask(__name__)
+task_manager = TaskManager()
+
+OUT_DIR = Global.api_webdl_directory
+
+try:
+    if not os.path.exists(OUT_DIR): os.makedirs(OUT_DIR)
+except Exception as e:
+    Global.errprint(f"Could not create output directory {OUT_DIR}")
+    Global.sprint(f"Defaulting to './' ")
+    Global.errprint(f"Error: {e}")
+    OUT_DIR = './'
+
+def setup_directory():
+    pass
+def download_pw_video(task_id, id, name, out_dir, progress_callback):
+
+    print(f"Downloading {name} with id {id} to {out_dir}")
+
+    ch = CheckState()
+    prefs = ch.checkup(Global.EXECUTABLES, directory="./", verbose=True)
+    nm3 = prefs['nm3']
+    ffmpeg = prefs['ffmpeg']
+    mp4d = prefs['mp4decrypt']
+    verbose = True
+    Main(id=id, name=f"{name}-{task_id}", directory=out_dir, tmpDir="/*auto*/", nm3Path=nm3, ffmpeg=ffmpeg, mp4d=mp4d, verbose=verbose, progress_callback=progress_callback).process()
+
+
+@app.route('/create_task', methods=['POST'])
+def create_task():
+    data = request.json
+    id = data.get('id')
+    name = data.get('name')
+
+    if not id or not name:
+        return jsonify({'error': 'id and name are required'}), 400
+
+    task_id = task_manager.create_task(download_pw_video, id, name, OUT_DIR)
+    return jsonify({'task_id': task_id}), 202
+
+@app.route('/progress/<task_id>', methods=['GET'])
+def get_progress(task_id):
+    progress = task_manager.get_progress(task_id)
+    return jsonify(progress), 200
+
+@app.route('/get-file/<task_id>/<name>', methods=['GET'])
+def get_file(task_id,name):
+    file = BasicUtils.abspath(f"{OUT_DIR}/{name}-{task_id}.mp4")
+    if not os.path.exists(file):
+        return jsonify({'error': 'file not found'}), 404
+    return send_file( f"{file}", as_attachment=True), 200
+
+
+@app.route('/', methods=['GET'])
+def index():
+    return jsonify({'message': 'Hello, World!'}), 200
+
+# if __name__ == '__main__':
+#     app.run(debug=True)

beta/api/task_manager.py

@@ -1,42 +1,42 @@
-import threading
-import time
-import uuid
-
-class TaskManager:
-
-    def handle_completion (self, task_id):
-        print(f"Task {task_id} completed")
-        self.tasks[task_id]['status'] = 'completed'
-
-    on_task_complete = handle_completion
-
-    def __init__(self):
-        self.tasks = {}
-        self.lock = threading.Lock()
-
-    def create_task(self, target, *args):
-        task_id = str(uuid.uuid4())
-        thread = threading.Thread(target=self._run_task, args=(task_id, target, *args))
-        with self.lock:
-            self.tasks[task_id] = {'progress': "0", 'status': 'running'}
-        thread.start()
-        return task_id
-
-    def _run_task(self, task_id, target, *args):
-        try:
-            target(task_id,*args, progress_callback=lambda progress: self._update_progress(task_id, progress))
-            with self.lock:
-                self.tasks[task_id]['status'] = 'completed'
-        except Exception as e:
-            with self.lock:
-                self.tasks[task_id]['status'] = 'failed'
-                self.tasks[task_id]['error'] = str(e)
-
-    def _update_progress(self, task_id, progress):
-        with self.lock:
-            if task_id in self.tasks:
-                self.tasks[task_id]['progress'] = progress
-
-    def get_progress(self, task_id):
-        with self.lock:
-            return self.tasks.get(task_id, {'status': 'not found'})
+import threading
+import time
+import uuid
+
+class TaskManager:
+
+    def handle_completion (self, task_id):
+        print(f"Task {task_id} completed")
+        self.tasks[task_id]['status'] = 'completed'
+
+    on_task_complete = handle_completion
+
+    def __init__(self):
+        self.tasks = {}
+        self.lock = threading.Lock()
+
+    def create_task(self, target, *args):
+        task_id = str(uuid.uuid4())
+        thread = threading.Thread(target=self._run_task, args=(task_id, target, *args))
+        with self.lock:
+            self.tasks[task_id] = {'progress': "0", 'status': 'running'}
+        thread.start()
+        return task_id
+
+    def _run_task(self, task_id, target, *args):
+        try:
+            target(task_id,*args, progress_callback=lambda progress: self._update_progress(task_id, progress))
+            with self.lock:
+                self.tasks[task_id]['status'] = 'completed'
+        except Exception as e:
+            with self.lock:
+                self.tasks[task_id]['status'] = 'failed'
+                self.tasks[task_id]['error'] = str(e)
+
+    def _update_progress(self, task_id, progress):
+        with self.lock:
+            if task_id in self.tasks:
+                self.tasks[task_id]['progress'] = progress
+
+    def get_progress(self, task_id):
+        with self.lock:
+            return self.tasks.get(task_id, {'status': 'not found'})

beta/shellLogic/HandleBasicCMDUtils.py

@@ -1,41 +1,41 @@
-import sys
-from beta.shellLogic import simpleParser
-from mainLogic.utils.os2 import SysFunc
-
-os2 = SysFunc()
-
-
-class HandleBasicCMDUtils:
-    # basic class for handling basic commands
-    # every such class must have a method to parse command (regex based) a help for each command handled by the class
-
-    def __init__(self):
-        self.commandList = {
-            "cls":
-                {
-                    "desc": "Clear the screen",
-                    "regex": r"cls",
-                    "func": self.cls
-                },
-            "exit":
-                {
-                    "desc": "Exit the shell",
-                    "regex": r"exit",
-                    "func": self.exit_shell
-                },
-        }
-
-    def cls(self,args=[]):
-        os2.clear()
-        if args: print(args)
-
-    def exit_shell(self,args=[]):
-        sys.exit(10)
-
-    def parseAndRun(self, command,args=[]):
-        # for key in self.commandList:
-        #     if re.match(self.commandList[key]["regex"], command):
-        #         self.commandList[key]["func"]()
-        #         return
-        # raise logicError.commandNotFound(command)
-        simpleParser.parseAndRun(self.commandList, command, args)
+import sys
+from beta.shellLogic import simpleParser
+from mainLogic.utils.os2 import SysFunc
+
+os2 = SysFunc()
+
+
+class HandleBasicCMDUtils:
+    # basic class for handling basic commands
+    # every such class must have a method to parse command (regex based) a help for each command handled by the class
+
+    def __init__(self):
+        self.commandList = {
+            "cls":
+                {
+                    "desc": "Clear the screen",
+                    "regex": r"cls",
+                    "func": self.cls
+                },
+            "exit":
+                {
+                    "desc": "Exit the shell",
+                    "regex": r"exit",
+                    "func": self.exit_shell
+                },
+        }
+
+    def cls(self,args=[]):
+        os2.clear()
+        if args: print(args)
+
+    def exit_shell(self,args=[]):
+        sys.exit(10)
+
+    def parseAndRun(self, command,args=[]):
+        # for key in self.commandList:
+        #     if re.match(self.commandList[key]["regex"], command):
+        #         self.commandList[key]["func"]()
+        #         return
+        # raise logicError.commandNotFound(command)
+        simpleParser.parseAndRun(self.commandList, command, args)

beta/shellLogic/HandleKeyAndAvailiblity.py

@@ -1,34 +1,34 @@
-from mainLogic.big4.decrypt.key import getKey
-from beta.shellLogic import simpleParser
-
-
-class HandleKeyAndAvailiblity:
-
-    def __init__(self):
-        self.commandList = {
-            "get_key":{
-                "regex": r"(get_key|key)",
-                "func": self.get_key,
-            },
-            "check":{
-                "func": self.check
-            }
-
-        }
-
-    def get_key(self,args=[]):
-        if args:
-            getKey(args[0])
-
-    def check(self,args=[]):
-        print("Checking the availiblity of the key...")
-        if args:
-            if getKey(args[0],verbose=False):
-                print("Key is available")
-            else:
-                print("Key is not available")
-        else:
-            print("Please provide a key to check")
-
-    def parseAndRun(self,command,args=[]):
-        simpleParser.parseAndRun(self.commandList, command, args)
+from mainLogic.big4.decrypt.key import getKey
+from beta.shellLogic import simpleParser
+
+
+class HandleKeyAndAvailiblity:
+
+    def __init__(self):
+        self.commandList = {
+            "get_key":{
+                "regex": r"(get_key|key)",
+                "func": self.get_key,
+            },
+            "check":{
+                "func": self.check
+            }
+
+        }
+
+    def get_key(self,args=[]):
+        if args:
+            getKey(args[0])
+
+    def check(self,args=[]):
+        print("Checking the availiblity of the key...")
+        if args:
+            if getKey(args[0],verbose=False):
+                print("Key is available")
+            else:
+                print("Key is not available")
+        else:
+            print("Please provide a key to check")
+
+    def parseAndRun(self,command,args=[]):
+        simpleParser.parseAndRun(self.commandList, command, args)

beta/shellLogic/HandleShellDL.py

@@ -1,62 +1,62 @@
-from mainLogic.big4.dl import DL
-from mainLogic.startup.checkup import CheckState
-from mainLogic.utils.glv import Global
-from mainLogic.main import Main
-from beta.shellLogic import simpleParser
-
-
-class HandleShellDL:
-
-    def __init__(self):
-        self.commandList = {
-            "edl":{
-                "func": self.edownload
-            },
-            "dl":{
-                "func": self.download
-            }
-        }
-
-    def edownload(self,args=[]):
-        # print(args)
-        if not args or len(args) < 2:
-            print("Please provide a name and id")
-            return
-
-        name = args[0]
-        id = args[1]
-
-        dl = DL()
-        ch =CheckState()
-        prefs = ch.checkup(Global.EXECUTABLES,verbose=False)
-        dl.downloadAudioAndVideo(name=name,
-                                 id=id,
-                                 directory='./',
-                                 nm3Path=prefs['nm3'],
-                                 verbose=False if not 'verbose' in prefs else prefs['verbose'],
-                                 )
-
-    def download(self,args=[]):
-        if not args or len(args) < 2:
-            print("Please provide a name and id")
-            return
-
-        name = args[0]
-        id = args[1]
-
-        ch = CheckState()
-        prefs = ch.checkup(Global.EXECUTABLES,verbose=False)
-
-        Main(id=id,
-             name=name,
-             directory='./',
-             nm3Path=prefs['nm3'],
-             mp4d=prefs['mp4decrypt'],
-             ffmpeg=prefs['ffmpeg']
-             ).process()
-
-
-
-    def parseAndRun(self,command,args=[]):
-        simpleParser.parseAndRun(self.commandList, command, args)
-
+from mainLogic.big4.dl import DL
+from mainLogic.startup.checkup import CheckState
+from mainLogic.utils.glv import Global
+from mainLogic.main import Main
+from beta.shellLogic import simpleParser
+
+
+class HandleShellDL:
+
+    def __init__(self):
+        self.commandList = {
+            "edl":{
+                "func": self.edownload
+            },
+            "dl":{
+                "func": self.download
+            }
+        }
+
+    def edownload(self,args=[]):
+        # print(args)
+        if not args or len(args) < 2:
+            print("Please provide a name and id")
+            return
+
+        name = args[0]
+        id = args[1]
+
+        dl = DL()
+        ch =CheckState()
+        prefs = ch.checkup(Global.EXECUTABLES,verbose=False)
+        dl.downloadAudioAndVideo(name=name,
+                                 id=id,
+                                 directory='./',
+                                 nm3Path=prefs['nm3'],
+                                 verbose=False if not 'verbose' in prefs else prefs['verbose'],
+                                 )
+
+    def download(self,args=[]):
+        if not args or len(args) < 2:
+            print("Please provide a name and id")
+            return
+
+        name = args[0]
+        id = args[1]
+
+        ch = CheckState()
+        prefs = ch.checkup(Global.EXECUTABLES,verbose=False)
+
+        Main(id=id,
+             name=name,
+             directory='./',
+             nm3Path=prefs['nm3'],
+             mp4d=prefs['mp4decrypt'],
+             ffmpeg=prefs['ffmpeg']
+             ).process()
+
+
+
+    def parseAndRun(self,command,args=[]):
+        simpleParser.parseAndRun(self.commandList, command, args)
+

beta/shellLogic/logic.py

@@ -1,24 +1,24 @@
-from mainLogic.utils.os2 import SysFunc
-from beta.shellLogic.HandleBasicCMDUtils import HandleBasicCMDUtils
-from beta.shellLogic.HandleKeyAndAvailiblity import HandleKeyAndAvailiblity
-from beta.shellLogic.HandleShellDL import HandleShellDL
-
-os2 = SysFunc()
-f1 = HandleBasicCMDUtils()
-key_utils =  HandleKeyAndAvailiblity()
-dl_utils = HandleShellDL()
-
-commands_available={
-    # command: [location_of_function,help_class]
-    "exit": [f1.parseAndRun,""],
-    "cls" : [f1.parseAndRun,""],
-    "get_key":[key_utils.parseAndRun,""],
-    "check": [key_utils.parseAndRun,""],
-    "edl": [dl_utils.parseAndRun,""],
-    "dl":[dl_utils.parseAndRun,""]
-
-}
-
-def execute(command,args=[]):
-    if command in commands_available:
+from mainLogic.utils.os2 import SysFunc
+from beta.shellLogic.HandleBasicCMDUtils import HandleBasicCMDUtils
+from beta.shellLogic.HandleKeyAndAvailiblity import HandleKeyAndAvailiblity
+from beta.shellLogic.HandleShellDL import HandleShellDL
+
+os2 = SysFunc()
+f1 = HandleBasicCMDUtils()
+key_utils =  HandleKeyAndAvailiblity()
+dl_utils = HandleShellDL()
+
+commands_available={
+    # command: [location_of_function,help_class]
+    "exit": [f1.parseAndRun,""],
+    "cls" : [f1.parseAndRun,""],
+    "get_key":[key_utils.parseAndRun,""],
+    "check": [key_utils.parseAndRun,""],
+    "edl": [dl_utils.parseAndRun,""],
+    "dl":[dl_utils.parseAndRun,""]
+
+}
+
+def execute(command,args=[]):
+    if command in commands_available:
         commands_available[command][0](command,args)

beta/shellLogic/logicError.py

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

beta/shellLogic/shell.py

@@ -1,53 +1,53 @@
-from prompt_toolkit import PromptSession
-from mainLogic.utils.glv import Global
-from mainLogic.startup.checkup import CheckState
-import json
-from mainLogic.utils.os2 import SysFunc
-
-glv = Global()
-EXECUTABLES = glv.EXECUTABLES
-os2 = SysFunc()
-
-# Initialize Prompt Toolkit session
-session = PromptSession()
-
-def main():
-    # Perform checkup and get preferences
-    # Hardcoded verbose to False
-    state = CheckState().checkup(EXECUTABLES, False)
-    prefs = state['prefs']
-
-    # Convert preferences to JSON string for display
-    prefs_json = json.dumps(prefs, indent=4)
-
-
-
-    # Define available commands for auto-completion
-    #commands = ['show_prefs', 'exit']
-    #completer = WordCompleter(commands, ignore_case=True)
-
-    from beta.shellLogic import logic
-
-    # Command-line interface loop
-    while True:
-        try:
-            user_input = session.prompt('|pwdl> ',)
-
-            # 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 = []
-
-            logic.execute(command, args)
-
-        except KeyboardInterrupt:
-            continue
-        except EOFError:
-            break
-
-
-
-if __name__ == "__main__":
-    main()
+from prompt_toolkit import PromptSession
+from mainLogic.utils.glv import Global
+from mainLogic.startup.checkup import CheckState
+import json
+from mainLogic.utils.os2 import SysFunc
+
+glv = Global()
+EXECUTABLES = glv.EXECUTABLES
+os2 = SysFunc()
+
+# Initialize Prompt Toolkit session
+session = PromptSession()
+
+def main():
+    # Perform checkup and get preferences
+    # Hardcoded verbose to False
+    state = CheckState().checkup(EXECUTABLES, False)
+    prefs = state['prefs']
+
+    # Convert preferences to JSON string for display
+    prefs_json = json.dumps(prefs, indent=4)
+
+
+
+    # Define available commands for auto-completion
+    #commands = ['show_prefs', 'exit']
+    #completer = WordCompleter(commands, ignore_case=True)
+
+    from beta.shellLogic import logic
+
+    # Command-line interface loop
+    while True:
+        try:
+            user_input = session.prompt('|pwdl> ',)
+
+            # 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 = []
+
+            logic.execute(command, args)
+
+        except KeyboardInterrupt:
+            continue
+        except EOFError:
+            break
+
+
+
+if __name__ == "__main__":
+    main()

beta/shellLogic/simpleParser.py

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

beta/util.py

@@ -1,47 +1,47 @@
-import json
-
-csv_file = input('Enter CSV file:')
-
-json = ''
-
-x = json.loads(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_filename(filename):
-  """
-  Converts a filename to a safe format containing only alphabets, periods (.), and colons (:).
-
-  Args:
-      filename: The original filename to be converted.
-
-  Returns:
-      A safe filename string with only allowed characters.
-  """
-  # Replace all characters except alphabets, periods, and colons with underscores
-  safe_filename = re.sub(r"[^\w\.\:]", "_", filename)
-  return safe_filename
-
-lines = []
-
-for videos in x['data']:
-
-    line = f"{generate_safe_filename(videos['title'])},{extract_uuid(videos['content'][0]['videoUrl'])[0]}"
-    lines.append(line)
-
-with open(csv_file, 'w') as f:
+import json
+
+csv_file = input('Enter CSV file:')
+
+json = ''
+
+x = json.loads(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_filename(filename):
+  """
+  Converts a filename to a safe format containing only alphabets, periods (.), and colons (:).
+
+  Args:
+      filename: The original filename to be converted.
+
+  Returns:
+      A safe filename string with only allowed characters.
+  """
+  # Replace all characters except alphabets, periods, and colons with underscores
+  safe_filename = re.sub(r"[^\w\.\:]", "_", filename)
+  return safe_filename
+
+lines = []
+
+for videos in x['data']:
+
+    line = f"{generate_safe_filename(videos['title'])},{extract_uuid(videos['content'][0]['videoUrl'])[0]}"
+    lines.append(line)
+
+with open(csv_file, 'w') as f:
     f.write('\n'.join(lines))

defaults.json

@@ -1,11 +1,11 @@
-{
-    "cloudfront_id" : "d1d34p8vz63oiq",
-    "patched"       : false,
-    "os-info"       : "winX64",
-    "tmpDir"        : "%temp%" ,
-    "verbose"       : true,
-    "nm3"           :"$script/bin/nm3.exe",
-    "ffmpeg"        :"",
-    "hr"            : true,
-    "mp4decrypt"    :"$script/bin/mp4decrypt.exe"
+{
+    "cloudfront_id" : "d1d34p8vz63oiq",
+    "patched"       : false,
+    "os-info"       : "winX64",
+    "tmpDir"        : "%temp%" ,
+    "verbose"       : true,
+    "nm3"           :"$script/bin/nm3.exe",
+    "ffmpeg"        :"",
+    "hr"            : true,
+    "mp4decrypt"    :"$script/bin/mp4decrypt.exe"
 }

defaults.linux.json

@@ -1,11 +1,11 @@
-{
-    "flare_url"     : "http://localhost:8191/v1",
-    "cloudfront_id" : "d1d34p8vz63oiq",
-    "patched"       : false,
-    "os-info"       : "linux",
-    "tmpDir"        : "/tmp" ,
-    "verbose"       : false,
-    "nm3"           :"$script/bin/nm3",
-    "ffmpeg"        :"",
-    "mp4decrypt"    :"$script/bin/mp4decrypt"
+{
+    "flare_url"     : "http://localhost:8191/v1",
+    "cloudfront_id" : "d1d34p8vz63oiq",
+    "patched"       : false,
+    "os-info"       : "linux",
+    "tmpDir"        : "/tmp" ,
+    "verbose"       : false,
+    "nm3"           :"$script/bin/nm3",
+    "ffmpeg"        :"",
+    "mp4decrypt"    :"$script/bin/mp4decrypt"
 }

mainLogic/big4/cleanup.py

@@ -1,37 +1,37 @@
-import os
-from mainLogic.utils.glv import Global
-class Clean:
-
-    def removeFile(self,file,verbose):
-        try:
-            os.remove(file)
-            if verbose: Global.sprint(f"Removed file: {file}")
-        except:
-            Global.errprint(f"Could not remove file: {file}")
-
-    def remove(self,path,file,verbose=True):
-
-        audio_enc = f"{path}/{file}-enc.m4a" if os.path.exists(f"{path}/{file}-enc.m4a") else f"{path}/{file}-enc.en.m4a"
-        video_enc = f"{path}/{file}-enc.mp4"
-
-        audio = f"{path}/{file}-Audio.mp4"
-        video = f"{path}/{file}-Video.mp4"
-
-        if verbose:
-            Global.hr()
-            Global.dprint("Removing TemporaryDL Files...")
-            Global.hr()
-
-        if verbose: Global.dprint("Removing Audio...")    
-        self.removeFile(audio_enc,verbose)
-
-        if verbose: Global.dprint("Removing Video...")
-        self.removeFile(video_enc,verbose)
-
-        if verbose: Global.dprint("Removing Dncrypted Audio...")
-        self.removeFile(audio,verbose)
-
-        if verbose: Global.dprint("Removing Dncrypted Video...")
-        self.removeFile(video,verbose)
-
-        
+import os
+from mainLogic.utils.glv import Global
+class Clean:
+
+    def removeFile(self,file,verbose):
+        try:
+            os.remove(file)
+            if verbose: Global.sprint(f"Removed file: {file}")
+        except:
+            Global.errprint(f"Could not remove file: {file}")
+
+    def remove(self,path,file,verbose=True):
+
+        audio_enc = f"{path}/{file}-enc.m4a" if os.path.exists(f"{path}/{file}-enc.m4a") else f"{path}/{file}-enc.en.m4a"
+        video_enc = f"{path}/{file}-enc.mp4"
+
+        audio = f"{path}/{file}-Audio.mp4"
+        video = f"{path}/{file}-Video.mp4"
+
+        if verbose:
+            Global.hr()
+            Global.dprint("Removing TemporaryDL Files...")
+            Global.hr()
+
+        if verbose: Global.dprint("Removing Audio...")    
+        self.removeFile(audio_enc,verbose)
+
+        if verbose: Global.dprint("Removing Video...")
+        self.removeFile(video_enc,verbose)
+
+        if verbose: Global.dprint("Removing Dncrypted Audio...")
+        self.removeFile(audio,verbose)
+
+        if verbose: Global.dprint("Removing Dncrypted Video...")
+        self.removeFile(video,verbose)
+
+        

mainLogic/big4/decrypt/decrypt.py

@@ -1,54 +1,54 @@
-from mainLogic.utils.glv import Global
-from mainLogic.utils.process import shell
-from mainLogic.utils.basicUtils import BasicUtils
-from mainLogic import error
-import os
-
-class Decrypt:
-
-    def decrypt(self,path,name,key,mp4d="mp4decrypt",out="None",outfile="",verbose=True,suppress_exit=False):
-        
-        Global.hr()
-
-        # making path absolute if not already absolute
-        path = BasicUtils.abspath(path)
-        Global.dprint(f"Decrypting {out}...")
-
-        # during various tests
-        # it was found that the decrypted audio file is named as <name>.en.m4a 
-        # hence a simple logic to work around this issue is to check if the file exists
-        if not os.path.exists(f'{path}/{name}.m4a') and out == "Audio":
-            name = name + ".en"
-
-        # setting extension based on out
-        # i.e if out is Audio then extension is 'm4a' else 'mp4'
-        extension = "m4a" if out == "Audio" else "mp4"
-
-        decrypt_command = f'{mp4d} --key 1:{key} {path}/{name}.{extension} {path}/{"" if not outfile else outfile+"-" }{out}.mp4'
-
-        if verbose: Global.dprint(f"{out} Decryption Started..."); Global.dprint(f'{decrypt_command}')
-
-        
-
-        # the main part where the decryption happens
-        code = shell(f'{decrypt_command}',stderr="",stdout="")
-
-        # simple check to see if the decryption was successful or not
-        if code == 0:
-            Global.dprint(f"{out} Decrypted Successfully")
-        else:
-
-            # if decryption failed then print error message and exit
-            error.errorList[f"couldNotDecrypt{out}"]["func"]()
-            if not suppress_exit:
-                exit(error.errorList[f"couldNotDecrypt{out}"]["code"])
-
-        
-
-    # decrypts audio
-    def decryptAudio(self,path,name,key,mp4d="mp4decrypt",outfile='None',verbose=True,suppress_exit=False):
-        self.decrypt(path,name,key,mp4d,"Audio",outfile,verbose,suppress_exit=suppress_exit)
-
-    # decrypts video
-    def decryptVideo(self,path,name,key,mp4d="mp4decrypt",outfile='None',verbose=True,suppress_exit=False):
+from mainLogic.utils.glv import Global
+from mainLogic.utils.process import shell
+from mainLogic.utils.basicUtils import BasicUtils
+from mainLogic import error
+import os
+
+class Decrypt:
+
+    def decrypt(self,path,name,key,mp4d="mp4decrypt",out="None",outfile="",verbose=True,suppress_exit=False):
+        
+        Global.hr()
+
+        # making path absolute if not already absolute
+        path = BasicUtils.abspath(path)
+        Global.dprint(f"Decrypting {out}...")
+
+        # during various tests
+        # it was found that the decrypted audio file is named as <name>.en.m4a 
+        # hence a simple logic to work around this issue is to check if the file exists
+        if not os.path.exists(f'{path}/{name}.m4a') and out == "Audio":
+            name = name + ".en"
+
+        # setting extension based on out
+        # i.e if out is Audio then extension is 'm4a' else 'mp4'
+        extension = "m4a" if out == "Audio" else "mp4"
+
+        decrypt_command = f'{mp4d} --key 1:{key} {path}/{name}.{extension} {path}/{"" if not outfile else outfile+"-" }{out}.mp4'
+
+        if verbose: Global.dprint(f"{out} Decryption Started..."); Global.dprint(f'{decrypt_command}')
+
+        
+
+        # the main part where the decryption happens
+        code = shell(f'{decrypt_command}',stderr="",stdout="")
+
+        # simple check to see if the decryption was successful or not
+        if code == 0:
+            Global.dprint(f"{out} Decrypted Successfully")
+        else:
+
+            # if decryption failed then print error message and exit
+            error.errorList[f"couldNotDecrypt{out}"]["func"]()
+            if not suppress_exit:
+                exit(error.errorList[f"couldNotDecrypt{out}"]["code"])
+
+        
+
+    # decrypts audio
+    def decryptAudio(self,path,name,key,mp4d="mp4decrypt",outfile='None',verbose=True,suppress_exit=False):
+        self.decrypt(path,name,key,mp4d,"Audio",outfile,verbose,suppress_exit=suppress_exit)
+
+    # decrypts video
+    def decryptVideo(self,path,name,key,mp4d="mp4decrypt",outfile='None',verbose=True,suppress_exit=False):
         self.decrypt(path,name,key,mp4d,"Video",outfile,verbose,suppress_exit=suppress_exit)

mainLogic/big4/decrypt/key.old.py

@@ -1,86 +1,86 @@
-# import requests
-# import json
-# from bs4 import BeautifulSoup as BS
-# import re
-# from utils.keyUtils import base64_to_hex
-# from utils.glv import Global
-# import error
-#
-#
-# def log_info(id, verbose, attempt=0):
-#     if verbose:
-#         Global.dprint("Starting the script for key extraction" +( f" Retry: {attempt}" if attempt > 0 else ""))
-#         Global.sprint(f'id -> {id}')
-#         Global.sprint("Sending request to the server")
-#         Global.dprint(f"Hardcoded URL: request.get -> http://studyrays.site/drmplayer.php?v=https://d1d34p8vz63oiq"
-#                       f".cloudfront.net/{id}/master.mpd")
-#
-#
-# def send_request(id):
-#     try:
-#
-#         import http.client
-#
-#         conn = http.client.HTTPSConnection("api.scrapingant.com")
-#
-#         conn.request("GET",
-#                      f"/v2/general?url=https%3A%2F%2Fstudyrays.site%2Fdrmplayer.php%3Fv%3Dhttps%3A%2F%2Fd1d34p8vz63oiq.cloudfront.net%2F{id}%2Fmaster.mpd&x-api-key=806b77b95dd643caae01d4e240da9159&proxy_type=residential&proxy_country=IN&browser=false")
-#
-#         res = conn.getresponse()
-#
-#         return res.read()
-#
-#     except requests.exceptions.RequestException as e:
-#         error.errorList["flareNotStarted"]["func"]()
-#         exit(error.errorList["flareNotStarted"]["code"])
-#
-#
-# def parse_response(response):
-#     try:
-#
-#         return response.decode('utf-8')
-#
-#     except (KeyError, json.JSONDecodeError):
-#         error.errorList["requestFailedDueToUnknownReason"]["func"](response.status_code)
-#         exit(error.errorList["requestFailedDueToUnknownReason"]["code"])
-#
-#
-# def extract_key(html):
-#
-#     soup = BS(html, 'html.parser')
-#     scripts = soup.find_all('script')
-#
-#     for script in scripts:
-#         script_content = script.text
-#         if 'const protData' in script_content:
-#             protData_script = script_content
-#             break
-#     else:
-#         return None
-#
-#     pattern = r'const\s+protData\s*=\s*({.*?});'
-#     match = re.search(pattern, protData_script, re.DOTALL)
-#
-#     if match:
-#         protData_content = match.group(1)
-#         keylist = json.loads(protData_content)['org.w3.clearkey']['clearkeys']
-#         for kid in keylist:
-#             return base64_to_hex(keylist[kid])
-#     return None
-#
-# # main function
-# def getKey(id, verbose=True,retries=2):
-#
-#     for attempt in range(retries):
-#         log_info(id, verbose, attempt)
-#
-#         response = send_request(id)
-#         html = parse_response(response)
-#
-#         key = extract_key(html)
-#         if key:
-#             return key
-#         else:
-#             if verbose:
-#                 Global.sprint("protData variable not found in the script. Retrying!")
+# import requests
+# import json
+# from bs4 import BeautifulSoup as BS
+# import re
+# from utils.keyUtils import base64_to_hex
+# from utils.glv import Global
+# import error
+#
+#
+# def log_info(id, verbose, attempt=0):
+#     if verbose:
+#         Global.dprint("Starting the script for key extraction" +( f" Retry: {attempt}" if attempt > 0 else ""))
+#         Global.sprint(f'id -> {id}')
+#         Global.sprint("Sending request to the server")
+#         Global.dprint(f"Hardcoded URL: request.get -> http://studyrays.site/drmplayer.php?v=https://d1d34p8vz63oiq"
+#                       f".cloudfront.net/{id}/master.mpd")
+#
+#
+# def send_request(id):
+#     try:
+#
+#         import http.client
+#
+#         conn = http.client.HTTPSConnection("api.scrapingant.com")
+#
+#         conn.request("GET",
+#                      f"/v2/general?url=https%3A%2F%2Fstudyrays.site%2Fdrmplayer.php%3Fv%3Dhttps%3A%2F%2Fd1d34p8vz63oiq.cloudfront.net%2F{id}%2Fmaster.mpd&x-api-key=806b77b95dd643caae01d4e240da9159&proxy_type=residential&proxy_country=IN&browser=false")
+#
+#         res = conn.getresponse()
+#
+#         return res.read()
+#
+#     except requests.exceptions.RequestException as e:
+#         error.errorList["flareNotStarted"]["func"]()
+#         exit(error.errorList["flareNotStarted"]["code"])
+#
+#
+# def parse_response(response):
+#     try:
+#
+#         return response.decode('utf-8')
+#
+#     except (KeyError, json.JSONDecodeError):
+#         error.errorList["requestFailedDueToUnknownReason"]["func"](response.status_code)
+#         exit(error.errorList["requestFailedDueToUnknownReason"]["code"])
+#
+#
+# def extract_key(html):
+#
+#     soup = BS(html, 'html.parser')
+#     scripts = soup.find_all('script')
+#
+#     for script in scripts:
+#         script_content = script.text
+#         if 'const protData' in script_content:
+#             protData_script = script_content
+#             break
+#     else:
+#         return None
+#
+#     pattern = r'const\s+protData\s*=\s*({.*?});'
+#     match = re.search(pattern, protData_script, re.DOTALL)
+#
+#     if match:
+#         protData_content = match.group(1)
+#         keylist = json.loads(protData_content)['org.w3.clearkey']['clearkeys']
+#         for kid in keylist:
+#             return base64_to_hex(keylist[kid])
+#     return None
+#
+# # main function
+# def getKey(id, verbose=True,retries=2):
+#
+#     for attempt in range(retries):
+#         log_info(id, verbose, attempt)
+#
+#         response = send_request(id)
+#         html = parse_response(response)
+#
+#         key = extract_key(html)
+#         if key:
+#             return key
+#         else:
+#             if verbose:
+#                 Global.sprint("protData variable not found in the script. Retrying!")
 #     return -1

mainLogic/big4/decrypt/key.py

@@ -1,166 +1,166 @@
-import requests
-import re
-import base64
-from mainLogic.big4.dl import DL
-import json
-from mainLogic.utils.glv import Global
-
-TOKEN = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3MTgzMzQ2NjUuMDA3LCJkYXRhIjp7Il9pZCI6IjY0MzE3NTQyNDBlOTc5MDAxODAwMjAyYiIsInVzZXJuYW1lIjoiOTQ3MjUwNzEwMCIsImZpcnN0TmFtZSI6IkFrc2hpdCBTaHViaGFtIiwibGFzdE5hbWUiOiIiLCJvcmdhbml6YXRpb24iOnsiX2lkIjoiNWViMzkzZWU5NWZhYjc0NjhhNzlkMTg5Iiwid2Vic2l0ZSI6InBoeXNpY3N3YWxsYWguY29tIiwibmFtZSI6IlBoeXNpY3N3YWxsYWgifSwiZW1haWwiOiJha3NoaXRzaHViaGFtbWFzQGdtYWlsLmNvbSIsInJvbGVzIjpbIjViMjdiZDk2NTg0MmY5NTBhNzc4YzZlZiJdLCJjb3VudHJ5R3JvdXAiOiJJTiIsInR5cGUiOiJVU0VSIn0sImlhdCI6MTcxNzcyOTg2NX0.1dbIi4bsDfKfyTkBegiS-ComvLXGnI4DmCO3Qc12e8I"
-
-def buildLicenseUrl(encoded_otp_key):
-    return f"https://api.penpencil.co/v1/videos/get-otp?key={encoded_otp_key}&isEncoded=true"
-
-def getHeaders():
-    headers = {
-        "accept": "*/*",
-        "accept-language": "en-US,en;q=0.9,la;q=0.8",
-        "authorization": f"Bearer {TOKEN}",
-        "cache-control": "no-cache",
-        "client-id": "5eb393ee95fab7468a79d189",
-        "client-type": "WEB",
-        "client-version": "200",
-        "content-type": "application/json",
-        "dnt": "1",
-        "origin": "https://www.pw.live",
-        "pragma": "no-cache",
-        "priority": "u=1, i",
-        "randomid": "180ff4c6-9ec3-4329-b1b5-1ad2f6746795",
-        "referer": "https://www.pw.live/",
-        "sec-ch-ua": "\"Google Chrome\";v=\"125\", \"Chromium\";v=\"125\", \"Not.A/Brand\";v=\"24\"",
-        "sec-ch-ua-mobile": "?0",
-        "sec-ch-ua-platform": "\"Windows\"",
-        "sec-fetch-dest": "empty",
-        "sec-fetch-mode": "cors",
-        "sec-fetch-site": "cross-site",
-        "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36"
-    }
-    return headers
-
-# required by xor_encrypt
-def key_char_at(key, i):
-    return ord(key[i % len(key)])
-
-# converts the xor_encrypted data to base64 (xor_encrypt was given TOKEN, kid)
-def b64_encode(data):
-    if not data:
-        return data
-    encoded = base64.b64encode(bytes(data)).decode('utf-8')
-    return encoded
-
-# converts the base64 encoded data to hex
-# the received OTP is base64 encoded, so we need to convert it to hex
-# the otp is nothing but key for decryption
-# key type: clearkeys
-# code copied from 'https://github.com/jarvistuts/Penpencil_Keys/blob/main/penpencil.py'
-# originally by 'https://github.com/ItsVJp'
-#
-def get_key_final(otp: str, token: str) -> str:
-    decoded_bytes = base64.b64decode(otp)
-    length = len(decoded_bytes)
-    decoded_ints = [int(byte) for byte in decoded_bytes]
-
-    result = "".join(
-        chr(
-            decoded_ints[i] ^ ord(token[i % len(token)])
-        )
-        for i in range(length)
-    )
-
-    return result
-
-
-# encrypting algorithm for the kid so that the request to the server remains secure
-def xor_encrypt(token, data):
-    return [ord(c) ^ key_char_at(token, i) for i, c in enumerate(data)]
-
-# custom function to insert zeros in the hex string (as the hex string is completely void of padding)
-# current logic [start_with_ '00' -> add '00' every 2 characters -> end must not contain '00']
-def insert_zeros(hex_string):
-    # Initialize an empty result string
-    result = "00"
-    # Loop through the input string two characters at a time
-    for i in range(0, len(hex_string), 2):
-
-        # Append the current two characters to the result
-        result += hex_string[i:i+2]
-        # If we're not at the end of the string, append "00"
-        if i + 2 < len(hex_string):
-            result += "00"
-    return result
-
-def extract_kid_from_mpd(url):
-    # Fetch the MPD file content
-    response = requests.get(url)
-    response.raise_for_status()  # Check for request errors
-
-    # Extract the content as a string
-    mpd_content = response.text
-
-    # Define the regex pattern to find default_KID
-    pattern = r'default_KID="([0-9a-fA-F-]+)"'
-
-    # Search for the pattern in the MPD content
-    match = re.search(pattern, mpd_content)
-
-    # Return the KID if found, otherwise return None
-    if match:
-        return match.group(1)
-    else:
-        return None
-
-def getKey(id,verbose=True):
-
-    Global.hr();
-
-    if verbose: Global.dprint("Beginning to get the key for the video... & Audio :) ")
-    if verbose: Global.dprint(f"ID: {id}"); Global.dprint("Building the URL to get the key...")
-
-    try:
-        url = DL.buildUrl(id)
-        if verbose: Global.sprint(f"URL: {url}")
-
-        if verbose: Global.dprint("Extracting the KID from the MPD file...")
-        kid = extract_kid_from_mpd(url).replace("-", "")
-        if verbose: Global.sprint(f"KID: {kid}")
-
-        if verbose: Global.dprint("Encrypting the KID to get the key...")
-        otp_key = b64_encode(xor_encrypt(TOKEN, kid))
-        if verbose: Global.sprint(f"OTP Key: {otp_key}")
-
-        if verbose: Global.dprint("Encoding the OTP key to hex...")
-        encoded_otp_key_step1 = otp_key.encode('utf-8').hex()
-        encoded_otp_key = insert_zeros(encoded_otp_key_step1)
-        if verbose: Global.sprint(f"Encoded OTP Key: {encoded_otp_key}")
-
-        if verbose: Global.dprint("Building the license URL...")
-        license_url = buildLicenseUrl(encoded_otp_key)
-        if verbose: Global.sprint(f"License URL: {license_url}")
-
-        if verbose: Global.dprint("Getting the headers...")
-        headers = getHeaders()
-        if verbose: Global.sprint(f"Headers: {json.dumps(headers, indent=4)}")
-
-        if verbose: Global.dprint("Making a request to the server to get the license (key)...")
-        # make a request to the server to get the license(key)
-        response = requests.get(license_url, headers=headers)
-        if verbose: Global.sprint(f"Response: {response}")
-
-        # get the key from the response
-        if response.status_code == 200:
-            if 'data' in response.json():
-                if 'otp' in response.json()['data']:
-                    if verbose: Global.sprint("Key received successfully!")
-                    key = get_key_final(response.json()['data']['otp'], TOKEN)
-                    if verbose: Global.sprint(f"Key: {key}")
-
-                    Global.hr()
-                    return key
-        else:
-            Global.errprint("Could not get the key from the server. Exiting...")
-            return None
-
-    except Exception as e:
-        Global.errprint(f"An error occurred while getting the key: {e}")
-        return None
-
-
+import requests
+import re
+import base64
+from mainLogic.big4.dl import DL
+import json
+from mainLogic.utils.glv import Global
+
+TOKEN = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE3MTgzMzQ2NjUuMDA3LCJkYXRhIjp7Il9pZCI6IjY0MzE3NTQyNDBlOTc5MDAxODAwMjAyYiIsInVzZXJuYW1lIjoiOTQ3MjUwNzEwMCIsImZpcnN0TmFtZSI6IkFrc2hpdCBTaHViaGFtIiwibGFzdE5hbWUiOiIiLCJvcmdhbml6YXRpb24iOnsiX2lkIjoiNWViMzkzZWU5NWZhYjc0NjhhNzlkMTg5Iiwid2Vic2l0ZSI6InBoeXNpY3N3YWxsYWguY29tIiwibmFtZSI6IlBoeXNpY3N3YWxsYWgifSwiZW1haWwiOiJha3NoaXRzaHViaGFtbWFzQGdtYWlsLmNvbSIsInJvbGVzIjpbIjViMjdiZDk2NTg0MmY5NTBhNzc4YzZlZiJdLCJjb3VudHJ5R3JvdXAiOiJJTiIsInR5cGUiOiJVU0VSIn0sImlhdCI6MTcxNzcyOTg2NX0.1dbIi4bsDfKfyTkBegiS-ComvLXGnI4DmCO3Qc12e8I"
+
+def buildLicenseUrl(encoded_otp_key):
+    return f"https://api.penpencil.co/v1/videos/get-otp?key={encoded_otp_key}&isEncoded=true"
+
+def getHeaders():
+    headers = {
+        "accept": "*/*",
+        "accept-language": "en-US,en;q=0.9,la;q=0.8",
+        "authorization": f"Bearer {TOKEN}",
+        "cache-control": "no-cache",
+        "client-id": "5eb393ee95fab7468a79d189",
+        "client-type": "WEB",
+        "client-version": "200",
+        "content-type": "application/json",
+        "dnt": "1",
+        "origin": "https://www.pw.live",
+        "pragma": "no-cache",
+        "priority": "u=1, i",
+        "randomid": "180ff4c6-9ec3-4329-b1b5-1ad2f6746795",
+        "referer": "https://www.pw.live/",
+        "sec-ch-ua": "\"Google Chrome\";v=\"125\", \"Chromium\";v=\"125\", \"Not.A/Brand\";v=\"24\"",
+        "sec-ch-ua-mobile": "?0",
+        "sec-ch-ua-platform": "\"Windows\"",
+        "sec-fetch-dest": "empty",
+        "sec-fetch-mode": "cors",
+        "sec-fetch-site": "cross-site",
+        "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36"
+    }
+    return headers
+
+# required by xor_encrypt
+def key_char_at(key, i):
+    return ord(key[i % len(key)])
+
+# converts the xor_encrypted data to base64 (xor_encrypt was given TOKEN, kid)
+def b64_encode(data):
+    if not data:
+        return data
+    encoded = base64.b64encode(bytes(data)).decode('utf-8')
+    return encoded
+
+# converts the base64 encoded data to hex
+# the received OTP is base64 encoded, so we need to convert it to hex
+# the otp is nothing but key for decryption
+# key type: clearkeys
+# code copied from 'https://github.com/jarvistuts/Penpencil_Keys/blob/main/penpencil.py'
+# originally by 'https://github.com/ItsVJp'
+#
+def get_key_final(otp: str, token: str) -> str:
+    decoded_bytes = base64.b64decode(otp)
+    length = len(decoded_bytes)
+    decoded_ints = [int(byte) for byte in decoded_bytes]
+
+    result = "".join(
+        chr(
+            decoded_ints[i] ^ ord(token[i % len(token)])
+        )
+        for i in range(length)
+    )
+
+    return result
+
+
+# encrypting algorithm for the kid so that the request to the server remains secure
+def xor_encrypt(token, data):
+    return [ord(c) ^ key_char_at(token, i) for i, c in enumerate(data)]
+
+# custom function to insert zeros in the hex string (as the hex string is completely void of padding)
+# current logic [start_with_ '00' -> add '00' every 2 characters -> end must not contain '00']
+def insert_zeros(hex_string):
+    # Initialize an empty result string
+    result = "00"
+    # Loop through the input string two characters at a time
+    for i in range(0, len(hex_string), 2):
+
+        # Append the current two characters to the result
+        result += hex_string[i:i+2]
+        # If we're not at the end of the string, append "00"
+        if i + 2 < len(hex_string):
+            result += "00"
+    return result
+
+def extract_kid_from_mpd(url):
+    # Fetch the MPD file content
+    response = requests.get(url)
+    response.raise_for_status()  # Check for request errors
+
+    # Extract the content as a string
+    mpd_content = response.text
+
+    # Define the regex pattern to find default_KID
+    pattern = r'default_KID="([0-9a-fA-F-]+)"'
+
+    # Search for the pattern in the MPD content
+    match = re.search(pattern, mpd_content)
+
+    # Return the KID if found, otherwise return None
+    if match:
+        return match.group(1)
+    else:
+        return None
+
+def getKey(id,verbose=True):
+
+    Global.hr();
+
+    if verbose: Global.dprint("Beginning to get the key for the video... & Audio :) ")
+    if verbose: Global.dprint(f"ID: {id}"); Global.dprint("Building the URL to get the key...")
+
+    try:
+        url = DL.buildUrl(id)
+        if verbose: Global.sprint(f"URL: {url}")
+
+        if verbose: Global.dprint("Extracting the KID from the MPD file...")
+        kid = extract_kid_from_mpd(url).replace("-", "")
+        if verbose: Global.sprint(f"KID: {kid}")
+
+        if verbose: Global.dprint("Encrypting the KID to get the key...")
+        otp_key = b64_encode(xor_encrypt(TOKEN, kid))
+        if verbose: Global.sprint(f"OTP Key: {otp_key}")
+
+        if verbose: Global.dprint("Encoding the OTP key to hex...")
+        encoded_otp_key_step1 = otp_key.encode('utf-8').hex()
+        encoded_otp_key = insert_zeros(encoded_otp_key_step1)
+        if verbose: Global.sprint(f"Encoded OTP Key: {encoded_otp_key}")
+
+        if verbose: Global.dprint("Building the license URL...")
+        license_url = buildLicenseUrl(encoded_otp_key)
+        if verbose: Global.sprint(f"License URL: {license_url}")
+
+        if verbose: Global.dprint("Getting the headers...")
+        headers = getHeaders()
+        if verbose: Global.sprint(f"Headers: {json.dumps(headers, indent=4)}")
+
+        if verbose: Global.dprint("Making a request to the server to get the license (key)...")
+        # make a request to the server to get the license(key)
+        response = requests.get(license_url, headers=headers)
+        if verbose: Global.sprint(f"Response: {response}")
+
+        # get the key from the response
+        if response.status_code == 200:
+            if 'data' in response.json():
+                if 'otp' in response.json()['data']:
+                    if verbose: Global.sprint("Key received successfully!")
+                    key = get_key_final(response.json()['data']['otp'], TOKEN)
+                    if verbose: Global.sprint(f"Key: {key}")
+
+                    Global.hr()
+                    return key
+        else:
+            Global.errprint("Could not get the key from the server. Exiting...")
+            return None
+
+    except Exception as e:
+        Global.errprint(f"An error occurred while getting the key: {e}")
+        return None
+
+

mainLogic/big4/dl.py

@@ -1,175 +1,175 @@
-import re
-
-from mainLogic import error
-from mainLogic.utils.process import shell
-from mainLogic.utils.glv import Global
-from mainLogic.utils.basicUtils import BasicUtils
-class DL:
-
-    @staticmethod
-    def buildUrl(id):
-        if id == None:
-            error.errorList["idNotProvided"]["func"]()
-            exit(error.errorList["idNotProvided"]["code"])
-
-        return f"https://d1d34p8vz63oiq.cloudfront.net/{id}/master.mpd"
-    
-    def download(self,id,name=None,
-                 type="",
-                 directory="./",
-                 tmpDir="/*auto*/",
-                 nm3Path='nm3',
-                 ffmpeg='ffmpeg',
-                 verbose=True,
-                 progress_callback=None):
-        if id == None:
-            error.errorList["idNotProvided"]["func"]()
-            exit(error.errorList["idNotProvided"]["code"])
-
-        if name == None: name = id
-        
-
-        url = DL.buildUrl(id)
-
-        # setting identifier and filter based on type
-
-        # identifier is used to identify the type of file
-        identifier = "a" if type == "Audio" else "v" if type == "Video" else "av"
-
-        # filter is used to filter the output of the shell command
-        filter = r"^Aud" if type == "Audio" else r"^Vid" 
-
-        # command to download the file
-        command = f'{nm3Path} {url} --save-dir {directory} {"--tmp-dir "+tmpDir if not tmpDir == "/*auto*/" else "" } --save-name {name}  -s{identifier} best'
-        if verbose: Global.sprint(f"Command to download: {command}")
-
-        # Download the audio file using the id
-        code = shell(f'{command}',
-                     filter=filter,
-                     progress_callback=progress_callback,
-                     handleProgress=self.handleDownloadProgress,
-                     )
-
-        if code == 0:
-            return True
-        else:
-            error.errorList[f"couldNotDownload{type}"]["func"]()
-            exit(error.errorList[f"couldNotDownload{type}"]["code"])
-
-    def downloadAudioAndVideo(self,
-                              id,
-                              name=None,
-                              directory="./",
-                              tmpDir="/*auto*/",
-                              nm3Path='nm3',
-                              ffmpeg='ffmpeg',
-                              verbose=True,
-                              progress_callback=None):
-        if id == None:
-            error.errorList["idNotProvided"]["func"]()
-            exit(error.errorList["idNotProvided"]["code"])
-
-        if name == None: name = id; Global.dprint(f"Name not provided, using id as name: {name}")
-
-        # removing limitations of relative path
-        if not tmpDir == "/*auto*/": BasicUtils.abspath(tmpDir)
-        directory = BasicUtils.abspath(directory)
-
-        if verbose:
-            Global.hr()
-            Global.dprint(f"ID: {id}")
-            Global.dprint(f"Name: {name}")
-            Global.dprint(f"Directory: {directory}")
-            Global.dprint(f"TmpDir: {tmpDir}")
-            Global.dprint(f"Nm3Path: {nm3Path}")
-            Global.hr()
-            Global.dprint(f"Starting DL...")
-
-        # section to download audio 
-        Global.hr(); Global.dprint("Downloading Audio..."); Global.hr()
-        self.dlAudio(id,
-                     name,
-                     directory,
-                     tmpDir,
-                     nm3Path,
-                     verbose,
-                     progress_callback=progress_callback)
-
-        # section to download video
-        Global.hr(); Global.dprint("Downloading Video..."); Global.hr()
-        self.dlVideo(id,
-                     name,
-                     directory,
-                     tmpDir,
-                     nm3Path,
-                     verbose,
-                     progress_callback=progress_callback)
-
-        if progress_callback:
-            progress_callback({
-                "progress": 80,
-                "str": "download-completed",
-                "next": "decryption"
-            })
-
-        # return the paths of the downloaded files
-        return [f"{directory}/{name}.mp4",f"{directory}/{name}.m4a"]
-    
-
-
-    
-    def dlAudio(self,id,name=None,directory="./",tmpDir="/*auto*/",nm3Path='nm3',verbose=True,progress_callback=None):
-        self.download(id,
-                      name,
-                      "Audio",
-                      directory,
-                      tmpDir,
-                      nm3Path,
-                      verbose=verbose,
-                      progress_callback=progress_callback)
-        
-    def dlVideo(self,id,name=None,directory="./",tmpDir="/*auto*/",nm3Path='nm3',verbose=True,progress_callback=None):
-        self.download(id,
-                      name,
-                      "Video",
-                      directory,
-                      tmpDir,
-                      nm3Path,
-                      verbose=verbose,
-                      progress_callback=progress_callback)
-        
-
-    def handleDownloadProgress(self,output):
-
-
-        progress = {
-            "str": output,
-            "dl-progress": 0,
-            "progress": 0,
-            "next": "Aud"
-        }
-
-        # formats the output to get the progress
-        pattern = re.compile(r"[0-9][0-9][0-9]?%")
-        progress_percent = pattern.findall(output)
-
-        if progress_percent:
-
-            progress["dl-progress"] = int(progress_percent[0].replace("%",""))
-
-            if "Aud" in output:
-                progress["progress"] = progress["dl-progress"] * 0.4
-                progress["next"] = "Vid"
-
-            if "Vid" in output:
-                progress["progress"] = progress["dl-progress"] * 0.4 + 40
-                progress["next"] = "decryption"
-
-
-        return progress
-
-
-
-
-
-
+import re
+
+from mainLogic import error
+from mainLogic.utils.process import shell
+from mainLogic.utils.glv import Global
+from mainLogic.utils.basicUtils import BasicUtils
+class DL:
+
+    @staticmethod
+    def buildUrl(id):
+        if id == None:
+            error.errorList["idNotProvided"]["func"]()
+            exit(error.errorList["idNotProvided"]["code"])
+
+        return f"https://d1d34p8vz63oiq.cloudfront.net/{id}/master.mpd"
+    
+    def download(self,id,name=None,
+                 type="",
+                 directory="./",
+                 tmpDir="/*auto*/",
+                 nm3Path='nm3',
+                 ffmpeg='ffmpeg',
+                 verbose=True,
+                 progress_callback=None):
+        if id == None:
+            error.errorList["idNotProvided"]["func"]()
+            exit(error.errorList["idNotProvided"]["code"])
+
+        if name == None: name = id
+        
+
+        url = DL.buildUrl(id)
+
+        # setting identifier and filter based on type
+
+        # identifier is used to identify the type of file
+        identifier = "a" if type == "Audio" else "v" if type == "Video" else "av"
+
+        # filter is used to filter the output of the shell command
+        filter = r"^Aud" if type == "Audio" else r"^Vid" 
+
+        # command to download the file
+        command = f'{nm3Path} {url} --save-dir {directory} {"--tmp-dir "+tmpDir if not tmpDir == "/*auto*/" else "" } --save-name {name}  -s{identifier} best'
+        if verbose: Global.sprint(f"Command to download: {command}")
+
+        # Download the audio file using the id
+        code = shell(f'{command}',
+                     filter=filter,
+                     progress_callback=progress_callback,
+                     handleProgress=self.handleDownloadProgress,
+                     )
+
+        if code == 0:
+            return True
+        else:
+            error.errorList[f"couldNotDownload{type}"]["func"]()
+            exit(error.errorList[f"couldNotDownload{type}"]["code"])
+
+    def downloadAudioAndVideo(self,
+                              id,
+                              name=None,
+                              directory="./",
+                              tmpDir="/*auto*/",
+                              nm3Path='nm3',
+                              ffmpeg='ffmpeg',
+                              verbose=True,
+                              progress_callback=None):
+        if id == None:
+            error.errorList["idNotProvided"]["func"]()
+            exit(error.errorList["idNotProvided"]["code"])
+
+        if name == None: name = id; Global.dprint(f"Name not provided, using id as name: {name}")
+
+        # removing limitations of relative path
+        if not tmpDir == "/*auto*/": BasicUtils.abspath(tmpDir)
+        directory = BasicUtils.abspath(directory)
+
+        if verbose:
+            Global.hr()
+            Global.dprint(f"ID: {id}")
+            Global.dprint(f"Name: {name}")
+            Global.dprint(f"Directory: {directory}")
+            Global.dprint(f"TmpDir: {tmpDir}")
+            Global.dprint(f"Nm3Path: {nm3Path}")
+            Global.hr()
+            Global.dprint(f"Starting DL...")
+
+        # section to download audio 
+        Global.hr(); Global.dprint("Downloading Audio..."); Global.hr()
+        self.dlAudio(id,
+                     name,
+                     directory,
+                     tmpDir,
+                     nm3Path,
+                     verbose,
+                     progress_callback=progress_callback)
+
+        # section to download video
+        Global.hr(); Global.dprint("Downloading Video..."); Global.hr()
+        self.dlVideo(id,
+                     name,
+                     directory,
+                     tmpDir,
+                     nm3Path,
+                     verbose,
+                     progress_callback=progress_callback)
+
+        if progress_callback:
+            progress_callback({
+                "progress": 80,
+                "str": "download-completed",
+                "next": "decryption"
+            })
+
+        # return the paths of the downloaded files
+        return [f"{directory}/{name}.mp4",f"{directory}/{name}.m4a"]
+    
+
+
+    
+    def dlAudio(self,id,name=None,directory="./",tmpDir="/*auto*/",nm3Path='nm3',verbose=True,progress_callback=None):
+        self.download(id,
+                      name,
+                      "Audio",
+                      directory,
+                      tmpDir,
+                      nm3Path,
+                      verbose=verbose,
+                      progress_callback=progress_callback)
+        
+    def dlVideo(self,id,name=None,directory="./",tmpDir="/*auto*/",nm3Path='nm3',verbose=True,progress_callback=None):
+        self.download(id,
+                      name,
+                      "Video",
+                      directory,
+                      tmpDir,
+                      nm3Path,
+                      verbose=verbose,
+                      progress_callback=progress_callback)
+        
+
+    def handleDownloadProgress(self,output):
+
+
+        progress = {
+            "str": output,
+            "dl-progress": 0,
+            "progress": 0,
+            "next": "Aud"
+        }
+
+        # formats the output to get the progress
+        pattern = re.compile(r"[0-9][0-9][0-9]?%")
+        progress_percent = pattern.findall(output)
+
+        if progress_percent:
+
+            progress["dl-progress"] = int(progress_percent[0].replace("%",""))
+
+            if "Aud" in output:
+                progress["progress"] = progress["dl-progress"] * 0.4
+                progress["next"] = "Vid"
+
+            if "Vid" in output:
+                progress["progress"] = progress["dl-progress"] * 0.4 + 40
+                progress["next"] = "decryption"
+
+
+        return progress
+
+
+
+
+
+

mainLogic/big4/merge.py

@@ -1,12 +1,12 @@
-from mainLogic.utils.process import shell
-from mainLogic.utils.glv import Global
-class Merge:
-    def ffmpegMerge(self,input1,input2,output,ffmpeg_path="ffmpeg",verbose=False):
-
-
-        if verbose: Global.hr();Global.dprint('Attempting ffmpeg merge')
-        if verbose: Global.dprint(f'{ffmpeg_path} -i {input1} -i {input2} -c copy {output}')
-
-        shell(f'{ffmpeg_path} -i {input1} -i {input2} -c copy {output}',r'^\[out#0\/mp4')
-
+from mainLogic.utils.process import shell
+from mainLogic.utils.glv import Global
+class Merge:
+    def ffmpegMerge(self,input1,input2,output,ffmpeg_path="ffmpeg",verbose=False):
+
+
+        if verbose: Global.hr();Global.dprint('Attempting ffmpeg merge')
+        if verbose: Global.dprint(f'{ffmpeg_path} -i {input1} -i {input2} -c copy {output}')
+
+        shell(f'{ffmpeg_path} -i {input1} -i {input2} -c copy {output}',r'^\[out#0\/mp4')
+
         return output

mainLogic/error.py

@@ -1,78 +1,78 @@
-from mainLogic.utils.glv import Global
-
-errorList = {
-    "noError": {
-        "code": 0,
-        "func": lambda: None,
-    },
-    "defaultsNotFound"  : {
-        "code": 1,
-        "func": lambda: Global.errprint("defaults.json not found. Exiting..."),
-    },
-    "dependencyNotFound": {
-        "code": 2,
-        "func": lambda x=None: Global.errprint(f"{'Dependency' if x == None else x } not found. Exiting..."),
-    },
-    "dependencyNotFoundInPrefs":
-    {
-        "code": 3,
-        "func": lambda x=None: Global.errprint(f"{'Dependency' if x == None else x } not found in default settings. Exiting..."),
-    },
-    "csvFileNotFound": {
-        "code": 4,
-        "func": lambda fileName: Global.errprint(f"CSV file {fileName} not found. Exiting..."),
-    },
-    "downloadFailed": {
-        "code": 5,
-        "func": lambda name, id: Global.errprint(f"Download failed for {name} with id {id}. Exiting..."),
-    },
-    "couldNotMakeDir":{
-        "code": 6,
-        "func": lambda dirName: Global.errprint(f"Could not make directory {dirName}. Exiting..."),
-    },
-    "cantLoadFile": {
-        "code": 22,
-        "func": lambda fileName: Global.errprint(f"Can't load file {fileName}"),
-    },
-    "flareNotStarted": {
-        "code": 23,
-        "func": lambda: Global.errprint("Flare is not started. Start the flare server first.")
-    },
-    "requestFailedDueToUnknownReason": {
-        "code": 24,
-        "func": lambda status_code: Global.errprint("Request failed due to unknown reason. Status Code: " + str(status_code))
-    },
-    "keyExtractionFailed": {
-        "code": 25,
-        "func": lambda id: Global.errprint(f"Key extraction failed for id -> {id}. Exiting...")
-    },
-    "keyNotProvided": {
-        "code": 26,
-        "func": lambda: Global.errprint("Key not provided. Exiting...")
-    },
-    "couldNotDownloadAudio": {
-        "code": 27,
-        "func": lambda id: Global.errprint(f"Could not download audio for id -> {id} Exiting...")
-    },
-    "couldNotDownloadVideo": {
-        "code": 28,
-        "func": lambda: Global.errprint(f"Could not download video for {id} Exiting...")
-    },
-    "couldNotDecryptAudio": {
-        "code": 29,
-        "func": lambda: Global.errprint("Could not decrypt audio. Exiting...")
-    },
-    "couldNotDecryptVideo": {
-        "code": 30,
-        "func": lambda: Global.errprint("Could not decrypt video. Exiting...")
-    },
-    "methodPatched": {
-        "code": 31,
-        "func": lambda: Global.errprint("Method is patched. Exiting...")
-    },
-    "couldNotExtractKey": {
-        "code": 32,
-        "func": lambda: Global.errprint("Could not extract key. Exiting...")
-    },
-}
-
+from mainLogic.utils.glv import Global
+
+errorList = {
+    "noError": {
+        "code": 0,
+        "func": lambda: None,
+    },
+    "defaultsNotFound"  : {
+        "code": 1,
+        "func": lambda: Global.errprint("defaults.json not found. Exiting..."),
+    },
+    "dependencyNotFound": {
+        "code": 2,
+        "func": lambda x=None: Global.errprint(f"{'Dependency' if x == None else x } not found. Exiting..."),
+    },
+    "dependencyNotFoundInPrefs":
+    {
+        "code": 3,
+        "func": lambda x=None: Global.errprint(f"{'Dependency' if x == None else x } not found in default settings. Exiting..."),
+    },
+    "csvFileNotFound": {
+        "code": 4,
+        "func": lambda fileName: Global.errprint(f"CSV file {fileName} not found. Exiting..."),
+    },
+    "downloadFailed": {
+        "code": 5,
+        "func": lambda name, id: Global.errprint(f"Download failed for {name} with id {id}. Exiting..."),
+    },
+    "couldNotMakeDir":{
+        "code": 6,
+        "func": lambda dirName: Global.errprint(f"Could not make directory {dirName}. Exiting..."),
+    },
+    "cantLoadFile": {
+        "code": 22,
+        "func": lambda fileName: Global.errprint(f"Can't load file {fileName}"),
+    },
+    "flareNotStarted": {
+        "code": 23,
+        "func": lambda: Global.errprint("Flare is not started. Start the flare server first.")
+    },
+    "requestFailedDueToUnknownReason": {
+        "code": 24,
+        "func": lambda status_code: Global.errprint("Request failed due to unknown reason. Status Code: " + str(status_code))
+    },
+    "keyExtractionFailed": {
+        "code": 25,
+        "func": lambda id: Global.errprint(f"Key extraction failed for id -> {id}. Exiting...")
+    },
+    "keyNotProvided": {
+        "code": 26,
+        "func": lambda: Global.errprint("Key not provided. Exiting...")
+    },
+    "couldNotDownloadAudio": {
+        "code": 27,
+        "func": lambda id: Global.errprint(f"Could not download audio for id -> {id} Exiting...")
+    },
+    "couldNotDownloadVideo": {
+        "code": 28,
+        "func": lambda: Global.errprint(f"Could not download video for {id} Exiting...")
+    },
+    "couldNotDecryptAudio": {
+        "code": 29,
+        "func": lambda: Global.errprint("Could not decrypt audio. Exiting...")
+    },
+    "couldNotDecryptVideo": {
+        "code": 30,
+        "func": lambda: Global.errprint("Could not decrypt video. Exiting...")
+    },
+    "methodPatched": {
+        "code": 31,
+        "func": lambda: Global.errprint("Method is patched. Exiting...")
+    },
+    "couldNotExtractKey": {
+        "code": 32,
+        "func": lambda: Global.errprint("Could not extract key. Exiting...")
+    },
+}
+

mainLogic/main.py

@@ -1,119 +1,119 @@
-from mainLogic.utils.basicUtils import BasicUtils
-from mainLogic.utils.glv import Global
-from mainLogic.big4.cleanup import Clean
-import os
-
-
-class Main:
-    """
-    Main class to handle the processing of video and audio files including download,
-    decryption, merging, and cleanup.
-
-    Attributes:
-        id (str): Identifier for the process.
-        name (str): Name for the process. Defaults to the value of `id`.
-        directory (str): Directory to store the files. Defaults to "./".
-        tmpDir (str): Temporary directory for intermediate files. Defaults to './tmp/'.
-        nm3Path (str): Path to the NM3 binary. Defaults to 'nm3'.
-        ffmpeg (str): Path to the ffmpeg binary. Defaults to 'ffmpeg'.
-        mp4d (str): Path to the mp4decrypt binary. Defaults to 'mp4decrypt'.
-        flare_url (str): URL for the flare service. Defaults to 'http://localhost:8191/v1'.
-        verbose (bool): Flag for verbose output. Defaults to True.
-        suppress_exit (bool): Flag to suppress exit on error. Defaults to False.
-    """
-
-    def __init__(self, id, name=None, directory="./", tmpDir="/*auto*/", nm3Path='nm3', ffmpeg="ffmpeg",
-                 mp4d="mp4decrypt", verbose=True, suppress_exit=False,progress_callback=None):
-        """
-        Initialize the Main class with the given parameters.
-
-        Args:
-            id (str): Identifier for the process.
-            name (str, optional): Name for the process. Defaults to None.
-            directory (str, optional): Directory to store the files. Defaults to "./".
-            tmpDir (str, optional): Temporary directory for intermediate files. Defaults to '/*auto*/'.
-            nm3Path (str, optional): Path to the NM3 binary. Defaults to 'nm3'.
-            ffmpeg (str, optional): Path to the ffmpeg binary. Defaults to 'ffmpeg'.
-            mp4d (str, optional): Path to the mp4decrypt binary. Defaults to 'mp4decrypt'.
-            # flare_url (str, optional): URL for the flare service. Defaults to 'http://localhost:8191/v1'.
-            verbose (bool, optional): Flag for verbose output. Defaults to True.
-            suppress_exit (bool, optional): Flag to suppress exit on error. Defaults to False.
-            progress_callback (function, optional): Callback function to report progress. Defaults to None.
-        """
-        self.id = id
-        self.name = name if name else id
-        self.directory = directory
-        self.tmpDir = BasicUtils.abspath(tmpDir) if tmpDir != '/*auto*/' else BasicUtils.abspath('./tmp/')
-        # Create tmp directory if it does not exist
-        try:
-            if not os.path.exists(self.tmpDir):
-                os.makedirs(self.tmpDir)
-        except:
-            Global.errprint("Could not create tmp directory")
-            exit(-1)
-        self.nm3Path = BasicUtils.abspath(nm3Path) if nm3Path != 'nm3' else 'nm3'
-        self.ffmpeg = BasicUtils.abspath(ffmpeg) if ffmpeg != 'ffmpeg' else 'ffmpeg'
-        self.mp4d = BasicUtils.abspath(mp4d) if mp4d != 'mp4decrypt' else 'mp4decrypt'
-        self.verbose = verbose
-        self.suppress_exit = suppress_exit
-        self.progress_callback = progress_callback
-
-    def process(self):
-        """
-        Main processing function to handle downloading, decrypting, merging, and cleanup of files.
-        """
-
-        from mainLogic.big4.dl import DL
-        from mainLogic.big4.decrypt import key
-        from mainLogic.big4.decrypt import decrypt
-        from mainLogic.big4 import merge
-
-        if self.verbose:
-            Global.dprint("Starting Main Process... for ID: " + self.id)
-
-        # 1. Downloading Files
-
-        dl = DL()
-        audio, video = dl.downloadAudioAndVideo(self.id, f'{self.name}-enc', self.directory, self.tmpDir, self.nm3Path,
-                                                self.ffmpeg, self.verbose, progress_callback=self.progress_callback)
-
-
-        # 2. Decrypting Files
-
-        Global.sprint("Please wait while we decrypt the files...\nFetching key may take some time.")
-
-        key = key.getKey(self.id, self.verbose)
-
-        decrypt = decrypt.Decrypt()
-
-        decrypt.decryptAudio(self.directory, f'{self.name}-enc', key, mp4d=self.mp4d, outfile=self.name,
-                             verbose=self.verbose, suppress_exit=self.suppress_exit)
-        decrypt.decryptVideo(self.directory, f'{self.name}-enc', key, mp4d=self.mp4d, outfile=self.name,
-                             verbose=self.verbose, suppress_exit=self.suppress_exit)
-
-        # Call the progress callback for decryption completion
-        if self.progress_callback:
-            self.progress_callback({
-                "progress": 90,
-                "str": "decryption-completed",
-                "next": "merging"
-            })
-
-        # 3. Merging Files
-
-        merge = merge.Merge()
-        merge.ffmpegMerge(f"{self.directory}/{self.name}-Video.mp4", f"{self.directory}/{self.name}-Audio.mp4",
-                          f"{self.directory}/{self.name}.mp4", ffmpeg_path=self.ffmpeg, verbose=self.verbose)
-
-        # Call the progress callback for merge completion
-        if self.progress_callback:
-            self.progress_callback({
-                "progress": 100,
-                "str": "merge-completed",
-                "next": "cleanup"
-            })
-
-
-        # 4. Cleanup
-        clean = Clean()
-        clean.remove(self.directory, f'{self.name}', self.verbose)
+from mainLogic.utils.basicUtils import BasicUtils
+from mainLogic.utils.glv import Global
+from mainLogic.big4.cleanup import Clean
+import os
+
+
+class Main:
+    """
+    Main class to handle the processing of video and audio files including download,
+    decryption, merging, and cleanup.
+
+    Attributes:
+        id (str): Identifier for the process.
+        name (str): Name for the process. Defaults to the value of `id`.
+        directory (str): Directory to store the files. Defaults to "./".
+        tmpDir (str): Temporary directory for intermediate files. Defaults to './tmp/'.
+        nm3Path (str): Path to the NM3 binary. Defaults to 'nm3'.
+        ffmpeg (str): Path to the ffmpeg binary. Defaults to 'ffmpeg'.
+        mp4d (str): Path to the mp4decrypt binary. Defaults to 'mp4decrypt'.
+        flare_url (str): URL for the flare service. Defaults to 'http://localhost:8191/v1'.
+        verbose (bool): Flag for verbose output. Defaults to True.
+        suppress_exit (bool): Flag to suppress exit on error. Defaults to False.
+    """
+
+    def __init__(self, id, name=None, directory="./", tmpDir="/*auto*/", nm3Path='nm3', ffmpeg="ffmpeg",
+                 mp4d="mp4decrypt", verbose=True, suppress_exit=False,progress_callback=None):
+        """
+        Initialize the Main class with the given parameters.
+
+        Args:
+            id (str): Identifier for the process.
+            name (str, optional): Name for the process. Defaults to None.
+            directory (str, optional): Directory to store the files. Defaults to "./".
+            tmpDir (str, optional): Temporary directory for intermediate files. Defaults to '/*auto*/'.
+            nm3Path (str, optional): Path to the NM3 binary. Defaults to 'nm3'.
+            ffmpeg (str, optional): Path to the ffmpeg binary. Defaults to 'ffmpeg'.
+            mp4d (str, optional): Path to the mp4decrypt binary. Defaults to 'mp4decrypt'.
+            # flare_url (str, optional): URL for the flare service. Defaults to 'http://localhost:8191/v1'.
+            verbose (bool, optional): Flag for verbose output. Defaults to True.
+            suppress_exit (bool, optional): Flag to suppress exit on error. Defaults to False.
+            progress_callback (function, optional): Callback function to report progress. Defaults to None.
+        """
+        self.id = id
+        self.name = name if name else id
+        self.directory = directory
+        self.tmpDir = BasicUtils.abspath(tmpDir) if tmpDir != '/*auto*/' else BasicUtils.abspath('./tmp/')
+        # Create tmp directory if it does not exist
+        try:
+            if not os.path.exists(self.tmpDir):
+                os.makedirs(self.tmpDir)
+        except:
+            Global.errprint("Could not create tmp directory")
+            exit(-1)
+        self.nm3Path = BasicUtils.abspath(nm3Path) if nm3Path != 'nm3' else 'nm3'
+        self.ffmpeg = BasicUtils.abspath(ffmpeg) if ffmpeg != 'ffmpeg' else 'ffmpeg'
+        self.mp4d = BasicUtils.abspath(mp4d) if mp4d != 'mp4decrypt' else 'mp4decrypt'
+        self.verbose = verbose
+        self.suppress_exit = suppress_exit
+        self.progress_callback = progress_callback
+
+    def process(self):
+        """
+        Main processing function to handle downloading, decrypting, merging, and cleanup of files.
+        """
+
+        from mainLogic.big4.dl import DL
+        from mainLogic.big4.decrypt import key
+        from mainLogic.big4.decrypt import decrypt
+        from mainLogic.big4 import merge
+
+        if self.verbose:
+            Global.dprint("Starting Main Process... for ID: " + self.id)
+
+        # 1. Downloading Files
+
+        dl = DL()
+        audio, video = dl.downloadAudioAndVideo(self.id, f'{self.name}-enc', self.directory, self.tmpDir, self.nm3Path,
+                                                self.ffmpeg, self.verbose, progress_callback=self.progress_callback)
+
+
+        # 2. Decrypting Files
+
+        Global.sprint("Please wait while we decrypt the files...\nFetching key may take some time.")
+
+        key = key.getKey(self.id, self.verbose)
+
+        decrypt = decrypt.Decrypt()
+
+        decrypt.decryptAudio(self.directory, f'{self.name}-enc', key, mp4d=self.mp4d, outfile=self.name,
+                             verbose=self.verbose, suppress_exit=self.suppress_exit)
+        decrypt.decryptVideo(self.directory, f'{self.name}-enc', key, mp4d=self.mp4d, outfile=self.name,
+                             verbose=self.verbose, suppress_exit=self.suppress_exit)
+
+        # Call the progress callback for decryption completion
+        if self.progress_callback:
+            self.progress_callback({
+                "progress": 90,
+                "str": "decryption-completed",
+                "next": "merging"
+            })
+
+        # 3. Merging Files
+
+        merge = merge.Merge()
+        merge.ffmpegMerge(f"{self.directory}/{self.name}-Video.mp4", f"{self.directory}/{self.name}-Audio.mp4",
+                          f"{self.directory}/{self.name}.mp4", ffmpeg_path=self.ffmpeg, verbose=self.verbose)
+
+        # Call the progress callback for merge completion
+        if self.progress_callback:
+            self.progress_callback({
+                "progress": 100,
+                "str": "merge-completed",
+                "next": "cleanup"
+            })
+
+
+        # 4. Cleanup
+        clean = Clean()
+        clean.remove(self.directory, f'{self.name}', self.verbose)

mainLogic/startup/checkup.py

@@ -1,165 +1,165 @@
-from mainLogic import error
-import os
-from mainLogic.utils.os2 import SysFunc
-from mainLogic.utils.glv import Global
-
-class CheckState:
-
-    def __init__(self) -> None:
-        pass
-
-    def post_checkup(self,prefs,verbose=True):
-
-        """
-            Post Checkup Function
-            1. Setting up the tmpDir
-            2. Setting up the output directory
-            3. Setting up the horizontal rule
-        """
-
-        OUT_DIRECTORY = ""
-
-        # setting up prefs
-        if 'tmpDir' in prefs:
-            tmpDir = SysFunc.modify_path(prefs['tmpDir'])
-            if not os.path.exists(tmpDir):
-                try:
-                    os.makedirs(tmpDir)
-                except OSError as exc: # Guard against failure
-                    error.errorList["couldNotMakeDir"]['func'](tmpDir)
-                    Global.errprint("Failed to create TmpDir")
-                    Global.errprint("Falling Back to Default")
-        else:
-            tmpDir = './tmp/'
-
-        # setting up directory for pwdl
-        if "dir" in prefs:
-            try: OUT_DIRECTORY = os.path.abspath(os.path.expandvars(prefs['dir']))
-
-            # if the user provides a non-string value for the directory or dir is not found
-            except TypeError: OUT_DIRECTORY = './'
-
-            # if the directory is not found
-            except Exception as e:
-                Global.errprint(f"Error: {e}")
-                Global.errprint("Falling back to default")
-                OUT_DIRECTORY = './'
-        else:
-            OUT_DIRECTORY = './'
-
-        # setting up hr (horizontal rule)
-        if not 'hr' in prefs:
-            Global.disable_hr = False
-        elif not prefs['hr']:
-            Global.disable_hr = True
-
-        prefs['tmpDir'] = tmpDir
-        prefs['dir'] = OUT_DIRECTORY
-
-
-    def checkup(self,executable,directory="./",verbose=True):
-
-        state = {}
-
-        # set script path to ../startup
-        # this is the path to the folder containing the pwdl.py file
-        # since the checkup.py is in the startup folder, we need to go one level up
-        if verbose: Global.hr();Global.dprint("Setting script path...")
-        if verbose: Global.errprint('Warning! Hard Coded \'$script\' location to checkup.py/../../')
-
-        Global.script_path = os.path.abspath(os.path.join(os.path.dirname(__file__),'../..'))
-        default_json = os.path.join(Global.script_path,'defaults.json')
-
-        # check if defaults.json exists
-        # and if it does, load the preferences
-        if verbose: Global.hr();Global.dprint("Checking for default settings...")
-
-        if verbose: Global.hr();Global.dprint(f"Checking at {default_json}")
-        if verbose: Global.errprint('Warning!\nHard Coded \'defaults.json\' location to $script/default.json ')
-
-        if not os.path.exists(default_json):
-            error.errorList["defaultsNotFound"]["func"]()
-            exit(error.errorList["defaultsNotFound"]["code"])
-
-        if verbose: Global.sprint("Default settings found."); Global.hr()
-        
-        # load the preferences
-        from mainLogic.startup.userPrefs import PreferencesLoader
-        prefs = PreferencesLoader(file_name=default_json,verbose=verbose).prefs
-
-        # check if method is patched (currently via userPrefs.py)
-        if 'patched' in prefs:
-            if prefs['patched']:
-                error.errorList["methodPatched"]["func"]()
-                exit(error.errorList["methodPatched"]["code"])
-
-        # FLare no longer required
-        # if verbose: Global.hr(); Global.dprint("Checking for Flare...")
-        # default url is localhost:8191
-        # however user can change it in the preferences file
-        # if verbose: Global.dprint(f"Checking at {prefs['flare_url'] if 'flare_url' in prefs else 'http://localhost:8191/v1'}")
-        # if not checkFlare(prefs['flare_url'] if 'flare_url' in prefs else 'http://localhost:8191/v1'):
-        #     error.errorList["flareNotStarted"]["func"]()
-        #     exit(error.errorList["flareNotStarted"]["code"])
-        #
-        # if verbose: Global.sprint("Flare is running."); Global.hr()
-
-        os2 = SysFunc()
-
-        found= []
-        notFound = []
-
-        for exe in executable:
-            if verbose: Global.hr(); Global.dprint(f"Checking for {exe}...")
-
-            if os2.which(exe) == 1:
-                if verbose: error.errorList["dependencyNotFound"]["func"](exe)
-                if verbose: print(f"{exe} not found on path! Checking in default settings...")
-
-                # add exe's which are found to the found list
-                found.append(exe)
-                # add exe's which are not found to the notFound list
-                notFound.append(exe)
-
-            else: 
-                if verbose: Global.sprint(f"{exe} found.")
-                state[exe] = exe
-
-        if len(notFound) > 0:
-
-            if verbose: Global.hr();Global.dprint("Following dependencies were not found on path. Checking in default settings...")
-            if verbose: Global.dprint(notFound); Global.hr()
-
-            for exe in notFound:
-
-                if verbose: Global.dprint(f"Checking for {exe} in default settings...")
-
-                if exe in prefs:
-
-                    if verbose: Global.sprint(f"Key for {exe} found in default settings.")
-                    if verbose: Global.sprint(f"Value: {prefs[exe]}")
-                    if verbose: Global.dprint(f"Checking for {exe} at '{prefs[exe].strip()}' ...")
-
-                    if not os.path.exists(prefs[exe].strip()):
-                        Global.errprint(f"{exe} not found at {prefs[exe].strip()}")
-                        error.errorList["dependencyNotFoundInPrefs"]["func"](exe)
-                        exit(error.errorList["dependencyNotFoundInPrefs"]["code"])
-
-                    if verbose: Global.sprint(f"{exe} found at {prefs[exe].strip()}")
-                    state[exe] = prefs[exe].strip()
-
-
-                else:
-                    error.errorList["dependencyNotFoundInPrefs"]["func"](exe)
-                    exit(error.errorList["dependencyNotFoundInPrefs"]["code"])
-                
-                if verbose: Global.hr()
-        
-        state['prefs'] = prefs
-        prefs['dir'] = directory
-        self.post_checkup(prefs,verbose)
-        
-
-        return state
-
-
+from mainLogic import error
+import os
+from mainLogic.utils.os2 import SysFunc
+from mainLogic.utils.glv import Global
+
+class CheckState:
+
+    def __init__(self) -> None:
+        pass
+
+    def post_checkup(self,prefs,verbose=True):
+
+        """
+            Post Checkup Function
+            1. Setting up the tmpDir
+            2. Setting up the output directory
+            3. Setting up the horizontal rule
+        """
+
+        OUT_DIRECTORY = ""
+
+        # setting up prefs
+        if 'tmpDir' in prefs:
+            tmpDir = SysFunc.modify_path(prefs['tmpDir'])
+            if not os.path.exists(tmpDir):
+                try:
+                    os.makedirs(tmpDir)
+                except OSError as exc: # Guard against failure
+                    error.errorList["couldNotMakeDir"]['func'](tmpDir)
+                    Global.errprint("Failed to create TmpDir")
+                    Global.errprint("Falling Back to Default")
+        else:
+            tmpDir = './tmp/'
+
+        # setting up directory for pwdl
+        if "dir" in prefs:
+            try: OUT_DIRECTORY = os.path.abspath(os.path.expandvars(prefs['dir']))
+
+            # if the user provides a non-string value for the directory or dir is not found
+            except TypeError: OUT_DIRECTORY = './'
+
+            # if the directory is not found
+            except Exception as e:
+                Global.errprint(f"Error: {e}")
+                Global.errprint("Falling back to default")
+                OUT_DIRECTORY = './'
+        else:
+            OUT_DIRECTORY = './'
+
+        # setting up hr (horizontal rule)
+        if not 'hr' in prefs:
+            Global.disable_hr = False
+        elif not prefs['hr']:
+            Global.disable_hr = True
+
+        prefs['tmpDir'] = tmpDir
+        prefs['dir'] = OUT_DIRECTORY
+
+
+    def checkup(self,executable,directory="./",verbose=True):
+
+        state = {}
+
+        # set script path to ../startup
+        # this is the path to the folder containing the pwdl.py file
+        # since the checkup.py is in the startup folder, we need to go one level up
+        if verbose: Global.hr();Global.dprint("Setting script path...")
+        if verbose: Global.errprint('Warning! Hard Coded \'$script\' location to checkup.py/../../')
+
+        Global.script_path = os.path.abspath(os.path.join(os.path.dirname(__file__),'../..'))
+        default_json = os.path.join(Global.script_path,'defaults.json')
+
+        # check if defaults.json exists
+        # and if it does, load the preferences
+        if verbose: Global.hr();Global.dprint("Checking for default settings...")
+
+        if verbose: Global.hr();Global.dprint(f"Checking at {default_json}")
+        if verbose: Global.errprint('Warning!\nHard Coded \'defaults.json\' location to $script/default.json ')
+
+        if not os.path.exists(default_json):
+            error.errorList["defaultsNotFound"]["func"]()
+            exit(error.errorList["defaultsNotFound"]["code"])
+
+        if verbose: Global.sprint("Default settings found."); Global.hr()
+        
+        # load the preferences
+        from mainLogic.startup.userPrefs import PreferencesLoader
+        prefs = PreferencesLoader(file_name=default_json,verbose=verbose).prefs
+
+        # check if method is patched (currently via userPrefs.py)
+        if 'patched' in prefs:
+            if prefs['patched']:
+                error.errorList["methodPatched"]["func"]()
+                exit(error.errorList["methodPatched"]["code"])
+
+        # FLare no longer required
+        # if verbose: Global.hr(); Global.dprint("Checking for Flare...")
+        # default url is localhost:8191
+        # however user can change it in the preferences file
+        # if verbose: Global.dprint(f"Checking at {prefs['flare_url'] if 'flare_url' in prefs else 'http://localhost:8191/v1'}")
+        # if not checkFlare(prefs['flare_url'] if 'flare_url' in prefs else 'http://localhost:8191/v1'):
+        #     error.errorList["flareNotStarted"]["func"]()
+        #     exit(error.errorList["flareNotStarted"]["code"])
+        #
+        # if verbose: Global.sprint("Flare is running."); Global.hr()
+
+        os2 = SysFunc()
+
+        found= []
+        notFound = []
+
+        for exe in executable:
+            if verbose: Global.hr(); Global.dprint(f"Checking for {exe}...")
+
+            if os2.which(exe) == 1:
+                if verbose: error.errorList["dependencyNotFound"]["func"](exe)
+                if verbose: print(f"{exe} not found on path! Checking in default settings...")
+
+                # add exe's which are found to the found list
+                found.append(exe)
+                # add exe's which are not found to the notFound list
+                notFound.append(exe)
+
+            else: 
+                if verbose: Global.sprint(f"{exe} found.")
+                state[exe] = exe
+
+        if len(notFound) > 0:
+
+            if verbose: Global.hr();Global.dprint("Following dependencies were not found on path. Checking in default settings...")
+            if verbose: Global.dprint(notFound); Global.hr()
+
+            for exe in notFound:
+
+                if verbose: Global.dprint(f"Checking for {exe} in default settings...")
+
+                if exe in prefs:
+
+                    if verbose: Global.sprint(f"Key for {exe} found in default settings.")
+                    if verbose: Global.sprint(f"Value: {prefs[exe]}")
+                    if verbose: Global.dprint(f"Checking for {exe} at '{prefs[exe].strip()}' ...")
+
+                    if not os.path.exists(prefs[exe].strip()):
+                        Global.errprint(f"{exe} not found at {prefs[exe].strip()}")
+                        error.errorList["dependencyNotFoundInPrefs"]["func"](exe)
+                        exit(error.errorList["dependencyNotFoundInPrefs"]["code"])
+
+                    if verbose: Global.sprint(f"{exe} found at {prefs[exe].strip()}")
+                    state[exe] = prefs[exe].strip()
+
+
+                else:
+                    error.errorList["dependencyNotFoundInPrefs"]["func"](exe)
+                    exit(error.errorList["dependencyNotFoundInPrefs"]["code"])
+                
+                if verbose: Global.hr()
+        
+        state['prefs'] = prefs
+        prefs['dir'] = directory
+        self.post_checkup(prefs,verbose)
+        
+
+        return state
+
+

mainLogic/startup/flareCheck.py

@@ -1,17 +1,17 @@
-import requests
-
-def checkFlare(flareUrl="http://localhost:8191/v1"):
-    
-    url = f"{flareUrl}"
-    headers = {"Content-Type": "application/json"}
-    data = {
-        "cmd": "request.get",
-        "url": "http://www.google.com/",
-        "maxTimeout": 60000
-    }
-    try:
-        response = requests.post(url, headers=headers, json=data)
-        return response.ok
-    except Exception as e:
-        return False
-
+import requests
+
+def checkFlare(flareUrl="http://localhost:8191/v1"):
+    
+    url = f"{flareUrl}"
+    headers = {"Content-Type": "application/json"}
+    data = {
+        "cmd": "request.get",
+        "url": "http://www.google.com/",
+        "maxTimeout": 60000
+    }
+    try:
+        response = requests.post(url, headers=headers, json=data)
+        return response.ok
+    except Exception as e:
+        return False
+

mainLogic/startup/userPrefs.py

@@ -1,55 +1,55 @@
-import json
-from mainLogic import error
-import os
-from mainLogic.utils.basicUtils import BasicUtils
-
-class PreferencesLoader:
-    def __init__(self, file_name='defaults.json', verbose=True):
-        self.file_name = file_name
-        self.prefs = {}
-
-        # defining some variables that can be used in the preferences file 
-        self.vars = {
-
-            # $script is the path to the folder containing the pwdl.py file
-            # Since the userPrefs.py is in the startup folder,
-            # we need to go one level up however we make the exception that if the pwdl.py is in the same folder as
-            # the startup folder, we don't need to go one level up
-            "$script" : BasicUtils.abspath(os.path.dirname(__file__)+ ('/../..' if not os.path.exists(os.path.dirname(__file__) + '../pwdl.py') else '')),
-            "$home"   : os.path.expanduser("~"),
-        }
-
-        self.load_preferences()
-
-        # if verbose is true, print the preferences
-        if verbose:
-            self.print_preferences()
-        
-
-    def load_preferences(self):
-        try:
-
-            with open(self.file_name, 'r') as json_file:
-
-                # read the contents of the file (so that we can replace the variables with their values)
-                contents = json_file.read()
-                
-                # replace the variables with their values
-                for var in self.vars:
-                    contents = contents.replace(var,self.vars[var])
-
-                # replace the backslashes with forward slashes
-                contents.replace('\\','/')
-
-                self.prefs = json.loads(contents)
-
-        # if the file is not found, print an error message and exit
-        except FileNotFoundError:
-            error.errorList["cantLoadFile"]["func"](self.file_name)
-            exit(error.errorList["cantLoadFile"]["code"])
-
-
-    # print the preferences (internal function)
-    def print_preferences(self):
-        for key in self.prefs:
+import json
+from mainLogic import error
+import os
+from mainLogic.utils.basicUtils import BasicUtils
+
+class PreferencesLoader:
+    def __init__(self, file_name='defaults.json', verbose=True):
+        self.file_name = file_name
+        self.prefs = {}
+
+        # defining some variables that can be used in the preferences file 
+        self.vars = {
+
+            # $script is the path to the folder containing the pwdl.py file
+            # Since the userPrefs.py is in the startup folder,
+            # we need to go one level up however we make the exception that if the pwdl.py is in the same folder as
+            # the startup folder, we don't need to go one level up
+            "$script" : BasicUtils.abspath(os.path.dirname(__file__)+ ('/../..' if not os.path.exists(os.path.dirname(__file__) + '../pwdl.py') else '')),
+            "$home"   : os.path.expanduser("~"),
+        }
+
+        self.load_preferences()
+
+        # if verbose is true, print the preferences
+        if verbose:
+            self.print_preferences()
+        
+
+    def load_preferences(self):
+        try:
+
+            with open(self.file_name, 'r') as json_file:
+
+                # read the contents of the file (so that we can replace the variables with their values)
+                contents = json_file.read()
+                
+                # replace the variables with their values
+                for var in self.vars:
+                    contents = contents.replace(var,self.vars[var])
+
+                # replace the backslashes with forward slashes
+                contents.replace('\\','/')
+
+                self.prefs = json.loads(contents)
+
+        # if the file is not found, print an error message and exit
+        except FileNotFoundError:
+            error.errorList["cantLoadFile"]["func"](self.file_name)
+            exit(error.errorList["cantLoadFile"]["code"])
+
+
+    # print the preferences (internal function)
+    def print_preferences(self):
+        for key in self.prefs:
             print(f'{key} : {self.prefs[key]}')

mainLogic/utils/basicUtils.py

@@ -1,7 +1,7 @@
-import os
-
-class BasicUtils:
-
-    @staticmethod
-    def abspath(path):
-        return str(os.path.abspath(os.path.expandvars(path))).replace("\\", "/")
+import os
+
+class BasicUtils:
+
+    @staticmethod
+    def abspath(path):
+        return str(os.path.abspath(os.path.expandvars(path))).replace("\\", "/")

mainLogic/utils/glv.py

@@ -1,70 +1,70 @@
-from colorama import Fore, Style, init
-import shutil
-
-# Initialize colorama
-init()
-
-class Global:
-
-    disable_hr = False
-    EXECUTABLES = ['ffmpeg', 'mp4decrypt', 'nm3']
-    api_webdl_directory = "webdl"
-
-    def __init__(self, vout=True, outDir="./"):
-        self.outDir = outDir
-        self.vout = vout
-
-    @staticmethod
-    def set_color(color, style=None):
-        """Prints text in the specified color and style."""
-        print(getattr(Fore, color), end="")
-        if style:
-            print(getattr(Style, style), end="")
-
-    @staticmethod
-    def reset():
-        """Resets text color and style to defaults."""
-        print(Style.RESET_ALL, end="")
-
-    @staticmethod
-    def print_colored(text, color, style=None):
-        """Prints text in the specified color and style, resetting afterward."""
-        Global.set_color(color, style)
-        print(text)
-        Global.reset()
-
-    @staticmethod
-    def dprint(text):
-        """Prints debug text in yellow."""
-        Global.print_colored(text, "YELLOW")
-
-    @staticmethod
-    def errprint(text):
-        """Prints error text in red."""
-        Global.print_colored(text, "RED")
-
-    @staticmethod
-    def setDebug():
-        """Sets the text color to yellow (for debugging)."""
-        Global.set_color("YELLOW")
-
-    @staticmethod
-    def setSuccess():
-        """Sets the text color to green (for success messages)."""
-        Global.set_color("GREEN")
-
-    @staticmethod
-    def sprint(text):
-        """Prints success text in green."""
-        Global.print_colored(text, "GREEN")
-
-    @staticmethod
-    def hr():
-
-        # Disable horizontal rule if set
-        if Global.disable_hr:
-            return
-
-        """Fills the entire terminal with = (one row only)."""
-        columns, _ = shutil.get_terminal_size()
+from colorama import Fore, Style, init
+import shutil
+
+# Initialize colorama
+init()
+
+class Global:
+
+    disable_hr = False
+    EXECUTABLES = ['ffmpeg', 'mp4decrypt', 'nm3']
+    api_webdl_directory = "webdl"
+
+    def __init__(self, vout=True, outDir="./"):
+        self.outDir = outDir
+        self.vout = vout
+
+    @staticmethod
+    def set_color(color, style=None):
+        """Prints text in the specified color and style."""
+        print(getattr(Fore, color), end="")
+        if style:
+            print(getattr(Style, style), end="")
+
+    @staticmethod
+    def reset():
+        """Resets text color and style to defaults."""
+        print(Style.RESET_ALL, end="")
+
+    @staticmethod
+    def print_colored(text, color, style=None):
+        """Prints text in the specified color and style, resetting afterward."""
+        Global.set_color(color, style)
+        print(text)
+        Global.reset()
+
+    @staticmethod
+    def dprint(text):
+        """Prints debug text in yellow."""
+        Global.print_colored(text, "YELLOW")
+
+    @staticmethod
+    def errprint(text):
+        """Prints error text in red."""
+        Global.print_colored(text, "RED")
+
+    @staticmethod
+    def setDebug():
+        """Sets the text color to yellow (for debugging)."""
+        Global.set_color("YELLOW")
+
+    @staticmethod
+    def setSuccess():
+        """Sets the text color to green (for success messages)."""
+        Global.set_color("GREEN")
+
+    @staticmethod
+    def sprint(text):
+        """Prints success text in green."""
+        Global.print_colored(text, "GREEN")
+
+    @staticmethod
+    def hr():
+
+        # Disable horizontal rule if set
+        if Global.disable_hr:
+            return
+
+        """Fills the entire terminal with = (one row only)."""
+        columns, _ = shutil.get_terminal_size()
         print("-" * columns)

mainLogic/utils/keyUtils.py

@@ -1,25 +1,25 @@
-"""
-Obsolete module:
-no longer used in the project
-used when key.old.py was being used
-"""
-
-import base64
-
-def base64_to_hex(base64_str):
-    # Replace special characters not in base64 list with '/'
-    base64_str = base64_str.replace('-', '+').replace('_', '/')
-
-    # Add padding if necessary
-    padding = len(base64_str) % 4
-    if padding:
-        base64_str += '=' * (4 - padding)
-
-    # Convert base64 to bytes
-    base64_bytes = base64_str.encode('utf-8')
-
-    # Decode base64 bytes to hex bytes
-    hex_bytes = base64.b64decode(base64_bytes).hex()
-
-    return hex_bytes
-
+"""
+Obsolete module:
+no longer used in the project
+used when key.old.py was being used
+"""
+
+import base64
+
+def base64_to_hex(base64_str):
+    # Replace special characters not in base64 list with '/'
+    base64_str = base64_str.replace('-', '+').replace('_', '/')
+
+    # Add padding if necessary
+    padding = len(base64_str) % 4
+    if padding:
+        base64_str += '=' * (4 - padding)
+
+    # Convert base64 to bytes
+    base64_bytes = base64_str.encode('utf-8')
+
+    # Decode base64 bytes to hex bytes
+    hex_bytes = base64.b64decode(base64_bytes).hex()
+
+    return hex_bytes
+

mainLogic/utils/os2.py

@@ -1,53 +1,53 @@
-import platform
-import os
-from mainLogic import error
-from mainLogic.utils.process import shell
-# 0 - linux
-# 1 - windows
-# 2 - mac (currently not supported)
- 
-class SysFunc:
-    def __init__(self,os=1 if "Windows" in platform.system() else 0 if "Linux" in platform.system() else -1):
-        if os == -1:
-            raise Exception("UnsupportedOS")
-        self.os = os
-
-    
-    def clear(self):
-        if self.os == 0:
-            os.system("clear")
-        elif self.os == 1:
-            os.system("cls")
-        else:
-            raise Exception("UnsupportedOS")
-    
-
-    def which(self,program):
-
-        if self.os == 0:
-            if shell('which',stderr="",stdout="") != 1:
-                error.errorList["dependencyNotFound"]["func"]('which')
-                exit(error.errorList["dependencyNotFound"]["code"])
-            else:
-                self.whichPresent = True
-
-            return shell(f"which {program}",stderr="",stdout="")
-        
-        elif self.os == 1:
-
-            if shell('where',stderr="",stdout="") != 2:
-                error.errorList["dependencyNotFound"]["func"]('where')
-                exit(error.errorList["dependencyNotFound"]["code"])
-            else:
-                self.whichPresent = True
-            return shell(f"where {program}" , stderr="",stdout="")
-        else:
-            raise Exception("UnsupportedOS")
-
-    @staticmethod
-    def modify_path(path):
-        expanded_path = os.path.expandvars(path)
-        absolute_path = os.path.abspath(expanded_path)
-        modified_path = absolute_path.replace(os.sep, '/')
-        return modified_path
+import platform
+import os
+from mainLogic import error
+from mainLogic.utils.process import shell
+# 0 - linux
+# 1 - windows
+# 2 - mac (currently not supported)
+ 
+class SysFunc:
+    def __init__(self,os=1 if "Windows" in platform.system() else 0 if "Linux" in platform.system() else -1):
+        if os == -1:
+            raise Exception("UnsupportedOS")
+        self.os = os
+
+    
+    def clear(self):
+        if self.os == 0:
+            os.system("clear")
+        elif self.os == 1:
+            os.system("cls")
+        else:
+            raise Exception("UnsupportedOS")
+    
+
+    def which(self,program):
+
+        if self.os == 0:
+            if shell('which',stderr="",stdout="") != 1:
+                error.errorList["dependencyNotFound"]["func"]('which')
+                exit(error.errorList["dependencyNotFound"]["code"])
+            else:
+                self.whichPresent = True
+
+            return shell(f"which {program}",stderr="",stdout="")
+        
+        elif self.os == 1:
+
+            if shell('where',stderr="",stdout="") != 2:
+                error.errorList["dependencyNotFound"]["func"]('where')
+                exit(error.errorList["dependencyNotFound"]["code"])
+            else:
+                self.whichPresent = True
+            return shell(f"where {program}" , stderr="",stdout="")
+        else:
+            raise Exception("UnsupportedOS")
+
+    @staticmethod
+    def modify_path(path):
+        expanded_path = os.path.expandvars(path)
+        absolute_path = os.path.abspath(expanded_path)
+        modified_path = absolute_path.replace(os.sep, '/')
+        return modified_path
         

mainLogic/utils/process.py

@@ -1,42 +1,42 @@
-import subprocess
-import re
-import sys
-
-
-def shell(command, filter=None, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True, progress_callback=None, handleProgress=None):
-    import os
-
-    # Set PYTHONUNBUFFERED environment variable
-    os.environ['PYTHONUNBUFFERED'] = '1'
-
-    command = to_list(command)
-
-    process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True)
-
-    # Read and print the output in real-time
-    while True:
-        output = process.stdout.readline()
-        if output == '' and process.poll() is not None:
-            break
-        if output and filter is not None and re.search(filter, output):
-
-            # call the progress callback with the filtered output
-            if progress_callback:
-                if handleProgress:  progress_callback(handleProgress(output))
-                else:               progress_callback(output)
-            print(output.strip())
-
-    # Wait for the process to complete and get the return code
-    return_code = process.poll()
-
-    return return_code
-
-
-def to_list(variable):
-    if isinstance(variable, list):
-        return variable
-    elif variable is None:
-        return []
-    else:
-        # Convert to string and then to list by splitting at whitespaces
-        return variable.split()
+import subprocess
+import re
+import sys
+
+
+def shell(command, filter=None, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True, progress_callback=None, handleProgress=None):
+    import os
+
+    # Set PYTHONUNBUFFERED environment variable
+    os.environ['PYTHONUNBUFFERED'] = '1'
+
+    command = to_list(command)
+
+    process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True)
+
+    # Read and print the output in real-time
+    while True:
+        output = process.stdout.readline()
+        if output == '' and process.poll() is not None:
+            break
+        if output and filter is not None and re.search(filter, output):
+
+            # call the progress callback with the filtered output
+            if progress_callback:
+                if handleProgress:  progress_callback(handleProgress(output))
+                else:               progress_callback(output)
+            print(output.strip())
+
+    # Wait for the process to complete and get the return code
+    return_code = process.poll()
+
+    return return_code
+
+
+def to_list(variable):
+    if isinstance(variable, list):
+        return variable
+    elif variable is None:
+        return []
+    else:
+        # Convert to string and then to list by splitting at whitespaces
+        return variable.split()

pwdl.bat

@@ -1,12 +1,12 @@
-@echo off
-REM Batch script for running the Python script pwdl.py
-
-REM Check if Python is installed
-py --version >nul 2>&1
-if errorlevel 1 (
-    echo Python is not installed or not found in the PATH.
-    exit /b 1
-)
-
-REM Run the Python script with the provided arguments
-py "%~dp0pwdl.py" %*
+@echo off
+REM Batch script for running the Python script pwdl.py
+
+REM Check if Python is installed
+py --version >nul 2>&1
+if errorlevel 1 (
+    echo Python is not installed or not found in the PATH.
+    exit /b 1
+)
+
+REM Run the Python script with the provided arguments
+py "%~dp0pwdl.py" %*

pwdl.py

@@ -1,148 +1,148 @@
-import argparse
-from mainLogic.error import errorList
-from mainLogic.utils.glv import Global
-import sys
-from mainLogic.utils.os2 import SysFunc
-import os
-from mainLogic.main import Main
-from beta.shellLogic import shell
-from mainLogic.startup.checkup import CheckState
-
-# global variables
-prefs = {}
-glv = Global()
-os2 = SysFunc()
-
-# hardcoding the list of executables required for the script to run
-# should be available in the PATH or the user should provide the path to the executables
-EXECUTABLES = glv.EXECUTABLES
-
-
-
-
-def main():
-
-    # parsing the arguments
-    parser = argparse.ArgumentParser(description='PhysicsWallah M3u8 parser.')
-
-    parser.add_argument('--csv-file', type=str, help='Input csv file. Legacy Support too.')
-    parser.add_argument('--id', type=str,
-                        help='PhysicsWallh Video Id for single usage. Incompatible with --csv-file.   Must be used '
-                             'with --name')
-    parser.add_argument('--name', type=str,
-                        help='Name for the output file. Incompatible with --csv-file.   Must be used with --id')
-    parser.add_argument('--dir', type=str, help='Output Directory')
-    parser.add_argument('--verbose', action='store_true', help='Verbose Output')
-    parser.add_argument('--shell',action='store_true',help='Start the shell')
-    parser.add_argument('--version', action='version', version='%(prog)s 1.0')
-    parser.add_argument('--simulate', action='store_true',
-                        help='Simulate the download process. No files will be downloaded.)')
-
-    args = parser.parse_args()
-
-    if args.shell:
-        shell.main()
-
-
-    # user_input is given preference i.e if --verbose is true it will override
-    # however if --verbose is false but prefs['verbose'] is true
-    glv.vout = args.verbose
-
-    global prefs
-
-    # check if all dependencies are installed
-    state = CheckState().checkup(EXECUTABLES, directory=args.dir,verbose=glv.vout)
-    prefs = state['prefs']
-
-
-    # --------------------------------------------------------------------------------------------------------------------------------------
-    # setting verbose output
-    # gives preference to user input
-    if not glv.vout and prefs['verbose']: glv.vout = prefs['verbose']
-
-    verbose = glv.vout
-
-    OUT_DIRECTORY = prefs['dir']
-    if verbose: Global.hr(); glv.dprint(f"Tmp Dir is: {SysFunc.modify_path(prefs['tmpDir'])}")
-    if verbose: Global.hr(); glv.dprint(f'Output Directory: {OUT_DIRECTORY}')
-    if verbose: Global.hr(); glv.dprint(f"Horizontal Rule: {not Global.disable_hr}")
-
-    # --------------------------------------------------------------------------------------------------------------------------------------
-    # end of loading user preferences
-
-
-    # starting the main process
-
-    #if both csv file and (id or name) is provided then -> exit with error code 3
-    if args.csv_file and (args.id or args.name):
-        print("Both csv file and id (or name) is provided. Unable to decide. Aborting! ...")
-        sys.exit(3)
-
-    # handle in case --csv-file is provided
-    if args.csv_file:
-
-        # simulation mode
-        if args.simulate:
-            print("Simulating the download csv process. No files will be downloaded.")
-            print("File to be processed: ", args.csv_file)
-            exit(0)
-
-        # exiting in case the CSV File is not found
-        if not os.path.exists(args.csv_file):
-            errorList['csvFileNotFound']['func'](args.csv_file)
-            sys.exit(errorList['csvFileNotFound']['code'])
-
-        with open(args.csv_file, 'r') as f:
-            for line in f:
-                name, id = line.strip().split(',')
-
-                # adding support for csv file with partial errors
-                try:
-                    Main(id=id,
-                         name=name,
-                         directory=OUT_DIRECTORY,
-                         ffmpeg=state['ffmpeg'],
-                         nm3Path=state['nm3'],
-                         mp4d=state['mp4decrypt'],
-                         tmpDir=prefs['tmpDir'],
-                         verbose=verbose,
-                         suppress_exit=True  # suppress exit in case of error (as multiple files are being processed)
-                         ).process()
-
-                except Exception as e:
-                    errorList['downloadFailed']['func'](name, id)
-
-
-
-    # handle in case key and name is given
-    elif args.id and args.name:
-
-        # simulation mode
-        if args.simulate:
-            print("Simulating the download process. No files will be downloaded.")
-            print("Id to be processed: ", args.id)
-            print("Name to be processed: ", args.name)
-            exit(0)
-
-        try:
-
-            Main(id=args.id,
-                 name=args.name,
-                 directory=OUT_DIRECTORY,
-                 ffmpeg=state['ffmpeg'],
-                 nm3Path=state['nm3'],
-                 mp4d=state['mp4decrypt'],
-                 tmpDir=prefs['tmpDir'],
-                 verbose=verbose).process()
-
-        except Exception as e:
-            errorList['downloadFailed']['func'](args.name, args.id)
-            sys.exit(errorList['downloadFailed']['code'])
-
-    # in case neither is used
-    else:
-        exit(1)
-
-
-if __name__ == "__main__":
+import argparse
+from mainLogic.error import errorList
+from mainLogic.utils.glv import Global
+import sys
+from mainLogic.utils.os2 import SysFunc
+import os
+from mainLogic.main import Main
+from beta.shellLogic import shell
+from mainLogic.startup.checkup import CheckState
+
+# global variables
+prefs = {}
+glv = Global()
+os2 = SysFunc()
+
+# hardcoding the list of executables required for the script to run
+# should be available in the PATH or the user should provide the path to the executables
+EXECUTABLES = glv.EXECUTABLES
+
+
+
+
+def main():
+
+    # parsing the arguments
+    parser = argparse.ArgumentParser(description='PhysicsWallah M3u8 parser.')
+
+    parser.add_argument('--csv-file', type=str, help='Input csv file. Legacy Support too.')
+    parser.add_argument('--id', type=str,
+                        help='PhysicsWallh Video Id for single usage. Incompatible with --csv-file.   Must be used '
+                             'with --name')
+    parser.add_argument('--name', type=str,
+                        help='Name for the output file. Incompatible with --csv-file.   Must be used with --id')
+    parser.add_argument('--dir', type=str, help='Output Directory')
+    parser.add_argument('--verbose', action='store_true', help='Verbose Output')
+    parser.add_argument('--shell',action='store_true',help='Start the shell')
+    parser.add_argument('--version', action='version', version='%(prog)s 1.0')
+    parser.add_argument('--simulate', action='store_true',
+                        help='Simulate the download process. No files will be downloaded.)')
+
+    args = parser.parse_args()
+
+    if args.shell:
+        shell.main()
+
+
+    # user_input is given preference i.e if --verbose is true it will override
+    # however if --verbose is false but prefs['verbose'] is true
+    glv.vout = args.verbose
+
+    global prefs
+
+    # check if all dependencies are installed
+    state = CheckState().checkup(EXECUTABLES, directory=args.dir,verbose=glv.vout)
+    prefs = state['prefs']
+
+
+    # --------------------------------------------------------------------------------------------------------------------------------------
+    # setting verbose output
+    # gives preference to user input
+    if not glv.vout and prefs['verbose']: glv.vout = prefs['verbose']
+
+    verbose = glv.vout
+
+    OUT_DIRECTORY = prefs['dir']
+    if verbose: Global.hr(); glv.dprint(f"Tmp Dir is: {SysFunc.modify_path(prefs['tmpDir'])}")
+    if verbose: Global.hr(); glv.dprint(f'Output Directory: {OUT_DIRECTORY}')
+    if verbose: Global.hr(); glv.dprint(f"Horizontal Rule: {not Global.disable_hr}")
+
+    # --------------------------------------------------------------------------------------------------------------------------------------
+    # end of loading user preferences
+
+
+    # starting the main process
+
+    #if both csv file and (id or name) is provided then -> exit with error code 3
+    if args.csv_file and (args.id or args.name):
+        print("Both csv file and id (or name) is provided. Unable to decide. Aborting! ...")
+        sys.exit(3)
+
+    # handle in case --csv-file is provided
+    if args.csv_file:
+
+        # simulation mode
+        if args.simulate:
+            print("Simulating the download csv process. No files will be downloaded.")
+            print("File to be processed: ", args.csv_file)
+            exit(0)
+
+        # exiting in case the CSV File is not found
+        if not os.path.exists(args.csv_file):
+            errorList['csvFileNotFound']['func'](args.csv_file)
+            sys.exit(errorList['csvFileNotFound']['code'])
+
+        with open(args.csv_file, 'r') as f:
+            for line in f:
+                name, id = line.strip().split(',')
+
+                # adding support for csv file with partial errors
+                try:
+                    Main(id=id,
+                         name=name,
+                         directory=OUT_DIRECTORY,
+                         ffmpeg=state['ffmpeg'],
+                         nm3Path=state['nm3'],
+                         mp4d=state['mp4decrypt'],
+                         tmpDir=prefs['tmpDir'],
+                         verbose=verbose,
+                         suppress_exit=True  # suppress exit in case of error (as multiple files are being processed)
+                         ).process()
+
+                except Exception as e:
+                    errorList['downloadFailed']['func'](name, id)
+
+
+
+    # handle in case key and name is given
+    elif args.id and args.name:
+
+        # simulation mode
+        if args.simulate:
+            print("Simulating the download process. No files will be downloaded.")
+            print("Id to be processed: ", args.id)
+            print("Name to be processed: ", args.name)
+            exit(0)
+
+        try:
+
+            Main(id=args.id,
+                 name=args.name,
+                 directory=OUT_DIRECTORY,
+                 ffmpeg=state['ffmpeg'],
+                 nm3Path=state['nm3'],
+                 mp4d=state['mp4decrypt'],
+                 tmpDir=prefs['tmpDir'],
+                 verbose=verbose).process()
+
+        except Exception as e:
+            errorList['downloadFailed']['func'](args.name, args.id)
+            sys.exit(errorList['downloadFailed']['code'])
+
+    # in case neither is used
+    else:
+        exit(1)
+
+
+if __name__ == "__main__":
     main()