eaf-base-api 2.2.4__tar.gz → 2.2.6__tar.gz

{eaf_base_api-2.2.4 → eaf_base_api-2.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: eaf_base_api
-Version: 2.2.4
+Version: 2.2.6
 Summary: A base API for EchterAlsFake's Porn APIs
 Home-page: https://github.com/EchterAlsFake/eaf_base_api
 Author: Johannes Habel

{eaf_base_api-2.2.4 → eaf_base_api-2.2.6}/base_api/base.py

@@ -1,9 +1,9 @@
 import os
+import sys
 import time
 import m3u8
 import httpx
 import random
-import string
 import logging
 import traceback
 import threading
@@ -22,13 +22,78 @@ except (ModuleNotFoundError, ImportError):
     from .modules import consts
     from .modules.progress_bars import Callback
 
-logging.basicConfig(format='%(name)s %(levelname)s %(asctime)s %(message)s', datefmt='%I:%M:%S %p')
-logger = logging.getLogger("BASE API")
-logger.setLevel(logging.DEBUG)
+loggers = {}
+
+# Default formatter
+formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+
+
+def is_android():
+    """Detects if the script is running on an Android device."""
+    return "ANDROID_ROOT" in os.environ and "ANDROID_DATA" in os.environ
+
+def get_log_file_path(filename="app.log"):
+    """Returns a valid log file path that works on Android and other OS."""
+    if is_android():
+        return os.path.join(os.environ["HOME"], filename)  # Internal app storage
+    return filename  # Default for Linux, Windows, Mac
+
+
+# Define ANSI color codes for different log levels
+LOG_COLORS = {
+    'DEBUG': "\033[37m",   # White
+    'INFO': "\033[34m",    # Blue
+    'WARNING': "\033[33m", # Yellow
+    'ERROR': "\033[31m",   # Red
+    'CRITICAL': "\033[41m"  # Red background
+}
+RESET_COLOR = "\033[0m"
+
+class ColoredFormatter(logging.Formatter):
+    def format(self, record):
+        log_message = super().format(record)
+        color = LOG_COLORS.get(record.levelname, RESET_COLOR)
+        return f"{color}{log_message}{RESET_COLOR}"
+
+
+def setup_logger(name, log_file=None, level=logging.CRITICAL):
+    """Creates or updates a logger for a specific module."""
+    if name in loggers:
+        logger = loggers[name]
+        logger.setLevel(level)
+
+        file_handler_exists = any(isinstance(h, logging.FileHandler) for h in logger.handlers)
+        if log_file and not file_handler_exists:
+            log_file = get_log_file_path(log_file)
+            fh = logging.FileHandler(log_file, mode='a')
+            fh.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
+            logger.addHandler(fh)
+
+        return logger
+
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+
+    if not any(isinstance(h, logging.StreamHandler) for h in logger.handlers):
+        ch = logging.StreamHandler()
+        ch.setFormatter(ColoredFormatter("%(asctime)s - %(levelname)s - %(message)s"))
+        logger.addHandler(ch)
+
+    # Ensure the log file is overwritten only on the first program start
+    if log_file:
+        log_file = get_log_file_path(log_file)
+        if not hasattr(sys, '_first_run'):
+            sys._first_run = True
+            file_mode = 'w'
+        else:
+            file_mode = 'a'
 
-def disable_logging():
-    logger.setLevel(logging.CRITICAL)
+        fh = logging.FileHandler(log_file, mode=file_mode)
+        fh.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
+        logger.addHandler(fh)
 
+    loggers[name] = logger
+    return logger
 
 class Cache:
     """
@@ -38,6 +103,13 @@ class Cache:
     def __init__(self):
         self.cache_dictionary = {}
         self.lock = threading.Lock()
+        self.logger = setup_logger("BASE API - [Cache]", level=logging.CRITICAL)
+
+    def enable_logging(self, log_file=None, level=logging.DEBUG):
+        """
+        Enables logging dynamically for this module.
+        """
+        self.logger = setup_logger(name="BASE API - [Cache]", log_file=log_file, level=level)
 
     def handle_cache(self, url):
         if url is None:
@@ -53,13 +125,10 @@ class Cache:
                 first_key = next(iter(self.cache_dictionary))
                 # Delete the first item
                 del self.cache_dictionary[first_key]
-                logger.info(f"Deleting: {first_key} from cache, due to caching limits...")
+                self.logger.info(f"Deleting: {first_key} from cache, due to caching limits...")
 
             self.cache_dictionary[url] = content
 
-cache = Cache()
-
-
 class BaseCore:
     """
     The base class which has all necessary functions for other API packages
@@ -68,8 +137,16 @@ class BaseCore:
         self.last_request_time = time.time()
         self.total_requests = 0 # Tracks how many requests have been made
         self.session = None
+        self.cache = Cache()
         self.initialize_session()
+        self.logger = setup_logger("BASE API - [BaseCore]", log_file=False, level=logging.ERROR)
 
+    def enable_logging(self, log_file=None, level=logging.DEBUG):
+        """
+        Enables logging dynamically for this module.
+        """
+        self.logger = setup_logger(name="BASE API - [BaseCore]", log_file=log_file, level=level)
+        self.cache.logger = setup_logger(name="BASE API - [Cache]", log_file=log_file, level=level)
 
     def update_user_agent(self):
         """Updates the User-Agent"""
@@ -92,10 +169,10 @@ class BaseCore:
         delay = consts.REQUEST_DELAY
         if delay > 0:
             time_since_last_request = time.time() - self.last_request_time
-            logger.debug(f"Time since last request: {time_since_last_request:.2f} seconds.")
+            self.logger.debug(f"Time since last request: {time_since_last_request:.2f} seconds.")
             if time_since_last_request < delay:
                 sleep_time = delay - time_since_last_request
-                logger.debug(f"Enforcing delay of {sleep_time:.2f} seconds.")
+                self.logger.debug(f"Enforcing delay of {sleep_time:.2f} seconds.")
                 time.sleep(sleep_time)
 
     def fetch(
@@ -113,9 +190,9 @@ class BaseCore:
         support for proxies and custom timeout.
         """
         # Check cache first
-        content = cache.handle_cache(url)
+        content = self.cache.handle_cache(url)
         if content is not None:
-            logger.info(f"Fetched content for: {url} from cache!")
+            self.logger.info(f"Fetched content for: {url} from cache!")
             return content
 
         for attempt in range(1, consts.MAX_RETRIES + 1):
@@ -124,7 +201,7 @@ class BaseCore:
 
             try:
                 # Update user agent periodically
-                if self.total_requests % 3 == 0:
+                if self.total_requests % 5 == 0:
                     self.update_user_agent()
 
                 self.enforce_delay()
@@ -136,41 +213,54 @@ class BaseCore:
 
                     # Log and handle non-200 status codes
                     if response.status_code != 200:
-                        logger.warning(
+                        self.logger.warning(
                             f"Attempt {attempt}: Unexpected status code {response.status_code} for URL: {url}")
 
                         if response.status_code == 404:
-                            logger.error("Resource not found (404). This may indicate the content is unavailable.")
+                            self.logger.error("Resource not found (404). This may indicate the content is unavailable.")
                             return None  # Return None for unavailable resources
 
+                        elif response.status_code == 403 and attempt >= 2:
+                            self.logger.error(f"The website rejected access after {attempt} tries. Aborting!")
+                            return None # Return None for forbidden resources
+
                         continue  # Retry for other non-200 status codes
 
-                    logger.debug(f"Attempt {attempt}: Successfully fetched URL: {url}")
+                    self.logger.debug(f"Attempt {attempt}: Successfully fetched URL: {url}")
 
                     # Return response if requested
                     if get_response:
                         return response
 
                     # Process and return content
+                    # Collecting all chunks before processing because some sites cause issues with real-time decoding
+                    raw_content = b"".join(response.iter_bytes())
+
                     if get_bytes:
-                        content = b"".join([chunk for chunk in response.iter_bytes()])
+                        content = raw_content
+
                     else:
-                        content = "".join([chunk.decode("utf-8") for chunk in response.iter_bytes()])
-                        if save_cache:
-                            logger.debug(f"Saving content of {url} to local cache.")
-                            cache.save_cache(url, content)
+                        try:
+                            content = raw_content.decode("utf-8")
+
+                        except UnicodeDecodeError:
+                            content = raw_content.decode("latin1") # Fallback, hope that works somehow idk
+
+                        if save_cache and not get_bytes:
+                            self.logger.debug(f"Saving content of {url} to local cache.")
+                            self.cache.save_cache(url, content)
 
                     return content
 
             except httpx.RequestError as e:
-                logger.error(f"Attempt {attempt}: Request error for URL {url}: {e}")
+                self.logger.error(f"Attempt {attempt}: Request error for URL {url}: {e}")
 
             except Exception:
-                logger.error(f"Attempt {attempt}: Unexpected error for URL {url}: {traceback.format_exc()}")
+                self.logger.error(f"Attempt {attempt}: Unexpected error for URL {url}: {traceback.format_exc()}")
 
-            logger.info(f"Retrying ({attempt}/{consts.MAX_RETRIES}) for URL: {url}")
+            self.logger.info(f"Retrying ({attempt}/{consts.MAX_RETRIES}) for URL: {url}")
 
-        logger.error(f"Failed to fetch URL {url} after {consts.MAX_RETRIES} attempts.")
+        self.logger.error(f"Failed to fetch URL {url} after {consts.MAX_RETRIES} attempts.")
         return None  # Return None if all attempts fail
 
     @classmethod
@@ -179,9 +269,11 @@ class BaseCore:
         :param title:
         :return: str: strips out non UTF-8 chars of the title
         """
-        illegal_chars = '<>:"/\\|?*'
-        cleaned_title = ''.join([char for char in title if char in string.printable and char not in illegal_chars])
-        return cleaned_title
+        illegal_chars = ['<', '>', ':', '"', '/', '\\', '|', '?', '*']
+        for char in illegal_chars:
+            title = title.replace(char, "")
+
+        return title
 
     @lru_cache(maxsize=250)
     def get_m3u8_by_quality(self, m3u8_url: str, quality: str) -> str:
@@ -189,7 +281,7 @@ class BaseCore:
         m3u8 playlist"""
         playlist_content = self.fetch(url=m3u8_url)
         playlist = m3u8.loads(playlist_content)
-        logger.debug(f"Resolved m3u8 playlist: {m3u8_url}")
+        self.logger.debug(f"Resolved m3u8 playlist: {m3u8_url}")
 
         if not playlist.is_variant:
             raise ValueError("Provided URL is not a master playlist.")
@@ -226,7 +318,7 @@ class BaseCore:
     def get_segments(self, m3u8_url_master: str, quality: str) -> list:
         """Gets all video segments from a given quality and the primary m3u8 URL"""
         m3u8_url = self.get_m3u8_by_quality(m3u8_url=m3u8_url_master, quality=quality)
-        logger.debug(f"Trying to fetch segment from m3u8 ->: {m3u8_url}")
+        self.logger.debug(f"Trying to fetch segment from m3u8 ->: {m3u8_url}")
         content = self.fetch(url=m3u8_url)
         segments_ = m3u8.loads(content).segments
         segments = []
@@ -234,7 +326,7 @@ class BaseCore:
         for segment in segments_:
             segments.append(urljoin(m3u8_url, segment.uri)) # Get the full URL path to segment
 
-        logger.debug(f"Fetched {len(segments)} segments from m3u8 URL")
+        self.logger.debug(f"Fetched {len(segments)} segments from m3u8 URL")
         return segments
 
     def download(self, video, quality: str, downloader: str, path: str, callback=None) -> None:
@@ -298,7 +390,7 @@ class BaseCore:
                             successful_downloads += 1
                         callback(completed, length)  # Update progress callback
                     except Exception as e:
-                        logger.error(f"Error processing segment {hls_part}: {e}")
+                        self.logger.error(f"Error processing segment {hls_part}: {e}")
 
             # Write only successful segments to the output file
             with open(path, 'wb') as file:
@@ -314,7 +406,7 @@ class BaseCore:
                             if success:
                                 file.write(data)
                         except Exception as e:
-                            logger.error(f"Exception writing segment {segment_url}: {e}")
+                            self.logger.error(f"Exception writing segment {segment_url}: {e}")
 
         return wrapper
 
@@ -399,10 +491,10 @@ class BaseCore:
                 return True
 
         except httpx.RequestError as e:
-            logger.error(f"Request failed for URL {url}: {e}")
+            self.logger.error(f"Request failed for URL {url}: {e}")
             return False
         except Exception as e:
-            logger.error(f"Unexpected error during download: {e}")
+            self.logger.error(f"Unexpected error during download: {e}")
             return False
 
     @classmethod

{eaf_base_api-2.2.4 → eaf_base_api-2.2.6}/eaf_base_api.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: eaf_base_api
-Version: 2.2.4
+Version: 2.2.6
 Summary: A base API for EchterAlsFake's Porn APIs
 Home-page: https://github.com/EchterAlsFake/eaf_base_api
 Author: Johannes Habel

{eaf_base_api-2.2.4 → eaf_base_api-2.2.6}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="eaf_base_api",
-    version="2.2.4",
+    version="2.2.6",
     packages=find_packages(),
     install_requires=["ffmpeg-progress-yield", "m3u8", "httpx"],
     entry_points={