notify-tls-client 0.1.6__py3-none-any.whl → 0.1.9__py3-none-any.whl

notify_tls_client/core/notifytlsclient.py

@@ -1,146 +1,196 @@
-import time
-from datetime import datetime
-from typing import Optional
-
-from notify_tls_client import tls_client
-from notify_tls_client.core.client import *
-from notify_tls_client.core.proxiesmanager import ProxiesManager, Proxy
-
-from notify_tls_client.tls_client.response import Response
-from notify_tls_client.tls_client.settings import ClientIdentifiers
-from notify_tls_client.tls_client.structures import CaseInsensitiveDict
-
-
-class NotifyTLSClient:
-
-    def __init__(self,
-                 proxies_manager: Optional[ProxiesManager] = None,
-                 requests_limit_same_proxy: int = 1000,
-                 client_identifier: ClientIdentifiers = "chrome_133",
-                 random_tls_extension_order: bool = True):
-
-        self.client = None
-        self.free = True
-        self.requests_amount = 0
-        self.last_request_status = 0
-        self.headers = CaseInsensitiveDict({
-            "User-Agent": f"tls-client/1.0.0",
-            "Accept-Encoding": "gzip, deflate, br",
-            "Accept": "image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8",
-            "Connection": "keep-alive",
-        })
-
-        self.client_identifier = client_identifier
-        self.proxies_manager = proxies_manager
-        self.requests_limit_same_proxy = requests_limit_same_proxy
-        self.random_tls_extension_order = random_tls_extension_order
-        self.current_proxy = None
-        self._create_new_client(self.client_identifier, self.random_tls_extension_order)
-        self.change_proxy()
-
-    def _create_new_client(self, client_identifier: ClientIdentifiers = 'chrome_133', random_tls_extension_order: bool = False):
-        self.client = tls_client.Session(client_identifier=client_identifier,
-                                         random_tls_extension_order=random_tls_extension_order)
-
-    def set_requests_limit_same_proxy(self, requests_limit_same_proxy: int):
-        self.requests_limit_same_proxy = requests_limit_same_proxy
-
-    def set_proxies_manager(self, proxies_manager: ProxiesManager):
-        self.proxies_manager = proxies_manager
-
-
-    def change_proxy(self):
-        if self.proxies_manager and self.proxies_manager.get_proxies():
-            self.current_proxy = self.proxies_manager.get_next()
-            self.client.proxies = self.current_proxy.to_proxy_dict()
-            self.requests_amount = 0
-
-    def set_proxies(self, proxies: Proxy):
-        self.client.proxies = proxies.to_proxy_dict()
-
-    def set_headers(self, headers: dict):
-        self.client.headers = CaseInsensitiveDict(headers)
-
-    def get_cookies(self):
-        return self.client.cookies
-
-    def get_cookie_by_name(self, name: str):
-        return self.client.cookies.get(name)
-
-    @handle_exception_requests_decorator
-    @increment_requests_decorator
-    @handle_forbidden_requests_decorator
-    @print_request_infos_decorator
-    @change_state_decorator
-    def get(self, url: str, **kwargs) -> Response:
-        start = time.time()
-        response = self.client.get(url, **kwargs)
-        response.elapsed = round((time.time() - start) * 1000, 2)
-        self.last_request_status = response.status_code
-        return response
-
-    @handle_exception_requests_decorator
-    @increment_requests_decorator
-    @handle_forbidden_requests_decorator
-    @print_request_infos_decorator
-    @change_state_decorator
-    def post(self, url: str, **kwargs) -> Response:
-        start = time.time()
-        response = self.client.post(url, **kwargs)
-        response.elapsed = round((time.time() - start) * 1000, 2)
-
-        self.last_request_status = response.status_code
-        return response
-
-    @handle_exception_requests_decorator
-    @increment_requests_decorator
-    @handle_forbidden_requests_decorator
-    @print_request_infos_decorator
-    @change_state_decorator
-    def put(self, url: str, **kwargs) -> Response:
-        start = datetime.now()
-        response = self.client.put(url, **kwargs)
-        response.elapsed = datetime.now() - start
-
-        self.last_request_status = response.status_code
-        return response
-
-    @increment_requests_decorator
-    @handle_forbidden_requests_decorator
-    @print_request_infos_decorator
-    @change_state_decorator
-    def delete(self, url: str, **kwargs) -> Response:
-        start = time.time()
-        response = self.client.delete(url, **kwargs)
-        response.elapsed = round((time.time() - start) * 1000, 2)
-
-        self.last_request_status = response.status_code
-        return response
-
-    @handle_exception_requests_decorator
-    @increment_requests_decorator
-    @handle_forbidden_requests_decorator
-    @print_request_infos_decorator
-    @change_state_decorator
-    def patch(self, url: str, **kwargs) -> Response:
-        start = datetime.now()
-        response = self.client.patch(url, **kwargs)
-        response.elapsed = datetime.now() - start
-
-        self.last_request_status = response.status_code
-        return response
-
-    def _change_to_free(self):
-        self.free = True
-
-    def _change_to_busy(self):
-        self.free = False
-
-    def get_cookie_value_by_name(self, name: str):
-        return self.client.cookies.get(name)
-
-    def set_cookie(self, name: str, value: str):
-        self.client.cookies.set(name, value)
-
-    def get_tls(self):
-        return self.client
+import logging
+from typing import Optional
+
+from typing_extensions import TypeAlias, Literal
+
+from notify_tls_client.core.client import *
+from notify_tls_client.core.client_identifiers_manager import ClientIdentifiersManager
+from notify_tls_client.core.proxiesmanager import ProxiesManager, Proxy
+from notify_tls_client.tls_client.response import Response
+from notify_tls_client.tls_client.sessions import Session
+from notify_tls_client.tls_client.settings import ClientIdentifiers
+from notify_tls_client.tls_client.structures import CaseInsensitiveDict
+
+HttpMethods: TypeAlias = Literal["GET", "POST", "PUT", "DELETE", "PATCH"]
+logger = logging.Logger(__name__)
+
+
+class NotifyTLSClient:
+    def __init__(self,
+                 proxies_manager: Optional[ProxiesManager] = None,
+                 client_identifiers: list[ClientIdentifiers] = None,
+                 requests_limit_same_proxy: int = 1000,
+                 random_tls_extension_order: bool = True,
+                 requests_limit_with_same_client_identifier: int = -1,
+                 instantiate_new_client_on_forbidden_response: bool = False,
+                 instantiate_new_client_on_exception: bool = False,
+                 debug_mode: bool = False,
+                 status_codes_to_forbidden_response_handle: list[int] = None,
+                 change_client_identifier_on_forbidden_response: bool = False,
+                 default_headers: dict = None,
+                 disable_http3: bool = False
+                 ):
+
+        self.client: Optional[Session] = None
+        self.change_client_identifier_on_forbidden_response = change_client_identifier_on_forbidden_response
+        self.client_identifiers_manager = ClientIdentifiersManager(client_identifiers or ["chrome_133"])
+        self.status_codes_to_forbidden_response_handle = status_codes_to_forbidden_response_handle or [403]
+        self.free = True
+        self.requests_amount = 0
+        self.requests_amount_with_current_proxy = 0
+        self.requests_amount_with_current_client_identifier = 0
+        self.last_request_status = 0
+        self.headers = default_headers or CaseInsensitiveDict({
+            "User-Agent": f"tls-client/1.0.0",
+            "Accept-Encoding": "gzip, deflate, br",
+            "Accept": "image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8",
+            "Connection": "keep-alive",
+        })
+
+        self.disable_http3 = disable_http3
+        self.proxies_manager = proxies_manager
+        self.requests_limit_with_same_proxy = requests_limit_same_proxy
+        self.requests_limit_with_same_client_identifier = requests_limit_with_same_client_identifier
+        self.debug_mode = debug_mode
+
+        self.instantiate_new_client_on_forbidden_response = instantiate_new_client_on_forbidden_response
+        self.instantiate_new_client_on_exception = instantiate_new_client_on_exception
+
+        self.current_proxy = None
+        self._create_new_client(self.client_identifiers_manager.get_next(),
+                                random_tls_extension_order,
+                                proxy=self.proxies_manager.get_next() if self.proxies_manager else None)
+
+
+    def _create_new_client(self,
+                           client_identifier: ClientIdentifiers = 'chrome_133',
+                           random_tls_extension_order: bool = False,
+                           proxy: Optional[Proxy] = None):
+
+
+
+        if self.client:
+            self.client.close()
+
+        old_client_identifier = self.client.client_identifier if self.client else None
+
+        self.client = Session(client_identifier=client_identifier,
+                              random_tls_extension_order=random_tls_extension_order)
+
+        if old_client_identifier != client_identifier:
+            self.requests_amount_with_current_client_identifier = 0
+
+        if proxy:
+
+            self.client.proxies = proxy.to_proxy_dict()
+
+            if self.current_proxy != proxy:
+                self.current_proxy = proxy
+                self.requests_amount_with_current_proxy = 0
+
+
+    def set_requests_limit_same_proxy(self, requests_limit_same_proxy: int):
+        self.requests_limit_with_same_proxy = requests_limit_same_proxy
+
+    def set_proxies_manager(self, proxies_manager: ProxiesManager):
+        self.proxies_manager = proxies_manager
+
+    def change_proxy(self):
+        if self.proxies_manager and self.proxies_manager.get_proxies():
+            self.current_proxy = self.proxies_manager.get_next()
+            self.client.proxies = self.current_proxy.to_proxy_dict()
+            self.requests_amount_with_current_proxy = 0
+
+    def set_proxies(self, proxies: Proxy):
+        self.client.proxies = proxies.to_proxy_dict()
+
+    def set_headers(self, headers: dict):
+        self.client.headers = CaseInsensitiveDict(headers)
+
+    def get_cookies(self):
+        return self.client.cookies
+
+    def get_cookie_by_name(self, name: str) -> Optional[str]:
+        try:
+            return self.client.cookies.get(name)
+        except Exception as e:
+            logging.exception(f"Error getting cookie '{name}': {e}")
+
+    @request_guard_decorator
+    def execute_request(self, method: HttpMethods, url: str, **kwargs) -> Optional[Response]:
+        method = method.upper()
+        if method == "GET":
+            return self.client.get(url, **kwargs)
+        elif method == "POST":
+            return self.client.post(url, **kwargs)
+        elif method == "PUT":
+            return self.client.put(url, **kwargs)
+        elif method == "DELETE":
+            return self.client.delete(url, **kwargs)
+        elif method == "PATCH":
+            return self.client.delete(url, **kwargs)
+        else:
+            raise ValueError(f"Unsupported HTTP method: {method}")
+
+    def get(self, url: str, **kwargs) -> Optional[Response]:
+        return self.execute_request("GET", url, **kwargs)
+
+    def post(self, url: str, **kwargs) -> Optional[Response]:
+        return self.execute_request("POST", url, **kwargs)
+
+    def put(self, url: str, **kwargs) -> Optional[Response]:
+        return self.execute_request("PUT", url, **kwargs)
+
+    def delete(self, url: str, **kwargs) -> Optional[Response]:
+        return self.execute_request("DELETE", url, **kwargs)
+
+    def patch(self, url: str, **kwargs) -> Optional[Response]:
+        return self.execute_request("PATCH", url, **kwargs)
+
+    def _change_to_free(self):
+        self.free = True
+
+    def _change_to_busy(self):
+        self.free = False
+
+    def get_cookie_value_by_name(self, name: str):
+        return self.client.cookies.get(name)
+
+    def set_cookie(self, name: str, value: str):
+        self.client.cookies.set(name, value)
+
+    def get_tls(self):
+        return self.client
+
+    def get_current_client_identifier(self) -> ClientIdentifiers:
+        return self.client.client_identifier
+
+    def is_same_proxy_request_limit_reached(self) -> bool:
+        if self.requests_limit_with_same_proxy == -1:
+            return False
+
+        return self.requests_amount_with_current_proxy >= self.requests_limit_with_same_proxy
+
+    def is_same_client_identifier_request_limit_reached(self) -> bool:
+        if self.requests_limit_with_same_client_identifier == -1:
+            return False
+
+        return self.requests_amount_with_current_client_identifier >= self.requests_limit_with_same_client_identifier
+
+    def is_client_identifier_changeable_by_requests_limit_reached(self) -> bool:
+        return self.is_same_client_identifier_request_limit_reached() and self.has_multiple_client_identifiers()
+
+
+    def has_multiple_client_identifiers(self) -> bool:
+        return self.client_identifiers_manager.get_total_items() > 1
+
+
+    def is_forbidden_request_status(self, status_code: int) -> bool:
+        return status_code in self.status_codes_to_forbidden_response_handle
+
+    def has_proxies_manager(self) -> bool:
+        return self.proxies_manager is not None and self.proxies_manager.get_proxies()
+
+    def set_default_headers(self, headers: dict):
+        self.headers = headers
+        self.client.headers = self.headers

notify_tls_client/core/proxiesmanager/__init__.py

@@ -1,2 +1,2 @@
-from .proxiesmanager import ProxiesManager, Proxy
+from .proxiesmanager import ProxiesManager, Proxy
 from .proxiesmanagerloader import ProxiesManagerLoader

notify_tls_client/core/proxiesmanager/proxiesmanager.py

@@ -1,67 +1,67 @@
-from dataclasses import dataclass, field
-from typing import Optional
-
-from dataclasses_json import dataclass_json
-
-
-@dataclass_json
-@dataclass
-class Proxy:
-    host: str
-    port: int
-    username: Optional[str] = None
-    password: Optional[str] = None
-
-    def to_proxy_dict(self):
-        if self.username is None:
-            return {
-                'http': f'http://{self.host}:{self.port}',
-                'https': f'https://{self.host}:{self.port}'
-            }
-
-        return {
-            'http': f'http://{self.username}:{self.password}@{self.host}:{self.port}',
-            'https': f'https://{self.username}:{self.password}@{self.host}:{self.port}'
-        }
-
-
-@dataclass_json
-@dataclass
-class ProxiesManager:
-    _proxies: list[Proxy] = field(default_factory=list)
-    _current_proxy_index: int = 0
-    _current_proxy: Optional[Proxy] = None
-
-    def get_next(self) -> Proxy:
-
-        if not self._proxies:
-            raise Exception('No proxies available')
-
-        if self._current_proxy_index < len(self._proxies):
-            proxy = self._proxies[self._current_proxy_index]
-            self._current_proxy_index += 1
-        else:
-            self._current_proxy_index = 0
-            proxy = self._proxies[self._current_proxy_index]
-
-        return proxy
-
-    def get_current_proxy(self) -> Optional[Proxy]:
-        if not self._current_proxy:
-            return None
-
-        return self._current_proxy
-
-    def set_proxies(self, proxies: list[Proxy]):
-        self._proxies = proxies
-        self._current_proxy_index = 0
-        self._current_proxy = None
-
-    def add_proxy(self, proxy: Proxy):
-        self._proxies.append(proxy)
-        self._current_proxy_index = 0
-    def get_proxies(self) -> list[Proxy]:
-        return self._proxies
-
-
-
+from dataclasses import dataclass, field
+from typing import Optional
+
+from dataclasses_json import dataclass_json
+
+
+@dataclass_json
+@dataclass
+class Proxy:
+    host: str
+    port: int
+    username: Optional[str] = None
+    password: Optional[str] = None
+
+    def to_proxy_dict(self):
+        if self.username is None:
+            return {
+                'http': f'http://{self.host}:{self.port}',
+                'https': f'https://{self.host}:{self.port}'
+            }
+
+        return {
+            'http': f'http://{self.username}:{self.password}@{self.host}:{self.port}',
+            'https': f'https://{self.username}:{self.password}@{self.host}:{self.port}'
+        }
+
+
+@dataclass_json
+@dataclass
+class ProxiesManager:
+    _proxies: list[Proxy] = field(default_factory=list)
+    _current_proxy_index: int = 0
+    _current_proxy: Optional[Proxy] = None
+
+    def get_next(self) -> Proxy:
+
+        if not self._proxies:
+            raise Exception('No proxies available')
+
+        if self._current_proxy_index < len(self._proxies):
+            proxy = self._proxies[self._current_proxy_index]
+            self._current_proxy_index += 1
+        else:
+            self._current_proxy_index = 0
+            proxy = self._proxies[self._current_proxy_index]
+
+        return proxy
+
+    def get_current_proxy(self) -> Optional[Proxy]:
+        if not self._current_proxy:
+            return None
+
+        return self._current_proxy
+
+    def set_proxies(self, proxies: list[Proxy]):
+        self._proxies = proxies
+        self._current_proxy_index = 0
+        self._current_proxy = None
+
+    def add_proxy(self, proxy: Proxy):
+        self._proxies.append(proxy)
+        self._current_proxy_index = 0
+    def get_proxies(self) -> list[Proxy]:
+        return self._proxies
+
+
+

notify_tls_client/core/proxiesmanager/proxiesmanagerloader.py

@@ -1,33 +1,33 @@
-import traceback
-from typing import Optional
-
-from notify_tls_client.core.proxiesmanager.proxiesmanager import Proxy, ProxiesManager
-
-
-class ProxiesManagerLoader:
-
-    def from_txt(self, path: str) -> Optional[ProxiesManager]:
-        try:
-            proxies = []
-            with open(path, 'r') as f:
-                for proxy in f.read().splitlines():
-                    _proxy = proxy.split(':')
-                    if len(_proxy) == 2:
-                        proxies.append(Proxy(host=_proxy[0],
-                                             port=int(_proxy[1])))
-                    elif len(_proxy) == 4:
-                        proxy = Proxy(host=_proxy[0],
-                                      port=int(_proxy[1]),
-                                      username=_proxy[2],
-                                      password=_proxy[3])
-
-                        proxies.append(proxy)
-                    else:
-                        raise (ValueError('Invalid proxy format'))
-
-            return ProxiesManager(proxies)
-
-        except Exception as e:
-            print(e)
-            print(traceback.format_exc())
-            return None
+import traceback
+from typing import Optional
+
+from notify_tls_client.core.proxiesmanager.proxiesmanager import Proxy, ProxiesManager
+
+
+class ProxiesManagerLoader:
+
+    def from_txt(self, path: str) -> Optional[ProxiesManager]:
+        try:
+            proxies = []
+            with open(path, 'r') as f:
+                for proxy in f.read().splitlines():
+                    _proxy = proxy.split(':')
+                    if len(_proxy) == 2:
+                        proxies.append(Proxy(host=_proxy[0],
+                                             port=int(_proxy[1])))
+                    elif len(_proxy) == 4:
+                        proxy = Proxy(host=_proxy[0],
+                                      port=int(_proxy[1]),
+                                      username=_proxy[2],
+                                      password=_proxy[3])
+
+                        proxies.append(proxy)
+                    else:
+                        raise (ValueError('Invalid proxy format'))
+
+            return ProxiesManager(proxies)
+
+        except Exception as e:
+            print(e)
+            print(traceback.format_exc())
+            return None

notify_tls_client/tls_client/__init__.py

@@ -1,15 +1,15 @@
-#  _____  __  __         ___ _ _            _
-# /__   \/ / / _\       / __\ (_) ___ _ __ | |_
-#   / /\/ /  \ \ _____ / /  | | |/ _ \ '_ \| __|
-#  / / / /____\ \_____/ /___| | |  __/ | | | |_
-#  \/  \____/\__/     \____/|_|_|\___|_| |_|\__|
-
-# Disclaimer:
-# Big shout out to Bogdanfinn for open sourcing his tls-client in Golang.
-# Also to requests, as most of the cookie handling is copied from it. :'D
-# I wanted to keep the syntax as similar as possible to requests, as most people use it and are familiar with it!
-# Links:
-# tls-client: https://github.com/bogdanfinn/tls-client
-# requests: https://github.com/psf/requests
-
+#  _____  __  __         ___ _ _            _
+# /__   \/ / / _\       / __\ (_) ___ _ __ | |_
+#   / /\/ /  \ \ _____ / /  | | |/ _ \ '_ \| __|
+#  / / / /____\ \_____/ /___| | |  __/ | | | |_
+#  \/  \____/\__/     \____/|_|_|\___|_| |_|\__|
+
+# Disclaimer:
+# Big shout out to Bogdanfinn for open sourcing his tls-client in Golang.
+# Also to requests, as most of the cookie handling is copied from it. :'D
+# I wanted to keep the syntax as similar as possible to requests, as most people use it and are familiar with it!
+# Links:
+# tls-client: https://github.com/bogdanfinn/tls-client
+# requests: https://github.com/psf/requests
+
 from .sessions import Session

notify_tls_client/tls_client/__version__.py

@@ -1,11 +1,11 @@
-#  _____  __  __         ___ _ _            _
-# /__   \/ / / _\       / __\ (_) ___ _ __ | |_
-#   / /\/ /  \ \ _____ / /  | | |/ _ \ '_ \| __|
-#  / / / /____\ \_____/ /___| | |  __/ | | | |_
-#  \/  \____/\__/     \____/|_|_|\___|_| |_|\__|
-
-__title__ = "tls_client"
-__description__ = "Advanced Python HTTP Client."
-__version__ = "1.0.1"
-__author__ = "Florian Zager"
+#  _____  __  __         ___ _ _            _
+# /__   \/ / / _\       / __\ (_) ___ _ __ | |_
+#   / /\/ /  \ \ _____ / /  | | |/ _ \ '_ \| __|
+#  / / / /____\ \_____/ /___| | |  __/ | | | |_
+#  \/  \____/\__/     \____/|_|_|\___|_| |_|\__|
+
+__title__ = "tls_client"
+__description__ = "Advanced Python HTTP Client."
+__version__ = "1.0.1"
+__author__ = "Florian Zager"
 __license__ = "MIT"