phub 4.7.7__py3-none-any.whl → 4.7.9__py3-none-any.whl

phub/__init__.py

@@ -11,12 +11,11 @@ __copyright__ = 'Copyright 2024, PHUB'
 __license__ = 'GPLv3'
 __version__  = '4.7.2'
 
-__all__ = ['Client', 'Quality', 'core', 'utils',
+__all__ = ['Client', 'core', 'utils',
            'consts', 'errors', 'objects', 'modules']
 
 # Shortcuts
 from .core import Client
-from .utils import Quality
 
 # Sub modules
 from . import core

phub/__main__.py

@@ -4,9 +4,9 @@ PHUB built-in CLI.
 
 import os
 import argparse
+import re
 
 from phub import Client, Video
-from phub.modules.download import threaded, FFMPEG, default
 
 
 def text_progress_bar(downloaded, total, title=False):
@@ -33,21 +33,13 @@ def download_video(client: Client, url: [str, Video], output: str, quality: str,
     else:
         raise "Some error happened here, please report on GitHub, thank you :) "
 
-    title = video.title
+    title =  re.sub(r'[<>:"/\\|?*]', '', video.title)
     final_output_path = os.path.join(output, title + ".mp4")
 
     print(f"Downloading: {title} to: {final_output_path}")
     video.download(path=final_output_path, quality=quality, downloader=downloader, display=text_progress_bar)
     print(f"Successfully downloaded: {title}")
 
-def resolve_threading_mode(mode, workers=10, timeout=10):
-    """Resolve the appropriate threading mode based on input."""
-    return {
-        "threaded": threaded(max_workers=workers, timeout=timeout),
-        "ffmpeg": FFMPEG,
-        "default": default
-    }.get(mode, default)
-
 
 def main():
     parser = argparse.ArgumentParser(description="PHUB built-in CLI")
@@ -67,7 +59,7 @@ def main():
     args = parser.parse_args()
     quality = args.quality
     output = args.output
-    downloader = resolve_threading_mode(mode=args.downloader)
+    downloader = args.downloader
     url = args.url
     model = args.model
     video_limit = args.video_limit
@@ -109,4 +101,4 @@ def main():
 if __name__ == '__main__':
     main()
 
-# EOF
+# EOF

phub/consts.py

@@ -36,22 +36,6 @@ LOGIN_PAYLOAD = {
 }
 
 RSS = 'https://www.pornhub.com/video/webmasterss'
-
-PROXY = None
-# Can be any http or socks proxy
-
-
-MAX_CALL_RETRIES = 4 # Maximum times a HTTPError can be reproduced
-MAX_CALL_TIMEOUT = .4 # Time to wait before retrying basic calls
-CALL_TIMEOUT = 30 # Time to wait before retrying calls (in case no error happens)
-CHALLENGE_TIMEOUT = 2 # Time to wait before injecting the new cookie for resolving the challenge (needs to be at least 1)
-DELAY = 0 # Minimum time between requests
-
-DOWNLOAD_SEGMENT_MAX_ATTEMPS = 5
-DOWNLOAD_SEGMENT_ERROR_DELAY = .5
-
-FFMPEG_EXECUTABLE = 'ffmpeg' # Use from PATH by default
-
 IFRAME = '<iframe src="https://www.pornhub.com/embed/{key}" frameborder="0" width="{width}" height="{height}" scrolling="no" allowfullscreen></iframe>'
 
 # Supported languages
@@ -243,8 +227,7 @@ class re:
     container                = find( engine.DOTALL,              r'class=\"container(.*)'                                                      ) # Get the page container
     document                 = find( engine.DOTALL,              r'.*'                                                                         ) # Match a whole document
     get_playlist_unavailable = find( engine.DOTALL,              r': (\d+)</h5'                                                                ) # Get playlist unavailable videos amount
-    playlist_data            = find( engine.DOTALL,              r'id=\"playlistWrapper(.*?)playlistSectionWrapper\"'                          ) # Get playlist data container
-    get_playlist_size        = find( engine.DOTALL,              r'- (\d+).*?\"avatarPosition'                                                 ) # Get playlist video amount
+    get_playlist_size        = find( engine.DOTALL,              r'var itemsCount = (.*?) ||'                                                 ) # Get playlist video amount
     get_playlist_likes       = find( engine.DOTALL,              r'<span class="votesUp">(.*?)</span>'                                         ) # Get playlist likes
     get_playlist_dislikes    = find( engine.DOTALL,              r'<span class="votesDown">(.*?)</span>'                                       ) # Get playlist dislikes
     get_playlist_ratings     = find( engine.DOTALL,              r'<span class="percent">(.*?)%</span>'                                        ) # Get paylist like/dislike ratio

phub/core.py

@@ -1,27 +1,27 @@
 '''
 PHUB core module.
 '''
-
+import re
 import time
 import logging
 import random
-
 import httpx
+
 from typing import Iterable, Union
 from functools import cached_property
+from base_api.base import BaseCore, setup_logger
 
 from . import utils
 from . import consts
 from . import errors
 from . import literals
+from .errors import LoginFailed
 
 from .modules import parser
 
 from .objects import (Video, User,
                       Account, Query, queries, Playlist)
 
-logger = logging.getLogger(__name__)
-
 
 class Client:
     '''
@@ -38,7 +38,8 @@ class Client:
                  login: bool = True,
                  bypass_geo_blocking: bool = False,
                  change_title_language: bool = True,
-                 use_webmaster_api: bool = True) -> None:
+                 use_webmaster_api: bool = True,
+                 core=None) -> None:
         '''
         Initialises a new client.
         
@@ -54,8 +55,13 @@ class Client:
             LoginFailed: If Pornhub refuses the authentication.
                 The reason will be passed as the error body.
         '''
-        
-        logger.debug('Initialised new Client %s', self)
+
+        self.logger = setup_logger(name="PHUB API - [Client]", log_file=None, level=logging.ERROR)
+        self.core = core or BaseCore()
+        self.core.config.cookies = consts.COOKIES
+        self.core.config.headers = consts.HEADERS
+        # Applying PornHub specific cookies and headers to base API
+        self.logger.debug('Initialised new Client %s', self)
 
         # Initialise session
         Client.use_webmaster_api = use_webmaster_api
@@ -65,41 +71,30 @@ class Client:
 
         self.reset()
 
-        self.session.headers.update({"Accept-Language": language})
+        self.core.config.headers.update({"Accept-Language": language})
+        self.core.update_headers({"Accept-Language": language})
         self.credentials = {'email': email,
                             'password': password}
-        
-        self.delay = consts.DELAY
-        self.start_delay = False
-        self.last_request_time = None
-        
+
+
         # Connect account
         self.logged = False
         self.account = Account(self)
-        logger.debug('Connected account to client %s', self.account)
+        self.logger.debug('Connected account to client %s', self.account)
         
         # Automatic login
         if login and self.account:
             self.login()
-    
+
+    def enable_logging(self, log_file: str = None, level = None, log_ip=None, log_port=None):
+        self.logger = setup_logger(name="PHUB API - [Client]", log_file=log_file, level=level, http_ip=log_ip, http_port=log_port)
+
     def reset(self) -> None:
         '''
         Reset the client requests session.
         This is useful if you are keeping the client running
         for a long time and can help with Pornhub rate limit.
         '''
-        verify = True
-        if consts.PROXY is not None:
-            verify = False
-
-        # Initialise session
-        self.session = httpx.Client(
-            headers = consts.HEADERS,
-            cookies = consts.COOKIES,
-            follow_redirects = True,
-            proxy = consts.PROXY,
-            verify = verify)
-
         self._clear_granted_token()
 
         if self.bypass_geo_blocking:
@@ -107,21 +102,21 @@ class Client:
             language_code = "fr"
 
             # Faking the X-Forwarded-For header (Fake IP source)
-            self.session.headers.update({"X-Forwarded-For": f"{ip}"})
+            self.core.config.headers.update({"X-Forwarded-For": f"{ip}"})
             # Setting the Accept-Language tag to French, because the faked IP comes from france
-            self.session.headers.update({"Accept-Language": f"{language_code}"})
+            self.core.config.headers.update({"Accept-Language": f"{language_code}"})
             # Setting the country code also to french
-            self.session.headers.update({"CF-IPCountry": f"{language_code}"})
-            logging.debug(f"Using faked headers for geo-bypass: {self.session.headers}")
+            self.core.config.headers.update({"CF-IPCountry": f"{language_code}"})
+            logging.debug(f"Using faked headers for geo-bypass: {self.core.config.session.headers}")
 
     def call(self,
              func: str,
              method: str = 'GET',
              data: dict = None,
              headers: dict = None,
-             timeout: float = consts.CALL_TIMEOUT,
              throw: bool = True,
-             silent: bool = False) -> httpx.Response:
+             silent: bool = False,
+             get_response = True) -> httpx.Response:
         '''
         Used internally to send a request or an API call.
 
@@ -130,7 +125,6 @@ class Client:
             method (str): Request method (GET, POST, PUT, ...).
             data (dict): Optional data to send to the server.
             headers (dict): Additional request headers.
-            timeout (float): Request maximum response time.
             throw (bool): Whether to raise an error when a request explicitly fails.
             silent (bool): Whether to supress this call from logs.
 
@@ -142,15 +136,10 @@ class Client:
             HTTPError: If the request failed, for any reason.
         '''
         func = utils.fix_url(func)
-        logger.log(logging.DEBUG if silent else logging.INFO, 'Fetching %s', func or '/')
+        self.logger.log(logging.DEBUG if silent else logging.INFO, 'Fetching %s', func or '/')
 
-        # Delay mechanism
-        if self.last_request_time:
-            elapsed_time = time.time() - self.last_request_time
-            if elapsed_time < self.delay:
-                time.sleep(self.delay - elapsed_time)
-
-        self.last_request_time = time.time()  # Update the time of the last request
+        if headers:
+            self.core.config.headers = headers
 
         if not self.language == "en":
             host = consts.LANGUAGE_MAPPING.get(self.language)
@@ -160,15 +149,13 @@ class Client:
             host = consts.HOST
 
         url = func if 'http' in func else utils.concat(host, func)
-        for i in range(consts.MAX_CALL_RETRIES):
+        for i in range(self.core.config.max_retries):
             try:
-                response = self.session.request(
+                response = self.core.fetch(
                     method = method,
                     url = url,
-                    headers = headers,
                     data = data,
-                    timeout = timeout
-                )
+                    get_response=get_response)
 
                 # Silent 429 errors
                 if b'429</title>' in response.content:
@@ -177,19 +164,18 @@ class Client:
                 # Attempt to resolve the challenge if needed
                 challenge = consts.re.get_challenge(response.text, False)
                 if challenge:
-                    logger.info('Challenge found, attempting to resolve')
+                    self.logger.info('Challenge found, attempting to resolve')
                     parser.challenge(self, *challenge)
                     
-                    logger.info(f"Sleeping for {consts.CHALLENGE_TIMEOUT} seconds")
-                    time.sleep(consts.CHALLENGE_TIMEOUT)
+                    self.logger.info(f"Sleeping for 1.5 seconds")
+                    time.sleep(1.5) # Yes, we need to sleep that amount, otherwise PornHub refuses the challenge.
                     continue  # Reload page
 
                 break
 
             except Exception as err:
-                logger.log(logging.DEBUG if silent else logging.WARNING,
-                           f'Call failed: {repr(err)}. Retrying (attempt {i + 1}/{consts.MAX_CALL_RETRIES})')
-                time.sleep(consts.MAX_CALL_TIMEOUT)
+                self.logger.log(logging.DEBUG if silent else logging.WARNING,
+                           f'Call failed: {repr(err)}. Retrying (attempt {i + 1}/{self.core.config.max_retries})')
                 continue
 
         else:
@@ -216,16 +202,21 @@ class Client:
             LoginFailed: If the login failed, for a reason passed in the error body.
         '''
         
-        logger.debug('Attempting login')
+        self.logger.debug('Attempting login')
         
         if not force and self.logged:
-            logger.error('Client is already logged in')
+            self.logger.error('Client is already logged in')
             raise errors.ClientAlreadyLogged()
     
         # Get token
-        page = self.call('').text
-        base_token = consts.re.get_token(page)
-        
+        page = self.call('https://www.pornhub.com').text
+        try:
+            base_token = consts.re.get_token(page)
+
+        except errors.RegexError:
+            self.logger.warning("Couldn't get token. Trying alternative method...")
+            base_token = re.search(r'data-token="(.*?)"', string=page).group(1)
+
         # Send credentials
         payload = consts.LOGIN_PAYLOAD | self.credentials | {'token': base_token}
         response = self.call('front/authenticate', method = 'POST', data = payload)
@@ -236,7 +227,7 @@ class Client:
         message = data.get('message')
         
         if throw and not success:
-            logger.error('Login failed: Received error: %s', message)
+            self.logger.error('Login failed: Received error: %s', message)
             raise errors.LoginFailed(message)
         
         # Reset token
@@ -258,7 +249,7 @@ class Client:
             Video: The corresponding video object.
         '''
         
-        logger.debug(f'Fetching video at {video}')
+        self.logger.debug(f'Fetching video at {video}')
 
         if isinstance(video, Video):
             # User might want to re-init a video,
@@ -296,7 +287,7 @@ class Client:
         if isinstance(user, User):
             user = user.url
         
-        logger.debug('Fetching user %s', user)
+        self.logger.debug('Fetching user %s', user)
         return User.get(self, user)
 
     def search_hubtraffic(self,
@@ -308,7 +299,7 @@ class Client:
                period: literals.ht_period = None) -> Query:
         '''
         Perform searching on Pornhub using the HubTraffic API.
-        It is condidered to be much faster but has less filters.
+        It is considered to be much faster but has less filters.
         
         Args:
             query (str): The query to search.

phub/modules/__init__.py

@@ -2,11 +2,10 @@
 PHUB submodules.
 '''
 
-__all__ = ['parser', 'display', 'download', 'rss']
+__all__ = ['parser', 'display', 'rss']
 
 from . import rss
 from . import parser
 from . import display
-from . import download
 
 # EOF

phub/modules/parser.py

@@ -79,7 +79,8 @@ def challenge(client: Client, challenge: str, token: str) -> None:
     
     # Build and inject cookie
     cookie = f'{n}*{p // n}:{s}:{token}:1'
-    client.session.cookies.set('KEY', cookie)
+    client.core.config.cookies = {'KEY', cookie}
+    client.core.update_cookies()
     logger.info('Injected cookie %s', cookie)
-
+    print("Injected cookie for authentication")
 # EOF

phub/objects/account.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import logging
 from functools import cached_property
+from base_api.base import setup_logger
 from typing import TYPE_CHECKING, Literal, Iterator, Union
 
 from .. import utils
@@ -12,8 +13,6 @@ if TYPE_CHECKING:
     from ..core import Client
     from . import Feed, queries, User
 
-logger = logging.getLogger(__name__)
-
 
 class Account:
     '''
@@ -45,6 +44,7 @@ class Account:
         '''
         
         self.client = client
+        self.logger = setup_logger(name="PHUB API - [Account]", log_file=None, level=logging.ERROR)
         
         self.name: str = None
         self.avatar: Image = None
@@ -54,9 +54,12 @@ class Account:
         # Save data keys so far, so we can make a difference with the
         # cached property ones.
         self.loaded_keys = list(self.__dict__.keys()) + ['loaded_keys']
-            
+
+    def enable_logging(self, log_file: str = None, level=None, log_ip=None, log_port=None):
+        self.logger = setup_logger(name="PHUB API - [Account]", log_file=log_file, level=level, http_ip=log_ip,
+                                   http_port=log_port)
+
     def __repr__(self) -> str:
-        
         status = 'logged-out' if self.name is None else f'name={self.name}' 
         return f'phub.Account({status})'
 
@@ -77,7 +80,7 @@ class Account:
         
         # We assert that the account is from a normal user (not model, etc.)
         if not 'users/' in self.user.url:
-            logger.error('Invalid user type: %s', url)
+            self.logger.error('Invalid user type: %s', url)
             raise NotImplementedError('Non-user account are not supported.')
     
     def refresh(self, refresh_login: bool = False) -> None:
@@ -88,25 +91,25 @@ class Account:
             refresh_login (bool): Whether to also attempt to re-log in.
         '''
         
-        logger.info('Refreshing account %s', self)
+        self.logger.info('Refreshing account %s', self)
         
         if refresh_login:
-            logger.info('Forcing login refresh')
+            self.logger.info('Forcing login refresh')
             self.client.login(force = True)
         
         # Clear properties cache
         for key in list(self.__dict__.keys()):
             if not key in self.loaded_keys:
                 
-                logger.debug('Deleting key %s', key)
+                self.logger.debug('Deleting key %s', key)
                 delattr(self, key)
     
     def fix_recommendations(self) -> None:
         '''
-        Allow recommandations cookies.
+        Allow recommendations cookies.
         '''
         
-        logger.info('Fixing account recommendations')
+        self.logger.info('Fixing account recommendations')
         
         payload = utils.urlify({
             'token': self.client._granted_token,

phub/objects/feed.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import logging
 from functools import cached_property
+from base_api.base import setup_logger
 from typing import TYPE_CHECKING, Callable, Iterator, Union
 
 from .. import literals
@@ -11,8 +12,6 @@ if TYPE_CHECKING:
     from . import queries
     from ..core import Client
 
-logger = logging.getLogger(__name__)
-
 
 class Feed:
     '''
@@ -28,9 +27,13 @@ class Feed:
         '''
         
         self.client = client
-        
-        logger.debug('Initialised account feed: %s', self)
-    
+        self.logger = setup_logger(name="PHUB API - [Feed]", log_file=None, level=logging.ERROR)
+        self.logger.debug('Initialised account feed: %s', self)
+
+    def enable_logging(self, log_file: str = None, level=None, log_ip=None, log_port=None):
+        self.logger = setup_logger(name="PHUB API - [Feed]", log_file=log_file, level=level, http_ip=log_ip,
+                                   http_port=log_port)
+
     def __repr__(self) -> str:
         
         return f'phub.FeedCreator(for={self.client.account.name})'
@@ -51,7 +54,7 @@ class Feed:
         # Generate args
         username = user.name if isinstance(user, User) else user
         
-        logger.info('Generating new filter feed using args', )
+        self.logger.info('Generating new filter feed using args', )
         
         return queries.FeedQuery(
             client = self.client,

phub/objects/image.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import os
 import logging
+from base_api.base import setup_logger
 from typing import TYPE_CHECKING, Literal, Union
 
 from .. import utils
@@ -10,9 +11,6 @@ if TYPE_CHECKING:
     from ..core import Client
 
 
-logger = logging.getLogger(__name__)
-
-
 class Image:
     '''
     Represents an image hosted on Pornhub.
@@ -34,19 +32,24 @@ class Image:
             name (str): Image name.
         '''
 
+        self.logger = setup_logger(name="PHUB API - [Image]", log_file=None, level=logging.ERROR)
         self.url = url
         self.name = name
         self.client = client
         self._servers = servers or []
         
-        logger.debug('Generated new image object: %s', self)
+        self.logger.debug('Generated new image object: %s', self)
         
         # Check server image sizes
         sizes = [s.get('size') for s in self._servers]
         
         if len(set(sizes)) > 1:
-            logger.warning('Detected different image sizes on alt servers: %s', sizes)
-    
+            self.logger.warning('Detected different image sizes on alt servers: %s', sizes)
+
+    def enable_logging(self, log_file: str = None, level=None, log_ip=None, log_port=None):
+        self.logger = setup_logger(name="PHUB API - [Image]", log_file=log_file, level=level, http_ip=log_ip,
+                                   http_port=log_port)
+
     def __repr__(self) -> str:
         
         return f'phub.Image(name={self.name})'
@@ -70,7 +73,7 @@ class Image:
         if os.path.isdir(path):
             path = utils.concat(path, self.name + ext)
         
-        logger.info('Saving %s at %s', self, path)
+        self.logger.info('Saving %s at %s', self, path)
         
         with open(path, 'wb') as file:
             
@@ -81,12 +84,12 @@ class Image:
                 
             except Exception as err:
                 
-                logger.warning('Failed to get image `%s`', url)
+                self.logger.warning('Failed to get image `%s`', url)
                 if not self._servers: raise err
                 
                 # Pop server and retry
                 server = self._servers.pop(0)
-                logger.info('Retrying download with server %s', server)
+                self.logger.info('Retrying download with server %s', server)
                 self.url = server['src']
                 self.download(path)
 

phub/objects/playlist.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import re
+import time
 from typing import TYPE_CHECKING
 from functools import cache, cached_property
 
@@ -34,7 +36,6 @@ class Playlist(queries.VideoQuery):
         
         # Initialise 
         super().__init__(client, func = None)
-        
         # Define both playlist url (first page) and chunked (next pages)
         self.url = 'playlist/' + str(pid)
         self.chunk_url = f'playlist/viewChunked?id={pid}' '&token={token}&page={page}'
@@ -70,13 +71,9 @@ class Playlist(queries.VideoQuery):
             raise errors.NoResult()
         
         return response.text
-    
-    @cached_property
-    def _data(self) -> str:
-        return consts.re.playlist_data(self._page)
 
     def __len__(self) -> int:
-        return int(consts.re.get_playlist_size(self._page))
+        return int(re.search(r'var\s+itemsCount\s*=\s*(\d+)\s*\|\|', string=self._page).group(1))
     
     @cached_property
     def hidden_videos_amount(self) -> int:
@@ -89,27 +86,27 @@ class Playlist(queries.VideoQuery):
     @cached_property
     def like(self) -> Like:
         return Like(
-            int(consts.re.get_playlist_likes(self._data)),
-            int(consts.re.get_playlist_dislikes(self._data)),
-            float(consts.re.get_playlist_ratings(self._data))
+            int(consts.re.get_playlist_likes(self._page)),
+            int(consts.re.get_playlist_dislikes(self._page)),
+            float(consts.re.get_playlist_ratings(self._page))
         )
 
     @cached_property
     def views(self) -> int:
-        raw: str = consts.re.get_playlist_views(self._data)
+        raw: str = consts.re.get_playlist_views(self._page)
         return int(raw.replace(',', ''))
     
     @cached_property
     def tags(self) -> list[str]:
-        return consts.re.get_playlist_tags(self._data)
+        return consts.re.get_playlist_tags(self._page)
 
     @cached_property
     def author(self) -> User:
-        url = consts.re.get_playlist_author(self._data)
+        url = consts.re.get_playlist_author(self._page)
         return User.get(self.client, consts.HOST + url)
     
     @cached_property
     def title(self) -> str:
-        return consts.re.get_playlist_title(self._data)
+        return consts.re.get_playlist_title(self._page)
 
 # EOF