refactor(utils): centralize HTTP requests and update public IP caching in get_public_ip

- Replace internal low-level curl implementation with shared `send_query` (returns QueryResult)
  to unify proxy/TLS/timeout handling.
- Prefer `FileCache` for IP caching (use system temp dir). Fall back to legacy JSON cache file
  on error to preserve previous behavior.
- Convert proxy handling to build proxy URLs and call `send_query` for each proxy type.
- Rename `debug` parameter to `verbose` and wire verbose logging through new calls.
- Use `QueryResult.response` when available and skip on `QueryResult.error`.
- Persist cache via `FileCache.write_cache` when available, otherwise write legacy JSON.
- Add `tempfile` import and minor cleanup/comments.

Notes:
- No behavioral logic changes to IP extraction, only networking and caching plumbing refactor.

Author: dimaslanjaka

proxy_checker/utils/get_public_ip.py

@@ -3,10 +3,9 @@
 import time
 import hashlib
 import re
+import tempfile
 from typing import Optional, Dict, Any, List
-import pycurl
-from io import BytesIO
-import certifi
+from .curl import send_query, QueryResult
 
 
 IP_REGEX = re.compile(
@@ -25,64 +24,14 @@
 ]
 
 
-def _curl_request(
-    url: str,
-    proxy: Optional[str],
-    proxy_type: Optional[str],
-    username: Optional[str],
-    password: Optional[str],
-    timeout: int = 5,
-) -> Optional[str]:
-
-    buffer = BytesIO()
-    curl = pycurl.Curl()
-    curl.setopt(pycurl.URL, url)
-    curl.setopt(pycurl.USERAGENT, "Mozilla/5.0 (Python Proxy IP Checker)")
-    curl.setopt(pycurl.TIMEOUT, timeout)
-    curl.setopt(pycurl.CONNECTTIMEOUT, timeout)
-    curl.setopt(pycurl.WRITEDATA, buffer)
-    curl.setopt(pycurl.CAINFO, certifi.where())
-
-    # Proxy setup
-    if proxy:
-        curl.setopt(pycurl.PROXY, proxy)
-
-        if proxy_type:
-            proxy_type = proxy_type.lower()
-            if proxy_type == "http":
-                curl.setopt(pycurl.PROXYTYPE, pycurl.PROXYTYPE_HTTP)
-            elif proxy_type == "socks4":
-                curl.setopt(pycurl.PROXYTYPE, pycurl.PROXYTYPE_SOCKS4)
-            elif proxy_type == "socks5":
-                curl.setopt(pycurl.PROXYTYPE, pycurl.PROXYTYPE_SOCKS5)
-            elif proxy_type == "socks4a":
-                curl.setopt(pycurl.PROXYTYPE, pycurl.PROXYTYPE_SOCKS4A)
-            elif proxy_type == "socks5h":
-                curl.setopt(pycurl.PROXYTYPE, pycurl.PROXYTYPE_SOCKS5_HOSTNAME)
-
-        if username and password:
-            curl.setopt(pycurl.PROXYUSERPWD, f"{username}:{password}")
-
-    try:
-        curl.perform()
-        http_code = curl.getinfo(pycurl.RESPONSE_CODE)
-    except Exception:
-        curl.close()
-        return None
-
-    curl.close()
-
-    if http_code != 200:
-        return None
-
-    return buffer.getvalue().decode(errors="ignore").strip()
+# Replaced _curl_request with calls to shared send_query (returns QueryResult)
 
 
 def get_public_ip(
     cache: bool = False,
     cache_timeout: int = 300,
     proxy_info: Dict[str, Any] = {},
-    debug: bool = False,
+    verbose: bool = False,
 ) -> str:
 
     # ------------ CACHE HANDLING ------------
@@ -99,13 +48,29 @@ def get_public_ip(
     cache_key = hashlib.md5(proxy_key.encode()).hexdigest() if proxy_key else ""
     cache_file = os.path.join(cache_dir, f"{cache_key}.cache")
 
-    if cache and cache_key and os.path.exists(cache_file):
+    # Prefer FileCache when available to centralize cache logic; fall back to JSON
+    fc = None
+    if cache and cache_key:
         try:
-            data = json.load(open(cache_file))
-            if "ip" in data and "expires" in data and data["expires"] > time.time():
-                return data["ip"]
+            from ..FileCache import FileCache
+
+            fc = FileCache(cache_file)
+            cached = fc.read_cache()
+            if cached:
+                return cached
         except Exception:
-            pass
+            # fallback to legacy JSON file check
+            try:
+                if os.path.exists(cache_file):
+                    data = json.load(open(cache_file))
+                    if (
+                        "ip" in data
+                        and "expires" in data
+                        and data["expires"] > time.time()
+                    ):
+                        return data["ip"]
+            except Exception:
+                pass
 
     # ------------ PROXY HANDLING ------------
     proxy_types = proxy_info.get("type", "")
@@ -124,27 +89,38 @@ def get_public_ip(
     for url in IP_SERVICES:
         if proxy:
             for ptype in proxy_types:
-                if debug:
+                if verbose:
                     print(f"Trying {url} using proxy {proxy} type={ptype}")
 
-                response = _curl_request(url, proxy, ptype, username, password)
+                # convert proxy and type to proxy URL for send_query
+                proxy_url = f"{ptype}://{proxy}"
+                qr: QueryResult = send_query(
+                    url=url,
+                    proxy=proxy_url,
+                    user=username,
+                    password=password,
+                    timeout=5000,
+                    verbose=verbose,
+                )
+                response = qr.response if (qr and not qr.error) else None
 
                 if response:
-                    if debug:
+                    if verbose:
                         print(f"Response (proxy {ptype}): {response[:80]}")
                     break
 
             if response:
                 break
 
         else:
-            if debug:
+            if verbose:
                 print(f"Trying {url} without proxy")
 
-            response = _curl_request(url, None, None, None, None)
+            qr: QueryResult = send_query(url=url, timeout=5000, verbose=verbose)
+            response = qr.response if (qr and not qr.error) else None
 
             if response:
-                if debug:
+                if verbose:
                     print(f"Response: {response[:80]}")
                 break
 
@@ -161,10 +137,20 @@ def get_public_ip(
     # ------------ SAVE CACHE ------------
     if cache and cache_key:
         try:
-            json.dump(
-                {"ip": ip, "expires": time.time() + cache_timeout},
-                open(cache_file, "w"),
-            )
+            if fc:
+                try:
+                    fc.write_cache(ip, expires_in=cache_timeout)
+                except Exception:
+                    # fallback to JSON write
+                    json.dump(
+                        {"ip": ip, "expires": time.time() + cache_timeout},
+                        open(cache_file, "w"),
+                    )
+            else:
+                json.dump(
+                    {"ip": ip, "expires": time.time() + cache_timeout},
+                    open(cache_file, "w"),
+                )
         except Exception:
             pass