Upload 22 files

.dockerignore

@@ -0,0 +1,38 @@
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+.env
+.idea/
+*.service
+
+# Ignore all files under drm folder
+mediaflow_proxy/drm/*
+
+# Unignore specific files
+!mediaflow_proxy/drm/__init__.py
+!mediaflow_proxy/drm/decrypter.py

.github/FUNDING.yml

@@ -0,0 +1,2 @@
+
+github: [mhdzumair]

.github/dependabot.yml

@@ -0,0 +1,8 @@
+version: 2
+updates:
+  - package-ecosystem: "pip"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    commit-message:
+      prefix: "dependabot"

.github/workflows/main.yml

@@ -0,0 +1,40 @@
+name: MediaFlow Proxy CI/CD
+
+on:
+  release:
+    types: [ created ]
+
+jobs:
+  mediaflow_proxy_docker_build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: mhdzumair
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build and push
+        id: docker_build
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: Dockerfile
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: |
+            mhdzumair/mediaflow-proxy:v${{ github.ref_name }}
+            mhdzumair/mediaflow-proxy:latest
+
+      - name: Image digest
+        run: echo ${{ steps.docker_build.outputs.digest }}

.gitignore

@@ -0,0 +1,140 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+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/
+
+# 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
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.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
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__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/
+
+.idea/
+*.service
+
+# Ignore all files under drm folder
+mediaflow_proxy/drm/*
+
+# Unignore specific files
+!mediaflow_proxy/drm/__init__.py
+!mediaflow_proxy/drm/decrypter.py
+

mediaflow_proxy/configs.py

@@ -0,0 +1,14 @@
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    api_password: str  # The password for accessing the API endpoints.
+    proxy_url: str | None = None  # The URL of the proxy server to route requests through.
+    mpd_live_stream_delay: int = 30  # The delay in seconds for live MPD streams.
+
+    class Config:
+        env_file = ".env"
+        extra = "ignore"
+
+
+settings = Settings()

mediaflow_proxy/drm/__init__.py

@@ -0,0 +1,11 @@
+import os
+import tempfile
+
+
+async def create_temp_file(suffix: str, content: bytes = None, prefix: str = None) -> tempfile.NamedTemporaryFile:
+    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=suffix, prefix=prefix)
+    temp_file.delete_file = lambda: os.unlink(temp_file.name)
+    if content:
+        temp_file.write(content)
+        temp_file.close()
+    return temp_file

mediaflow_proxy/drm/decrypter.py

@@ -0,0 +1,778 @@
+import argparse
+import struct
+import sys
+
+from Crypto.Cipher import AES
+from collections import namedtuple
+import array
+
+CENCSampleAuxiliaryDataFormat = namedtuple("CENCSampleAuxiliaryDataFormat", ["is_encrypted", "iv", "sub_samples"])
+
+
+class MP4Atom:
+    """
+    Represents an MP4 atom, which is a basic unit of data in an MP4 file.
+    Each atom contains a header (size and type) and data.
+    """
+
+    __slots__ = ("atom_type", "size", "data")
+
+    def __init__(self, atom_type: bytes, size: int, data: memoryview | bytearray):
+        """
+        Initializes an MP4Atom instance.
+
+        Args:
+            atom_type (bytes): The type of the atom.
+            size (int): The size of the atom.
+            data (memoryview | bytearray): The data contained in the atom.
+        """
+        self.atom_type = atom_type
+        self.size = size
+        self.data = data
+
+    def __repr__(self):
+        return f"<MP4Atom type={self.atom_type}, size={self.size}>"
+
+    def pack(self):
+        """
+        Packs the atom into binary data.
+
+        Returns:
+            bytes: Packed binary data with size, type, and data.
+        """
+        return struct.pack(">I", self.size) + self.atom_type + self.data
+
+
+class MP4Parser:
+    """
+    Parses MP4 data to extract atoms and their structure.
+    """
+
+    def __init__(self, data: memoryview):
+        """
+        Initializes an MP4Parser instance.
+
+        Args:
+            data (memoryview): The binary data of the MP4 file.
+        """
+        self.data = data
+        self.position = 0
+
+    def read_atom(self) -> MP4Atom | None:
+        """
+        Reads the next atom from the data.
+
+        Returns:
+            MP4Atom | None: MP4Atom object or None if no more atoms are available.
+        """
+        pos = self.position
+        if pos + 8 > len(self.data):
+            return None
+
+        size, atom_type = struct.unpack_from(">I4s", self.data, pos)
+        pos += 8
+
+        if size == 1:
+            if pos + 8 > len(self.data):
+                return None
+            size = struct.unpack_from(">Q", self.data, pos)[0]
+            pos += 8
+
+        if size < 8 or pos + size - 8 > len(self.data):
+            return None
+
+        atom_data = self.data[pos : pos + size - 8]
+        self.position = pos + size - 8
+        return MP4Atom(atom_type, size, atom_data)
+
+    def list_atoms(self) -> list[MP4Atom]:
+        """
+        Lists all atoms in the data.
+
+        Returns:
+            list[MP4Atom]: List of MP4Atom objects.
+        """
+        atoms = []
+        original_position = self.position
+        self.position = 0
+        while self.position + 8 <= len(self.data):
+            atom = self.read_atom()
+            if not atom:
+                break
+            atoms.append(atom)
+        self.position = original_position
+        return atoms
+
+    def _read_atom_at(self, pos: int, end: int) -> MP4Atom | None:
+        if pos + 8 > end:
+            return None
+
+        size, atom_type = struct.unpack_from(">I4s", self.data, pos)
+        pos += 8
+
+        if size == 1:
+            if pos + 8 > end:
+                return None
+            size = struct.unpack_from(">Q", self.data, pos)[0]
+            pos += 8
+
+        if size < 8 or pos + size - 8 > end:
+            return None
+
+        atom_data = self.data[pos : pos + size - 8]
+        return MP4Atom(atom_type, size, atom_data)
+
+    def print_atoms_structure(self, indent: int = 0):
+        """
+        Prints the structure of all atoms in the data.
+
+        Args:
+            indent (int): The indentation level for printing.
+        """
+        pos = 0
+        end = len(self.data)
+        while pos + 8 <= end:
+            atom = self._read_atom_at(pos, end)
+            if not atom:
+                break
+            self.print_single_atom_structure(atom, pos, indent)
+            pos += atom.size
+
+    def print_single_atom_structure(self, atom: MP4Atom, parent_position: int, indent: int):
+        """
+        Prints the structure of a single atom.
+
+        Args:
+            atom (MP4Atom): The atom to print.
+            parent_position (int): The position of the parent atom.
+            indent (int): The indentation level for printing.
+        """
+        try:
+            atom_type = atom.atom_type.decode("utf-8")
+        except UnicodeDecodeError:
+            atom_type = repr(atom.atom_type)
+        print(" " * indent + f"Type: {atom_type}, Size: {atom.size}")
+
+        child_pos = 0
+        child_end = len(atom.data)
+        while child_pos + 8 <= child_end:
+            child_atom = self._read_atom_at(parent_position + 8 + child_pos, parent_position + 8 + child_end)
+            if not child_atom:
+                break
+            self.print_single_atom_structure(child_atom, parent_position, indent + 2)
+            child_pos += child_atom.size
+
+
+class MP4Decrypter:
+    """
+    Class to handle the decryption of CENC encrypted MP4 segments.
+
+    Attributes:
+        key_map (dict[bytes, bytes]): Mapping of track IDs to decryption keys.
+        current_key (bytes | None): Current decryption key.
+        trun_sample_sizes (array.array): Array of sample sizes from the 'trun' box.
+        current_sample_info (list): List of sample information from the 'senc' box.
+        encryption_overhead (int): Total size of encryption-related boxes.
+    """
+
+    def __init__(self, key_map: dict[bytes, bytes]):
+        """
+        Initializes the MP4Decrypter with a key map.
+
+        Args:
+            key_map (dict[bytes, bytes]): Mapping of track IDs to decryption keys.
+        """
+        self.key_map = key_map
+        self.current_key = None
+        self.trun_sample_sizes = array.array("I")
+        self.current_sample_info = []
+        self.encryption_overhead = 0
+
+    def decrypt_segment(self, combined_segment: bytes) -> bytes:
+        """
+        Decrypts a combined MP4 segment.
+
+        Args:
+            combined_segment (bytes): Combined initialization and media segment.
+
+        Returns:
+            bytes: Decrypted segment content.
+        """
+        data = memoryview(combined_segment)
+        parser = MP4Parser(data)
+        atoms = parser.list_atoms()
+
+        atom_process_order = [b"moov", b"moof", b"sidx", b"mdat"]
+
+        processed_atoms = {}
+        for atom_type in atom_process_order:
+            if atom := next((a for a in atoms if a.atom_type == atom_type), None):
+                processed_atoms[atom_type] = self._process_atom(atom_type, atom)
+
+        result = bytearray()
+        for atom in atoms:
+            if atom.atom_type in processed_atoms:
+                processed_atom = processed_atoms[atom.atom_type]
+                result.extend(processed_atom.pack())
+            else:
+                result.extend(atom.pack())
+
+        return bytes(result)
+
+    def _process_atom(self, atom_type: bytes, atom: MP4Atom) -> MP4Atom:
+        """
+        Processes an MP4 atom based on its type.
+
+        Args:
+            atom_type (bytes): Type of the atom.
+            atom (MP4Atom): The atom to process.
+
+        Returns:
+            MP4Atom: Processed atom.
+        """
+        match atom_type:
+            case b"moov":
+                return self._process_moov(atom)
+            case b"moof":
+                return self._process_moof(atom)
+            case b"sidx":
+                return self._process_sidx(atom)
+            case b"mdat":
+                return self._decrypt_mdat(atom)
+            case _:
+                return atom
+
+    def _process_moov(self, moov: MP4Atom) -> MP4Atom:
+        """
+        Processes the 'moov' (Movie) atom, which contains metadata about the entire presentation.
+        This includes information about tracks, media data, and other movie-level metadata.
+
+        Args:
+            moov (MP4Atom): The 'moov' atom to process.
+
+        Returns:
+            MP4Atom: Processed 'moov' atom with updated track information.
+        """
+        parser = MP4Parser(moov.data)
+        new_moov_data = bytearray()
+
+        for atom in iter(parser.read_atom, None):
+            if atom.atom_type == b"trak":
+                new_trak = self._process_trak(atom)
+                new_moov_data.extend(new_trak.pack())
+            elif atom.atom_type != b"pssh":
+                # Skip PSSH boxes as they are not needed in the decrypted output
+                new_moov_data.extend(atom.pack())
+
+        return MP4Atom(b"moov", len(new_moov_data) + 8, new_moov_data)
+
+    def _process_moof(self, moof: MP4Atom) -> MP4Atom:
+        """
+        Processes the 'moov' (Movie) atom, which contains metadata about the entire presentation.
+        This includes information about tracks, media data, and other movie-level metadata.
+
+        Args:
+            moov (MP4Atom): The 'moov' atom to process.
+
+        Returns:
+            MP4Atom: Processed 'moov' atom with updated track information.
+        """
+        parser = MP4Parser(moof.data)
+        new_moof_data = bytearray()
+
+        for atom in iter(parser.read_atom, None):
+            if atom.atom_type == b"traf":
+                new_traf = self._process_traf(atom)
+                new_moof_data.extend(new_traf.pack())
+            else:
+                new_moof_data.extend(atom.pack())
+
+        return MP4Atom(b"moof", len(new_moof_data) + 8, new_moof_data)
+
+    def _process_traf(self, traf: MP4Atom) -> MP4Atom:
+        """
+        Processes the 'traf' (Track Fragment) atom, which contains information about a track fragment.
+        This includes sample information, sample encryption data, and other track-level metadata.
+
+        Args:
+            traf (MP4Atom): The 'traf' atom to process.
+
+        Returns:
+            MP4Atom: Processed 'traf' atom with updated sample information.
+        """
+        parser = MP4Parser(traf.data)
+        new_traf_data = bytearray()
+        tfhd = None
+        sample_count = 0
+        sample_info = []
+
+        atoms = parser.list_atoms()
+
+        # calculate encryption_overhead earlier to avoid dependency on trun
+        self.encryption_overhead = sum(a.size for a in atoms if a.atom_type in {b"senc", b"saiz", b"saio"})
+
+        for atom in atoms:
+            if atom.atom_type == b"tfhd":
+                tfhd = atom
+                new_traf_data.extend(atom.pack())
+            elif atom.atom_type == b"trun":
+                sample_count = self._process_trun(atom)
+                new_trun = self._modify_trun(atom)
+                new_traf_data.extend(new_trun.pack())
+            elif atom.atom_type == b"senc":
+                # Parse senc but don't include it in the new decrypted traf data and similarly don't include saiz and saio
+                sample_info = self._parse_senc(atom, sample_count)
+            elif atom.atom_type not in {b"saiz", b"saio"}:
+                new_traf_data.extend(atom.pack())
+
+        if tfhd:
+            tfhd_track_id = struct.unpack_from(">I", tfhd.data, 4)[0]
+            self.current_key = self._get_key_for_track(tfhd_track_id)
+            self.current_sample_info = sample_info
+
+        return MP4Atom(b"traf", len(new_traf_data) + 8, new_traf_data)
+
+    def _decrypt_mdat(self, mdat: MP4Atom) -> MP4Atom:
+        """
+        Decrypts the 'mdat' (Media Data) atom, which contains the actual media data (audio, video, etc.).
+        The decryption is performed using the current decryption key and sample information.
+
+        Args:
+            mdat (MP4Atom): The 'mdat' atom to decrypt.
+
+        Returns:
+            MP4Atom: Decrypted 'mdat' atom with decrypted media data.
+        """
+        if not self.current_key or not self.current_sample_info:
+            return mdat  # Return original mdat if we don't have decryption info
+
+        decrypted_samples = bytearray()
+        mdat_data = mdat.data
+        position = 0
+
+        for i, info in enumerate(self.current_sample_info):
+            if position >= len(mdat_data):
+                break  # No more data to process
+
+            sample_size = self.trun_sample_sizes[i] if i < len(self.trun_sample_sizes) else len(mdat_data) - position
+            sample = mdat_data[position : position + sample_size]
+            position += sample_size
+            decrypted_sample = self._process_sample(sample, info, self.current_key)
+            decrypted_samples.extend(decrypted_sample)
+
+        return MP4Atom(b"mdat", len(decrypted_samples) + 8, decrypted_samples)
+
+    def _parse_senc(self, senc: MP4Atom, sample_count: int) -> list[CENCSampleAuxiliaryDataFormat]:
+        """
+        Parses the 'senc' (Sample Encryption) atom, which contains encryption information for samples.
+        This includes initialization vectors (IVs) and sub-sample encryption data.
+
+        Args:
+            senc (MP4Atom): The 'senc' atom to parse.
+            sample_count (int): The number of samples.
+
+        Returns:
+            list[CENCSampleAuxiliaryDataFormat]: List of sample auxiliary data formats with encryption information.
+        """
+        data = memoryview(senc.data)
+        version_flags = struct.unpack_from(">I", data, 0)[0]
+        version, flags = version_flags >> 24, version_flags & 0xFFFFFF
+        position = 4
+
+        if version == 0:
+            sample_count = struct.unpack_from(">I", data, position)[0]
+            position += 4
+
+        sample_info = []
+        for _ in range(sample_count):
+            if position + 8 > len(data):
+                break
+
+            iv = data[position : position + 8].tobytes()
+            position += 8
+
+            sub_samples = []
+            if flags & 0x000002 and position + 2 <= len(data):  # Check if subsample information is present
+                subsample_count = struct.unpack_from(">H", data, position)[0]
+                position += 2
+
+                for _ in range(subsample_count):
+                    if position + 6 <= len(data):
+                        clear_bytes, encrypted_bytes = struct.unpack_from(">HI", data, position)
+                        position += 6
+                        sub_samples.append((clear_bytes, encrypted_bytes))
+                    else:
+                        break
+
+            sample_info.append(CENCSampleAuxiliaryDataFormat(True, iv, sub_samples))
+
+        return sample_info
+
+    def _get_key_for_track(self, track_id: int) -> bytes:
+        """
+        Retrieves the decryption key for a given track ID from the key map.
+
+        Args:
+            track_id (int): The track ID.
+
+        Returns:
+            bytes: The decryption key for the specified track ID.
+        """
+        if len(self.key_map) == 1:
+            return next(iter(self.key_map.values()))
+        key = self.key_map.get(track_id.pack(4, "big"))
+        if not key:
+            raise ValueError(f"No key found for track ID {track_id}")
+        return key
+
+    @staticmethod
+    def _process_sample(
+        sample: memoryview, sample_info: CENCSampleAuxiliaryDataFormat, key: bytes
+    ) -> memoryview | bytearray | bytes:
+        """
+        Processes and decrypts a sample using the provided sample information and decryption key.
+        This includes handling sub-sample encryption if present.
+
+        Args:
+            sample (memoryview): The sample data.
+            sample_info (CENCSampleAuxiliaryDataFormat): The sample auxiliary data format with encryption information.
+            key (bytes): The decryption key.
+
+        Returns:
+            memoryview | bytearray | bytes: The decrypted sample.
+        """
+        if not sample_info.is_encrypted:
+            return sample
+
+        # pad IV to 16 bytes
+        iv = sample_info.iv + b"\x00" * (16 - len(sample_info.iv))
+        cipher = AES.new(key, AES.MODE_CTR, initial_value=iv, nonce=b"")
+
+        if not sample_info.sub_samples:
+            # If there are no sub_samples, decrypt the entire sample
+            return cipher.decrypt(sample)
+
+        result = bytearray()
+        offset = 0
+        for clear_bytes, encrypted_bytes in sample_info.sub_samples:
+            result.extend(sample[offset : offset + clear_bytes])
+            offset += clear_bytes
+            result.extend(cipher.decrypt(sample[offset : offset + encrypted_bytes]))
+            offset += encrypted_bytes
+
+        # If there's any remaining data, treat it as encrypted
+        if offset < len(sample):
+            result.extend(cipher.decrypt(sample[offset:]))
+
+        return result
+
+    def _process_trun(self, trun: MP4Atom) -> int:
+        """
+        Processes the 'trun' (Track Fragment Run) atom, which contains information about the samples in a track fragment.
+        This includes sample sizes, durations, flags, and composition time offsets.
+
+        Args:
+            trun (MP4Atom): The 'trun' atom to process.
+
+        Returns:
+            int: The number of samples in the 'trun' atom.
+        """
+        trun_flags, sample_count = struct.unpack_from(">II", trun.data, 0)
+        data_offset = 8
+
+        if trun_flags & 0x000001:
+            data_offset += 4
+        if trun_flags & 0x000004:
+            data_offset += 4
+
+        self.trun_sample_sizes = array.array("I")
+
+        for _ in range(sample_count):
+            if trun_flags & 0x000100:  # sample-duration-present flag
+                data_offset += 4
+            if trun_flags & 0x000200:  # sample-size-present flag
+                sample_size = struct.unpack_from(">I", trun.data, data_offset)[0]
+                self.trun_sample_sizes.append(sample_size)
+                data_offset += 4
+            else:
+                self.trun_sample_sizes.append(0)  # Using 0 instead of None for uniformity in the array
+            if trun_flags & 0x000400:  # sample-flags-present flag
+                data_offset += 4
+            if trun_flags & 0x000800:  # sample-composition-time-offsets-present flag
+                data_offset += 4
+
+        return sample_count
+
+    def _modify_trun(self, trun: MP4Atom) -> MP4Atom:
+        """
+        Modifies the 'trun' (Track Fragment Run) atom to update the data offset.
+        This is necessary to account for the encryption overhead.
+
+        Args:
+            trun (MP4Atom): The 'trun' atom to modify.
+
+        Returns:
+            MP4Atom: Modified 'trun' atom with updated data offset.
+        """
+        trun_data = bytearray(trun.data)
+        current_flags = struct.unpack_from(">I", trun_data, 0)[0] & 0xFFFFFF
+
+        # If the data-offset-present flag is set, update the data offset to account for encryption overhead
+        if current_flags & 0x000001:
+            current_data_offset = struct.unpack_from(">i", trun_data, 8)[0]
+            struct.pack_into(">i", trun_data, 8, current_data_offset - self.encryption_overhead)
+
+        return MP4Atom(b"trun", len(trun_data) + 8, trun_data)
+
+    def _process_sidx(self, sidx: MP4Atom) -> MP4Atom:
+        """
+        Processes the 'sidx' (Segment Index) atom, which contains indexing information for media segments.
+        This includes references to media segments and their durations.
+
+        Args:
+            sidx (MP4Atom): The 'sidx' atom to process.
+
+        Returns:
+            MP4Atom: Processed 'sidx' atom with updated segment references.
+        """
+        sidx_data = bytearray(sidx.data)
+
+        current_size = struct.unpack_from(">I", sidx_data, 32)[0]
+        reference_type = current_size >> 31
+        current_referenced_size = current_size & 0x7FFFFFFF
+
+        # Remove encryption overhead from referenced size
+        new_referenced_size = current_referenced_size - self.encryption_overhead
+        new_size = (reference_type << 31) | new_referenced_size
+        struct.pack_into(">I", sidx_data, 32, new_size)
+
+        return MP4Atom(b"sidx", len(sidx_data) + 8, sidx_data)
+
+    def _process_trak(self, trak: MP4Atom) -> MP4Atom:
+        """
+        Processes the 'trak' (Track) atom, which contains information about a single track in the movie.
+        This includes track header, media information, and other track-level metadata.
+
+        Args:
+            trak (MP4Atom): The 'trak' atom to process.
+
+        Returns:
+            MP4Atom: Processed 'trak' atom with updated track information.
+        """
+        parser = MP4Parser(trak.data)
+        new_trak_data = bytearray()
+
+        for atom in iter(parser.read_atom, None):
+            if atom.atom_type == b"mdia":
+                new_mdia = self._process_mdia(atom)
+                new_trak_data.extend(new_mdia.pack())
+            else:
+                new_trak_data.extend(atom.pack())
+
+        return MP4Atom(b"trak", len(new_trak_data) + 8, new_trak_data)
+
+    def _process_mdia(self, mdia: MP4Atom) -> MP4Atom:
+        """
+        Processes the 'mdia' (Media) atom, which contains media information for a track.
+        This includes media header, handler reference, and media information container.
+
+        Args:
+            mdia (MP4Atom): The 'mdia' atom to process.
+
+        Returns:
+            MP4Atom: Processed 'mdia' atom with updated media information.
+        """
+        parser = MP4Parser(mdia.data)
+        new_mdia_data = bytearray()
+
+        for atom in iter(parser.read_atom, None):
+            if atom.atom_type == b"minf":
+                new_minf = self._process_minf(atom)
+                new_mdia_data.extend(new_minf.pack())
+            else:
+                new_mdia_data.extend(atom.pack())
+
+        return MP4Atom(b"mdia", len(new_mdia_data) + 8, new_mdia_data)
+
+    def _process_minf(self, minf: MP4Atom) -> MP4Atom:
+        """
+        Processes the 'minf' (Media Information) atom, which contains information about the media data in a track.
+        This includes data information, sample table, and other media-level metadata.
+
+        Args:
+            minf (MP4Atom): The 'minf' atom to process.
+
+        Returns:
+            MP4Atom: Processed 'minf' atom with updated media information.
+        """
+        parser = MP4Parser(minf.data)
+        new_minf_data = bytearray()
+
+        for atom in iter(parser.read_atom, None):
+            if atom.atom_type == b"stbl":
+                new_stbl = self._process_stbl(atom)
+                new_minf_data.extend(new_stbl.pack())
+            else:
+                new_minf_data.extend(atom.pack())
+
+        return MP4Atom(b"minf", len(new_minf_data) + 8, new_minf_data)
+
+    def _process_stbl(self, stbl: MP4Atom) -> MP4Atom:
+        """
+        Processes the 'stbl' (Sample Table) atom, which contains information about the samples in a track.
+        This includes sample descriptions, sample sizes, sample times, and other sample-level metadata.
+
+        Args:
+            stbl (MP4Atom): The 'stbl' atom to process.
+
+        Returns:
+            MP4Atom: Processed 'stbl' atom with updated sample information.
+        """
+        parser = MP4Parser(stbl.data)
+        new_stbl_data = bytearray()
+
+        for atom in iter(parser.read_atom, None):
+            if atom.atom_type == b"stsd":
+                new_stsd = self._process_stsd(atom)
+                new_stbl_data.extend(new_stsd.pack())
+            else:
+                new_stbl_data.extend(atom.pack())
+
+        return MP4Atom(b"stbl", len(new_stbl_data) + 8, new_stbl_data)
+
+    def _process_stsd(self, stsd: MP4Atom) -> MP4Atom:
+        """
+        Processes the 'stsd' (Sample Description) atom, which contains descriptions of the sample entries in a track.
+        This includes codec information, sample entry details, and other sample description metadata.
+
+        Args:
+            stsd (MP4Atom): The 'stsd' atom to process.
+
+        Returns:
+            MP4Atom: Processed 'stsd' atom with updated sample descriptions.
+        """
+        parser = MP4Parser(stsd.data)
+        entry_count = struct.unpack_from(">I", parser.data, 4)[0]
+        new_stsd_data = bytearray(stsd.data[:8])
+
+        parser.position = 8  # Move past version_flags and entry_count
+
+        for _ in range(entry_count):
+            sample_entry = parser.read_atom()
+            if not sample_entry:
+                break
+
+            processed_entry = self._process_sample_entry(sample_entry)
+            new_stsd_data.extend(processed_entry.pack())
+
+        return MP4Atom(b"stsd", len(new_stsd_data) + 8, new_stsd_data)
+
+    def _process_sample_entry(self, entry: MP4Atom) -> MP4Atom:
+        """
+        Processes a sample entry atom, which contains information about a specific type of sample.
+        This includes codec-specific information and other sample entry details.
+
+        Args:
+            entry (MP4Atom): The sample entry atom to process.
+
+        Returns:
+            MP4Atom: Processed sample entry atom with updated information.
+        """
+        # Determine the size of fixed fields based on sample entry type
+        if entry.atom_type in {b"mp4a", b"enca"}:
+            fixed_size = 28  # 8 bytes for size, type and reserved, 20 bytes for fixed fields in Audio Sample Entry.
+        elif entry.atom_type in {b"mp4v", b"encv", b"avc1", b"hev1", b"hvc1"}:
+            fixed_size = 78  # 8 bytes for size, type and reserved, 70 bytes for fixed fields in Video Sample Entry.
+        else:
+            fixed_size = 16  # 8 bytes for size, type and reserved, 8 bytes for fixed fields in other Sample Entries.
+
+        new_entry_data = bytearray(entry.data[:fixed_size])
+        parser = MP4Parser(entry.data[fixed_size:])
+        codec_format = None
+
+        for atom in iter(parser.read_atom, None):
+            if atom.atom_type in {b"sinf", b"schi", b"tenc", b"schm"}:
+                if atom.atom_type == b"sinf":
+                    codec_format = self._extract_codec_format(atom)
+                continue  # Skip encryption-related atoms
+            new_entry_data.extend(atom.pack())
+
+        # Replace the atom type with the extracted codec format
+        new_type = codec_format if codec_format else entry.atom_type
+        return MP4Atom(new_type, len(new_entry_data) + 8, new_entry_data)
+
+    def _extract_codec_format(self, sinf: MP4Atom) -> bytes | None:
+        """
+        Extracts the codec format from the 'sinf' (Protection Scheme Information) atom.
+        This includes information about the original format of the protected content.
+
+        Args:
+            sinf (MP4Atom): The 'sinf' atom to extract from.
+
+        Returns:
+            bytes | None: The codec format or None if not found.
+        """
+        parser = MP4Parser(sinf.data)
+        for atom in iter(parser.read_atom, None):
+            if atom.atom_type == b"frma":
+                return atom.data
+        return None
+
+
+def decrypt_segment(init_segment: bytes, segment_content: bytes, key_id: str, key: str) -> bytes:
+    """
+    Decrypts a CENC encrypted MP4 segment.
+
+    Args:
+        init_segment (bytes): Initialization segment data.
+        segment_content (bytes): Encrypted segment content.
+        key_id (str): Key ID in hexadecimal format.
+        key (str): Key in hexadecimal format.
+    """
+    key_map = {bytes.fromhex(key_id): bytes.fromhex(key)}
+    decrypter = MP4Decrypter(key_map)
+    decrypted_content = decrypter.decrypt_segment(init_segment + segment_content)
+    return decrypted_content
+
+
+def cli():
+    """
+    Command line interface for decrypting a CENC encrypted MP4 segment.
+    """
+    init_segment = b""
+
+    if args.init and args.segment:
+        with open(args.init, "rb") as f:
+            init_segment = f.read()
+        with open(args.segment, "rb") as f:
+            segment_content = f.read()
+    elif args.combined_segment:
+        with open(args.combined_segment, "rb") as f:
+            segment_content = f.read()
+    else:
+        print("Usage: python mp4decrypt.py --help")
+        sys.exit(1)
+
+    try:
+        decrypted_segment = decrypt_segment(init_segment, segment_content, args.key_id, args.key)
+        print(f"Decrypted content size is {len(decrypted_segment)} bytes")
+        with open(args.output, "wb") as f:
+            f.write(decrypted_segment)
+        print(f"Decrypted segment written to {args.output}")
+    except Exception as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    arg_parser = argparse.ArgumentParser(description="Decrypts a MP4 init and media segment using CENC encryption.")
+    arg_parser.add_argument("--init", help="Path to the init segment file", required=False)
+    arg_parser.add_argument("--segment", help="Path to the media segment file", required=False)
+    arg_parser.add_argument(
+        "--combined_segment", help="Path to the combined init and media segment file", required=False
+    )
+    arg_parser.add_argument("--key_id", help="Key ID in hexadecimal format", required=True)
+    arg_parser.add_argument("--key", help="Key in hexadecimal format", required=True)
+    arg_parser.add_argument("--output", help="Path to the output file", required=True)
+    args = arg_parser.parse_args()
+    cli()

mediaflow_proxy/handlers.py

@@ -0,0 +1,268 @@
+import base64
+import logging
+from ipaddress import ip_address
+
+import httpx
+from fastapi import Request, Response, HTTPException
+from fastapi.responses import StreamingResponse
+from pydantic import HttpUrl
+from starlette.background import BackgroundTask
+
+from .configs import settings
+from .mpd_processor import process_manifest, process_playlist, process_segment
+from .utils.cache_utils import get_cached_mpd, get_cached_init_segment
+from .utils.http_utils import Streamer, DownloadError, download_file_with_retry, request_with_retry
+from .utils.m3u8_processor import M3U8Processor
+from .utils.mpd_utils import pad_base64
+
+logger = logging.getLogger(__name__)
+
+
+async def handle_hls_stream_proxy(request: Request, destination: str, headers: dict, key_url: HttpUrl = None):
+    """
+    Handles the HLS stream proxy request, fetching and processing the m3u8 playlist or streaming the content.
+
+    Args:
+        request (Request): The incoming HTTP request.
+        destination (str): The destination URL to fetch the content from.
+        headers (dict): The headers to include in the request.
+        key_url (str, optional): The HLS Key URL to replace the original key URL. Defaults to None.
+
+    Returns:
+        Response: The HTTP response with the processed m3u8 playlist or streamed content.
+    """
+    try:
+        if destination.endswith((".m3u", ".m3u8")) or "mpegurl" in headers.get("accept", "").lower():
+            return await fetch_and_process_m3u8(destination, headers, request, key_url)
+
+        return await handle_stream_request(request.method, destination, headers)
+    except httpx.HTTPStatusError as e:
+        logger.error(f"HTTP error while fetching m3u8: {e}")
+        return Response(status_code=e.response.status_code, content=str(e))
+    except Exception as e:
+        logger.exception(f"Error in live_stream_proxy: {str(e)}")
+        return Response(status_code=500, content=f"Internal server error: {str(e)}")
+
+
+async def proxy_stream(method: str, video_url: str, headers: dict):
+    """
+    Proxies the stream request to the given video URL.
+
+    Args:
+        method (str): The HTTP method (e.g., GET, HEAD).
+        video_url (str): The URL of the video to stream.
+        headers (dict): The headers to include in the request.
+
+    Returns:
+        Response: The HTTP response with the streamed content.
+    """
+    return await handle_stream_request(method, video_url, headers)
+
+
+async def handle_stream_request(method: str, video_url: str, headers: dict):
+    """
+    Handles the stream request, fetching the content from the video URL and streaming it.
+
+    Args:
+        method (str): The HTTP method (e.g., GET, HEAD).
+        video_url (str): The URL of the video to stream.
+        headers (dict): The headers to include in the request.
+
+    Returns:
+        Response: The HTTP response with the streamed content.
+    """
+    client = httpx.AsyncClient(
+        follow_redirects=True,
+        timeout=httpx.Timeout(30.0),
+        limits=httpx.Limits(max_keepalive_connections=10, max_connections=20),
+        proxy=settings.proxy_url,
+    )
+    streamer = Streamer(client)
+    try:
+        response = await streamer.head(video_url, headers)
+        if method == "HEAD":
+            await streamer.close()
+            return Response(headers=response.headers, status_code=response.status_code)
+        else:
+            return StreamingResponse(
+                streamer.stream_content(video_url, headers),
+                headers=response.headers,
+                background=BackgroundTask(streamer.close),
+            )
+    except httpx.HTTPStatusError as e:
+        logger.error(f"Upstream service error while handling {method} request: {e}")
+        await client.aclose()
+        return Response(status_code=e.response.status_code, content=f"Upstream service error: {e}")
+    except DownloadError as e:
+        logger.error(f"Error downloading {video_url}: {e}")
+        return Response(status_code=502, content=str(e))
+    except Exception as e:
+        logger.error(f"Internal server error while handling {method} request: {e}")
+        await client.aclose()
+        return Response(status_code=502, content=f"Internal server error: {e}")
+
+
+async def fetch_and_process_m3u8(url: str, headers: dict, request: Request, key_url: HttpUrl = None):
+    """
+    Fetches and processes the m3u8 playlist, converting it to an HLS playlist.
+
+    Args:
+        url (str): The URL of the m3u8 playlist.
+        headers (dict): The headers to include in the request.
+        request (Request): The incoming HTTP request.
+        key_url (HttpUrl, optional): The HLS Key URL to replace the original key URL. Defaults to None.
+
+    Returns:
+        Response: The HTTP response with the processed m3u8 playlist.
+    """
+    async with httpx.AsyncClient(
+        follow_redirects=True,
+        timeout=httpx.Timeout(30.0),
+        limits=httpx.Limits(max_keepalive_connections=10, max_connections=20),
+        proxy=settings.proxy_url,
+    ) as client:
+        try:
+            streamer = Streamer(client)
+            content = await streamer.get_text(url, headers)
+            processor = M3U8Processor(request, key_url)
+            processed_content = await processor.process_m3u8(content, str(streamer.response.url))
+            return Response(
+                content=processed_content,
+                media_type="application/vnd.apple.mpegurl",
+                headers={
+                    "Content-Disposition": "inline",
+                    "Accept-Ranges": "none",
+                },
+            )
+        except httpx.HTTPStatusError as e:
+            logger.error(f"HTTP error while fetching m3u8: {e}")
+            return Response(status_code=e.response.status_code, content=str(e))
+        except DownloadError as e:
+            logger.error(f"Error downloading m3u8: {url}")
+            return Response(status_code=502, content=str(e))
+        except Exception as e:
+            logger.exception(f"Unexpected error while processing m3u8: {e}")
+            return Response(status_code=502, content=str(e))
+
+
+async def handle_drm_key_data(key_id, key, drm_info):
+    """
+    Handles the DRM key data, retrieving the key ID and key from the DRM info if not provided.
+
+    Args:
+        key_id (str): The DRM key ID.
+        key (str): The DRM key.
+        drm_info (dict): The DRM information from the MPD manifest.
+
+    Returns:
+        tuple: The key ID and key.
+    """
+    if drm_info and not drm_info.get("isDrmProtected"):
+        return None, None
+
+    if not key_id or not key:
+        if "keyId" in drm_info and "key" in drm_info:
+            key_id = drm_info["keyId"]
+            key = drm_info["key"]
+        elif "laUrl" in drm_info and "keyId" in drm_info:
+            raise HTTPException(status_code=400, detail="LA URL is not supported yet")
+        else:
+            raise HTTPException(
+                status_code=400, detail="Unable to determine key_id and key, and they were not provided"
+            )
+
+    return key_id, key
+
+
+async def get_manifest(request: Request, mpd_url: str, headers: dict, key_id: str = None, key: str = None):
+    """
+    Retrieves and processes the MPD manifest, converting it to an HLS manifest.
+
+    Args:
+        request (Request): The incoming HTTP request.
+        mpd_url (str): The URL of the MPD manifest.
+        headers (dict): The headers to include in the request.
+        key_id (str, optional): The DRM key ID. Defaults to None.
+        key (str, optional): The DRM key. Defaults to None.
+
+    Returns:
+        Response: The HTTP response with the HLS manifest.
+    """
+    try:
+        mpd_dict = await get_cached_mpd(mpd_url, headers=headers, parse_drm=not key_id and not key)
+    except DownloadError as e:
+        raise HTTPException(status_code=e.status_code, detail=f"Failed to download MPD: {e.message}")
+    drm_info = mpd_dict.get("drmInfo", {})
+
+    if drm_info and not drm_info.get("isDrmProtected"):
+        # For non-DRM protected MPD, we still create an HLS manifest
+        return await process_manifest(request, mpd_dict, None, None)
+
+    key_id, key = await handle_drm_key_data(key_id, key, drm_info)
+
+    # check if the provided key_id and key are valid
+    if key_id and len(key_id) != 32:
+        key_id = base64.urlsafe_b64decode(pad_base64(key_id)).hex()
+    if key and len(key) != 32:
+        key = base64.urlsafe_b64decode(pad_base64(key)).hex()
+
+    return await process_manifest(request, mpd_dict, key_id, key)
+
+
+async def get_playlist(
+    request: Request, mpd_url: str, profile_id: str, headers: dict, key_id: str = None, key: str = None
+):
+    """
+    Retrieves and processes the MPD manifest, converting it to an HLS playlist for a specific profile.
+
+    Args:
+        request (Request): The incoming HTTP request.
+        mpd_url (str): The URL of the MPD manifest.
+        profile_id (str): The profile ID to generate the playlist for.
+        headers (dict): The headers to include in the request.
+        key_id (str, optional): The DRM key ID. Defaults to None.
+        key (str, optional): The DRM key. Defaults to None.
+
+    Returns:
+        Response: The HTTP response with the HLS playlist.
+    """
+    mpd_dict = await get_cached_mpd(
+        mpd_url, headers=headers, parse_drm=not key_id and not key, parse_segment_profile_id=profile_id
+    )
+    return await process_playlist(request, mpd_dict, profile_id)
+
+
+async def get_segment(
+    init_url: str, segment_url: str, mimetype: str, headers: dict, key_id: str = None, key: str = None
+):
+    """
+    Retrieves and processes a media segment, decrypting it if necessary.
+
+    Args:
+        init_url (str): The URL of the initialization segment.
+        segment_url (str): The URL of the media segment.
+        mimetype (str): The MIME type of the segment.
+        headers (dict): The headers to include in the request.
+        key_id (str, optional): The DRM key ID. Defaults to None.
+        key (str, optional): The DRM key. Defaults to None.
+
+    Returns:
+        Response: The HTTP response with the processed segment.
+    """
+    try:
+        init_content = await get_cached_init_segment(init_url, headers)
+        segment_content = await download_file_with_retry(segment_url, headers)
+    except DownloadError as e:
+        raise HTTPException(status_code=e.status_code, detail=f"Failed to download segment: {e.message}")
+    return await process_segment(init_content, segment_content, mimetype, key_id, key)
+
+
+async def get_public_ip():
+    """
+    Retrieves the public IP address of the MediaFlow proxy.
+
+    Returns:
+        Response: The HTTP response with the public IP address.
+    """
+    ip_address_data = await request_with_retry("GET", "https://api.ipify.org?format=json", {})
+    return ip_address_data.json()

mediaflow_proxy/main.py

@@ -0,0 +1,51 @@
+import logging
+
+from fastapi import FastAPI, Depends, Security, HTTPException
+from fastapi.security import APIKeyQuery, APIKeyHeader
+from starlette.responses import RedirectResponse
+from starlette.staticfiles import StaticFiles
+
+from mediaflow_proxy.configs import settings
+from mediaflow_proxy.routes import proxy_router
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+app = FastAPI()
+api_password_query = APIKeyQuery(name="api_password", auto_error=False)
+api_password_header = APIKeyHeader(name="api_password", auto_error=False)
+
+
+async def verify_api_key(api_key: str = Security(api_password_query), api_key_alt: str = Security(api_password_header)):
+    """
+    Verifies the API key for the request.
+
+    Args:
+        api_key (str): The API key to validate.
+        api_key_alt (str): The alternative API key to validate.
+
+    Raises:
+        HTTPException: If the API key is invalid.
+    """
+    if api_key == settings.api_password or api_key_alt == settings.api_password:
+        return
+
+    raise HTTPException(status_code=403, detail="Could not validate credentials")
+
+
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy"}
+
+
+@app.get("/favicon.ico")
+async def get_favicon():
+    return RedirectResponse(url="/logo.png")
+
+
+app.include_router(proxy_router, prefix="/proxy", tags=["proxy"], dependencies=[Depends(verify_api_key)])
+app.mount("/", StaticFiles(directory="static", html=True), name="static")
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(app, host="127.0.0.1", port=8888)

mediaflow_proxy/mpd_processor.py

@@ -0,0 +1,202 @@
+import logging
+import math
+import time
+from datetime import datetime, timezone, timedelta
+
+from fastapi import Request, Response, HTTPException
+
+from mediaflow_proxy.configs import settings
+from mediaflow_proxy.drm.decrypter import decrypt_segment
+from mediaflow_proxy.utils.http_utils import encode_mediaflow_proxy_url
+
+logger = logging.getLogger(__name__)
+
+
+async def process_manifest(request: Request, mpd_dict: dict, key_id: str = None, key: str = None) -> Response:
+    """
+    Processes the MPD manifest and converts it to an HLS manifest.
+
+    Args:
+        request (Request): The incoming HTTP request.
+        mpd_dict (dict): The MPD manifest data.
+        key_id (str, optional): The DRM key ID. Defaults to None.
+        key (str, optional): The DRM key. Defaults to None.
+
+    Returns:
+        Response: The HLS manifest as an HTTP response.
+    """
+    hls_content = build_hls(mpd_dict, request, key_id, key)
+    return Response(content=hls_content, media_type="application/vnd.apple.mpegurl")
+
+
+async def process_playlist(request: Request, mpd_dict: dict, profile_id: str) -> Response:
+    """
+    Processes the MPD manifest and converts it to an HLS playlist for a specific profile.
+
+    Args:
+        request (Request): The incoming HTTP request.
+        mpd_dict (dict): The MPD manifest data.
+        profile_id (str): The profile ID to generate the playlist for.
+
+    Returns:
+        Response: The HLS playlist as an HTTP response.
+
+    Raises:
+        HTTPException: If the profile is not found in the MPD manifest.
+    """
+    matching_profiles = [p for p in mpd_dict["profiles"] if p["id"] == profile_id]
+    if not matching_profiles:
+        raise HTTPException(status_code=404, detail="Profile not found")
+
+    hls_content = build_hls_playlist(mpd_dict, matching_profiles, request)
+    return Response(content=hls_content, media_type="application/vnd.apple.mpegurl")
+
+
+async def process_segment(
+    init_content: bytes,
+    segment_content: bytes,
+    mimetype: str,
+    key_id: str = None,
+    key: str = None,
+) -> Response:
+    """
+    Processes and decrypts a media segment.
+
+    Args:
+        init_content (bytes): The initialization segment content.
+        segment_content (bytes): The media segment content.
+        mimetype (str): The MIME type of the segment.
+        key_id (str, optional): The DRM key ID. Defaults to None.
+        key (str, optional): The DRM key. Defaults to None.
+
+    Returns:
+        Response: The decrypted segment as an HTTP response.
+    """
+    if key_id and key:
+        # For DRM protected content
+        now = time.time()
+        decrypted_content = decrypt_segment(init_content, segment_content, key_id, key)
+        logger.info(f"Decryption of {mimetype} segment took {time.time() - now:.4f} seconds")
+    else:
+        # For non-DRM protected content, we just concatenate init and segment content
+        decrypted_content = init_content + segment_content
+
+    return Response(content=decrypted_content, media_type=mimetype)
+
+
+def build_hls(mpd_dict: dict, request: Request, key_id: str = None, key: str = None) -> str:
+    """
+    Builds an HLS manifest from the MPD manifest.
+
+    Args:
+        mpd_dict (dict): The MPD manifest data.
+        request (Request): The incoming HTTP request.
+        key_id (str, optional): The DRM key ID. Defaults to None.
+        key (str, optional): The DRM key. Defaults to None.
+
+    Returns:
+        str: The HLS manifest as a string.
+    """
+    hls = ["#EXTM3U", "#EXT-X-VERSION:6"]
+    query_params = dict(request.query_params)
+
+    video_profiles = {}
+    audio_profiles = {}
+
+    for profile in mpd_dict["profiles"]:
+        query_params.update({"profile_id": profile["id"], "key_id": key_id or "", "key": key or ""})
+        playlist_url = encode_mediaflow_proxy_url(
+            str(request.url_for("playlist_endpoint")),
+            query_params=query_params,
+        )
+
+        if "video" in profile["mimeType"]:
+            video_profiles[profile["id"]] = (profile, playlist_url)
+        elif "audio" in profile["mimeType"]:
+            audio_profiles[profile["id"]] = (profile, playlist_url)
+
+    # Add audio streams
+    for i, (profile, playlist_url) in enumerate(audio_profiles.values()):
+        is_default = "YES" if i == 0 else "NO"  # Set the first audio track as default
+        hls.append(
+            f'#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio",NAME="{profile["id"]}",DEFAULT={is_default},AUTOSELECT={is_default},LANGUAGE="{profile.get("lang", "und")}",URI="{playlist_url}"'
+        )
+
+    # Add video streams
+    for profile, playlist_url in video_profiles.values():
+        hls.append(
+            f'#EXT-X-STREAM-INF:BANDWIDTH={profile["bandwidth"]},RESOLUTION={profile["width"]}x{profile["height"]},CODECS="{profile["codecs"]}",FRAME-RATE={profile["frameRate"]},AUDIO="audio"'
+        )
+        hls.append(playlist_url)
+
+    return "\n".join(hls)
+
+
+def build_hls_playlist(mpd_dict: dict, profiles: list[dict], request: Request) -> str:
+    """
+    Builds an HLS playlist from the MPD manifest for specific profiles.
+
+    Args:
+        mpd_dict (dict): The MPD manifest data.
+        profiles (list[dict]): The profiles to include in the playlist.
+        request (Request): The incoming HTTP request.
+
+    Returns:
+        str: The HLS playlist as a string.
+    """
+    hls = ["#EXTM3U", "#EXT-X-VERSION:6"]
+
+    added_segments = 0
+    current_time = datetime.now(timezone.utc)
+    live_stream_delay = timedelta(seconds=settings.mpd_live_stream_delay)
+    target_end_time = current_time - live_stream_delay
+    for index, profile in enumerate(profiles):
+        segments = profile["segments"]
+        if not segments:
+            logger.warning(f"No segments found for profile {profile['id']}")
+            continue
+
+        # Add headers for only the first profile
+        if index == 0:
+            sequence = segments[0]["number"]
+            extinf_values = [f["extinf"] for f in segments if "extinf" in f]
+            target_duration = math.ceil(max(extinf_values)) if extinf_values else 3
+            hls.extend(
+                [
+                    f"#EXT-X-TARGETDURATION:{target_duration}",
+                    f"#EXT-X-MEDIA-SEQUENCE:{sequence}",
+                ]
+            )
+            if mpd_dict["isLive"]:
+                hls.append("#EXT-X-PLAYLIST-TYPE:EVENT")
+            else:
+                hls.append("#EXT-X-PLAYLIST-TYPE:VOD")
+
+        init_url = profile["initUrl"]
+
+        query_params = dict(request.query_params)
+        query_params.pop("profile_id", None)
+        query_params.pop("d", None)
+
+        for segment in segments:
+            if mpd_dict["isLive"]:
+                if segment["end_time"] > target_end_time:
+                    continue
+                hls.append(f"#EXT-X-PROGRAM-DATE-TIME:{segment['program_date_time']}")
+            hls.append(f'#EXTINF:{segment["extinf"]:.3f},')
+            query_params.update(
+                {"init_url": init_url, "segment_url": segment["media"], "mime_type": profile["mimeType"]}
+            )
+            hls.append(
+                encode_mediaflow_proxy_url(
+                    str(request.url_for("segment_endpoint")),
+                    query_params=query_params,
+                )
+            )
+            added_segments += 1
+
+    if not mpd_dict["isLive"]:
+        hls.append("#EXT-X-ENDLIST")
+
+    logger.info(f"Added {added_segments} segments to HLS playlist")
+    return "\n".join(hls)

mediaflow_proxy/routes.py

@@ -0,0 +1,148 @@
+from fastapi import Request, Depends, APIRouter
+from pydantic import HttpUrl
+
+from .handlers import handle_hls_stream_proxy, proxy_stream, get_manifest, get_playlist, get_segment, get_public_ip
+
+proxy_router = APIRouter()
+
+
+def get_proxy_headers(request: Request) -> dict:
+    """
+    Extracts proxy headers from the request query parameters.
+
+    Args:
+        request (Request): The incoming HTTP request.
+
+    Returns:
+        dict: A dictionary of proxy headers.
+    """
+    return {k[2:]: v for k, v in request.query_params.items() if k.startswith("h_")}
+
+
+@proxy_router.head("/hls")
+@proxy_router.get("/hls")
+async def hls_stream_proxy(
+    request: Request,
+    d: HttpUrl,
+    headers: dict = Depends(get_proxy_headers),
+    key_url: HttpUrl | None = None,
+):
+    """
+    Proxify HLS stream requests, fetching and processing the m3u8 playlist or streaming the content.
+
+    Args:
+        request (Request): The incoming HTTP request.
+        d (HttpUrl): The destination URL to fetch the content from.
+        key_url (HttpUrl, optional): The HLS Key URL to replace the original key URL. Defaults to None. (Useful for bypassing some sneaky protection)
+        headers (dict): The headers to include in the request.
+
+    Returns:
+        Response: The HTTP response with the processed m3u8 playlist or streamed content.
+    """
+    destination = str(d)
+    return await handle_hls_stream_proxy(request, destination, headers, key_url)
+
+
+@proxy_router.head("/stream")
+@proxy_router.get("/stream")
+async def proxy_stream_endpoint(request: Request, d: HttpUrl, headers: dict = Depends(get_proxy_headers)):
+    """
+    Proxies stream requests to the given video URL.
+
+    Args:
+        request (Request): The incoming HTTP request.
+        d (HttpUrl): The URL of the video to stream.
+        headers (dict): The headers to include in the request.
+
+    Returns:
+        Response: The HTTP response with the streamed content.
+    """
+    headers.update({"range": headers.get("range", "bytes=0-")})
+    return await proxy_stream(request.method, str(d), headers)
+
+
+@proxy_router.get("/mpd/manifest")
+async def manifest_endpoint(
+    request: Request,
+    d: HttpUrl,
+    headers: dict = Depends(get_proxy_headers),
+    key_id: str = None,
+    key: str = None,
+):
+    """
+    Retrieves and processes the MPD manifest, converting it to an HLS manifest.
+
+    Args:
+        request (Request): The incoming HTTP request.
+        d (HttpUrl): The URL of the MPD manifest.
+        headers (dict): The headers to include in the request.
+        key_id (str, optional): The DRM key ID. Defaults to None.
+        key (str, optional): The DRM key. Defaults to None.
+
+    Returns:
+        Response: The HTTP response with the HLS manifest.
+    """
+    return await get_manifest(request, str(d), headers, key_id, key)
+
+
+@proxy_router.get("/mpd/playlist")
+async def playlist_endpoint(
+    request: Request,
+    d: HttpUrl,
+    profile_id: str,
+    headers: dict = Depends(get_proxy_headers),
+    key_id: str = None,
+    key: str = None,
+):
+    """
+    Retrieves and processes the MPD manifest, converting it to an HLS playlist for a specific profile.
+
+    Args:
+        request (Request): The incoming HTTP request.
+        d (HttpUrl): The URL of the MPD manifest.
+        profile_id (str): The profile ID to generate the playlist for.
+        headers (dict): The headers to include in the request.
+        key_id (str, optional): The DRM key ID. Defaults to None.
+        key (str, optional): The DRM key. Defaults to None.
+
+    Returns:
+        Response: The HTTP response with the HLS playlist.
+    """
+    return await get_playlist(request, str(d), profile_id, headers, key_id, key)
+
+
+@proxy_router.get("/mpd/segment")
+async def segment_endpoint(
+    init_url: HttpUrl,
+    segment_url: HttpUrl,
+    mime_type: str,
+    headers: dict = Depends(get_proxy_headers),
+    key_id: str = None,
+    key: str = None,
+):
+    """
+    Retrieves and processes a media segment, decrypting it if necessary.
+
+    Args:
+        init_url (HttpUrl): The URL of the initialization segment.
+        segment_url (HttpUrl): The URL of the media segment.
+        mime_type (str): The MIME type of the segment.
+        headers (dict): The headers to include in the request.
+        key_id (str, optional): The DRM key ID. Defaults to None.
+        key (str, optional): The DRM key. Defaults to None.
+
+    Returns:
+        Response: The HTTP response with the processed segment.
+    """
+    return await get_segment(str(init_url), str(segment_url), mime_type, headers, key_id, key)
+
+
+@proxy_router.get("/ip")
+async def get_mediaflow_proxy_public_ip():
+    """
+    Retrieves the public IP address of the MediaFlow proxy server.
+
+    Returns:
+        Response: The HTTP response with the public IP address in the form of a JSON object. {"ip": "xxx.xxx.xxx.xxx"}
+    """
+    return await get_public_ip()

mediaflow_proxy/utils/cache_utils.py

@@ -0,0 +1,58 @@
+import datetime
+import logging
+
+from cachetools import TTLCache
+
+from .http_utils import download_file_with_retry
+from .mpd_utils import parse_mpd, parse_mpd_dict
+
+logger = logging.getLogger(__name__)
+
+# cache dictionary
+mpd_cache = TTLCache(maxsize=100, ttl=300)  # 5 minutes default TTL
+init_segment_cache = TTLCache(maxsize=100, ttl=3600)  # 1 hour default TTL
+
+
+async def get_cached_mpd(
+    mpd_url: str, headers: dict, parse_drm: bool, parse_segment_profile_id: str | None = None
+) -> dict:
+    """
+    Retrieves and caches the MPD manifest, parsing it if not already cached.
+
+    Args:
+        mpd_url (str): The URL of the MPD manifest.
+        headers (dict): The headers to include in the request.
+        parse_drm (bool): Whether to parse DRM information.
+        parse_segment_profile_id (str, optional): The profile ID to parse segments for. Defaults to None.
+
+    Returns:
+        dict: The parsed MPD manifest data.
+    """
+    current_time = datetime.datetime.now(datetime.UTC)
+    if mpd_url in mpd_cache and mpd_cache[mpd_url]["expires"] > current_time:
+        logger.info(f"Using cached MPD for {mpd_url}")
+        return parse_mpd_dict(mpd_cache[mpd_url]["mpd"], mpd_url, parse_drm, parse_segment_profile_id)
+
+    mpd_dict = parse_mpd(await download_file_with_retry(mpd_url, headers))
+    parsed_mpd_dict = parse_mpd_dict(mpd_dict, mpd_url, parse_drm, parse_segment_profile_id)
+    current_time = datetime.datetime.now(datetime.UTC)
+    expiration_time = current_time + datetime.timedelta(seconds=parsed_mpd_dict.get("minimumUpdatePeriod", 300))
+    mpd_cache[mpd_url] = {"mpd": mpd_dict, "expires": expiration_time}
+    return parsed_mpd_dict
+
+
+async def get_cached_init_segment(init_url: str, headers: dict) -> bytes:
+    """
+    Retrieves and caches the initialization segment.
+
+    Args:
+        init_url (str): The URL of the initialization segment.
+        headers (dict): The headers to include in the request.
+
+    Returns:
+        bytes: The initialization segment content.
+    """
+    if init_url not in init_segment_cache:
+        init_content = await download_file_with_retry(init_url, headers)
+        init_segment_cache[init_url] = init_content
+    return init_segment_cache[init_url]

mediaflow_proxy/utils/http_utils.py

@@ -0,0 +1,220 @@
+import logging
+from urllib import parse
+
+import httpx
+import tenacity
+from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
+
+from mediaflow_proxy.configs import settings
+
+logger = logging.getLogger(__name__)
+
+
+class DownloadError(Exception):
+    def __init__(self, status_code, message):
+        self.status_code = status_code
+        self.message = message
+        super().__init__(message)
+
+
+@retry(
+    stop=stop_after_attempt(3),
+    wait=wait_exponential(multiplier=1, min=4, max=10),
+    retry=retry_if_exception_type(DownloadError),
+)
+async def fetch_with_retry(client, method, url, headers, follow_redirects=True, **kwargs):
+    """
+    Fetches a URL with retry logic.
+
+    Args:
+        client (httpx.AsyncClient): The HTTP client to use for the request.
+        method (str): The HTTP method to use (e.g., GET, POST).
+        url (str): The URL to fetch.
+        headers (dict): The headers to include in the request.
+        follow_redirects (bool, optional): Whether to follow redirects. Defaults to True.
+        **kwargs: Additional arguments to pass to the request.
+
+    Returns:
+        httpx.Response: The HTTP response.
+
+    Raises:
+        DownloadError: If the request fails after retries.
+    """
+    try:
+        response = await client.request(method, url, headers=headers, follow_redirects=follow_redirects, **kwargs)
+        response.raise_for_status()
+        return response
+    except httpx.TimeoutException:
+        logger.warning(f"Timeout while downloading {url}")
+        raise DownloadError(409, f"Timeout while downloading {url}")
+    except httpx.HTTPStatusError as e:
+        logger.error(f"HTTP error {e.response.status_code} while downloading {url}")
+        # if e.response.status_code == 404:
+        #     logger.error(f"Segment Resource not found: {url}")
+        #     raise e
+        raise DownloadError(e.response.status_code, f"HTTP error {e.response.status_code} while downloading {url}")
+    except Exception as e:
+        logger.error(f"Error downloading {url}: {e}")
+        raise
+
+
+class Streamer:
+    def __init__(self, client):
+        """
+        Initializes the Streamer with an HTTP client.
+
+        Args:
+            client (httpx.AsyncClient): The HTTP client to use for streaming.
+        """
+        self.client = client
+        self.response = None
+
+    async def stream_content(self, url: str, headers: dict):
+        """
+        Streams content from a URL.
+
+        Args:
+            url (str): The URL to stream content from.
+            headers (dict): The headers to include in the request.
+
+        Yields:
+            bytes: Chunks of the streamed content.
+        """
+        async with self.client.stream("GET", url, headers=headers, follow_redirects=True) as self.response:
+            self.response.raise_for_status()
+            async for chunk in self.response.aiter_bytes():
+                yield chunk
+
+    async def head(self, url: str, headers: dict):
+        """
+        Sends a HEAD request to a URL.
+
+        Args:
+            url (str): The URL to send the HEAD request to.
+            headers (dict): The headers to include in the request.
+
+        Returns:
+            httpx.Response: The HTTP response.
+        """
+        try:
+            self.response = await fetch_with_retry(self.client, "HEAD", url, headers)
+        except tenacity.RetryError as e:
+            raise e.last_attempt.result()
+        return self.response
+
+    async def get_text(self, url: str, headers: dict):
+        """
+        Sends a GET request to a URL and returns the response text.
+
+        Args:
+            url (str): The URL to send the GET request to.
+            headers (dict): The headers to include in the request.
+
+        Returns:
+            str: The response text.
+        """
+        try:
+            self.response = await fetch_with_retry(self.client, "GET", url, headers)
+        except tenacity.RetryError as e:
+            raise e.last_attempt.result()
+        return self.response.text
+
+    async def close(self):
+        """
+        Closes the HTTP client and response.
+        """
+        if self.response:
+            await self.response.aclose()
+        await self.client.aclose()
+
+
+async def download_file_with_retry(url: str, headers: dict, timeout: float = 10.0):
+    """
+    Downloads a file with retry logic.
+
+    Args:
+        url (str): The URL of the file to download.
+        headers (dict): The headers to include in the request.
+        timeout (float, optional): The request timeout. Defaults to 10.0.
+
+    Returns:
+        bytes: The downloaded file content.
+
+    Raises:
+        DownloadError: If the download fails after retries.
+    """
+    async with httpx.AsyncClient(follow_redirects=True, timeout=timeout, proxy=settings.proxy_url) as client:
+        try:
+            response = await fetch_with_retry(client, "GET", url, headers)
+            return response.content
+        except DownloadError as e:
+            logger.error(f"Failed to download file: {e}")
+            raise e
+        except tenacity.RetryError as e:
+            raise DownloadError(502, f"Failed to download file: {e.last_attempt.result()}")
+
+
+async def request_with_retry(method: str, url: str, headers: dict, timeout: float = 10.0, **kwargs):
+    """
+    Sends an HTTP request with retry logic.
+
+    Args:
+        method (str): The HTTP method to use (e.g., GET, POST).
+        url (str): The URL to send the request to.
+        headers (dict): The headers to include in the request.
+        timeout (float, optional): The request timeout. Defaults to 10.0.
+        **kwargs: Additional arguments to pass to the request.
+
+    Returns:
+        httpx.Response: The HTTP response.
+
+    Raises:
+        DownloadError: If the request fails after retries.
+    """
+    async with httpx.AsyncClient(follow_redirects=True, timeout=timeout, proxy=settings.proxy_url) as client:
+        try:
+            response = await fetch_with_retry(client, method, url, headers, **kwargs)
+            return response
+        except DownloadError as e:
+            logger.error(f"Failed to download file: {e}")
+            raise
+
+
+def encode_mediaflow_proxy_url(
+    mediaflow_proxy_url: str,
+    endpoint: str | None = None,
+    destination_url: str | None = None,
+    query_params: dict | None = None,
+    request_headers: dict | None = None,
+) -> str:
+    """
+    Encodes a MediaFlow proxy URL with query parameters and headers.
+
+    Args:
+        mediaflow_proxy_url (str): The base MediaFlow proxy URL.
+        endpoint (str, optional): The endpoint to append to the base URL. Defaults to None.
+        destination_url (str, optional): The destination URL to include in the query parameters. Defaults to None.
+        query_params (dict, optional): Additional query parameters to include. Defaults to None.
+        request_headers (dict, optional): Headers to include as query parameters. Defaults to None.
+
+    Returns:
+        str: The encoded MediaFlow proxy URL.
+    """
+    query_params = query_params or {}
+    if destination_url is not None:
+        query_params["d"] = destination_url
+
+    # Add headers if provided
+    if request_headers:
+        query_params.update(
+            {key if key.startswith("h_") else f"h_{key}": value for key, value in request_headers.items()}
+        )
+    # Encode the query parameters
+    encoded_params = parse.urlencode(query_params, quote_via=parse.quote)
+
+    # Construct the full URL
+    if endpoint is None:
+        return f"{mediaflow_proxy_url}?{encoded_params}"
+
+    base_url = parse.urljoin(mediaflow_proxy_url, endpoint)
+    return f"{base_url}?{encoded_params}"

mediaflow_proxy/utils/m3u8_processor.py

@@ -0,0 +1,82 @@
+import re
+from urllib import parse
+
+from pydantic import HttpUrl
+
+from mediaflow_proxy.utils.http_utils import encode_mediaflow_proxy_url
+
+
+class M3U8Processor:
+    def __init__(self, request, key_url: HttpUrl = None):
+        """
+        Initializes the M3U8Processor with the request and URL prefix.
+
+        Args:
+            request (Request): The incoming HTTP request.
+            key_url (HttpUrl, optional): The URL of the key server. Defaults to None.
+        """
+        self.request = request
+        self.key_url = key_url
+
+    async def process_m3u8(self, content: str, base_url: str) -> str:
+        """
+        Processes the m3u8 content, proxying URLs and handling key lines.
+
+        Args:
+            content (str): The m3u8 content to process.
+            base_url (str): The base URL to resolve relative URLs.
+
+        Returns:
+            str: The processed m3u8 content.
+        """
+        lines = content.splitlines()
+        processed_lines = []
+        for line in lines:
+            if "URI=" in line:
+                processed_lines.append(await self.process_key_line(line, base_url))
+            elif not line.startswith("#") and line.strip():
+                processed_lines.append(await self.proxy_url(line, base_url))
+            else:
+                processed_lines.append(line)
+        return "\n".join(processed_lines)
+
+    async def process_key_line(self, line: str, base_url: str) -> str:
+        """
+        Processes a key line in the m3u8 content, proxying the URI.
+
+        Args:
+            line (str): The key line to process.
+            base_url (str): The base URL to resolve relative URLs.
+
+        Returns:
+            str: The processed key line.
+        """
+        uri_match = re.search(r'URI="([^"]+)"', line)
+        if uri_match:
+            original_uri = uri_match.group(1)
+            uri = parse.urlparse(original_uri)
+            if self.key_url:
+                uri = uri._replace(scheme=self.key_url.scheme, netloc=self.key_url.host)
+            new_uri = await self.proxy_url(uri.geturl(), base_url)
+            line = line.replace(f'URI="{original_uri}"', f'URI="{new_uri}"')
+        return line
+
+    async def proxy_url(self, url: str, base_url: str) -> str:
+        """
+        Proxies a URL, encoding it with the MediaFlow proxy URL.
+
+        Args:
+            url (str): The URL to proxy.
+            base_url (str): The base URL to resolve relative URLs.
+
+        Returns:
+            str: The proxied URL.
+        """
+        full_url = parse.urljoin(base_url, url)
+
+        return encode_mediaflow_proxy_url(
+            str(self.request.url_for("hls_stream_proxy")),
+            "",
+            full_url,
+            query_params=dict(self.request.query_params),
+        )

mediaflow_proxy/utils/mpd_utils.py

@@ -0,0 +1,555 @@
+import logging
+import math
+import re
+from datetime import datetime, timedelta, timezone
+from typing import List, Dict
+from urllib.parse import urljoin
+
+import xmltodict
+
+logger = logging.getLogger(__name__)
+
+
+def parse_mpd(mpd_content: str) -> dict:
+    """
+    Parses the MPD content into a dictionary.
+
+    Args:
+        mpd_content (str): The MPD content as a string.
+
+    Returns:
+        dict: The parsed MPD content as a dictionary.
+    """
+    return xmltodict.parse(mpd_content)
+
+
+def parse_mpd_dict(
+    mpd_dict: dict, mpd_url: str, parse_drm: bool = True, parse_segment_profile_id: str | None = None
+) -> dict:
+    """
+    Parses the MPD dictionary and extracts relevant information.
+
+    Args:
+        mpd_dict (dict): The MPD content as a dictionary.
+        mpd_url (str): The URL of the MPD manifest.
+        parse_drm (bool, optional): Whether to parse DRM information. Defaults to True.
+        parse_segment_profile_id (str, optional): The profile ID to parse segments for. Defaults to None.
+
+    Returns:
+        dict: The parsed MPD information including profiles and DRM info.
+
+    This function processes the MPD dictionary to extract profiles, DRM information, and other relevant data.
+    It handles both live and static MPD manifests.
+    """
+    profiles = []
+    parsed_dict = {}
+    source = "/".join(mpd_url.split("/")[:-1])
+
+    is_live = mpd_dict["MPD"].get("@type", "static").lower() == "dynamic"
+    parsed_dict["isLive"] = is_live
+
+    media_presentation_duration = mpd_dict["MPD"].get("@mediaPresentationDuration")
+
+    # Parse additional MPD attributes for live streams
+    if is_live:
+        parsed_dict["minimumUpdatePeriod"] = parse_duration(mpd_dict["MPD"].get("@minimumUpdatePeriod", "PT0S"))
+        parsed_dict["timeShiftBufferDepth"] = parse_duration(mpd_dict["MPD"].get("@timeShiftBufferDepth", "PT2M"))
+        parsed_dict["availabilityStartTime"] = datetime.fromisoformat(
+            mpd_dict["MPD"]["@availabilityStartTime"].replace("Z", "+00:00")
+        )
+        parsed_dict["publishTime"] = datetime.fromisoformat(
+            mpd_dict["MPD"].get("@publishTime", "").replace("Z", "+00:00")
+        )
+
+    periods = mpd_dict["MPD"]["Period"]
+    periods = periods if isinstance(periods, list) else [periods]
+
+    for period in periods:
+        parsed_dict["PeriodStart"] = parse_duration(period.get("@start", "PT0S"))
+        for adaptation in period["AdaptationSet"]:
+            representations = adaptation["Representation"]
+            representations = representations if isinstance(representations, list) else [representations]
+
+            for representation in representations:
+                profile = parse_representation(
+                    parsed_dict,
+                    representation,
+                    adaptation,
+                    source,
+                    media_presentation_duration,
+                    parse_segment_profile_id,
+                )
+                if profile:
+                    profiles.append(profile)
+    parsed_dict["profiles"] = profiles
+
+    if parse_drm:
+        drm_info = extract_drm_info(periods, mpd_url)
+    else:
+        drm_info = {}
+    parsed_dict["drmInfo"] = drm_info
+
+    return parsed_dict
+
+
+def pad_base64(encoded_key_id):
+    """
+    Pads a base64 encoded key ID to make its length a multiple of 4.
+
+    Args:
+        encoded_key_id (str): The base64 encoded key ID.
+
+    Returns:
+        str: The padded base64 encoded key ID.
+    """
+    return encoded_key_id + "=" * (4 - len(encoded_key_id) % 4)
+
+
+def extract_drm_info(periods: List[Dict], mpd_url: str) -> Dict:
+    """
+    Extracts DRM information from the MPD periods.
+
+    Args:
+        periods (List[Dict]): The list of periods in the MPD.
+        mpd_url (str): The URL of the MPD manifest.
+
+    Returns:
+        Dict: The extracted DRM information.
+
+    This function processes the ContentProtection elements in the MPD to extract DRM system information,
+    such as ClearKey, Widevine, and PlayReady.
+    """
+    drm_info = {"isDrmProtected": False}
+
+    for period in periods:
+        adaptation_sets: list[dict] | dict = period.get("AdaptationSet", [])
+        if not isinstance(adaptation_sets, list):
+            adaptation_sets = [adaptation_sets]
+
+        for adaptation_set in adaptation_sets:
+            # Check ContentProtection in AdaptationSet
+            process_content_protection(adaptation_set.get("ContentProtection", []), drm_info)
+
+            # Check ContentProtection inside each Representation
+            representations: list[dict] | dict = adaptation_set.get("Representation", [])
+            if not isinstance(representations, list):
+                representations = [representations]
+
+            for representation in representations:
+                process_content_protection(representation.get("ContentProtection", []), drm_info)
+
+    # If we have a license acquisition URL, make sure it's absolute
+    if "laUrl" in drm_info and not drm_info["laUrl"].startswith(("http://", "https://")):
+        drm_info["laUrl"] = urljoin(mpd_url, drm_info["laUrl"])
+
+    return drm_info
+
+
+def process_content_protection(content_protection: list[dict] | dict, drm_info: dict):
+    """
+    Processes the ContentProtection elements to extract DRM information.
+
+    Args:
+        content_protection (list[dict] | dict): The ContentProtection elements.
+        drm_info (dict): The dictionary to store DRM information.
+
+    This function updates the drm_info dictionary with DRM system information found in the ContentProtection elements.
+    """
+    if not isinstance(content_protection, list):
+        content_protection = [content_protection]
+
+    for protection in content_protection:
+        drm_info["isDrmProtected"] = True
+        scheme_id_uri = protection.get("@schemeIdUri", "").lower()
+
+        if "clearkey" in scheme_id_uri:
+            drm_info["drmSystem"] = "clearkey"
+            if "clearkey:Laurl" in protection:
+                la_url = protection["clearkey:Laurl"].get("#text")
+                if la_url and "laUrl" not in drm_info:
+                    drm_info["laUrl"] = la_url
+
+        elif "widevine" in scheme_id_uri or "edef8ba9-79d6-4ace-a3c8-27dcd51d21ed" in scheme_id_uri:
+            drm_info["drmSystem"] = "widevine"
+            pssh = protection.get("cenc:pssh", {}).get("#text")
+            if pssh:
+                drm_info["pssh"] = pssh
+
+        elif "playready" in scheme_id_uri or "9a04f079-9840-4286-ab92-e65be0885f95" in scheme_id_uri:
+            drm_info["drmSystem"] = "playready"
+
+        if "@cenc:default_KID" in protection:
+            key_id = protection["@cenc:default_KID"].replace("-", "")
+            if "keyId" not in drm_info:
+                drm_info["keyId"] = key_id
+
+        if "ms:laurl" in protection:
+            la_url = protection["ms:laurl"].get("@licenseUrl")
+            if la_url and "laUrl" not in drm_info:
+                drm_info["laUrl"] = la_url
+
+    return drm_info
+
+
+def parse_representation(
+    parsed_dict: dict,
+    representation: dict,
+    adaptation: dict,
+    source: str,
+    media_presentation_duration: str,
+    parse_segment_profile_id: str | None,
+) -> dict | None:
+    """
+    Parses a representation and extracts profile information.
+
+    Args:
+        parsed_dict (dict): The parsed MPD data.
+        representation (dict): The representation data.
+        adaptation (dict): The adaptation set data.
+        source (str): The source URL.
+        media_presentation_duration (str): The media presentation duration.
+        parse_segment_profile_id (str, optional): The profile ID to parse segments for. Defaults to None.
+
+    Returns:
+        dict | None: The parsed profile information or None if not applicable.
+    """
+    mime_type = _get_key(adaptation, representation, "@mimeType") or (
+        "video/mp4" if "avc" in representation["@codecs"] else "audio/mp4"
+    )
+    if "video" not in mime_type and "audio" not in mime_type:
+        return None
+
+    profile = {
+        "id": representation.get("@id") or adaptation.get("@id"),
+        "mimeType": mime_type,
+        "lang": representation.get("@lang") or adaptation.get("@lang"),
+        "codecs": representation.get("@codecs") or adaptation.get("@codecs"),
+        "bandwidth": int(representation.get("@bandwidth") or adaptation.get("@bandwidth")),
+        "startWithSAP": (_get_key(adaptation, representation, "@startWithSAP") or "1") == "1",
+        "mediaPresentationDuration": media_presentation_duration,
+    }
+
+    if "audio" in profile["mimeType"]:
+        profile["audioSamplingRate"] = representation.get("@audioSamplingRate") or adaptation.get("@audioSamplingRate")
+        profile["channels"] = representation.get("AudioChannelConfiguration", {}).get("@value", "2")
+    else:
+        profile["width"] = int(representation["@width"])
+        profile["height"] = int(representation["@height"])
+        frame_rate = representation.get("@frameRate") or adaptation.get("@maxFrameRate") or "30000/1001"
+        frame_rate = frame_rate if "/" in frame_rate else f"{frame_rate}/1"
+        profile["frameRate"] = round(int(frame_rate.split("/")[0]) / int(frame_rate.split("/")[1]), 3)
+        profile["sar"] = representation.get("@sar", "1:1")
+
+    if parse_segment_profile_id is None or profile["id"] != parse_segment_profile_id:
+        return profile
+
+    item = adaptation.get("SegmentTemplate") or representation.get("SegmentTemplate")
+    if item:
+        profile["segments"] = parse_segment_template(parsed_dict, item, profile, source)
+    else:
+        profile["segments"] = parse_segment_base(representation, source)
+
+    return profile
+
+
+def _get_key(adaptation: dict, representation: dict, key: str) -> str | None:
+    """
+    Retrieves a key from the representation or adaptation set.
+
+    Args:
+        adaptation (dict): The adaptation set data.
+        representation (dict): The representation data.
+        key (str): The key to retrieve.
+
+    Returns:
+        str | None: The value of the key or None if not found.
+    """
+    return representation.get(key, adaptation.get(key, None))
+
+
+def parse_segment_template(parsed_dict: dict, item: dict, profile: dict, source: str) -> List[Dict]:
+    """
+    Parses a segment template and extracts segment information.
+
+    Args:
+        parsed_dict (dict): The parsed MPD data.
+        item (dict): The segment template data.
+        profile (dict): The profile information.
+        source (str): The source URL.
+
+    Returns:
+        List[Dict]: The list of parsed segments.
+    """
+    segments = []
+    timescale = int(item.get("@timescale", 1))
+
+    # Initialization
+    if "@initialization" in item:
+        media = item["@initialization"]
+        media = media.replace("$RepresentationID$", profile["id"])
+        media = media.replace("$Bandwidth$", str(profile["bandwidth"]))
+        if not media.startswith("http"):
+            media = f"{source}/{media}"
+        profile["initUrl"] = media
+
+    # Segments
+    if "SegmentTimeline" in item:
+        segments.extend(parse_segment_timeline(parsed_dict, item, profile, source, timescale))
+    elif "@duration" in item:
+        segments.extend(parse_segment_duration(parsed_dict, item, profile, source, timescale))
+
+    return segments
+
+
+def parse_segment_timeline(parsed_dict: dict, item: dict, profile: dict, source: str, timescale: int) -> List[Dict]:
+    """
+    Parses a segment timeline and extracts segment information.
+
+    Args:
+        parsed_dict (dict): The parsed MPD data.
+        item (dict): The segment timeline data.
+        profile (dict): The profile information.
+        source (str): The source URL.
+        timescale (int): The timescale for the segments.
+
+    Returns:
+        List[Dict]: The list of parsed segments.
+    """
+    timelines = item["SegmentTimeline"]["S"]
+    timelines = timelines if isinstance(timelines, list) else [timelines]
+    period_start = parsed_dict["availabilityStartTime"] + timedelta(seconds=parsed_dict.get("PeriodStart", 0))
+    presentation_time_offset = int(item.get("@presentationTimeOffset", 0))
+    start_number = int(item.get("@startNumber", 1))
+
+    segments = [
+        create_segment_data(timeline, item, profile, source, timescale)
+        for timeline in preprocess_timeline(timelines, start_number, period_start, presentation_time_offset, timescale)
+    ]
+    return segments
+
+
+def preprocess_timeline(
+    timelines: List[Dict], start_number: int, period_start: datetime, presentation_time_offset: int, timescale: int
+) -> List[Dict]:
+    """
+    Preprocesses the segment timeline data.
+
+    Args:
+        timelines (List[Dict]): The list of timeline segments.
+        start_number (int): The starting segment number.
+        period_start (datetime): The start time of the period.
+        presentation_time_offset (int): The presentation time offset.
+        timescale (int): The timescale for the segments.
+
+    Returns:
+        List[Dict]: The list of preprocessed timeline segments.
+    """
+    processed_data = []
+    current_time = 0
+    for timeline in timelines:
+        repeat = int(timeline.get("@r", 0))
+        duration = int(timeline["@d"])
+        start_time = int(timeline.get("@t", current_time))
+
+        for _ in range(repeat + 1):
+            segment_start_time = period_start + timedelta(seconds=(start_time - presentation_time_offset) / timescale)
+            segment_end_time = segment_start_time + timedelta(seconds=duration / timescale)
+            processed_data.append(
+                {
+                    "number": start_number,
+                    "start_time": segment_start_time,
+                    "end_time": segment_end_time,
+                    "duration": duration,
+                    "time": start_time,
+                }
+            )
+            start_time += duration
+            start_number += 1
+
+        current_time = start_time
+
+    return processed_data
+
+
+def parse_segment_duration(parsed_dict: dict, item: dict, profile: dict, source: str, timescale: int) -> List[Dict]:
+    """
+    Parses segment duration and extracts segment information.
+    This is used for static or live MPD manifests.
+
+    Args:
+        parsed_dict (dict): The parsed MPD data.
+        item (dict): The segment duration data.
+        profile (dict): The profile information.
+        source (str): The source URL.
+        timescale (int): The timescale for the segments.
+
+    Returns:
+        List[Dict]: The list of parsed segments.
+    """
+    duration = int(item["@duration"])
+    start_number = int(item.get("@startNumber", 1))
+    segment_duration_sec = duration / timescale
+
+    if parsed_dict["isLive"]:
+        segments = generate_live_segments(parsed_dict, segment_duration_sec, start_number)
+    else:
+        segments = generate_vod_segments(profile, duration, timescale, start_number)
+
+    return [create_segment_data(seg, item, profile, source, timescale) for seg in segments]
+
+
+def generate_live_segments(parsed_dict: dict, segment_duration_sec: float, start_number: int) -> List[Dict]:
+    """
+    Generates live segments based on the segment duration and start number.
+    This is used for live MPD manifests.
+
+    Args:
+        parsed_dict (dict): The parsed MPD data.
+        segment_duration_sec (float): The segment duration in seconds.
+        start_number (int): The starting segment number.
+
+    Returns:
+        List[Dict]: The list of generated live segments.
+    """
+    time_shift_buffer_depth = timedelta(seconds=parsed_dict.get("timeShiftBufferDepth", 60))
+    segment_count = math.ceil(time_shift_buffer_depth.total_seconds() / segment_duration_sec)
+    current_time = datetime.now(tz=timezone.utc)
+    earliest_segment_number = max(
+        start_number
+        + math.floor((current_time - parsed_dict["availabilityStartTime"]).total_seconds() / segment_duration_sec)
+        - segment_count,
+        start_number,
+    )
+
+    return [
+        {
+            "number": number,
+            "start_time": parsed_dict["availabilityStartTime"]
+            + timedelta(seconds=(number - start_number) * segment_duration_sec),
+            "duration": segment_duration_sec,
+        }
+        for number in range(earliest_segment_number, earliest_segment_number + segment_count)
+    ]
+
+
+def generate_vod_segments(profile: dict, duration: int, timescale: int, start_number: int) -> List[Dict]:
+    """
+    Generates VOD segments based on the segment duration and start number.
+    This is used for static MPD manifests.
+
+    Args:
+        profile (dict): The profile information.
+        duration (int): The segment duration.
+        timescale (int): The timescale for the segments.
+        start_number (int): The starting segment number.
+
+    Returns:
+        List[Dict]: The list of generated VOD segments.
+    """
+    total_duration = profile.get("mediaPresentationDuration") or 0
+    if isinstance(total_duration, str):
+        total_duration = parse_duration(total_duration)
+    segment_count = math.ceil(total_duration * timescale / duration)
+
+    return [{"number": start_number + i, "duration": duration / timescale} for i in range(segment_count)]
+
+
+def create_segment_data(segment: Dict, item: dict, profile: dict, source: str, timescale: int | None = None) -> Dict:
+    """
+    Creates segment data based on the segment information. This includes the segment URL and metadata.
+
+    Args:
+        segment (Dict): The segment information.
+        item (dict): The segment template data.
+        profile (dict): The profile information.
+        source (str): The source URL.
+        timescale (int, optional): The timescale for the segments. Defaults to None.
+
+    Returns:
+        Dict: The created segment data.
+    """
+    media_template = item["@media"]
+    media = media_template.replace("$RepresentationID$", profile["id"])
+    media = media.replace("$Number%04d$", f"{segment['number']:04d}")
+    media = media.replace("$Number$", str(segment["number"]))
+    media = media.replace("$Bandwidth$", str(profile["bandwidth"]))
+
+    if "time" in segment and timescale is not None:
+        media = media.replace("$Time$", str(int(segment["time"] * timescale)))
+
+    if not media.startswith("http"):
+        media = f"{source}/{media}"
+
+    segment_data = {
+        "type": "segment",
+        "media": media,
+        "number": segment["number"],
+    }
+
+    if "start_time" in segment and "end_time" in segment:
+        segment_data.update(
+            {
+                "start_time": segment["start_time"],
+                "end_time": segment["end_time"],
+                "extinf": (segment["end_time"] - segment["start_time"]).total_seconds(),
+                "program_date_time": segment["start_time"].isoformat() + "Z",
+            }
+        )
+    elif "start_time" in segment and "duration" in segment:
+        duration = segment["duration"]
+        segment_data.update(
+            {
+                "start_time": segment["start_time"],
+                "end_time": segment["start_time"] + timedelta(seconds=duration),
+                "extinf": duration,
+                "program_date_time": segment["start_time"].isoformat() + "Z",
+            }
+        )
+    elif "duration" in segment:
+        segment_data["extinf"] = segment["duration"]
+
+    return segment_data
+
+
+def parse_segment_base(representation: dict, source: str) -> List[Dict]:
+    """
+    Parses segment base information and extracts segment data. This is used for single-segment representations.
+
+    Args:
+        representation (dict): The representation data.
+        source (str): The source URL.
+
+    Returns:
+        List[Dict]: The list of parsed segments.
+    """
+    segment = representation["SegmentBase"]
+    start, end = map(int, segment["@indexRange"].split("-"))
+    if "Initialization" in segment:
+        start, _ = map(int, segment["Initialization"]["@range"].split("-"))
+
+    return [
+        {
+            "type": "segment",
+            "range": f"{start}-{end}",
+            "media": f"{source}/{representation['BaseURL']}",
+        }
+    ]
+
+
+def parse_duration(duration_str: str) -> float:
+    """
+    Parses a duration ISO 8601 string into seconds.
+
+    Args:
+        duration_str (str): The duration string to parse.
+
+    Returns:
+        float: The parsed duration in seconds.
+    """
+    pattern = re.compile(r"P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)D)?T?(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?")
+    match = pattern.match(duration_str)
+    if not match:
+        raise ValueError(f"Invalid duration format: {duration_str}")
+
+    years, months, days, hours, minutes, seconds = [float(g) if g else 0 for g in match.groups()]
+    return years * 365 * 24 * 3600 + months * 30 * 24 * 3600 + days * 24 * 3600 + hours * 3600 + minutes * 60 + seconds

poetry.lock

@@ -0,0 +1,578 @@
+# This file is automatically @generated by Poetry 1.7.1 and should not be changed by hand.
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+description = "Reusable constraint types to use with typing.Annotated"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53"},
+    {file = "annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89"},
+]
+
+[[package]]
+name = "anyio"
+version = "4.4.0"
+description = "High level compatibility layer for multiple asynchronous event loop implementations"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "anyio-4.4.0-py3-none-any.whl", hash = "sha256:c1b2d8f46a8a812513012e1107cb0e68c17159a7a594208005a57dc776e1bdc7"},
+    {file = "anyio-4.4.0.tar.gz", hash = "sha256:5aadc6a1bbb7cdb0bede386cac5e2940f5e2ff3aa20277e991cf028e0585ce94"},
+]
+
+[package.dependencies]
+idna = ">=2.8"
+sniffio = ">=1.1"
+
+[package.extras]
+doc = ["Sphinx (>=7)", "packaging", "sphinx-autodoc-typehints (>=1.2.0)", "sphinx-rtd-theme"]
+test = ["anyio[trio]", "coverage[toml] (>=7)", "exceptiongroup (>=1.2.0)", "hypothesis (>=4.0)", "psutil (>=5.9)", "pytest (>=7.0)", "pytest-mock (>=3.6.1)", "trustme", "uvloop (>=0.17)"]
+trio = ["trio (>=0.23)"]
+
+[[package]]
+name = "black"
+version = "24.8.0"
+description = "The uncompromising code formatter."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "black-24.8.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:09cdeb74d494ec023ded657f7092ba518e8cf78fa8386155e4a03fdcc44679e6"},
+    {file = "black-24.8.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:81c6742da39f33b08e791da38410f32e27d632260e599df7245cccee2064afeb"},
+    {file = "black-24.8.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:707a1ca89221bc8a1a64fb5e15ef39cd755633daa672a9db7498d1c19de66a42"},
+    {file = "black-24.8.0-cp310-cp310-win_amd64.whl", hash = "sha256:d6417535d99c37cee4091a2f24eb2b6d5ec42b144d50f1f2e436d9fe1916fe1a"},
+    {file = "black-24.8.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:fb6e2c0b86bbd43dee042e48059c9ad7830abd5c94b0bc518c0eeec57c3eddc1"},
+    {file = "black-24.8.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:837fd281f1908d0076844bc2b801ad2d369c78c45cf800cad7b61686051041af"},
+    {file = "black-24.8.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:62e8730977f0b77998029da7971fa896ceefa2c4c4933fcd593fa599ecbf97a4"},
+    {file = "black-24.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:72901b4913cbac8972ad911dc4098d5753704d1f3c56e44ae8dce99eecb0e3af"},
+    {file = "black-24.8.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:7c046c1d1eeb7aea9335da62472481d3bbf3fd986e093cffd35f4385c94ae368"},
+    {file = "black-24.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:649f6d84ccbae73ab767e206772cc2d7a393a001070a4c814a546afd0d423aed"},
+    {file = "black-24.8.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2b59b250fdba5f9a9cd9d0ece6e6d993d91ce877d121d161e4698af3eb9c1018"},
+    {file = "black-24.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:6e55d30d44bed36593c3163b9bc63bf58b3b30e4611e4d88a0c3c239930ed5b2"},
+    {file = "black-24.8.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:505289f17ceda596658ae81b61ebbe2d9b25aa78067035184ed0a9d855d18afd"},
+    {file = "black-24.8.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:b19c9ad992c7883ad84c9b22aaa73562a16b819c1d8db7a1a1a49fb7ec13c7d2"},
+    {file = "black-24.8.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1f13f7f386f86f8121d76599114bb8c17b69d962137fc70efe56137727c7047e"},
+    {file = "black-24.8.0-cp38-cp38-win_amd64.whl", hash = "sha256:f490dbd59680d809ca31efdae20e634f3fae27fba3ce0ba3208333b713bc3920"},
+    {file = "black-24.8.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:eab4dd44ce80dea27dc69db40dab62d4ca96112f87996bca68cd75639aeb2e4c"},
+    {file = "black-24.8.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:3c4285573d4897a7610054af5a890bde7c65cb466040c5f0c8b732812d7f0e5e"},
+    {file = "black-24.8.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9e84e33b37be070ba135176c123ae52a51f82306def9f7d063ee302ecab2cf47"},
+    {file = "black-24.8.0-cp39-cp39-win_amd64.whl", hash = "sha256:73bbf84ed136e45d451a260c6b73ed674652f90a2b3211d6a35e78054563a9bb"},
+    {file = "black-24.8.0-py3-none-any.whl", hash = "sha256:972085c618ee94f402da1af548a4f218c754ea7e5dc70acb168bfaca4c2542ed"},
+    {file = "black-24.8.0.tar.gz", hash = "sha256:2500945420b6784c38b9ee885af039f5e7471ef284ab03fa35ecdde4688cd83f"},
+]
+
+[package.dependencies]
+click = ">=8.0.0"
+mypy-extensions = ">=0.4.3"
+packaging = ">=22.0"
+pathspec = ">=0.9.0"
+platformdirs = ">=2"
+
+[package.extras]
+colorama = ["colorama (>=0.4.3)"]
+d = ["aiohttp (>=3.7.4)", "aiohttp (>=3.7.4,!=3.9.0)"]
+jupyter = ["ipython (>=7.8.0)", "tokenize-rt (>=3.2.0)"]
+uvloop = ["uvloop (>=0.15.2)"]
+
+[[package]]
+name = "cachetools"
+version = "5.5.0"
+description = "Extensible memoizing collections and decorators"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "cachetools-5.5.0-py3-none-any.whl", hash = "sha256:02134e8439cdc2ffb62023ce1debca2944c3f289d66bb17ead3ab3dede74b292"},
+    {file = "cachetools-5.5.0.tar.gz", hash = "sha256:2cc24fb4cbe39633fb7badd9db9ca6295d766d9c2995f245725a46715d050f2a"},
+]
+
+[[package]]
+name = "certifi"
+version = "2024.7.4"
+description = "Python package for providing Mozilla's CA Bundle."
+optional = false
+python-versions = ">=3.6"
+files = [
+    {file = "certifi-2024.7.4-py3-none-any.whl", hash = "sha256:c198e21b1289c2ab85ee4e67bb4b4ef3ead0892059901a8d5b622f24a1101e90"},
+    {file = "certifi-2024.7.4.tar.gz", hash = "sha256:5a1e7645bc0ec61a09e26c36f6106dd4cf40c6db3a1fb6352b0244e7fb057c7b"},
+]
+
+[[package]]
+name = "click"
+version = "8.1.7"
+description = "Composable command line interface toolkit"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "click-8.1.7-py3-none-any.whl", hash = "sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28"},
+    {file = "click-8.1.7.tar.gz", hash = "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de"},
+]
+
+[package.dependencies]
+colorama = {version = "*", markers = "platform_system == \"Windows\""}
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+description = "Cross-platform colored terminal text."
+optional = false
+python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7"
+files = [
+    {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"},
+    {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"},
+]
+
+[[package]]
+name = "fastapi"
+version = "0.112.1"
+description = "FastAPI framework, high performance, easy to learn, fast to code, ready for production"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "fastapi-0.112.1-py3-none-any.whl", hash = "sha256:bcbd45817fc2a1cd5da09af66815b84ec0d3d634eb173d1ab468ae3103e183e4"},
+    {file = "fastapi-0.112.1.tar.gz", hash = "sha256:b2537146f8c23389a7faa8b03d0bd38d4986e6983874557d95eed2acc46448ef"},
+]
+
+[package.dependencies]
+pydantic = ">=1.7.4,<1.8 || >1.8,<1.8.1 || >1.8.1,<2.0.0 || >2.0.0,<2.0.1 || >2.0.1,<2.1.0 || >2.1.0,<3.0.0"
+starlette = ">=0.37.2,<0.39.0"
+typing-extensions = ">=4.8.0"
+
+[package.extras]
+all = ["email_validator (>=2.0.0)", "fastapi-cli[standard] (>=0.0.5)", "httpx (>=0.23.0)", "itsdangerous (>=1.1.0)", "jinja2 (>=2.11.2)", "orjson (>=3.2.1)", "pydantic-extra-types (>=2.0.0)", "pydantic-settings (>=2.0.0)", "python-multipart (>=0.0.7)", "pyyaml (>=5.3.1)", "ujson (>=4.0.1,!=4.0.2,!=4.1.0,!=4.2.0,!=4.3.0,!=5.0.0,!=5.1.0)", "uvicorn[standard] (>=0.12.0)"]
+standard = ["email_validator (>=2.0.0)", "fastapi-cli[standard] (>=0.0.5)", "httpx (>=0.23.0)", "jinja2 (>=2.11.2)", "python-multipart (>=0.0.7)", "uvicorn[standard] (>=0.12.0)"]
+
+[[package]]
+name = "gunicorn"
+version = "23.0.0"
+description = "WSGI HTTP Server for UNIX"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "gunicorn-23.0.0-py3-none-any.whl", hash = "sha256:ec400d38950de4dfd418cff8328b2c8faed0edb0d517d3394e457c317908ca4d"},
+    {file = "gunicorn-23.0.0.tar.gz", hash = "sha256:f014447a0101dc57e294f6c18ca6b40227a4c90e9bdb586042628030cba004ec"},
+]
+
+[package.dependencies]
+packaging = "*"
+
+[package.extras]
+eventlet = ["eventlet (>=0.24.1,!=0.36.0)"]
+gevent = ["gevent (>=1.4.0)"]
+setproctitle = ["setproctitle"]
+testing = ["coverage", "eventlet", "gevent", "pytest", "pytest-cov"]
+tornado = ["tornado (>=0.2)"]
+
+[[package]]
+name = "h11"
+version = "0.14.0"
+description = "A pure-Python, bring-your-own-I/O implementation of HTTP/1.1"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "h11-0.14.0-py3-none-any.whl", hash = "sha256:e3fe4ac4b851c468cc8363d500db52c2ead036020723024a109d37346efaa761"},
+    {file = "h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d"},
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.5"
+description = "A minimal low-level HTTP client."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "httpcore-1.0.5-py3-none-any.whl", hash = "sha256:421f18bac248b25d310f3cacd198d55b8e6125c107797b609ff9b7a6ba7991b5"},
+    {file = "httpcore-1.0.5.tar.gz", hash = "sha256:34a38e2f9291467ee3b44e89dd52615370e152954ba21721378a87b2960f7a61"},
+]
+
+[package.dependencies]
+certifi = "*"
+h11 = ">=0.13,<0.15"
+
+[package.extras]
+asyncio = ["anyio (>=4.0,<5.0)"]
+http2 = ["h2 (>=3,<5)"]
+socks = ["socksio (==1.*)"]
+trio = ["trio (>=0.22.0,<0.26.0)"]
+
+[[package]]
+name = "httpx"
+version = "0.27.0"
+description = "The next generation HTTP client."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "httpx-0.27.0-py3-none-any.whl", hash = "sha256:71d5465162c13681bff01ad59b2cc68dd838ea1f10e51574bac27103f00c91a5"},
+    {file = "httpx-0.27.0.tar.gz", hash = "sha256:a0cb88a46f32dc874e04ee956e4c2764aba2aa228f650b06788ba6bda2962ab5"},
+]
+
+[package.dependencies]
+anyio = "*"
+certifi = "*"
+httpcore = "==1.*"
+idna = "*"
+sniffio = "*"
+socksio = {version = "==1.*", optional = true, markers = "extra == \"socks\""}
+
+[package.extras]
+brotli = ["brotli", "brotlicffi"]
+cli = ["click (==8.*)", "pygments (==2.*)", "rich (>=10,<14)"]
+http2 = ["h2 (>=3,<5)"]
+socks = ["socksio (==1.*)"]
+
+[[package]]
+name = "idna"
+version = "3.8"
+description = "Internationalized Domain Names in Applications (IDNA)"
+optional = false
+python-versions = ">=3.6"
+files = [
+    {file = "idna-3.8-py3-none-any.whl", hash = "sha256:050b4e5baadcd44d760cedbd2b8e639f2ff89bbc7a5730fcc662954303377aac"},
+    {file = "idna-3.8.tar.gz", hash = "sha256:d838c2c0ed6fced7693d5e8ab8e734d5f8fda53a039c0164afb0b82e771e3603"},
+]
+
+[[package]]
+name = "mypy-extensions"
+version = "1.0.0"
+description = "Type system extensions for programs checked with the mypy type checker."
+optional = false
+python-versions = ">=3.5"
+files = [
+    {file = "mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d"},
+    {file = "mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782"},
+]
+
+[[package]]
+name = "packaging"
+version = "24.1"
+description = "Core utilities for Python packages"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "packaging-24.1-py3-none-any.whl", hash = "sha256:5b8f2217dbdbd2f7f384c41c628544e6d52f2d0f53c6d0c3ea61aa5d1d7ff124"},
+    {file = "packaging-24.1.tar.gz", hash = "sha256:026ed72c8ed3fcce5bf8950572258698927fd1dbda10a5e981cdf0ac37f4f002"},
+]
+
+[[package]]
+name = "pathspec"
+version = "0.12.1"
+description = "Utility library for gitignore style pattern matching of file paths."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08"},
+    {file = "pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712"},
+]
+
+[[package]]
+name = "platformdirs"
+version = "4.2.2"
+description = "A small Python package for determining appropriate platform-specific dirs, e.g. a `user data dir`."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "platformdirs-4.2.2-py3-none-any.whl", hash = "sha256:2d7a1657e36a80ea911db832a8a6ece5ee53d8de21edd5cc5879af6530b1bfee"},
+    {file = "platformdirs-4.2.2.tar.gz", hash = "sha256:38b7b51f512eed9e84a22788b4bce1de17c0adb134d6becb09836e37d8654cd3"},
+]
+
+[package.extras]
+docs = ["furo (>=2023.9.10)", "proselint (>=0.13)", "sphinx (>=7.2.6)", "sphinx-autodoc-typehints (>=1.25.2)"]
+test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=7.4.3)", "pytest-cov (>=4.1)", "pytest-mock (>=3.12)"]
+type = ["mypy (>=1.8)"]
+
+[[package]]
+name = "pycryptodome"
+version = "3.20.0"
+description = "Cryptographic library for Python"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
+files = [
+    {file = "pycryptodome-3.20.0-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:f0e6d631bae3f231d3634f91ae4da7a960f7ff87f2865b2d2b831af1dfb04e9a"},
+    {file = "pycryptodome-3.20.0-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:baee115a9ba6c5d2709a1e88ffe62b73ecc044852a925dcb67713a288c4ec70f"},
+    {file = "pycryptodome-3.20.0-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:417a276aaa9cb3be91f9014e9d18d10e840a7a9b9a9be64a42f553c5b50b4d1d"},
+    {file = "pycryptodome-3.20.0-cp27-cp27m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2a1250b7ea809f752b68e3e6f3fd946b5939a52eaeea18c73bdab53e9ba3c2dd"},
+    {file = "pycryptodome-3.20.0-cp27-cp27m-musllinux_1_1_aarch64.whl", hash = "sha256:d5954acfe9e00bc83ed9f5cb082ed22c592fbbef86dc48b907238be64ead5c33"},
+    {file = "pycryptodome-3.20.0-cp27-cp27m-win32.whl", hash = "sha256:06d6de87c19f967f03b4cf9b34e538ef46e99a337e9a61a77dbe44b2cbcf0690"},
+    {file = "pycryptodome-3.20.0-cp27-cp27m-win_amd64.whl", hash = "sha256:ec0bb1188c1d13426039af8ffcb4dbe3aad1d7680c35a62d8eaf2a529b5d3d4f"},
+    {file = "pycryptodome-3.20.0-cp27-cp27mu-manylinux2010_i686.whl", hash = "sha256:5601c934c498cd267640b57569e73793cb9a83506f7c73a8ec57a516f5b0b091"},
+    {file = "pycryptodome-3.20.0-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:d29daa681517f4bc318cd8a23af87e1f2a7bad2fe361e8aa29c77d652a065de4"},
+    {file = "pycryptodome-3.20.0-cp27-cp27mu-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3427d9e5310af6680678f4cce149f54e0bb4af60101c7f2c16fdf878b39ccccc"},
+    {file = "pycryptodome-3.20.0-cp27-cp27mu-musllinux_1_1_aarch64.whl", hash = "sha256:3cd3ef3aee1079ae44afaeee13393cf68b1058f70576b11439483e34f93cf818"},
+    {file = "pycryptodome-3.20.0-cp35-abi3-macosx_10_9_universal2.whl", hash = "sha256:ac1c7c0624a862f2e53438a15c9259d1655325fc2ec4392e66dc46cdae24d044"},
+    {file = "pycryptodome-3.20.0-cp35-abi3-macosx_10_9_x86_64.whl", hash = "sha256:76658f0d942051d12a9bd08ca1b6b34fd762a8ee4240984f7c06ddfb55eaf15a"},
+    {file = "pycryptodome-3.20.0-cp35-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f35d6cee81fa145333137009d9c8ba90951d7d77b67c79cbe5f03c7eb74d8fe2"},
+    {file = "pycryptodome-3.20.0-cp35-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:76cb39afede7055127e35a444c1c041d2e8d2f1f9c121ecef573757ba4cd2c3c"},
+    {file = "pycryptodome-3.20.0-cp35-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:49a4c4dc60b78ec41d2afa392491d788c2e06edf48580fbfb0dd0f828af49d25"},
+    {file = "pycryptodome-3.20.0-cp35-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:fb3b87461fa35afa19c971b0a2b7456a7b1db7b4eba9a8424666104925b78128"},
+    {file = "pycryptodome-3.20.0-cp35-abi3-musllinux_1_1_i686.whl", hash = "sha256:acc2614e2e5346a4a4eab6e199203034924313626f9620b7b4b38e9ad74b7e0c"},
+    {file = "pycryptodome-3.20.0-cp35-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:210ba1b647837bfc42dd5a813cdecb5b86193ae11a3f5d972b9a0ae2c7e9e4b4"},
+    {file = "pycryptodome-3.20.0-cp35-abi3-win32.whl", hash = "sha256:8d6b98d0d83d21fb757a182d52940d028564efe8147baa9ce0f38d057104ae72"},
+    {file = "pycryptodome-3.20.0-cp35-abi3-win_amd64.whl", hash = "sha256:9b3ae153c89a480a0ec402e23db8d8d84a3833b65fa4b15b81b83be9d637aab9"},
+    {file = "pycryptodome-3.20.0-pp27-pypy_73-manylinux2010_x86_64.whl", hash = "sha256:4401564ebf37dfde45d096974c7a159b52eeabd9969135f0426907db367a652a"},
+    {file = "pycryptodome-3.20.0-pp27-pypy_73-win32.whl", hash = "sha256:ec1f93feb3bb93380ab0ebf8b859e8e5678c0f010d2d78367cf6bc30bfeb148e"},
+    {file = "pycryptodome-3.20.0-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:acae12b9ede49f38eb0ef76fdec2df2e94aad85ae46ec85be3648a57f0a7db04"},
+    {file = "pycryptodome-3.20.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f47888542a0633baff535a04726948e876bf1ed880fddb7c10a736fa99146ab3"},
+    {file = "pycryptodome-3.20.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6e0e4a987d38cfc2e71b4a1b591bae4891eeabe5fa0f56154f576e26287bfdea"},
+    {file = "pycryptodome-3.20.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:c18b381553638414b38705f07d1ef0a7cf301bc78a5f9bc17a957eb19446834b"},
+    {file = "pycryptodome-3.20.0-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:a60fedd2b37b4cb11ccb5d0399efe26db9e0dd149016c1cc6c8161974ceac2d6"},
+    {file = "pycryptodome-3.20.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:405002eafad114a2f9a930f5db65feef7b53c4784495dd8758069b89baf68eab"},
+    {file = "pycryptodome-3.20.0-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2ab6ab0cb755154ad14e507d1df72de9897e99fd2d4922851a276ccc14f4f1a5"},
+    {file = "pycryptodome-3.20.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:acf6e43fa75aca2d33e93409f2dafe386fe051818ee79ee8a3e21de9caa2ac9e"},
+    {file = "pycryptodome-3.20.0.tar.gz", hash = "sha256:09609209ed7de61c2b560cc5c8c4fbf892f8b15b1faf7e4cbffac97db1fffda7"},
+]
+
+[[package]]
+name = "pydantic"
+version = "2.8.2"
+description = "Data validation using Python type hints"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "pydantic-2.8.2-py3-none-any.whl", hash = "sha256:73ee9fddd406dc318b885c7a2eab8a6472b68b8fb5ba8150949fc3db939f23c8"},
+    {file = "pydantic-2.8.2.tar.gz", hash = "sha256:6f62c13d067b0755ad1c21a34bdd06c0c12625a22b0fc09c6b149816604f7c2a"},
+]
+
+[package.dependencies]
+annotated-types = ">=0.4.0"
+pydantic-core = "2.20.1"
+typing-extensions = [
+    {version = ">=4.12.2", markers = "python_version >= \"3.13\""},
+    {version = ">=4.6.1", markers = "python_version < \"3.13\""},
+]
+
+[package.extras]
+email = ["email-validator (>=2.0.0)"]
+
+[[package]]
+name = "pydantic-core"
+version = "2.20.1"
+description = "Core functionality for Pydantic validation and serialization"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "pydantic_core-2.20.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:3acae97ffd19bf091c72df4d726d552c473f3576409b2a7ca36b2f535ffff4a3"},
+    {file = "pydantic_core-2.20.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:41f4c96227a67a013e7de5ff8f20fb496ce573893b7f4f2707d065907bffdbd6"},
+    {file = "pydantic_core-2.20.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5f239eb799a2081495ea659d8d4a43a8f42cd1fe9ff2e7e436295c38a10c286a"},
+    {file = "pydantic_core-2.20.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:53e431da3fc53360db73eedf6f7124d1076e1b4ee4276b36fb25514544ceb4a3"},
+    {file = "pydantic_core-2.20.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f1f62b2413c3a0e846c3b838b2ecd6c7a19ec6793b2a522745b0869e37ab5bc1"},
+    {file = "pydantic_core-2.20.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5d41e6daee2813ecceea8eda38062d69e280b39df793f5a942fa515b8ed67953"},
+    {file = "pydantic_core-2.20.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3d482efec8b7dc6bfaedc0f166b2ce349df0011f5d2f1f25537ced4cfc34fd98"},
+    {file = "pydantic_core-2.20.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e93e1a4b4b33daed65d781a57a522ff153dcf748dee70b40c7258c5861e1768a"},
+    {file = "pydantic_core-2.20.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:e7c4ea22b6739b162c9ecaaa41d718dfad48a244909fe7ef4b54c0b530effc5a"},
+    {file = "pydantic_core-2.20.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:4f2790949cf385d985a31984907fecb3896999329103df4e4983a4a41e13e840"},
+    {file = "pydantic_core-2.20.1-cp310-none-win32.whl", hash = "sha256:5e999ba8dd90e93d57410c5e67ebb67ffcaadcea0ad973240fdfd3a135506250"},
+    {file = "pydantic_core-2.20.1-cp310-none-win_amd64.whl", hash = "sha256:512ecfbefef6dac7bc5eaaf46177b2de58cdf7acac8793fe033b24ece0b9566c"},
+    {file = "pydantic_core-2.20.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:d2a8fa9d6d6f891f3deec72f5cc668e6f66b188ab14bb1ab52422fe8e644f312"},
+    {file = "pydantic_core-2.20.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:175873691124f3d0da55aeea1d90660a6ea7a3cfea137c38afa0a5ffabe37b88"},
+    {file = "pydantic_core-2.20.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:37eee5b638f0e0dcd18d21f59b679686bbd18917b87db0193ae36f9c23c355fc"},
+    {file = "pydantic_core-2.20.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:25e9185e2d06c16ee438ed39bf62935ec436474a6ac4f9358524220f1b236e43"},
+    {file = "pydantic_core-2.20.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:150906b40ff188a3260cbee25380e7494ee85048584998c1e66df0c7a11c17a6"},
+    {file = "pydantic_core-2.20.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8ad4aeb3e9a97286573c03df758fc7627aecdd02f1da04516a86dc159bf70121"},
+    {file = "pydantic_core-2.20.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d3f3ed29cd9f978c604708511a1f9c2fdcb6c38b9aae36a51905b8811ee5cbf1"},
+    {file = "pydantic_core-2.20.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b0dae11d8f5ded51699c74d9548dcc5938e0804cc8298ec0aa0da95c21fff57b"},
+    {file = "pydantic_core-2.20.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:faa6b09ee09433b87992fb5a2859efd1c264ddc37280d2dd5db502126d0e7f27"},
+    {file = "pydantic_core-2.20.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9dc1b507c12eb0481d071f3c1808f0529ad41dc415d0ca11f7ebfc666e66a18b"},
+    {file = "pydantic_core-2.20.1-cp311-none-win32.whl", hash = "sha256:fa2fddcb7107e0d1808086ca306dcade7df60a13a6c347a7acf1ec139aa6789a"},
+    {file = "pydantic_core-2.20.1-cp311-none-win_amd64.whl", hash = "sha256:40a783fb7ee353c50bd3853e626f15677ea527ae556429453685ae32280c19c2"},
+    {file = "pydantic_core-2.20.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:595ba5be69b35777474fa07f80fc260ea71255656191adb22a8c53aba4479231"},
+    {file = "pydantic_core-2.20.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a4f55095ad087474999ee28d3398bae183a66be4823f753cd7d67dd0153427c9"},
+    {file = "pydantic_core-2.20.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f9aa05d09ecf4c75157197f27cdc9cfaeb7c5f15021c6373932bf3e124af029f"},
+    {file = "pydantic_core-2.20.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e97fdf088d4b31ff4ba35db26d9cc472ac7ef4a2ff2badeabf8d727b3377fc52"},
+    {file = "pydantic_core-2.20.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bc633a9fe1eb87e250b5c57d389cf28998e4292336926b0b6cdaee353f89a237"},
+    {file = "pydantic_core-2.20.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d573faf8eb7e6b1cbbcb4f5b247c60ca8be39fe2c674495df0eb4318303137fe"},
+    {file = "pydantic_core-2.20.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:26dc97754b57d2fd00ac2b24dfa341abffc380b823211994c4efac7f13b9e90e"},
+    {file = "pydantic_core-2.20.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:33499e85e739a4b60c9dac710c20a08dc73cb3240c9a0e22325e671b27b70d24"},
+    {file = "pydantic_core-2.20.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:bebb4d6715c814597f85297c332297c6ce81e29436125ca59d1159b07f423eb1"},
+    {file = "pydantic_core-2.20.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:516d9227919612425c8ef1c9b869bbbee249bc91912c8aaffb66116c0b447ebd"},
+    {file = "pydantic_core-2.20.1-cp312-none-win32.whl", hash = "sha256:469f29f9093c9d834432034d33f5fe45699e664f12a13bf38c04967ce233d688"},
+    {file = "pydantic_core-2.20.1-cp312-none-win_amd64.whl", hash = "sha256:035ede2e16da7281041f0e626459bcae33ed998cca6a0a007a5ebb73414ac72d"},
+    {file = "pydantic_core-2.20.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:0827505a5c87e8aa285dc31e9ec7f4a17c81a813d45f70b1d9164e03a813a686"},
+    {file = "pydantic_core-2.20.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:19c0fa39fa154e7e0b7f82f88ef85faa2a4c23cc65aae2f5aea625e3c13c735a"},
+    {file = "pydantic_core-2.20.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4aa223cd1e36b642092c326d694d8bf59b71ddddc94cdb752bbbb1c5c91d833b"},
+    {file = "pydantic_core-2.20.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c336a6d235522a62fef872c6295a42ecb0c4e1d0f1a3e500fe949415761b8a19"},
+    {file = "pydantic_core-2.20.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7eb6a0587eded33aeefea9f916899d42b1799b7b14b8f8ff2753c0ac1741edac"},
+    {file = "pydantic_core-2.20.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:70c8daf4faca8da5a6d655f9af86faf6ec2e1768f4b8b9d0226c02f3d6209703"},
+    {file = "pydantic_core-2.20.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e9fa4c9bf273ca41f940bceb86922a7667cd5bf90e95dbb157cbb8441008482c"},
+    {file = "pydantic_core-2.20.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:11b71d67b4725e7e2a9f6e9c0ac1239bbc0c48cce3dc59f98635efc57d6dac83"},
+    {file = "pydantic_core-2.20.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:270755f15174fb983890c49881e93f8f1b80f0b5e3a3cc1394a255706cabd203"},
+    {file = "pydantic_core-2.20.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:c81131869240e3e568916ef4c307f8b99583efaa60a8112ef27a366eefba8ef0"},
+    {file = "pydantic_core-2.20.1-cp313-none-win32.whl", hash = "sha256:b91ced227c41aa29c672814f50dbb05ec93536abf8f43cd14ec9521ea09afe4e"},
+    {file = "pydantic_core-2.20.1-cp313-none-win_amd64.whl", hash = "sha256:65db0f2eefcaad1a3950f498aabb4875c8890438bc80b19362cf633b87a8ab20"},
+    {file = "pydantic_core-2.20.1-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:4745f4ac52cc6686390c40eaa01d48b18997cb130833154801a442323cc78f91"},
+    {file = "pydantic_core-2.20.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:a8ad4c766d3f33ba8fd692f9aa297c9058970530a32c728a2c4bfd2616d3358b"},
+    {file = "pydantic_core-2.20.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:41e81317dd6a0127cabce83c0c9c3fbecceae981c8391e6f1dec88a77c8a569a"},
+    {file = "pydantic_core-2.20.1-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:04024d270cf63f586ad41fff13fde4311c4fc13ea74676962c876d9577bcc78f"},
+    {file = "pydantic_core-2.20.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:eaad4ff2de1c3823fddf82f41121bdf453d922e9a238642b1dedb33c4e4f98ad"},
+    {file = "pydantic_core-2.20.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:26ab812fa0c845df815e506be30337e2df27e88399b985d0bb4e3ecfe72df31c"},
+    {file = "pydantic_core-2.20.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3c5ebac750d9d5f2706654c638c041635c385596caf68f81342011ddfa1e5598"},
+    {file = "pydantic_core-2.20.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2aafc5a503855ea5885559eae883978c9b6d8c8993d67766ee73d82e841300dd"},
+    {file = "pydantic_core-2.20.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:4868f6bd7c9d98904b748a2653031fc9c2f85b6237009d475b1008bfaeb0a5aa"},
+    {file = "pydantic_core-2.20.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:aa2f457b4af386254372dfa78a2eda2563680d982422641a85f271c859df1987"},
+    {file = "pydantic_core-2.20.1-cp38-none-win32.whl", hash = "sha256:225b67a1f6d602de0ce7f6c1c3ae89a4aa25d3de9be857999e9124f15dab486a"},
+    {file = "pydantic_core-2.20.1-cp38-none-win_amd64.whl", hash = "sha256:6b507132dcfc0dea440cce23ee2182c0ce7aba7054576efc65634f080dbe9434"},
+    {file = "pydantic_core-2.20.1-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:b03f7941783b4c4a26051846dea594628b38f6940a2fdc0df00b221aed39314c"},
+    {file = "pydantic_core-2.20.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1eedfeb6089ed3fad42e81a67755846ad4dcc14d73698c120a82e4ccf0f1f9f6"},
+    {file = "pydantic_core-2.20.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:635fee4e041ab9c479e31edda27fcf966ea9614fff1317e280d99eb3e5ab6fe2"},
+    {file = "pydantic_core-2.20.1-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:77bf3ac639c1ff567ae3b47f8d4cc3dc20f9966a2a6dd2311dcc055d3d04fb8a"},
+    {file = "pydantic_core-2.20.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7ed1b0132f24beeec5a78b67d9388656d03e6a7c837394f99257e2d55b461611"},
+    {file = "pydantic_core-2.20.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c6514f963b023aeee506678a1cf821fe31159b925c4b76fe2afa94cc70b3222b"},
+    {file = "pydantic_core-2.20.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:10d4204d8ca33146e761c79f83cc861df20e7ae9f6487ca290a97702daf56006"},
+    {file = "pydantic_core-2.20.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2d036c7187b9422ae5b262badb87a20a49eb6c5238b2004e96d4da1231badef1"},
+    {file = "pydantic_core-2.20.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:9ebfef07dbe1d93efb94b4700f2d278494e9162565a54f124c404a5656d7ff09"},
+    {file = "pydantic_core-2.20.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:6b9d9bb600328a1ce523ab4f454859e9d439150abb0906c5a1983c146580ebab"},
+    {file = "pydantic_core-2.20.1-cp39-none-win32.whl", hash = "sha256:784c1214cb6dd1e3b15dd8b91b9a53852aed16671cc3fbe4786f4f1db07089e2"},
+    {file = "pydantic_core-2.20.1-cp39-none-win_amd64.whl", hash = "sha256:d2fe69c5434391727efa54b47a1e7986bb0186e72a41b203df8f5b0a19a4f669"},
+    {file = "pydantic_core-2.20.1-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:a45f84b09ac9c3d35dfcf6a27fd0634d30d183205230a0ebe8373a0e8cfa0906"},
+    {file = "pydantic_core-2.20.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:d02a72df14dfdbaf228424573a07af10637bd490f0901cee872c4f434a735b94"},
+    {file = "pydantic_core-2.20.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d2b27e6af28f07e2f195552b37d7d66b150adbaa39a6d327766ffd695799780f"},
+    {file = "pydantic_core-2.20.1-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:084659fac3c83fd674596612aeff6041a18402f1e1bc19ca39e417d554468482"},
+    {file = "pydantic_core-2.20.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:242b8feb3c493ab78be289c034a1f659e8826e2233786e36f2893a950a719bb6"},
+    {file = "pydantic_core-2.20.1-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:38cf1c40a921d05c5edc61a785c0ddb4bed67827069f535d794ce6bcded919fc"},
+    {file = "pydantic_core-2.20.1-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:e0bbdd76ce9aa5d4209d65f2b27fc6e5ef1312ae6c5333c26db3f5ade53a1e99"},
+    {file = "pydantic_core-2.20.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:254ec27fdb5b1ee60684f91683be95e5133c994cc54e86a0b0963afa25c8f8a6"},
+    {file = "pydantic_core-2.20.1-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:407653af5617f0757261ae249d3fba09504d7a71ab36ac057c938572d1bc9331"},
+    {file = "pydantic_core-2.20.1-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:c693e916709c2465b02ca0ad7b387c4f8423d1db7b4649c551f27a529181c5ad"},
+    {file = "pydantic_core-2.20.1-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5b5ff4911aea936a47d9376fd3ab17e970cc543d1b68921886e7f64bd28308d1"},
+    {file = "pydantic_core-2.20.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:177f55a886d74f1808763976ac4efd29b7ed15c69f4d838bbd74d9d09cf6fa86"},
+    {file = "pydantic_core-2.20.1-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:964faa8a861d2664f0c7ab0c181af0bea66098b1919439815ca8803ef136fc4e"},
+    {file = "pydantic_core-2.20.1-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:4dd484681c15e6b9a977c785a345d3e378d72678fd5f1f3c0509608da24f2ac0"},
+    {file = "pydantic_core-2.20.1-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f6d6cff3538391e8486a431569b77921adfcdef14eb18fbf19b7c0a5294d4e6a"},
+    {file = "pydantic_core-2.20.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:a6d511cc297ff0883bc3708b465ff82d7560193169a8b93260f74ecb0a5e08a7"},
+    {file = "pydantic_core-2.20.1.tar.gz", hash = "sha256:26ca695eeee5f9f1aeeb211ffc12f10bcb6f71e2989988fda61dabd65db878d4"},
+]
+
+[package.dependencies]
+typing-extensions = ">=4.6.0,<4.7.0 || >4.7.0"
+
+[[package]]
+name = "pydantic-settings"
+version = "2.4.0"
+description = "Settings management using Pydantic"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "pydantic_settings-2.4.0-py3-none-any.whl", hash = "sha256:bb6849dc067f1687574c12a639e231f3a6feeed0a12d710c1382045c5db1c315"},
+    {file = "pydantic_settings-2.4.0.tar.gz", hash = "sha256:ed81c3a0f46392b4d7c0a565c05884e6e54b3456e6f0fe4d8814981172dc9a88"},
+]
+
+[package.dependencies]
+pydantic = ">=2.7.0"
+python-dotenv = ">=0.21.0"
+
+[package.extras]
+azure-key-vault = ["azure-identity (>=1.16.0)", "azure-keyvault-secrets (>=4.8.0)"]
+toml = ["tomli (>=2.0.1)"]
+yaml = ["pyyaml (>=6.0.1)"]
+
+[[package]]
+name = "python-dotenv"
+version = "1.0.1"
+description = "Read key-value pairs from a .env file and set them as environment variables"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "python-dotenv-1.0.1.tar.gz", hash = "sha256:e324ee90a023d808f1959c46bcbc04446a10ced277783dc6ee09987c37ec10ca"},
+    {file = "python_dotenv-1.0.1-py3-none-any.whl", hash = "sha256:f7b63ef50f1b690dddf550d03497b66d609393b40b564ed0d674909a68ebf16a"},
+]
+
+[package.extras]
+cli = ["click (>=5.0)"]
+
+[[package]]
+name = "sniffio"
+version = "1.3.1"
+description = "Sniff out which async library your code is running under"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2"},
+    {file = "sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc"},
+]
+
+[[package]]
+name = "socksio"
+version = "1.0.0"
+description = "Sans-I/O implementation of SOCKS4, SOCKS4A, and SOCKS5."
+optional = false
+python-versions = ">=3.6"
+files = [
+    {file = "socksio-1.0.0-py3-none-any.whl", hash = "sha256:95dc1f15f9b34e8d7b16f06d74b8ccf48f609af32ab33c608d08761c5dcbb1f3"},
+    {file = "socksio-1.0.0.tar.gz", hash = "sha256:f88beb3da5b5c38b9890469de67d0cb0f9d494b78b106ca1845f96c10b91c4ac"},
+]
+
+[[package]]
+name = "starlette"
+version = "0.38.2"
+description = "The little ASGI library that shines."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "starlette-0.38.2-py3-none-any.whl", hash = "sha256:4ec6a59df6bbafdab5f567754481657f7ed90dc9d69b0c9ff017907dd54faeff"},
+    {file = "starlette-0.38.2.tar.gz", hash = "sha256:c7c0441065252160993a1a37cf2a73bb64d271b17303e0b0c1eb7191cfb12d75"},
+]
+
+[package.dependencies]
+anyio = ">=3.4.0,<5"
+
+[package.extras]
+full = ["httpx (>=0.22.0)", "itsdangerous", "jinja2", "python-multipart (>=0.0.7)", "pyyaml"]
+
+[[package]]
+name = "tenacity"
+version = "9.0.0"
+description = "Retry code until it succeeds"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "tenacity-9.0.0-py3-none-any.whl", hash = "sha256:93de0c98785b27fcf659856aa9f54bfbd399e29969b0621bc7f762bd441b4539"},
+    {file = "tenacity-9.0.0.tar.gz", hash = "sha256:807f37ca97d62aa361264d497b0e31e92b8027044942bfa756160d908320d73b"},
+]
+
+[package.extras]
+doc = ["reno", "sphinx"]
+test = ["pytest", "tornado (>=4.5)", "typeguard"]
+
+[[package]]
+name = "typing-extensions"
+version = "4.12.2"
+description = "Backported and Experimental Type Hints for Python 3.8+"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d"},
+    {file = "typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8"},
+]
+
+[[package]]
+name = "uvicorn"
+version = "0.30.6"
+description = "The lightning-fast ASGI server."
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "uvicorn-0.30.6-py3-none-any.whl", hash = "sha256:65fd46fe3fda5bdc1b03b94eb634923ff18cd35b2f084813ea79d1f103f711b5"},
+    {file = "uvicorn-0.30.6.tar.gz", hash = "sha256:4b15decdda1e72be08209e860a1e10e92439ad5b97cf44cc945fcbee66fc5788"},
+]
+
+[package.dependencies]
+click = ">=7.0"
+h11 = ">=0.8"
+
+[package.extras]
+standard = ["colorama (>=0.4)", "httptools (>=0.5.0)", "python-dotenv (>=0.13)", "pyyaml (>=5.1)", "uvloop (>=0.14.0,!=0.15.0,!=0.15.1)", "watchfiles (>=0.13)", "websockets (>=10.4)"]
+
+[[package]]
+name = "xmltodict"
+version = "0.13.0"
+description = "Makes working with XML feel like you are working with JSON"
+optional = false
+python-versions = ">=3.4"
+files = [
+    {file = "xmltodict-0.13.0-py2.py3-none-any.whl", hash = "sha256:aa89e8fd76320154a40d19a0df04a4695fb9dc5ba977cbb68ab3e4eb225e7852"},
+    {file = "xmltodict-0.13.0.tar.gz", hash = "sha256:341595a488e3e01a85a9d8911d8912fd922ede5fecc4dce437eb4b6c8d037e56"},
+]
+
+[metadata]
+lock-version = "2.0"
+python-versions = "^3.12"
+content-hash = "8cfbb5ac5e9e2098578646c06fbc895ae04531d66c9985635f06ee2b787e3c75"

pyproject.toml

@@ -0,0 +1,29 @@
+[tool.poetry]
+name = "mediaflow proxy"
+version = "1.0.0"
+description = "A high-performance proxy server for streaming media, supporting HTTP(S), HLS, and MPEG-DASH with real-time DRM decryption."
+authors = ["mhdzumair <mhdzumair@gmail.com>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.12"
+fastapi = "^0.112.0"
+httpx = {extras = ["socks"], version = "^0.27.0"}
+tenacity = "^9.0.0"
+xmltodict = "^0.13.0"
+cachetools = "^5.4.0"
+pydantic-settings = "^2.4.0"
+gunicorn = "^23.0.0"
+pycryptodome = "^3.20.0"
+uvicorn = "^0.30.6"
+
+
+[tool.poetry.group.dev.dependencies]
+black = "^24.8.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.black]
+line-length = 120

static/index.html

@@ -0,0 +1,76 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>MediaFlow Proxy</title>
+    <link rel="icon" href="/logo.png" type="image/x-icon">
+    <style>
+        body {
+            font-family: Arial, sans-serif;
+            line-height: 1.6;
+            color: #333;
+            max-width: 800px;
+            margin: 0 auto;
+            padding: 20px;
+            background-color: #f9f9f9;
+        }
+
+        header {
+            background-color: #90aacc;
+            color: #fff;
+            padding: 10px 0;
+            text-align: center;
+        }
+
+        header img {
+            width: 200px;
+            height: 200px;
+            vertical-align: middle;
+            border-radius: 15px;
+        }
+
+        header h1 {
+            display: inline;
+            margin-left: 20px;
+            font-size: 36px;
+        }
+
+        .feature {
+            background-color: #f4f4f4;
+            border-left: 4px solid #3498db;
+            padding: 10px;
+            margin-bottom: 10px;
+        }
+
+        a {
+            color: #3498db;
+        }
+    </style>
+</head>
+<body>
+<header>
+    <img src="/logo.png" alt="MediaFlow Proxy Logo">
+    <h1>MediaFlow Proxy</h1>
+</header>
+<p>A high-performance proxy server for streaming media, supporting HTTP(S), HLS, and MPEG-DASH with real-time DRM decryption.</p>
+
+<h2>Key Features</h2>
+<div class="feature">Convert MPEG-DASH streams (DRM-protected and non-protected) to HLS</div>
+<div class="feature">Support for Clear Key DRM-protected MPD DASH streams</div>
+<div class="feature">Handle both live and video-on-demand (VOD) DASH streams</div>
+<div class="feature">Proxy HTTP/HTTPS links with custom headers</div>
+<div class="feature">Proxy and modify HLS (M3U8) streams in real-time with custom headers and key URL modifications for bypassing some sneaky restrictions.</div>
+<div class="feature">Protect against unauthorized access and network bandwidth abuses</div>
+
+<h2>Getting Started</h2>
+<p>Visit the <a href="https://github.com/mhdzumair/mediaflow-proxy">GitHub repository</a> for installation instructions and documentation.</p>
+
+<h2>Premium Hosted Service</h2>
+<p>For a hassle-free experience, check out <a href="https://store.elfhosted.com/product/mediaflow-proxy">premium hosted service on ElfHosted</a>.</p>
+
+<h2>API Documentation</h2>
+<p>Explore the <a href="/docs">Swagger UI</a> for comprehensive details about the API endpoints and their usage.</p>
+
+</body>
+</html>