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

notify_tls_client/config/recovery_config.py

@@ -44,10 +44,15 @@ class 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])
+    status_codes_to_forbidden_response_handle: tuple[int, ...] = field(default_factory=lambda: (403,))
 
     def __post_init__(self):
         """Valida os parâmetros de configuração."""
+        # Converter lista para tuple se necessário (compatibilidade)
+        if isinstance(self.status_codes_to_forbidden_response_handle, list):
+            object.__setattr__(self, 'status_codes_to_forbidden_response_handle',
+                             tuple(self.status_codes_to_forbidden_response_handle))
+
         if not self.status_codes_to_forbidden_response_handle:
             raise ValueError("status_codes_to_forbidden_response_handle não pode ser vazio")
 

notify_tls_client/core/client/decorators.py

@@ -3,6 +3,8 @@ from datetime import datetime
 from typing import Optional
 from urllib.parse import urlparse
 
+from orjson import orjson
+
 from notify_tls_client.tls_client.response import Response
 
 logger = logging.getLogger(__name__)
@@ -79,41 +81,65 @@ def _log_request_info(self,
                       response: Optional[Response],
                       request_url: Optional[str],
                       request_headers: dict):
+    if not logger.isEnabledFor(logging.DEBUG):
+        return
+
     if response:
-        logger.debug(f"""Request finished
-                                        client_identifier={self.get_current_client_identifier()}
-                                        request_url={request_url}
-                                        request_headers={request_headers}
-                                        response_url={response.url}
-                                        status_code={response.status_code}
-                                        response_time={response.elapsed}ms
-                                        response_headers={dict(response.headers)}
-                                        proxy={self.client.proxies['http'] if self.client.proxies else None}
-                             """,
+        proxy = self.client.proxies['http'] if self.client.proxies else None
+        client_id = self.get_current_client_identifier()
+        response_headers_dict = dict(response.headers)
+
+        # Serializar dados complexos com orjson (mais rápido)
+        try:
+            request_headers_json = orjson.dumps(request_headers).decode('utf-8')
+            response_headers_json = orjson.dumps(response_headers_dict).decode('utf-8')
+        except Exception:
+            request_headers_json = str(request_headers)
+            response_headers_json = str(response_headers_dict)
+
+        logger.debug("Request finished\n"
+                     "                                        client_identifier=%s\n"
+                     "                                        request_url=%s\n"
+                     "                                        request_headers=%s\n"
+                     "                                        response_url=%s\n"
+                     "                                        status_code=%s\n"
+                     "                                        response_time=%sms\n"
+                     "                                        response_headers=%s\n"
+                     "                                        proxy=%s",
+                     client_id, request_url, request_headers_json, response.url,
+                     response.status_code, response.elapsed, response_headers_json, proxy,
                      extra={
                          "date": datetime.now().strftime("%d-%m-%Y %H:%M:%S.%f")[:-3],
                          "request_url": request_url,
                          "request_headers": request_headers,
                          "response_url": response.url,
                          "status_code": response.status_code,
-                         "response_headers": dict(response.headers),
+                         "response_headers": response_headers_dict,
                          "response_elapsed_ms": response.elapsed,
-                         "proxy": self.client.proxies['http'] if self.client.proxies else None,
-                         "client_identifier": self.get_current_client_identifier()
-
+                         "proxy": proxy,
+                         "client_identifier": client_id
                      })
 
     if not response:
-        logger.debug(f"""Request failed before getting a response
-                                        client_identifier={self.get_current_client_identifier()}
-                                        request_url={request_url}
-                                        request_headers={request_headers}
-                                        response_url=None
-                                        status_code=None
-                                        response_headers=None
-                                        response_time=0
-                                        proxy={self.client.proxies['http'] if self.client.proxies else None}
-                             """,
+        proxy = self.client.proxies['http'] if self.client.proxies else None
+        client_id = self.get_current_client_identifier()
+
+        # Serializar request_headers com orjson
+        try:
+            request_headers_json = orjson.dumps(request_headers).decode('utf-8')
+        except Exception:
+            request_headers_json = str(request_headers)
+
+        logger.debug("Request failed before getting a response\n"
+                     "                                        client_identifier=%s\n"
+                     "                                        request_url=%s\n"
+                     "                                        request_headers=%s\n"
+                     "                                        response_url=None\n"
+                     "                                        status_code=None\n"
+                     "                                        response_headers=None\n"
+                     "                                        response_time=0\n"
+                     "                                        proxy=%s",
+                     client_id, request_url, request_headers_json, proxy,
                      extra={
                          "date": datetime.now().strftime("%d-%m-%Y %H:%M:%S.%f")[:-3],
                          "request_url": request_url,
@@ -122,9 +148,8 @@ def _log_request_info(self,
                          "status_code": None,
                          "response_headers": None,
                          "response_elapsed_ms": 0,
-                         "proxy": self.client.proxies['http'] if self.client.proxies else None,
-                         "client_identifier": self.get_current_client_identifier()
-
+                         "proxy": proxy,
+                         "client_identifier": client_id
                      })
 
 

notify_tls_client/core/client_identifiers_manager.py

@@ -7,12 +7,15 @@ from notify_tls_client.tls_client.settings import ClientIdentifiers
 
 @dataclass
 class ClientIdentifiersManager:
-    _items: list[ClientIdentifiers] = field(default_factory=list)
+    _items: tuple[ClientIdentifiers, ...] = field(default_factory=tuple)
     _current_index: int = 0
     _current_item: Optional[ClientIdentifiers] = None
 
     def __post_init__(self):
         self._lock = threading.Lock()
+        # Converter lista para tuple se necessário
+        if isinstance(self._items, list):
+            object.__setattr__(self, '_items', tuple(self._items))
 
     def get_next(self) -> ClientIdentifiers:
         with self._lock:
@@ -26,19 +29,19 @@ class ClientIdentifiersManager:
             return _item
 
     def get_current_item(self) -> Optional[ClientIdentifiers]:
-        with self._lock:
-            return self._current_item
+        # Lock-free read - safe para strings imutáveis
+        return self._current_item
 
     def set_items(self, items: list[ClientIdentifiers]):
         with self._lock:
-            self._items = items
+            self._items = tuple(items) if isinstance(items, list) else items
             self._current_index = 0
             self._current_item = None
 
-    def get_item(self) -> list[ClientIdentifiers]:
-        with self._lock:
-            return self._items.copy()
+    def get_item(self) -> tuple[ClientIdentifiers, ...]:
+        # Lock-free read - tuple é imutável
+        return self._items
 
     def get_total_items(self) -> int:
-        with self._lock:
-            return len(self._items)
+        # Lock-free read - len é thread-safe para objetos imutáveis
+        return len(self._items)

notify_tls_client/core/notifytlsclient.py

@@ -19,6 +19,16 @@ logger = logging.getLogger(__name__)
 
 
 class NotifyTLSClient:
+    __slots__ = (
+        'config', 'client', 'free', 'requests_amount', 'requests_amount_with_current_proxy',
+        'requests_amount_with_current_client_identifier', 'last_request_status', 'current_proxy',
+        '_lock', 'client_identifiers_manager', 'proxies_manager', 'requests_limit_with_same_proxy',
+        'requests_limit_with_same_client_identifier', 'random_tls_extension_order',
+        'instantiate_new_client_on_forbidden_response', 'instantiate_new_client_on_exception',
+        'change_client_identifier_on_forbidden_response', 'status_codes_to_forbidden_response_handle',
+        'disable_http3', 'debug_mode', 'headers'
+    )
+
     def __init__(self,
                  config: Optional[ClientConfiguration] = None,
                  # Parâmetros legados - mantidos para compatibilidade mas deprecados
@@ -143,34 +153,35 @@ class NotifyTLSClient:
                            random_tls_extension_order: bool = False,
                            proxy: Optional[Proxy] = None):
 
-        with self._lock:
-            old_client_identifier = None
-            old_client = None
+        # Preparar novo cliente fora do lock
+        new_client = Session(client_identifier=client_identifier,
+                            random_tls_extension_order=random_tls_extension_order,
+                            disable_http3=self.disable_http3)
 
-            if self.client:
-                old_client_identifier = self.client.client_identifier
-                old_client = self.client
+        # Aplicar configurações ao novo cliente
+        if proxy:
+            new_client.proxies = proxy.to_proxy_dict()
 
-            self.client = Session(client_identifier=client_identifier,
-                                  random_tls_extension_order=random_tls_extension_order,
-                                  disable_http3=self.disable_http3)
+        if self.headers:
+            new_client.headers = CaseInsensitiveDict(self.headers)
 
-            if old_client:
-                old_client.close()
+        # Lock apenas para swap atômico
+        with self._lock:
+            old_client = self.client
+            old_client_identifier = old_client.client_identifier if old_client else None
+
+            self.client = new_client
 
             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
+            if proxy and 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)
+        # Fechar cliente antigo fora do lock
+        if old_client:
+            old_client.close()
 
 
     def set_requests_limit_same_proxy(self, requests_limit_same_proxy: int):

notify_tls_client/core/proxiesmanager/proxiesmanager.py

@@ -8,22 +8,33 @@ from dataclasses_json import dataclass_json
 @dataclass_json
 @dataclass
 class Proxy:
+    __slots__ = ('host', 'port', 'username', 'password', '_proxy_dict_cache')
+
     host: str
     port: int
     username: Optional[str] = None
     password: Optional[str] = None
 
+    def __post_init__(self):
+        object.__setattr__(self, '_proxy_dict_cache', None)
+
     def to_proxy_dict(self):
+        if self._proxy_dict_cache is not None:
+            return self._proxy_dict_cache
+
         if self.username is None:
-            return {
-                'http': f'http://{self.host}:{self.port}',
-                'https': f'https://{self.host}:{self.port}'
+            proxy_dict = {
+                'http': 'http://' + self.host + ':' + str(self.port),
+                'https': 'https://' + self.host + ':' + str(self.port)
+            }
+        else:
+            proxy_dict = {
+                'http': 'http://' + self.username + ':' + self.password + '@' + self.host + ':' + str(self.port),
+                'https': 'https://' + self.username + ':' + self.password + '@' + self.host + ':' + str(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}'
-        }
+        object.__setattr__(self, '_proxy_dict_cache', proxy_dict)
+        return proxy_dict
 
     def __eq__(self, other):
         if not isinstance(other, Proxy):
@@ -58,8 +69,8 @@ class ProxiesManager:
             return proxy
 
     def get_current_proxy(self) -> Optional[Proxy]:
-        with self._lock:
-            return self._current_proxy
+        # Lock-free read - Proxy é imutável (frozen dataclass)
+        return self._current_proxy
 
     def set_proxies(self, proxies: list[Proxy]):
         with self._lock:
@@ -69,11 +80,14 @@ class ProxiesManager:
 
     def add_proxy(self, proxy: Proxy):
         with self._lock:
-            self._proxies.append(proxy)
+            # Criar nova lista ao invés de modificar in-place
+            new_proxies = self._proxies.copy()
+            new_proxies.append(proxy)
+            self._proxies = new_proxies
 
     def get_proxies(self) -> list[Proxy]:
-        with self._lock:
-            return self._proxies.copy()
+        # Lock-free read - retornar referência direta (lista é copiada pelo caller se necessário)
+        return self._proxies
 
 
 

notify_tls_client/tls_client/response.py

@@ -9,6 +9,7 @@ import json
 
 class Response:
     """object, which contains the response to an HTTP request."""
+    __slots__ = ('elapsed', 'url', 'status_code', 'text', 'headers', 'cookies', '_content', '_content_consumed')
 
     def __init__(self):
 

notify_tls_client-2.0.1.dist-info/METADATA

@@ -0,0 +1,338 @@
+Metadata-Version: 2.4
+Name: notify-tls-client
+Version: 2.0.1
+Summary: Cliente HTTP avançado com TLS fingerprinting, rotação automática de proxies e recuperação inteligente para web scraping profissional
+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"
+
+# Notify TLS Client
+
+[![PyPI version](https://badge.fury.io/py/notify-tls-client.svg)](https://badge.fury.io/py/notify-tls-client)
+[![Python Version](https://img.shields.io/pypi/pyversions/notify-tls-client.svg)](https://pypi.org/project/notify-tls-client/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Cliente HTTP avançado em Python com suporte a TLS/SSL customizado, fingerprinting de navegadores e rotação automática de proxies. Construído sobre a biblioteca `tls-client` com funcionalidades adicionais para web scraping e automação resiliente.
+
+## 🚀 Características Principais
+
+- **Fingerprinting TLS Avançado**: Emula múltiplos navegadores (Chrome, Firefox, Safari, Edge, Mobile)
+- **Rotação Automática**: Proxies e client identifiers com políticas configuráveis
+- **Recuperação Automática**: Reconexão inteligente em erros e respostas proibidas
+- **Thread-Safe**: Uso seguro em ambientes multi-threaded
+- **Configuração Modular**: Sistema de configuração baseado em objetos reutilizáveis
+- **Presets Prontos**: Configurações pré-definidas para casos de uso comuns
+- **HTTP/3 Support**: Suporte opcional a QUIC/HTTP3
+
+## 📦 Instalação
+
+```bash
+pip install notify-tls-client
+```
+
+### Requisitos
+
+- Python >= 3.12
+- Sistema operacional: Windows, macOS, Linux (x86_64, ARM64)
+
+## 🎯 Quick Start
+
+### Uso Básico
+
+```python
+from notify_tls_client import NotifyTLSClient
+
+# Cliente com configuração padrão
+client = NotifyTLSClient()
+
+# Fazer requisição
+response = client.get("https://api.example.com/data")
+print(response.status_code)
+print(response.json())
+```
+
+### Usando Presets (Recomendado)
+
+```python
+from notify_tls_client import NotifyTLSClient
+from notify_tls_client.config import ClientConfiguration
+from notify_tls_client.core.proxiesmanager import ProxiesManagerLoader
+
+# Carregar proxies
+proxies = ProxiesManagerLoader().from_txt("proxies.txt")
+
+# Preset para scraping agressivo
+config = ClientConfiguration.aggressive(proxies)
+client = NotifyTLSClient(config)
+
+# Fazer múltiplas requisições
+for i in range(100):
+    response = client.get("https://example.com/api/endpoint")
+    print(f"Request {i}: {response.status_code}")
+```
+
+### Configuração Customizada
+
+```python
+from notify_tls_client import NotifyTLSClient
+from notify_tls_client.config import (
+    ClientConfiguration,
+    RotationConfig,
+    RecoveryConfig,
+    ClientConfig
+)
+
+config = ClientConfiguration(
+    proxies_manager=proxies,
+    rotation=RotationConfig(
+        requests_limit_same_proxy=50,
+        requests_limit_same_client_identifier=200,
+        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"],
+        disable_http3=False,
+        debug_mode=False
+    )
+)
+
+client = NotifyTLSClient(config)
+```
+
+## 📚 Presets Disponíveis
+
+### Simple
+Uso básico com rotação de proxies padrão.
+```python
+config = ClientConfiguration.simple(proxies)
+```
+
+### Aggressive
+Para scraping intensivo com recuperação automática completa.
+```python
+config = ClientConfiguration.aggressive(proxies)
+```
+- Troca proxy a cada 10 requisições
+- Troca client identifier a cada 50 requisições
+- Recuperação automática em erros e 403/429/503
+- Múltiplos client identifiers
+
+### Stealth
+Foco em evitar detecção através de diversidade.
+```python
+config = ClientConfiguration.stealth(proxies)
+```
+- 4 client identifiers diferentes
+- Ordem de extensões TLS randomizada
+- Rotação moderada (100 req/proxy)
+
+### Mobile
+Simula dispositivos móveis.
+```python
+# Android
+config = ClientConfiguration.mobile(proxies, platform="android")
+
+# iOS
+config = ClientConfiguration.mobile(proxies, platform="ios")
+```
+
+## 🔧 Funcionalidades Avançadas
+
+### Rotação de Proxies
+
+```python
+from notify_tls_client.core.proxiesmanager import ProxiesManagerLoader
+
+# Carregar de arquivo
+proxies = ProxiesManagerLoader().from_txt("proxies.txt")
+
+# Formato do arquivo (um por linha):
+# host:port
+# host:port:username:password
+# http://username:password@host:port
+```
+
+### Client Identifiers Suportados
+
+**Desktop:**
+- Chrome: `chrome_133`, `chrome_131`, `chrome_120`, etc.
+- Firefox: `firefox_120`, `firefox_117`, `firefox_110`, etc.
+- Safari: `safari_17_0`, `safari_16_0`, etc.
+- Edge, Opera
+
+**Mobile:**
+- Android: `okhttp4_android_13`, `okhttp4_android_12`, etc.
+- iOS: `safari_ios_16_0`, `safari_ios_15_6`, etc.
+
+### Recuperação Automática
+
+```python
+config = ClientConfiguration(
+    recovery=RecoveryConfig(
+        # Criar nova sessão em respostas proibidas
+        instantiate_new_client_on_forbidden_response=True,
+
+        # Criar nova sessão em exceções
+        instantiate_new_client_on_exception=True,
+
+        # Trocar identifier em respostas proibidas
+        change_client_identifier_on_forbidden_response=True,
+
+        # Status codes que acionam recuperação
+        status_codes_to_forbidden_response_handle=[403, 429, 503]
+    )
+)
+```
+
+### Headers Customizados
+
+```python
+config = ClientConfiguration(
+    client=ClientConfig(
+        default_headers={
+            "User-Agent": "Mozilla/5.0...",
+            "Accept-Language": "pt-BR,pt;q=0.9",
+            "Custom-Header": "value"
+        }
+    )
+)
+
+# Ou por requisição
+response = client.get(
+    "https://example.com",
+    headers={"Authorization": "Bearer token"}
+)
+```
+
+### Cookies
+
+```python
+# Obter todos os cookies
+cookies = client.get_cookies()
+
+# Obter cookie específico
+value = client.get_cookie_by_name("session_id")
+
+# Definir cookie
+client.set_cookie("name", "value")
+```
+
+## 🔒 Thread Safety
+
+A biblioteca é thread-safe e pode ser usada em ambientes multi-threaded:
+
+```python
+import concurrent.futures
+
+client = NotifyTLSClient(ClientConfiguration.aggressive(proxies))
+
+def make_request(url):
+    return client.get(url)
+
+with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
+    urls = ["https://example.com"] * 100
+    results = list(executor.map(make_request, urls))
+```
+
+## 📊 Logging
+
+```python
+import logging
+
+# Habilitar logs de debug
+logging.basicConfig(level=logging.DEBUG)
+
+# Ou configurar apenas para notify_tls_client
+logger = logging.getLogger("notify_tls_client")
+logger.setLevel(logging.DEBUG)
+```
+
+## 🛠️ Métodos HTTP Suportados
+
+```python
+# GET
+response = client.get(url, params={"key": "value"})
+
+# POST
+response = client.post(url, json={"data": "value"})
+response = client.post(url, data="form data")
+
+# PUT
+response = client.put(url, json={"data": "value"})
+
+# PATCH
+response = client.patch(url, json={"data": "value"})
+
+# DELETE
+response = client.delete(url)
+```
+
+## 📖 Documentação Completa
+
+Para documentação detalhada sobre arquitetura, componentes internos e exemplos avançados, consulte:
+- [CLAUDE.md](CLAUDE.md) - Guia completo de desenvolvimento
+- [examples/](examples/) - Exemplos de código
+
+## 🤝 Contribuindo
+
+Contribuições são bem-vindas! Por favor, leia [CONTRIBUTING.md](CONTRIBUTING.md) para detalhes sobre nosso código de conduta e processo de submissão de pull requests.
+
+## 📝 Changelog
+
+Veja [CHANGELOG.md](CHANGELOG.md) para histórico de versões e mudanças.
+
+## 📄 Licença
+
+Este projeto está licenciado sob a Licença MIT - veja o arquivo [LICENSE](LICENSE) para detalhes.
+
+## ⚠️ Aviso Legal
+
+Esta biblioteca é fornecida apenas para fins educacionais e de pesquisa. O uso desta ferramenta para violar termos de serviço de websites, realizar scraping não autorizado ou qualquer atividade ilegal é de sua responsabilidade. Os desenvolvedores não se responsabilizam pelo uso indevido desta biblioteca.
+
+## 🙏 Agradecimentos
+
+- [tls-client](https://github.com/bogdanfinn/tls-client) - Biblioteca Go subjacente para TLS fingerprinting
+- Comunidade Python por ferramentas e bibliotecas incríveis
+
+## 📞 Suporte
+
+- **Issues**: [GitHub Issues](https://github.com/jefersonAlbara/notify-tls-client/issues)
+- **Discussões**: [GitHub Discussions](https://github.com/jefersonAlbara/notify-tls-client/discussions)
+
+---
+
+**Desenvolvido com ❤️ para a comunidade Python**

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

@@ -2,22 +2,22 @@ notify_tls_client/__init__.py,sha256=APA8wxvkGYZiVMMbTWGo7prB3iKE-OzUajd0bfc8PwE
 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/recovery_config.py,sha256=zKBjSdCHJ4iF0PXUawPh3EktOxGdn-8bzpjl7LOIoa4,3202
 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=ko4Y5IVMxNTRgk4e6jiJF_kcMjzej9rRt7BJtX-OMyg,1346
-notify_tls_client/core/notifytlsclient.py,sha256=Mj6myXtzc_M52oOj_-cj4NcSx2WOuDIfg396CtOLmDo,12598
+notify_tls_client/core/client_identifiers_manager.py,sha256=D8xJ89aaxZ_8Pssx9VqEH05G8cp3bMez14-KrTMtJiU,1646
+notify_tls_client/core/notifytlsclient.py,sha256=CcDS-yFj5g3Vw-mtbu_AFXZZD7wDjyPF_P5ha4vysqo,13307
 notify_tls_client/core/client/__init__.py,sha256=VKjpq02hC-r9ER6mbfkwG6W2ybv_jND9d9bidte0CjU,51
-notify_tls_client/core/client/decorators.py,sha256=GjGUl5eE5KZGB7Bc6XRFgmJ1Xjz6gNBXxOH8jldCAl8,8554
+notify_tls_client/core/client/decorators.py,sha256=TMKHLkWuVUy802TzY3iLwR1WV9QymcCxCelzBocPJH0,9705
 notify_tls_client/core/proxiesmanager/__init__.py,sha256=emF4vnZvSfb9zlHkt9dDdTcGwkfs1DADi7XVw_DxsWs,105
-notify_tls_client/core/proxiesmanager/proxiesmanager.py,sha256=V-X5dWskGHUjrX-hpl9E4L6pv53LBg1M0giEbWmG6JE,2286
+notify_tls_client/core/proxiesmanager/proxiesmanager.py,sha256=kfW7nEIyeXtDj1YzaAZo2ctPGMk3MnNIXV15Cj7iiY0,3010
 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=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=7j4iJa59Hcdw5ZWPvaxgLTvC_AWrch9hwMbrK4HNJjo,2618
+notify_tls_client/tls_client/response.py,sha256=v4mQhZroNL9203mA5KDJvxSP4GntVq0sjYRtJNfIoE0,2732
 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
@@ -26,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-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-2.0.1.dist-info/METADATA,sha256=Fk4CucsgT0kffRjqOMLZQ1eFFDAU0Z3yg1YMCMdcdI4,10565
+notify_tls_client-2.0.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+notify_tls_client-2.0.1.dist-info/top_level.txt,sha256=fq9YA0cFdpCuUO7cdMFN7oxm1zDfZm_m1KPXehUqA5o,18
+notify_tls_client-2.0.1.dist-info/RECORD,,

notify_tls_client-2.0.0.dist-info/METADATA

@@ -1,38 +0,0 @@
-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'