eaf-base-api 1.0__tar.gz

eaf_base_api-1.0/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.1
+Name: eaf_base_api
+Version: 1.0
+Summary: A base API for EchterAlsFake's Porn APIs
+Home-page: https://github.com/EchterAlsFake/eaf_base_api
+Author: Johannes Habel
+Author-email: EchterAlsFake@proton.me
+License: LGPLv3
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
+Classifier: Programming Language :: Python
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+Requires-Dist: ffmpeg-progress-yield
+
+# EAF Base API
+
+! Still in Development
+
+This Python package is a base api for all my Porn Site APIs. A lot of sites use the same methods, and
+there's a lot of code that I've rewritten again and again. This is why I created this base api, so that 
+I need to write less code and everything is easier to be maintainable. 
+
+# PRs
+Pull Requests are welcome, but if you make changes run `pytest` on all APIs that are using this to make sure your
+PR didn't break anything.
+
+# Documentation
+
+As this is some kind of 'raw' base API, this won't be documented, as it's only functional when used together
+with the main APIs. 
+
+Maybe you can look at the code comments. They could be helpful
+
+# Implementation
+You are welcome to implement this API in your own projects. If it's useful... But I don't recommend this, as things
+might change without a warning. But things like the threaded downloads can be useful for other projects :) 
+
+I'd say the threaded modes from the download module are already very well optimized, so feel free to just copy them
+for your own projects. You don't need to do any attribution, I don't care :) 
+
+
+# License
+
+LGPLv3

eaf_base_api-1.0/README.md

@@ -0,0 +1,30 @@
+# EAF Base API
+
+! Still in Development
+
+This Python package is a base api for all my Porn Site APIs. A lot of sites use the same methods, and
+there's a lot of code that I've rewritten again and again. This is why I created this base api, so that 
+I need to write less code and everything is easier to be maintainable. 
+
+# PRs
+Pull Requests are welcome, but if you make changes run `pytest` on all APIs that are using this to make sure your
+PR didn't break anything.
+
+# Documentation
+
+As this is some kind of 'raw' base API, this won't be documented, as it's only functional when used together
+with the main APIs. 
+
+Maybe you can look at the code comments. They could be helpful
+
+# Implementation
+You are welcome to implement this API in your own projects. If it's useful... But I don't recommend this, as things
+might change without a warning. But things like the threaded downloads can be useful for other projects :) 
+
+I'd say the threaded modes from the download module are already very well optimized, so feel free to just copy them
+for your own projects. You don't need to do any attribution, I don't care :) 
+
+
+# License
+
+LGPLv3

eaf_base_api-1.0/base_api/base.py

@@ -0,0 +1,110 @@
+import requests
+import logging
+import time
+
+from base_api.modules.quality import Quality
+from base_api.modules.progress_bars import Callback
+from base_api.modules.download import default, threaded, FFMPEG
+
+
+def setup_api(do_logging=False):
+    if do_logging:
+        logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+        logging.getLogger("urllib3").setLevel(logging.WARNING)
+
+    else:
+        logging.disable(logging.CRITICAL)
+
+
+base_qualities = ["250p", "360p", "480p", "720p", "1080p", "1440p", "2160p"]
+
+
+class Core:
+    @classmethod
+    def get_content(cls, url, headers=None, cookies=None, retries=4):
+        for i in range(retries):
+            try:
+                logging.debug(f"Trying to fetch {url} / Attempt: [{i+1}]")
+                response = requests.get(url, headers=headers, cookies=cookies)
+                if response.status_code == 200:
+                    logging.info(f"Successfully fetched {url} on attempt [{i+1}]")
+                    return response.content
+                else:
+                    logging.warning(f"Failed to fetch {url} with status code {response.status_code} on attempt [{i+1}]")
+            except requests.exceptions.RequestException as e:
+                logging.error(f"Exception occurred when trying to fetch {url} on attempt [{i+1}]: {e}")
+            if i < retries - 1:  # Implement exponential backoff
+                time.sleep(2 ** i)
+        logging.error(f"Failed to fetch {url} after {retries} attempts.")
+        logging.error("Returning None")
+        return None
+
+    @classmethod
+    def fix_quality(cls, quality):
+        """This method gives the user the opportunity to pass a string instead of the quality object"""
+        if isinstance(quality, Quality):
+            return quality
+
+        elif str(quality) == "best":
+            return Quality.BEST
+
+        elif str(quality) == "half":
+            return Quality.HALF
+
+        elif str(quality) == "worst":
+            return Quality.WORST
+
+    def get_available_qualities(self, m3u8_base_url):
+        """Returns the available qualities from the M3U8 base url"""
+        content = self.get_content(m3u8_base_url).decode("utf-8")
+        lines = content.splitlines()
+
+        quality_url_map = {}
+
+        for line in lines:
+            for quality in base_qualities:
+                if f"hls-{quality}" in line:
+                    quality_url_map[quality] = line
+
+        self.quality_url_map = quality_url_map
+        self.available_qualities = list(quality_url_map.keys())
+        return self.available_qualities
+
+    def get_m3u8_by_quality(self, quality, m3u8_base_url):
+        """Returns the m3u8 url for the given quality"""
+        quality = self.fix_quality(quality)
+
+        self.get_available_qualities(m3u8_base_url)
+        if quality == Quality.BEST:
+            selected_quality = max(self.available_qualities, key=lambda q: base_qualities.index(q))
+        elif quality == Quality.WORST:
+            selected_quality = min(self.available_qualities, key=lambda q: base_qualities.index(q))
+        elif quality == Quality.HALF:
+            sorted_qualities = sorted(self.available_qualities, key=lambda q: base_qualities.index(q))
+            middle_index = len(sorted_qualities) // 2
+            selected_quality = sorted_qualities[middle_index]
+
+        return self.quality_url_map.get(selected_quality)
+
+    def download(self, video, quality, downloader, output_path, callback=None):
+        """
+        :param callback:
+        :param downloader:
+        :param quality:
+        :param output_path:
+        :return:
+        """
+        quality = self.fix_quality(quality)
+
+        if callback is None:
+            callback = Callback.text_progress_bar
+
+        if downloader == default or str(downloader) == "default":
+            default(video=video, quality=quality, path=output_path, callback=callback)
+
+        elif downloader == threaded or str(downloader) == "threaded":
+            threaded_download = threaded(max_workers=20, timeout=10)
+            threaded_download(video=video, quality=quality, path=output_path, callback=callback)
+
+        elif downloader == FFMPEG or str(downloader) == "FFMPEG":
+            FFMPEG(video=video, quality=quality, path=output_path, callback=callback)

eaf_base_api-1.0/base_api/modules/download.py

@@ -0,0 +1,129 @@
+# Thanks to: https://github.com/EchterAlsFake/PHUB/blob/master/src/phub/modules/download.py
+# oh and of course ChatGPT lol
+import logging
+import time
+import requests
+import os
+from ffmpeg_progress_yield import FfmpegProgress
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Callable, List
+
+CallbackType = Callable[[int, int], None]
+
+"""
+Important: The title of the video isn't applied to the output path. You need to manually append it to 
+the output path. This has good reasons, to make this library more adaptable into other applications.
+"""
+
+
+def download_segment(url: str, timeout: int, retries: int = 3, backoff_factor: float = 0.3) -> tuple[str, bytes, bool]:
+    """
+    Attempt to download a single segment, retrying on failure.
+    Returns a tuple of the URL, content (empty if failed after retries), and a success flag.
+    """
+    for attempt in range(retries):
+        try:
+            response = requests.get(url, timeout=timeout)
+            response.raise_for_status()  # Raises stored HTTPError, if one occurred.
+            return (url, response.content, True)  # Success
+        except requests.RequestException as e:
+            print(f"Retry {attempt + 1} for {url}: {e}")
+            time.sleep(backoff_factor * (2 ** attempt))  # Exponential backoff
+
+    # After all retries have failed
+    return (url, b'', False)  # Failed download
+
+
+def threaded(max_workers: int = 20, timeout: int = 10, retries: int = 3):
+    """
+    Creates a wrapper function for the actual download process, with retry logic.
+    """
+    def wrapper(video, quality, callback, path):
+        """
+        Download video segments in parallel, with retries for failures, and write to a file.
+        """
+        segments = video.get_segments(quality=quality)
+        length = len(segments)
+        completed, successful_downloads = 0, 0
+
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            # Map the last part of the URL (filename) to the future
+            future_to_hls_part = {executor.submit(download_segment, url, timeout, retries): os.path.basename(url) for url in segments}
+
+            for future in as_completed(future_to_hls_part):
+                hls_part = future_to_hls_part[future]
+                try:
+                    _, data, success = future.result()
+                    completed += 1
+                    if success:
+                        successful_downloads += 1
+                    callback(completed, length)  # Update callback regardless of success to reflect progress
+                except Exception as e:
+                    raise e
+
+        # Writing only successful downloads to the file
+        with open(path, 'wb') as file:
+            for segment_url in segments:
+                # Find the future object using the HLS part of the URL as the key
+                matched_futures = [future for future, hls_part in future_to_hls_part.items() if hls_part == os.path.basename(segment_url)]
+                if matched_futures:
+                    logging.info("Got a match")
+                    future = matched_futures[0]  # Assuming unique HLS parts, take the first match
+                    try:
+                        _, data, success = future.result()
+                        if success:
+                            file.write(data)
+                    except Exception as e:
+                        pass  # Optionally handle or log the exception here
+
+    return wrapper
+
+
+def default(video, quality, callback, path, start: int = 0) -> bool:
+    buffer = b''
+    segments = video.get_segments(quality)[start:]
+    length = len(segments)
+
+    for i, url in enumerate(segments):
+        for _ in range(5):
+
+            segment = requests.get(url)
+
+            if segment.ok:
+                buffer += segment.content
+                callback(i + 1, length)
+                break
+
+    with open(path, 'wb') as file:
+        file.write(buffer)
+
+    return True
+
+
+def FFMPEG(video, quality, callback, path, start=0) -> bool:
+    base_url = video.m3u8_base_url
+    new_segment = video.get_m3u8_by_quality(quality)
+    url_components = base_url.split('/')
+    url_components[-1] = new_segment
+    new_url = '/'.join(url_components)
+
+    # Build the command for FFMPEG as a list directly
+    command = [
+        "ffmpeg",
+        "-i", new_url,  # Input URL
+        "-bsf:a", "aac_adtstoasc",
+        "-y",  # Overwrite output files without asking
+        "-c", "copy",  # Copy streams without reencoding
+        path  # Output file path
+    ]
+
+    # Initialize FfmpegProgress and execute the command
+    ff = FfmpegProgress(command)
+    for progress in ff.run_command_with_progress():
+        # Update the callback with the current progress
+        callback(int(round(progress)), 100)
+
+        if progress == 100:
+            return True
+
+    return False

eaf_base_api-1.0/base_api/modules/progress_bars.py

@@ -0,0 +1,40 @@
+import sys
+
+
+class Callback:
+    @classmethod
+    def custom_callback(cls, downloaded, total):
+        """This is an example of how you can implement the custom callback"""
+
+        percentage = (downloaded / total) * 100
+        print(f"Downloaded: {downloaded} bytes / {total} bytes ({percentage:.2f}%)")
+
+    @classmethod
+    def text_progress_bar(cls, downloaded, total):
+        bar_length = 50
+        filled_length = int(round(bar_length * downloaded / float(total)))
+        percents = round(100.0 * downloaded / float(total), 1)
+        bar = '#' * filled_length + '-' * (bar_length - filled_length)
+        print(f"\r[{bar}] {percents}%", end='')
+
+    @staticmethod
+    def update_progress(downloaded, total, animation_phase):
+        bar_length = 50
+        filled_length = int(round(bar_length * downloaded / float(total)))
+        percents = round(100.0 * downloaded / float(total), 1)
+
+        # Animation phases could be anything. Here's a simple example with a rotating bar
+        animation_characters = ['|', '/', '-', '\\']
+        animation_char = animation_characters[animation_phase % len(animation_characters)]
+
+        bar = '#' * filled_length + animation_char + '-' * (bar_length - filled_length - 1)
+
+        sys.stdout.write(f"\r[{bar}] {percents}%")
+        sys.stdout.flush()
+
+    @classmethod
+    def animated_text_progress(cls, downloaded, total_size):
+        animation_phase = 0
+        while downloaded <= total_size:
+            cls.update_progress(downloaded, total_size, animation_phase)
+            animation_phase += 1

eaf_base_api-1.0/base_api/modules/quality.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class Quality(Enum):
+    BEST = 'BEST'
+    HALF = 'HALF'
+    WORST = 'WORST'

eaf_base_api-1.0/eaf_base_api.egg-info/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.1
+Name: eaf_base_api
+Version: 1.0
+Summary: A base API for EchterAlsFake's Porn APIs
+Home-page: https://github.com/EchterAlsFake/eaf_base_api
+Author: Johannes Habel
+Author-email: EchterAlsFake@proton.me
+License: LGPLv3
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
+Classifier: Programming Language :: Python
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+Requires-Dist: ffmpeg-progress-yield
+
+# EAF Base API
+
+! Still in Development
+
+This Python package is a base api for all my Porn Site APIs. A lot of sites use the same methods, and
+there's a lot of code that I've rewritten again and again. This is why I created this base api, so that 
+I need to write less code and everything is easier to be maintainable. 
+
+# PRs
+Pull Requests are welcome, but if you make changes run `pytest` on all APIs that are using this to make sure your
+PR didn't break anything.
+
+# Documentation
+
+As this is some kind of 'raw' base API, this won't be documented, as it's only functional when used together
+with the main APIs. 
+
+Maybe you can look at the code comments. They could be helpful
+
+# Implementation
+You are welcome to implement this API in your own projects. If it's useful... But I don't recommend this, as things
+might change without a warning. But things like the threaded downloads can be useful for other projects :) 
+
+I'd say the threaded modes from the download module are already very well optimized, so feel free to just copy them
+for your own projects. You don't need to do any attribution, I don't care :) 
+
+
+# License
+
+LGPLv3

eaf_base_api-1.0/eaf_base_api.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+setup.py
+base_api/__init__.py
+base_api/base.py
+base_api/modules/__init__.py
+base_api/modules/download.py
+base_api/modules/progress_bars.py
+base_api/modules/quality.py
+eaf_base_api.egg-info/PKG-INFO
+eaf_base_api.egg-info/SOURCES.txt
+eaf_base_api.egg-info/dependency_links.txt
+eaf_base_api.egg-info/requires.txt
+eaf_base_api.egg-info/top_level.txt

eaf_base_api-1.0/eaf_base_api.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

eaf_base_api-1.0/eaf_base_api.egg-info/requires.txt

@@ -0,0 +1,2 @@
+requests
+ffmpeg-progress-yield

eaf_base_api-1.0/eaf_base_api.egg-info/top_level.txt

@@ -0,0 +1 @@
+base_api

eaf_base_api-1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

eaf_base_api-1.0/setup.py

@@ -0,0 +1,27 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="eaf_base_api",
+    version="1.0",
+    packages=find_packages(),
+    install_requires=[
+        "requests", "ffmpeg-progress-yield"
+    ],
+    entry_points={
+        'console_scripts': [
+            # If you want to create any executable scripts
+        ],
+    },
+    author="Johannes Habel",
+    author_email="EchterAlsFake@proton.me",
+    description="A base API for EchterAlsFake's Porn APIs",
+    long_description=open('README.md').read(),
+    long_description_content_type='text/markdown',
+    license="LGPLv3",
+    url="https://github.com/EchterAlsFake/eaf_base_api",
+    classifiers=[
+        # Classifiers help users find your project on PyPI
+        "License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)",
+        "Programming Language :: Python",
+    ],
+)