refactor(proxy-checker): improve probe coverage, logging, and error reporting

- Rename `ip` -> `device_ip` on `ProxyChecker` to clarify intent.
- Add verbose logging for country lookup when `verbose=True`.
- Iterate TLS versions per protocol (test multiple TLS levels for HTTPS proxies).
- Collect `send_query` error messages grouped by protocol and TLS (messages[protocol][tls]).
- Add `messages` field to `ProxyChekerResult` to return detailed per-protocol/TLS errors.
- Update tests to use `device_ip` and simplify test invocation formatting.

This refactor improves diagnostics and robustness when probing proxies across protocol/TLS combinations.

Author: dimaslanjaka

proxy_checker/ProxyChecker.py

@@ -18,8 +18,8 @@ def __init__(self, timeout: int = 30000, verbose: bool = False):
         self.timeout = timeout
         self.verbose = verbose
 
-        self.ip = get_device_ip(timeout=self.timeout, verbose=self.verbose)
-        if not self.ip:
+        self.device_ip = get_device_ip(timeout=self.timeout, verbose=self.verbose)
+        if not self.device_ip:
             print("ERROR: cannot get device ip")
 
         # ProxyAnonymity helper used for parsing judge responses
@@ -37,6 +37,8 @@ def get_country(self, ip: str) -> list:
             timeout=self.timeout,
             verbose=self.verbose,
         )
+        if self.verbose:
+            print(f"Country lookup for IP {ip}: {r}")
         if r and not getattr(r, "error", False) and (r.response or "").startswith("1"):
             fields = (r.response or "").split(";")
             return [fields[3], fields[1]]
@@ -111,39 +113,55 @@ def check_proxy(
         else:
             protocols_to_test = all_protocols
 
+        tls_to_test = []
+        if isinstance(tls, str) and tls in ["1.3", "1.2", "1.1", "1.0"]:
+            tls_to_test.append(tls)
+        else:
+            tls_to_test = ["1.3", "1.2", "1.1", "1.0"]
+
         protocols: Dict[str, QueryResult] = {}
         latencies = []
+        # messages[protocol][tls] = message string or None
+        messages: Dict[str, Dict[str, Optional[str]]] = {}
 
         for _ in range(retries):
             for proto in protocols_to_test:
-                # Query a fixed probe URL using the protocol-prefixed proxy URL
-                proxy_url = f"{proto}://{proxy}"
-                result = send_query(
-                    url=test_url or "https://www.google.com",
-                    proxy=proxy_url,
-                    user=user,
-                    password=password,
-                    tls=tls,
-                    timeout=timeout if timeout is not None else self.timeout,
-                    verbose=self.verbose,
-                )
-                if not result or result.error:
-                    continue
-
-                protocols[proto] = result
-                t = getattr(result, "total_time", None)
-                if t is not None:
-                    latencies.append(t * 1000)
-
-                if not check_all_protocols:
-                    break
+                for tls in tls_to_test:
+                    proxy_url = f"{proto}://{proxy}"
+                    result = send_query(
+                        url=test_url or "https://www.google.com",
+                        proxy=proxy_url,
+                        user=user,
+                        password=password,
+                        tls=tls,
+                        timeout=timeout if timeout is not None else self.timeout,
+                        verbose=self.verbose,
+                    )
+                    # capture message for this protocol/tls attempt
+                    msg = (
+                        getattr(result, "message", None) if result is not None else None
+                    )
+                    if not result or result.error:
+                        messages.setdefault(proto, {})[tls] = msg
+                        continue
+
+                    protocols[proto] = result
+                    # mark success for this tls version
+                    messages.setdefault(proto, {})[tls] = None
+                    t = getattr(result, "total_time", None)
+                    if t is not None:
+                        latencies.append(t * 1000)
+
+                    if not check_all_protocols:
+                        break
 
         if not protocols:
             return ProxyChekerResult(
                 protocols=[],
                 anonymity="",
                 latency=0,
                 response="",
+                messages=messages,
                 country=None,
                 country_code=None,
                 proxy=None,
@@ -182,6 +200,7 @@ def check_proxy(
             anonymity=anonymity,
             latency=latency,
             response=sample_response,
+            messages=messages,
             country=country[0],
             country_code=country[1],
             proxy=remote_addr,

proxy_checker/ProxyChekerResult.py

@@ -2,6 +2,7 @@
 from typing import List, Optional, Union, Literal
 from dataclasses import asdict
 import json
+from typing import Dict
 
 
 @dataclass
@@ -10,6 +11,8 @@ class ProxyChekerResult:
     anonymity: Union[Literal["Transparent", "Anonymous", "Elite"], str]
     latency: int
     response: Optional[str] = None
+    # messages[protocol][tls] = message string or None
+    messages: Optional[Dict[str, Dict[str, Optional[str]]]] = None
     country: Optional[str] = None
     country_code: Optional[str] = None
     proxy: Optional[str] = None

tests/ProxyChecker_test.py

@@ -1,19 +1,15 @@
-from proxy_checker import ProxyChecker
+from proxy_checker import ProxyChecker, get_device_ip
 
 checker = ProxyChecker(verbose=False)
-print(f"my IP {checker.ip}")
-proxy = "157.175.43.137:797"
-ip = proxy.split(":")[0]
-print(f"proxy IP {ip}")
+print(f"my IP {checker.device_ip}")
+proxy = "16.78.41.33:9011"
+proxy_ip = proxy.split(":")[0]
+print(f"proxy IP {proxy_ip}")
 result = checker.check_proxy(
-    proxy=proxy,
-    check_all_protocols=True,
-    check_address=True,
-    check_country=True,
-    retries=4,
+    proxy=proxy, check_all_protocols=True, check_address=True, check_country=True
 )
 print(result)
 print(f"latency: {result.latency} ms")
 print(f"anonymity: {result.anonymity}")
-print(f"is proxy ip same {checker.ip == ip}")
+print(f"is device ip same {checker.device_ip == proxy_ip}")
 print(f"country: {result.country} ({result.country_code})")