Update proxy_pool.py

proxy_pool.py

@@ -1,7 +1,3 @@
-"""
-Proxy Pool — avec merge intelligent
-"""
-
 import random
 import threading
 import time
@@ -12,7 +8,6 @@ class ProxyEntry:
     __slots__ = (
         'proxy', 'protocol', 'proxy_url', 'latency',
         'proxy_ip', 'verified', 'fail_count', 'total_used',
-        'last_seen', 'test_count',
     )
 
     def __init__(self, proxy, protocol, proxy_url,
@@ -25,8 +20,6 @@ class ProxyEntry:
         self.verified = verified
         self.fail_count = 0
         self.total_used = 0
-        self.last_seen = time.time()
-        self.test_count = 1
 
     def to_dict(self):
         return {
@@ -37,8 +30,6 @@ class ProxyEntry:
             "proxy_ip": self.proxy_ip,
             "verified": self.verified,
             "total_used": self.total_used,
-            "age_s": round(time.time() - self.last_seen, 1),
-            "test_count": self.test_count,
         }
 
 
@@ -50,69 +41,28 @@ class ProxyPool:
         self._rr = defaultdict(int)
         self._lr = 0.0
         self._rc = 0
-        # config
-        self.max_age = 600       # 10 min max sans retest
-        self.max_pool_size = 500 # pas plus de 500 proxies
 
     def refresh(self, new_proxies):
-        """
-        MERGE les nouveaux proxies avec les existants.
-        - Nouveaux: ajoutés/mis à jour
-        - Anciens pas retestés: gardés si < max_age
-        - Très vieux: supprimés
-        """
         with self._lk:
-            now = time.time()
-            
-            # 1. Update/add les nouveaux
+            old = dict(self._um)
+            fresh, um = [], {}
             for px in new_proxies:
-                url = px["proxy_url"]
-                
-                if url in self._um:
-                    # existe déjà → update
-                    e = self._um[url]
-                    e.latency = px["latency"]
-                    e.proxy_ip = px.get("proxy_ip", e.proxy_ip)
-                    e.verified = px.get("verified", e.verified)
-                    e.last_seen = now
-                    e.test_count += 1
-                    e.fail_count = max(0, e.fail_count - 1)
-                else:
-                    # nouveau
-                    e = ProxyEntry(
-                        px["proxy"], px["protocol"],
-                        px["proxy_url"], px["latency"],
-                        px.get("proxy_ip", ""),
-                        px.get("verified", False),
-                    )
-                    e.last_seen = now
-                    self._um[url] = e
-            
-            # 2. Nettoyer les vieux proxies
-            to_remove = []
-            for url, e in self._um.items():
-                age = now - e.last_seen
-                if age > self.max_age:
-                    to_remove.append(url)
-            
-            for url in to_remove:
-                del self._um[url]
-            
-            # 3. Reconstruire la liste triée
-            self._px = sorted(
-                self._um.values(),
-                key=lambda x: x.latency
-            )
-            
-            # 4. Limiter la taille
-            if len(self._px) > self.max_pool_size:
-                # garder les plus rapides
-                removed = self._px[self.max_pool_size:]
-                self._px = self._px[:self.max_pool_size]
-                for e in removed:
-                    del self._um[e.proxy_url]
-            
-            self._lr = now
+                e = ProxyEntry(
+                    px["proxy"], px["protocol"],
+                    px["proxy_url"], px["latency"],
+                    px.get("proxy_ip", ""),
+                    px.get("verified", False),
+                )
+                o = old.get(e.proxy_url)
+                if o:
+                    e.total_used = o.total_used
+                    e.fail_count = max(0, o.fail_count - 1)
+                fresh.append(e)
+                um[e.proxy_url] = e
+            fresh.sort(key=lambda x: x.latency)
+            self._px = fresh
+            self._um = um
+            self._lr = time.time()
             self._rc += 1
 
     @property
@@ -175,7 +125,6 @@ class ProxyPool:
             p = self._um.get(url)
             if p:
                 p.fail_count = 0
-                p.last_seen = time.time()
 
     def get_all(self, protocol=None, verified=False, limit=500):
         with self._lk:
@@ -186,26 +135,36 @@ class ProxyPool:
 
     def get_stats(self):
         with self._lk:
-            now = time.time()
             bp = defaultdict(lambda: {"total": 0, "alive": 0})
-            ages = []
             for p in self._px:
                 bp[p.protocol]["total"] += 1
                 if p.fail_count < 3:
                     bp[p.protocol]["alive"] += 1
-                ages.append(now - p.last_seen)
-            
             alive = sum(d["alive"] for d in bp.values())
-            avg_age = round(sum(ages) / len(ages), 1) if ages else 0
-            
             return {
                 "total": len(self._px),
                 "alive": alive,
                 "by_protocol": dict(bp),
-                "avg_age_s": avg_age,
-                "max_age_config": self.max_age,
                 "refresh_count": self._rc,
                 "last_refresh_ago": round(
-                    now - self._lr, 1
+                    time.time() - self._lr, 1
                 ) if self._lr else None,
-            }
+            }
+
+    def export_json(self):
+        with self._lk:
+            return [p.to_dict() for p in self._px]
+
+    def import_json(self, data):
+        proxies = []
+        for p in data:
+            proxies.append({
+                "proxy": p["proxy"],
+                "protocol": p["protocol"],
+                "proxy_url": p["proxy_url"],
+                "latency": p["latency"],
+                "proxy_ip": p.get("proxy_ip", ""),
+                "verified": p.get("verified", False),
+            })
+        if proxies:
+            self.refresh(proxies)