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

notify_tls_client/config/__init__.py

@@ -0,0 +1,18 @@
+"""
+Módulo de configuração para NotifyTLSClient.
+
+Fornece classes de configuração especializadas para organizar
+os parâmetros do cliente TLS de forma mais limpa e reutilizável.
+"""
+
+from .rotation_config import RotationConfig
+from .recovery_config import RecoveryConfig
+from .client_config import ClientConfig
+from .client_configuration import ClientConfiguration
+
+__all__ = [
+    'RotationConfig',
+    'RecoveryConfig',
+    'ClientConfig',
+    'ClientConfiguration',
+]

notify_tls_client/config/client_config.py

@@ -0,0 +1,76 @@
+"""
+Configurações do cliente TLS (identifiers, headers, protocolos).
+"""
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+from notify_tls_client.tls_client.settings import ClientIdentifiers
+
+
+@dataclass
+class ClientConfig:
+    """
+    Configurações relacionadas ao cliente TLS e fingerprinting.
+
+    Attributes:
+        client_identifiers: Lista de client identifiers para rotação.
+            Identifiers disponíveis incluem chrome_133, firefox_120, safari_17_0, etc.
+            Se apenas um identifier for fornecido, não haverá rotação.
+            Default: ["chrome_133"]
+
+        default_headers: Headers padrão a serem enviados em todas as requisições.
+            Pode ser sobrescrito por requisição individual.
+            Default: None (usa headers padrão do tls-client)
+
+        disable_http3: Se True, força o uso de HTTP/2 ou HTTP/1.1, desabilitando HTTP/3.
+            Útil para ambientes que não suportam QUIC.
+            Default: False
+
+        debug_mode: Se True, habilita logs de debug detalhados.
+            IMPORTANTE: Pode vazar informações sensíveis nos logs.
+            Default: False
+
+    Examples:
+        >>> # Configuração padrão
+        >>> config = ClientConfig()
+
+        >>> # Múltiplos identifiers para stealth
+        >>> config = ClientConfig(
+        ...     client_identifiers=["chrome_133", "firefox_120", "safari_17_0"]
+        ... )
+
+        >>> # Headers customizados
+        >>> config = ClientConfig(
+        ...     default_headers={
+        ...         "User-Agent": "Mozilla/5.0...",
+        ...         "Accept-Language": "pt-BR,pt;q=0.9"
+        ...     }
+        ... )
+
+        >>> # Forçar HTTP/2
+        >>> config = ClientConfig(disable_http3=True)
+    """
+
+    client_identifiers: list[ClientIdentifiers] = field(default_factory=lambda: ["chrome_133"])
+    default_headers: Optional[dict] = None
+    disable_http3: bool = False
+    debug_mode: bool = False
+
+    def __post_init__(self):
+        """Valida os parâmetros de configuração."""
+        if not self.client_identifiers:
+            raise ValueError("client_identifiers não pode ser vazio")
+
+        if len(self.client_identifiers) != len(set(self.client_identifiers)):
+            raise ValueError("client_identifiers contém duplicatas")
+
+        # Valida default_headers se fornecido
+        if self.default_headers is not None:
+            if not isinstance(self.default_headers, dict):
+                raise ValueError("default_headers deve ser um dicionário")
+
+            # Valida que keys são strings
+            for key in self.default_headers.keys():
+                if not isinstance(key, str):
+                    raise ValueError(f"Header key inválido: {key}. Deve ser string")

notify_tls_client/config/client_configuration.py

@@ -0,0 +1,237 @@
+"""
+Configuração completa do NotifyTLSClient com factory methods para casos de uso comuns.
+"""
+
+from dataclasses import dataclass, field
+from typing import Optional
+
+from notify_tls_client.core.proxiesmanager import ProxiesManager
+from .rotation_config import RotationConfig
+from .recovery_config import RecoveryConfig
+from .client_config import ClientConfig
+
+
+@dataclass
+class ClientConfiguration:
+    """
+    Configuração completa para NotifyTLSClient.
+
+    Agrupa todas as configurações específicas em um único objeto para
+    simplificar a criação e reutilização de configurações.
+
+    Attributes:
+        proxies_manager: Gerenciador de proxies para rotação automática.
+            Default: None (sem proxies)
+
+        rotation: Configurações de rotação de proxies e client identifiers.
+            Default: RotationConfig com valores padrão
+
+        recovery: Configurações de recuperação automática.
+            Default: RecoveryConfig com valores padrão
+
+        client: Configurações do cliente TLS.
+            Default: ClientConfig com valores padrão
+
+    Examples:
+        >>> # Configuração padrão
+        >>> config = ClientConfiguration()
+
+        >>> # Configuração customizada
+        >>> config = ClientConfiguration(
+        ...     proxies_manager=ProxiesManager([...]),
+        ...     rotation=RotationConfig(requests_limit_same_proxy=10),
+        ...     recovery=RecoveryConfig(
+        ...         instantiate_new_client_on_forbidden_response=True,
+        ...         status_codes_to_forbidden_response_handle=[403, 429]
+        ...     ),
+        ...     client=ClientConfig(
+        ...         client_identifiers=["chrome_133", "firefox_120"]
+        ...     )
+        ... )
+
+        >>> # Usando factory method
+        >>> config = ClientConfiguration.aggressive(proxies_manager)
+    """
+
+    proxies_manager: Optional[ProxiesManager] = None
+    rotation: RotationConfig = field(default_factory=RotationConfig)
+    recovery: RecoveryConfig = field(default_factory=RecoveryConfig)
+    client: ClientConfig = field(default_factory=ClientConfig)
+
+    @classmethod
+    def aggressive(cls, proxies_manager: Optional[ProxiesManager] = None) -> 'ClientConfiguration':
+        """
+        Configuração agressiva: rotação rápida e recuperação automática completa.
+
+        Ideal para cenários de scraping intensivo onde detectar e contornar
+        bloqueios rapidamente é crítico.
+
+        Características:
+        - Troca proxy a cada 10 requisições
+        - Troca client identifier a cada 50 requisições
+        - Recuperação automática em erros e respostas proibidas
+        - Troca client identifier em respostas proibidas
+        - Monitora status codes 403, 429 e 503
+
+        Args:
+            proxies_manager: Gerenciador de proxies (obrigatório para rotação)
+
+        Returns:
+            ClientConfiguration configurado para modo agressivo
+
+        Example:
+            >>> tls = NotifyTLSClient(ClientConfiguration.aggressive(proxies))
+        """
+        return cls(
+            proxies_manager=proxies_manager,
+            rotation=RotationConfig(
+                requests_limit_same_proxy=10,
+                requests_limit_same_client_identifier=50,
+                random_tls_extension_order=True
+            ),
+            recovery=RecoveryConfig(
+                instantiate_new_client_on_forbidden_response=True,
+                instantiate_new_client_on_exception=True,
+                change_client_identifier_on_forbidden_response=True,
+                status_codes_to_forbidden_response_handle=[403, 429, 503]
+            ),
+            client=ClientConfig(
+                client_identifiers=["chrome_133", "firefox_120", "safari_17_0"]
+            )
+        )
+
+    @classmethod
+    def stealth(cls, proxies_manager: Optional[ProxiesManager] = None) -> 'ClientConfiguration':
+        """
+        Configuração stealth: foco em evitar detecção através de diversidade.
+
+        Ideal para cenários onde ser discreto é mais importante que velocidade,
+        utilizando múltiplos client identifiers e randomização.
+
+        Características:
+        - Múltiplos client identifiers (Chrome, Firefox, Safari, Edge)
+        - Ordem de extensões TLS randomizada
+        - Rotação moderada de proxies (100 requisições)
+        - Rotação de client identifier a cada 30 requisições
+        - Recuperação básica apenas para erros críticos
+
+        Args:
+            proxies_manager: Gerenciador de proxies (opcional mas recomendado)
+
+        Returns:
+            ClientConfiguration configurado para modo stealth
+
+        Example:
+            >>> tls = NotifyTLSClient(ClientConfiguration.stealth(proxies))
+        """
+        return cls(
+            proxies_manager=proxies_manager,
+            rotation=RotationConfig(
+                requests_limit_same_proxy=100,
+                requests_limit_same_client_identifier=30,
+                random_tls_extension_order=True
+            ),
+            recovery=RecoveryConfig(
+                instantiate_new_client_on_forbidden_response=False,
+                instantiate_new_client_on_exception=True,
+                change_client_identifier_on_forbidden_response=False,
+                status_codes_to_forbidden_response_handle=[403]
+            ),
+            client=ClientConfig(
+                client_identifiers=[
+                    "chrome_133",
+                    "firefox_120",
+                    "safari_17_0",
+                    "safari_ios_16_0"
+                ]
+            )
+        )
+
+    @classmethod
+    def simple(cls, proxies_manager: Optional[ProxiesManager] = None) -> 'ClientConfiguration':
+        """
+        Configuração simples: apenas rotação básica de proxies.
+
+        Ideal para uso geral onde não há necessidade de evasão agressiva,
+        mantendo a simplicidade e confiabilidade.
+
+        Características:
+        - Client identifier único (Chrome 133)
+        - Rotação de proxy padrão (1000 requisições)
+        - Sem rotação de client identifier
+        - Sem recuperação automática
+        - Monitora apenas status 403
+
+        Args:
+            proxies_manager: Gerenciador de proxies (opcional)
+
+        Returns:
+            ClientConfiguration configurado para modo simples
+
+        Example:
+            >>> tls = NotifyTLSClient(ClientConfiguration.simple())
+        """
+        return cls(
+            proxies_manager=proxies_manager,
+            rotation=RotationConfig(
+                requests_limit_same_proxy=1000,
+                requests_limit_same_client_identifier=-1,
+                random_tls_extension_order=False
+            ),
+            recovery=RecoveryConfig(
+                instantiate_new_client_on_forbidden_response=False,
+                instantiate_new_client_on_exception=False,
+                change_client_identifier_on_forbidden_response=False,
+                status_codes_to_forbidden_response_handle=[403]
+            ),
+            client=ClientConfig(
+                client_identifiers=["chrome_133"]
+            )
+        )
+
+    @classmethod
+    def mobile(cls, proxies_manager: Optional[ProxiesManager] = None, platform: str = "android") -> 'ClientConfiguration':
+        """
+        Configuração mobile: simula dispositivos móveis.
+
+        Ideal para APIs ou sites que têm comportamento diferente para mobile.
+
+        Características:
+        - Client identifiers mobile (Android ou iOS)
+        - Rotação moderada
+        - Recuperação automática em erros
+
+        Args:
+            proxies_manager: Gerenciador de proxies (opcional)
+            platform: "android" ou "ios"
+
+        Returns:
+            ClientConfiguration configurado para modo mobile
+
+        Example:
+            >>> tls = NotifyTLSClient(ClientConfiguration.mobile(platform="ios"))
+        """
+        if platform.lower() == "android":
+            identifiers = ["okhttp4_android_13", "okhttp4_android_12"]
+        elif platform.lower() == "ios":
+            identifiers = ["safari_ios_16_0", "safari_ios_15_6"]
+        else:
+            raise ValueError(f"Platform inválida: {platform}. Use 'android' ou 'ios'")
+
+        return cls(
+            proxies_manager=proxies_manager,
+            rotation=RotationConfig(
+                requests_limit_same_proxy=50,
+                requests_limit_same_client_identifier=100,
+                random_tls_extension_order=True
+            ),
+            recovery=RecoveryConfig(
+                instantiate_new_client_on_forbidden_response=True,
+                instantiate_new_client_on_exception=True,
+                change_client_identifier_on_forbidden_response=False,
+                status_codes_to_forbidden_response_handle=[403, 429]
+            ),
+            client=ClientConfig(
+                client_identifiers=identifiers
+            )
+        )

notify_tls_client/config/recovery_config.py

@@ -0,0 +1,66 @@
+"""
+Configurações de recuperação automática em caso de erros e respostas proibidas.
+"""
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class RecoveryConfig:
+    """
+    Configurações para controlar o comportamento de recuperação automática.
+
+    Attributes:
+        instantiate_new_client_on_forbidden_response: Se True, cria uma nova sessão TLS
+            quando receber um status code configurado como "proibido".
+            Default: False
+
+        instantiate_new_client_on_exception: Se True, cria uma nova sessão TLS
+            quando ocorrer uma exceção durante a requisição.
+            Default: False
+
+        change_client_identifier_on_forbidden_response: Se True, além de criar uma nova
+            sessão, também troca o client identifier quando receber resposta proibida.
+            Requer instantiate_new_client_on_forbidden_response=True para ter efeito.
+            Default: False
+
+        status_codes_to_forbidden_response_handle: Lista de status codes HTTP que devem
+            acionar os mecanismos de recuperação automática.
+            Default: [403]
+
+    Examples:
+        >>> # Recuperação agressiva
+        >>> config = RecoveryConfig(
+        ...     instantiate_new_client_on_forbidden_response=True,
+        ...     instantiate_new_client_on_exception=True,
+        ...     change_client_identifier_on_forbidden_response=True,
+        ...     status_codes_to_forbidden_response_handle=[403, 429, 503]
+        ... )
+
+        >>> # Sem recuperação automática
+        >>> config = RecoveryConfig()
+    """
+
+    instantiate_new_client_on_forbidden_response: bool = False
+    instantiate_new_client_on_exception: bool = False
+    change_client_identifier_on_forbidden_response: bool = False
+    status_codes_to_forbidden_response_handle: list[int] = field(default_factory=lambda: [403])
+
+    def __post_init__(self):
+        """Valida os parâmetros de configuração."""
+        if not self.status_codes_to_forbidden_response_handle:
+            raise ValueError("status_codes_to_forbidden_response_handle não pode ser vazio")
+
+        for code in self.status_codes_to_forbidden_response_handle:
+            if not isinstance(code, int) or code < 100 or code > 599:
+                raise ValueError(f"Status code inválido: {code}. Deve estar entre 100 e 599")
+
+        # Aviso sobre configuração inconsistente
+        if self.change_client_identifier_on_forbidden_response and not self.instantiate_new_client_on_forbidden_response:
+            import warnings
+            warnings.warn(
+                "change_client_identifier_on_forbidden_response=True não terá efeito "
+                "porque instantiate_new_client_on_forbidden_response=False. "
+                "Considere habilitar ambos.",
+                UserWarning
+            )

notify_tls_client/config/rotation_config.py

@@ -0,0 +1,56 @@
+"""
+Configurações de rotação de proxies e client identifiers.
+"""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class RotationConfig:
+    """
+    Configurações para controlar a rotação automática de proxies e client identifiers.
+
+    Attributes:
+        requests_limit_same_proxy: Número máximo de requisições com o mesmo proxy.
+            Use -1 para desabilitar rotação automática por limite.
+            Default: 1000
+
+        requests_limit_same_client_identifier: Número máximo de requisições com o mesmo
+            client identifier. Use -1 para desabilitar rotação automática por limite.
+            Default: -1 (desabilitado)
+
+        random_tls_extension_order: Se True, randomiza a ordem das extensões TLS
+            para dificultar fingerprinting.
+            Default: True
+
+    Examples:
+        >>> # Rotação agressiva
+        >>> config = RotationConfig(
+        ...     requests_limit_same_proxy=10,
+        ...     requests_limit_same_client_identifier=50
+        ... )
+
+        >>> # Sem rotação automática
+        >>> config = RotationConfig(
+        ...     requests_limit_same_proxy=-1,
+        ...     requests_limit_same_client_identifier=-1
+        ... )
+    """
+
+    requests_limit_same_proxy: int = 1000
+    requests_limit_same_client_identifier: int = -1
+    random_tls_extension_order: bool = True
+
+    def __post_init__(self):
+        """Valida os parâmetros de configuração."""
+        if self.requests_limit_same_proxy < -1:
+            raise ValueError("requests_limit_same_proxy deve ser >= -1")
+
+        if self.requests_limit_same_client_identifier < -1:
+            raise ValueError("requests_limit_same_client_identifier deve ser >= -1")
+
+        if self.requests_limit_same_proxy == 0:
+            raise ValueError("requests_limit_same_proxy não pode ser 0 (use -1 para desabilitar)")
+
+        if self.requests_limit_same_client_identifier == 0:
+            raise ValueError("requests_limit_same_client_identifier não pode ser 0 (use -1 para desabilitar)")

notify_tls_client/core/client/decorators.py

@@ -38,8 +38,8 @@ def request_guard_decorator(callback):
                 request_headers = value
 
         try:
-            self.requests_amount += 1
             res = callback(*args, **kwargs)
+            self.requests_amount += 1
             _log_request_info(self, res, request_url, request_headers)
             _requests_handler(self, res)
             return res
@@ -63,10 +63,14 @@ def request_guard_decorator(callback):
 def _recover_on_exception(self):
     if self.instantiate_new_client_on_exception:
         logging.info("Instantiating new TLS client due to exception...")
-        self.get_tls().close()
-        self._create_new_client()
-
-    if self.proxies_manager:
+        current_identifier = self.client_identifiers_manager.get_current_item()
+        next_proxy = self.proxies_manager.get_next() if self.proxies_manager else None
+        self._create_new_client(
+            client_identifier=current_identifier or 'chrome_133',
+            random_tls_extension_order=self.random_tls_extension_order,
+            proxy=next_proxy
+        )
+    elif self.proxies_manager:
         logging.info("Changing proxy due to exception...")
         self.change_proxy()
 
@@ -194,46 +198,3 @@ def _requests_handler(self, response: Optional[Response]):
         if has_proxies_manager:
             logging.info("Changing proxy due to requests limit reached...")
             self.change_proxy()
-
-    # if client_identifier_changed_by_limit:
-    #     logging.info("Requests limit reached for current client identifier")
-    #     logging.info("Changing client identifier due to requests limit reached...")
-    #     # self._create_new_client(self.client_identifiers_manager.get_next(),
-    #     #                         proxy=self.proxies_manager.get_current_proxy() if self.proxies_manager else None)
-    #
-    #
-    #
-    #
-    # if self.requests_limit_with_same_proxy and self.requests_amount_with_current_proxy >= self.requests_limit_with_same_proxy:
-    #     logging.info("Requests limit reached for current proxy")
-    #     if self.proxies_manager:
-    #         proxy_changed_by_limit = True
-    #         logging.info("Changing proxy due to requests limit reached...")
-    #
-    #         if response.status_code in self.status_codes_to_forbidden_response_handle and self.instantiate_new_client_on_forbidden_response:
-    #             logging.info("Instantiating new TLS client due to forbidden response before changing proxy...")
-    #             self.get_tls().close()
-    #             if self.change_client_identifier_on_forbidden_response:
-    #                 self._create_new_client(self.client_identifiers_manager.get_next())
-    #             else:
-    #                 self._create_new_client(self.client_identifiers_manager.get_current())
-    #
-    #         self.change_proxy()
-    #
-    # # Metodo vai ter que ser usado para não trocar o proxy duas vezes, uma pelo status 403 e outra pelo limite de requests
-    # if not proxy_changed_by_limit:
-    #     return
-    #
-    # if response.status_code in self.status_codes_to_forbidden_response_handle:
-    #     if self.instantiate_new_client_on_forbidden_response:
-    #         logging.info("Instantiating new TLS client due to forbidden response...")
-    #         self.get_tls().close()
-    #
-    #         if self.change_client_identifier_on_forbidden_response:
-    #             self._create_new_client(self.client_identifiers_manager.get_next())
-    #         else:
-    #             self._create_new_client()
-    #
-    #     if self.proxies_manager:
-    #         logging.info("Changing proxy due to forbidden response...")
-    #         self.change_proxy()

notify_tls_client/core/client_identifiers_manager.py

@@ -1,45 +1,44 @@
+import threading
 from dataclasses import dataclass, field
 from typing import Optional
 
-from dataclasses_json import dataclass_json
-
 from notify_tls_client.tls_client.settings import ClientIdentifiers
 
 
-@dataclass_json
 @dataclass
 class ClientIdentifiersManager:
     _items: list[ClientIdentifiers] = field(default_factory=list)
     _current_index: int = 0
     _current_item: Optional[ClientIdentifiers] = None
 
+    def __post_init__(self):
+        self._lock = threading.Lock()
+
     def get_next(self) -> ClientIdentifiers:
-        if not self._items:
-            raise Exception('No items available')
+        with self._lock:
+            if not self._items:
+                raise Exception('No items available')
 
-        if self._current_index < len(self._items):
-            _item = self._items[self._current_index]
-            self._current_index += 1
-        else:
-            self._current_index = 0
             _item = self._items[self._current_index]
+            self._current_item = _item
+            self._current_index = (self._current_index + 1) % len(self._items)
 
-        return _item
+            return _item
 
     def get_current_item(self) -> Optional[ClientIdentifiers]:
-        if not self._items:
-            return None
-
-        return self._items[0] if self._current_index == 0 else self._items[self._current_index - 1]
-
+        with self._lock:
+            return self._current_item
 
     def set_items(self, items: list[ClientIdentifiers]):
-        self._items = items
-        self._current_proxy_index = 0
-        self._current_proxy = None
+        with self._lock:
+            self._items = items
+            self._current_index = 0
+            self._current_item = None
 
     def get_item(self) -> list[ClientIdentifiers]:
-        return self._items
+        with self._lock:
+            return self._items.copy()
 
     def get_total_items(self) -> int:
-        return len(self._items)
+        with self._lock:
+            return len(self._items)

notify_tls_client/core/notifytlsclient.py

@@ -1,4 +1,6 @@
 import logging
+import threading
+import warnings
 from typing import Optional
 
 from typing_extensions import TypeAlias, Literal
@@ -6,60 +8,134 @@ 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.config import ClientConfiguration, RotationConfig, RecoveryConfig, ClientConfig
 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__)
+logger = logging.getLogger(__name__)
 
 
 class NotifyTLSClient:
     def __init__(self,
+                 config: Optional[ClientConfiguration] = None,
+                 # Parâmetros legados - mantidos para compatibilidade mas deprecados
                  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,
+                 requests_limit_same_proxy: int = None,
+                 random_tls_extension_order: bool = None,
+                 requests_limit_with_same_client_identifier: int = None,
+                 instantiate_new_client_on_forbidden_response: bool = None,
+                 instantiate_new_client_on_exception: bool = None,
+                 debug_mode: bool = None,
                  status_codes_to_forbidden_response_handle: list[int] = None,
-                 change_client_identifier_on_forbidden_response: bool = False,
+                 change_client_identifier_on_forbidden_response: bool = None,
                  default_headers: dict = None,
-                 disable_http3: bool = False
+                 disable_http3: bool = None
                  ):
-
+        """
+        Inicializa um NotifyTLSClient.
+
+        Modo Recomendado - Usando ClientConfiguration:
+            >>> config = ClientConfiguration.aggressive(proxies_manager)
+            >>> client = NotifyTLSClient(config)
+
+        Modo Legado - Parâmetros individuais (DEPRECADO):
+            >>> client = NotifyTLSClient(
+            ...     proxies_manager=proxies,
+            ...     client_identifiers=["chrome_133"],
+            ...     requests_limit_same_proxy=15
+            ... )
+
+        Args:
+            config: Objeto ClientConfiguration com todas as configurações.
+                Se fornecido, sobrescreve todos os outros parâmetros.
+        """
+
+        # Se config não fornecido, criar a partir de parâmetros legados
+        if config is None:
+            # Emitir warning se usar API legada
+            if any(param is not None for param in [
+                proxies_manager, client_identifiers, requests_limit_same_proxy,
+                random_tls_extension_order, requests_limit_with_same_client_identifier,
+                instantiate_new_client_on_forbidden_response, instantiate_new_client_on_exception,
+                debug_mode, status_codes_to_forbidden_response_handle,
+                change_client_identifier_on_forbidden_response, default_headers, disable_http3
+            ]):
+                warnings.warn(
+                    "API com parâmetros individuais está DEPRECADA. "
+                    "Use ClientConfiguration ao invés. Exemplo: "
+                    "NotifyTLSClient(ClientConfiguration.aggressive(proxies))",
+                    DeprecationWarning,
+                    stacklevel=2
+                )
+
+            # Construir config a partir de parâmetros legados
+            config = ClientConfiguration(
+                proxies_manager=proxies_manager,
+                rotation=RotationConfig(
+                    requests_limit_same_proxy=requests_limit_same_proxy if requests_limit_same_proxy is not None else 1000,
+                    requests_limit_same_client_identifier=requests_limit_with_same_client_identifier if requests_limit_with_same_client_identifier is not None else -1,
+                    random_tls_extension_order=random_tls_extension_order if random_tls_extension_order is not None else True
+                ),
+                recovery=RecoveryConfig(
+                    instantiate_new_client_on_forbidden_response=instantiate_new_client_on_forbidden_response if instantiate_new_client_on_forbidden_response is not None else False,
+                    instantiate_new_client_on_exception=instantiate_new_client_on_exception if instantiate_new_client_on_exception is not None else False,
+                    change_client_identifier_on_forbidden_response=change_client_identifier_on_forbidden_response if change_client_identifier_on_forbidden_response is not None else False,
+                    status_codes_to_forbidden_response_handle=status_codes_to_forbidden_response_handle or [403]
+                ),
+                client=ClientConfig(
+                    client_identifiers=client_identifiers or ["chrome_133"],
+                    default_headers=default_headers,
+                    disable_http3=disable_http3 if disable_http3 is not None else False,
+                    debug_mode=debug_mode if debug_mode is not None else False
+                )
+            )
+
+        # Armazenar config
+        self.config = config
+
+        # Inicializar estado
         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({
+        self.current_proxy = None
+        self._lock = threading.Lock()
+
+        # Configurar a partir de config
+        self.client_identifiers_manager = ClientIdentifiersManager(config.client.client_identifiers)
+        self.proxies_manager = config.proxies_manager
+
+        # Aliases para compatibilidade interna
+        self.requests_limit_with_same_proxy = config.rotation.requests_limit_same_proxy
+        self.requests_limit_with_same_client_identifier = config.rotation.requests_limit_same_client_identifier
+        self.random_tls_extension_order = config.rotation.random_tls_extension_order
+
+        self.instantiate_new_client_on_forbidden_response = config.recovery.instantiate_new_client_on_forbidden_response
+        self.instantiate_new_client_on_exception = config.recovery.instantiate_new_client_on_exception
+        self.change_client_identifier_on_forbidden_response = config.recovery.change_client_identifier_on_forbidden_response
+        self.status_codes_to_forbidden_response_handle = config.recovery.status_codes_to_forbidden_response_handle
+
+        self.disable_http3 = config.client.disable_http3
+        self.debug_mode = config.client.debug_mode
+        self.headers = config.client.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)
+        # Criar primeiro cliente
+        self._create_new_client(
+            self.client_identifiers_manager.get_next(),
+            self.random_tls_extension_order,
+            proxy=self.proxies_manager.get_next() if self.proxies_manager else None
+        )
 
 
     def _create_new_client(self,
@@ -67,26 +143,34 @@ class NotifyTLSClient:
                            random_tls_extension_order: bool = False,
                            proxy: Optional[Proxy] = None):
 
+        with self._lock:
+            old_client_identifier = None
+            old_client = None
 
+            if self.client:
+                old_client_identifier = self.client.client_identifier
+                old_client = self.client
 
-        if self.client:
-            self.client.close()
+            self.client = Session(client_identifier=client_identifier,
+                                  random_tls_extension_order=random_tls_extension_order,
+                                  disable_http3=self.disable_http3)
 
-        old_client_identifier = self.client.client_identifier if self.client else None
+            if old_client:
+                old_client.close()
 
-        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 old_client_identifier != client_identifier:
-            self.requests_amount_with_current_client_identifier = 0
+            if proxy:
+                self.client.proxies = proxy.to_proxy_dict()
 
-        if proxy:
+                if self.current_proxy != proxy:
+                    self.current_proxy = proxy
+                    self.requests_amount_with_current_proxy = 0
 
-            self.client.proxies = proxy.to_proxy_dict()
-
-            if self.current_proxy != proxy:
-                self.current_proxy = proxy
-                self.requests_amount_with_current_proxy = 0
+            # Aplicar headers padrão
+            if self.headers:
+                self.client.headers = CaseInsensitiveDict(self.headers)
 
 
     def set_requests_limit_same_proxy(self, requests_limit_same_proxy: int):
@@ -128,7 +212,7 @@ class NotifyTLSClient:
         elif method == "DELETE":
             return self.client.delete(url, **kwargs)
         elif method == "PATCH":
-            return self.client.delete(url, **kwargs)
+            return self.client.patch(url, **kwargs)
         else:
             raise ValueError(f"Unsupported HTTP method: {method}")
 
@@ -147,15 +231,6 @@ class NotifyTLSClient:
     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)
 

notify_tls_client/core/proxiesmanager/proxiesmanager.py

@@ -1,3 +1,4 @@
+import threading
 from dataclasses import dataclass, field
 from typing import Optional
 
@@ -24,44 +25,55 @@ class Proxy:
             'https': f'https://{self.username}:{self.password}@{self.host}:{self.port}'
         }
 
+    def __eq__(self, other):
+        if not isinstance(other, Proxy):
+            return False
+        return (self.host == other.host and
+                self.port == other.port and
+                self.username == other.username and
+                self.password == other.password)
+
+    def __hash__(self):
+        return hash((self.host, self.port, self.username, self.password))
+
 
-@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:
+    def __post_init__(self):
+        self._lock = threading.Lock()
 
-        if not self._proxies:
-            raise Exception('No proxies available')
+    def get_next(self) -> Proxy:
+        with self._lock:
+            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]
+            self._current_proxy = proxy
+            self._current_proxy_index = (self._current_proxy_index + 1) % len(self._proxies)
 
-        return proxy
+            return proxy
 
     def get_current_proxy(self) -> Optional[Proxy]:
-        if not self._current_proxy:
-            return None
-
-        return self._current_proxy
+        with self._lock:
+            return self._current_proxy
 
     def set_proxies(self, proxies: list[Proxy]):
-        self._proxies = proxies
-        self._current_proxy_index = 0
-        self._current_proxy = None
+        with self._lock:
+            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
+        with self._lock:
+            self._proxies.append(proxy)
+
     def get_proxies(self) -> list[Proxy]:
-        return self._proxies
+        with self._lock:
+            return self._proxies.copy()
 
 
 

notify_tls_client/tls_client/cffi.py

@@ -18,6 +18,8 @@ else:
         file_ext = '-amd64-*.so'
 
 root_dir = os.path.abspath(os.path.dirname(__file__))
+lib_dir = os.path.join(root_dir, 'dependencies')
+lib_path = None
 matches = glob(f'{root_dir}/dependencies/tls-client{file_ext}')
 if not matches:
     raise FileNotFoundError(f'No tls-client library found for the current platform: {platform} {machine()}')

notify_tls_client/tls_client/response.py

@@ -27,8 +27,9 @@ class Response:
 
         # A CookieJar of Cookies the server sent back.
         self.cookies = cookiejar_from_dict({})
-        
+
         self._content = False
+        self._content_consumed = False
 
     def __enter__(self):
         return self

notify_tls_client/tls_client/sessions.py

@@ -328,6 +328,9 @@ class Session:
         # --- Request Body ---------------------------------------------------------------------------------------------
         # Prepare request body - build request body
         # Data has priority. JSON is only used if data is None.
+        request_body = None
+        content_type = None
+
         if data is None and json is not None:
             if type(json) in [dict, list]:
                 json = dumps(json)
@@ -336,9 +339,8 @@ class Session:
         elif data is not None and type(data) not in [str, bytes]:
             request_body = urllib.parse.urlencode(data, doseq=True)
             content_type = "application/x-www-form-urlencoded"
-        else:
+        elif data is not None:
             request_body = data
-            content_type = None
         # set content type if it isn't set
         # if content_type is not None and "content-type" not in self.headers:
         #     self.headers["Content-Type"] = content_type
@@ -391,7 +393,7 @@ class Session:
         certificate_pinning = self.certificate_pinning
         
         # --- Request --------------------------------------------------------------------------------------------------
-        is_byte_request = isinstance(request_body, (bytes, bytearray))
+        is_byte_request = isinstance(request_body, (bytes, bytearray)) if request_body is not None else False
         request_payload = {
             "sessionId": self._session_id,
             "followRedirects": allow_redirects,
@@ -406,7 +408,7 @@ class Session:
             "proxyUrl": proxy,
             "requestUrl": url,
             "requestMethod": method,
-            "requestBody": base64.b64encode(request_body).decode() if is_byte_request else request_body,
+            "requestBody": base64.b64encode(request_body).decode() if is_byte_request else (request_body or ""),
             "requestCookies": request_cookies,
             "timeoutSeconds": timeout_seconds,
             "disableHttp3": self.disable_http3,

notify_tls_client-2.0.0.dist-info/METADATA

@@ -0,0 +1,38 @@
+Metadata-Version: 2.4
+Name: notify-tls-client
+Version: 2.0.0
+Summary: Cliente HTTP avançado com TLS fingerprinting, rotação de proxies e recuperação automática para web scraping resiliente
+Author-email: Jeferson Albara <jeferson.albara@example.com>
+Maintainer-email: Jeferson Albara <jeferson.albara@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/jefersonAlbara/notify-tls-client
+Project-URL: Documentation, https://github.com/jefersonAlbara/notify-tls-client#readme
+Project-URL: Repository, https://github.com/jefersonAlbara/notify-tls-client
+Project-URL: Issues, https://github.com/jefersonAlbara/notify-tls-client/issues
+Project-URL: Changelog, https://github.com/jefersonAlbara/notify-tls-client/blob/main/CHANGELOG.md
+Keywords: tls-client,http-client,web-scraping,proxy-rotation,tls-fingerprinting,browser-emulation,http2,http3,requests,automation
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Internet :: Proxy Servers
+Classifier: Operating System :: OS Independent
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: dataclasses-json>=0.6.0
+Requires-Dist: typing-extensions>=4.8.0
+Requires-Dist: orjson>=3.9.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: mypy>=1.5.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+
+# MY TLS Client
+Pacote python privado com modificações na classe 'tls client'

{notify_tls_client-0.1.9.dist-info → notify_tls_client-2.0.0.dist-info}/RECORD

@@ -1,19 +1,24 @@
 notify_tls_client/__init__.py,sha256=APA8wxvkGYZiVMMbTWGo7prB3iKE-OzUajd0bfc8PwE,84
+notify_tls_client/config/__init__.py,sha256=2xsw7M2E8-ncpIDySYcgH500xAnYyO3qy3PRXkP2inQ,495
+notify_tls_client/config/client_config.py,sha256=Fwg6LS1zP8XFRPbTxNj2svCqeWh2GJcqrq7hnpQtYRQ,2837
+notify_tls_client/config/client_configuration.py,sha256=Zl71lxZSKU7oVJwnHPSYV9uufk2IgFtHW3u9deqo5HU,9103
+notify_tls_client/config/recovery_config.py,sha256=L5a_jMUfdUMdFBXeLPz9RAU0oXz-Ma4ZuzG7B-h7hDs,2876
+notify_tls_client/config/rotation_config.py,sha256=Av_K6BzgPknFYZXxe9WmDra8VGI9JEpDJSm0dDs8QqM,2089
 notify_tls_client/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-notify_tls_client/core/client_identifiers_manager.py,sha256=-JKAGR9tbBI60PNVokfGUTJ5DeD94geGAkBiwB45HHU,1355
-notify_tls_client/core/notifytlsclient.py,sha256=SORwwDsqaV3mdNWjM8SaT17bjEgOazlIqNB41mE2lRo,8247
+notify_tls_client/core/client_identifiers_manager.py,sha256=ko4Y5IVMxNTRgk4e6jiJF_kcMjzej9rRt7BJtX-OMyg,1346
+notify_tls_client/core/notifytlsclient.py,sha256=Mj6myXtzc_M52oOj_-cj4NcSx2WOuDIfg396CtOLmDo,12598
 notify_tls_client/core/client/__init__.py,sha256=VKjpq02hC-r9ER6mbfkwG6W2ybv_jND9d9bidte0CjU,51
-notify_tls_client/core/client/decorators.py,sha256=WYwWwodgmz3PhExz873Tta86j9Jic5wLleCZBfpBMFI,10528
+notify_tls_client/core/client/decorators.py,sha256=GjGUl5eE5KZGB7Bc6XRFgmJ1Xjz6gNBXxOH8jldCAl8,8554
 notify_tls_client/core/proxiesmanager/__init__.py,sha256=emF4vnZvSfb9zlHkt9dDdTcGwkfs1DADi7XVw_DxsWs,105
-notify_tls_client/core/proxiesmanager/proxiesmanager.py,sha256=6jb1RFUCD3zUDzmk4_t9oUj_aQAbwgdvJkNxLUzkgWM,1838
+notify_tls_client/core/proxiesmanager/proxiesmanager.py,sha256=V-X5dWskGHUjrX-hpl9E4L6pv53LBg1M0giEbWmG6JE,2286
 notify_tls_client/core/proxiesmanager/proxiesmanagerloader.py,sha256=7xr3SVdRnr95KWOdk15iehOCXG2huA-rY1j9VIe30YQ,1179
 notify_tls_client/tls_client/__init__.py,sha256=sThiIAzA650rfBlqZ_xalTjgTysUsjKua5ODnqyvhUE,669
 notify_tls_client/tls_client/__version__.py,sha256=32ZZ-ufGC9Yo6oPk5a1xig8YKJ2ZkRXnXoVqiqO0ptg,395
-notify_tls_client/tls_client/cffi.py,sha256=Ar7cuCJVz7-RcPBhsKg-xe6ThvlcLQPvXwR-688vMyM,1224
+notify_tls_client/tls_client/cffi.py,sha256=pedwBcQOwJvI66yp5GpyNU6zoqrQhTv3ocM1-1PtUm0,1291
 notify_tls_client/tls_client/cookies.py,sha256=1fIOnFDMWMeXuAjQybSrUJXnyjhP-_jJ68AxBUZYgYU,15609
 notify_tls_client/tls_client/exceptions.py,sha256=xIoFb5H3Suk7XssQ-yw3I1DBkPLqnDXsiAe2MMp1qNQ,80
-notify_tls_client/tls_client/response.py,sha256=6oxMRPDkLhiNghSSB7HRC58-gcGClnJ-Nh4o53ETnYA,2586
-notify_tls_client/tls_client/sessions.py,sha256=dLU_kSt5h7NcQeOEpaEIbraUaTXeLiVbHRGZebAqyfY,19142
+notify_tls_client/tls_client/response.py,sha256=7j4iJa59Hcdw5ZWPvaxgLTvC_AWrch9hwMbrK4HNJjo,2618
+notify_tls_client/tls_client/sessions.py,sha256=1xeUDR9H42wS900mCzkpu4At7Lx1O07QGoDuThbLG0M,19233
 notify_tls_client/tls_client/settings.py,sha256=x_2Vrph-QebbCjkxmnX8UPd5oYYU4ClqPOpfoqelno4,1485
 notify_tls_client/tls_client/structures.py,sha256=md-tJmo8X5bad0KrMUTVN8jxUIvui7NiBxaf10bLULU,2517
 notify_tls_client/tls_client/dependencies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -21,7 +26,7 @@ notify_tls_client/tls_client/dependencies/tls-client-darwin-amd64-1.12.0.dylib,s
 notify_tls_client/tls_client/dependencies/tls-client-linux-arm64-1.12.0.so,sha256=fQvdtCiRRS228WrFUE_ucq4OPC4Z7QU4_KI4B3Gf97Y,14404088
 notify_tls_client/tls_client/dependencies/tls-client-linux-ubuntu-amd64-1.12.0.so,sha256=UTvtZa93fWLWaSBINC_Cu8mNoLwsVdcQbQZsdQnZrJM,15210112
 notify_tls_client/tls_client/dependencies/tls-client-windows-64-1.12.0.dll,sha256=uk80UEGW8WepYMglh1Yo6VSrBSNDwon-OyFqE_1bWmM,24849278
-notify_tls_client-0.1.9.dist-info/METADATA,sha256=RyJBSFemDSfLwjQsTfM1-gC0fZ17IUQcnJ-DaKITpPM,465
-notify_tls_client-0.1.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-notify_tls_client-0.1.9.dist-info/top_level.txt,sha256=fq9YA0cFdpCuUO7cdMFN7oxm1zDfZm_m1KPXehUqA5o,18
-notify_tls_client-0.1.9.dist-info/RECORD,,
+notify_tls_client-2.0.0.dist-info/METADATA,sha256=O_m_lTWjraTbcqLAHr1GxwtNwOzHWnb6T1InhT5qiUA,1941
+notify_tls_client-2.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+notify_tls_client-2.0.0.dist-info/top_level.txt,sha256=fq9YA0cFdpCuUO7cdMFN7oxm1zDfZm_m1KPXehUqA5o,18
+notify_tls_client-2.0.0.dist-info/RECORD,,

{notify_tls_client-0.1.9.dist-info → notify_tls_client-2.0.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

notify_tls_client-0.1.9.dist-info/METADATA

@@ -1,14 +0,0 @@
-Metadata-Version: 2.4
-Name: notify_tls_client
-Version: 0.1.9
-Summary: Sem descrição
-Author-email: Naruto Uzumaki <naruto_uzumaki@gmail.com>
-License-Expression: MIT
-Project-URL: Homepage, https://github.com/jefersonAlbara/notify-tls-client
-Requires-Python: >=3.12
-Description-Content-Type: text/markdown
-Requires-Dist: dataclasses_json
-Requires-Dist: typing_extensions
-
-# MY TLS Client
-Pacote python privado com modificações na classe 'tls client'