proxy-reader 0.1.0__py3-none-any.whl → 2.1.0__py3-none-any.whl

proxy_reader/__init__.py

@@ -1,4 +1,3 @@
 from .reader import *
 
-
-__version__ = "0.1.0"
+__version__ = "2.1.0"

proxy_reader/_types.py

@@ -1,4 +1,4 @@
-from typing import TypedDict, NotRequired, List, Iterator, TypeAlias
+from typing import TypedDict, NotRequired, List, Iterator, TypeAlias, Any, Optional
 from .proxy import Proxy
 
 
@@ -10,5 +10,14 @@ class TelegramHTTP(TypedDict):
     password: NotRequired[str]
 
 
+GeneralDict: TypeAlias = dict[str, Any]
+
 ProxiesList: TypeAlias = List[Proxy]
 ProxyiesGen: TypeAlias = Iterator[Proxy]
+
+
+class ProxyDictT(TypedDict):
+    host: str
+    port: str
+    username: Optional[str]
+    password: Optional[str]

proxy_reader/logs_config.py

@@ -0,0 +1,20 @@
+import logging
+
+# Create the package-wide logger
+package_name = "proxy_reader"
+logger = logging.getLogger(package_name)
+logger.addHandler(logging.NullHandler())
+logger.setLevel(logging.WARNING)  # Default: Show only warnings/errors
+
+
+def enable_debug_logs() -> None:
+    logger = logging.getLogger(package_name)
+    logger.setLevel(logging.DEBUG)  # Set log level
+
+    # 🔥 Make sure a handler is added (VERY IMPORTANT)
+    ch = logging.StreamHandler()  # Console handler
+    ch.setLevel(logging.DEBUG)  # Match the logger's level
+    formatter = logging.Formatter("%(name)s - %(levelname)s - %(message)s")
+    ch.setFormatter(formatter)
+    logger.addHandler(ch)  # Attach the handler
+    logger.debug(f"Debugging enabled on {package_name!r}")

proxy_reader/protocols/reader.py

@@ -5,102 +5,70 @@ from ..proxy import Proxy
 
 class ProxiesReaderProtocol(Protocol):
     @property
-    def total(self) -> int:
-        pass
+    def total(self) -> int: ...
 
     @property
-    def total_working(self) -> int:
-        pass
+    def total_working(self) -> int: ...
 
     @property
-    def total_bad(self) -> int:
-        pass
+    def total_bad(self) -> int: ...
 
     @property
-    def proxies(self) -> ProxiesList:
-        pass
+    def proxies(self) -> ProxiesList: ...
 
     @property
-    def bad_proxies(self) -> ProxiesList:
-        pass
+    def bad_proxies(self) -> ProxiesList: ...
 
     @property
-    def working_proxies(self) -> ProxiesList:
-        pass
+    def working_proxies(self) -> ProxiesList: ...
 
     @working_proxies.setter
-    def working_proxies(self, working_proxies: List[Proxy]) -> None:
-        pass
+    def working_proxies(self, working_proxies: List[Proxy]) -> None: ...
 
-    def read_raw(self) -> List[str]:
-        pass
+    def _random_proxy_check_url(self) -> str: ...
 
-    def random_url(self) -> str:
-        pass
+    def read_with_auth(self) -> None: ...
 
-    def read_with_auth(self) -> None:
-        pass
-
-    def read_authless(self) -> None:
-        pass
+    def read_authless(self) -> None: ...
 
     async def _check_proxy(
         self, proxy: Proxy, response_time: Optional[int] = None
-    ) -> bool:
-        pass
+    ) -> bool: ...
 
-    async def check_all_proxies(self, max_resp_time: int = 30) -> None:
-        pass
+    async def check_all_proxies(self, max_resp_time: int = 30) -> None: ...
 
     async def _check_proxy_socks(
         self, proxy: Proxy, response_time: Optional[int] = None
-    ) -> bool:
-        pass
+    ) -> bool: ...
 
-    async def check_all_proxies_socks5(self, max_resp_time: int = 5) -> None:
-        pass
+    async def check_all_proxies_socks5(self, max_resp_time: int = 5) -> None: ...
 
-    def get_working_proxies_list_http(self) -> List[str]:
-        pass
+    def get_working_proxies_list_http(self) -> List[str]: ...
 
-    def write_working_proxies(self, filename: str) -> None:
-        pass
+    def write_working_proxies(self, filename: str) -> None: ...
 
-    def get_random_http(self) -> Optional[str]:
-        pass
+    def get_random_http(self) -> Optional[str]: ...
 
-    def get_random_socks5(self) -> Optional[str]:
-        pass
+    def get_random_socks5(self) -> Optional[str]: ...
 
-    def get_random_socks5_telegram(self) -> Optional[Dict[str, Any]]:
-        pass
+    def get_random_socks5_telegram(self) -> Optional[Dict[str, Any]]: ...
 
-    def next_http_from_list(self) -> Optional[str]:
-        pass
+    def next_http_from_list(self) -> Optional[str]: ...
 
-    def next_http_from_cycle(self) -> str:
-        pass
+    def next_http_from_cycle(self) -> str: ...
 
-    def next_socks5_from_list(self) -> str:
-        pass
+    def next_socks5_from_list(self) -> str: ...
 
-    def next_socks5_from_cycle(self) -> str:
-        pass
+    def next_socks5_from_cycle(self) -> str: ...
 
-    def next_http_telegram_from_list(self) -> Dict[str, Any]:
-        pass
+    def next_http_telegram_from_list(self) -> Dict[str, Any]: ...
 
-    def next_http_telegram_from_cycle(self) -> Dict[str, Any]:
-        pass
+    def next_http_telegram_from_cycle(self) -> Dict[str, Any]: ...
 
-    def next_socks5_telegram_from_cycle(self) -> Dict[str, Any]:
-        pass
+    def next_socks5_telegram_from_cycle(self) -> Dict[str, Any]: ...
 
-    def next_socks5_telegram_from_list(self) -> Dict[str, Any]:
-        pass
+    def next_socks5_telegram_from_list(self) -> Dict[str, Any]: ...
 
-    def next_https_from_list(self) -> str:
-        pass
+    def next_https_from_list(self) -> str: ...
 
-    def next_https_from_cycle(self) -> str:
-        pass
+    def next_https_from_cycle(self) -> str: ...

proxy_reader/proxy.py

@@ -1,78 +1,83 @@
-from typing import Optional, Dict, Any
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict, Optional
+
+if TYPE_CHECKING:
+    from ._types import GeneralDict, ProxyDictT
 
 
 class Proxy:
-    def __init__(self, ip: str, port: str, username: Optional[str] = None, password: Optional[str] = None) -> None:
-        self._ip = ip
-        self._port = port
-        self._username = username
-        self._password = password
+    def __init__(
+        self,
+        proxy: ProxyDictT,
+    ) -> None:
+        self._proxy = proxy
 
     @property
     def ip(self) -> str:
-        return self._ip
+        return self._proxy["host"]
 
     @property
     def port(self) -> str:
-        return self._port
+        return self._proxy["port"]
 
     @property
     def username(self) -> Optional[str]:
-        return self._username
+        return self._proxy["username"]
 
     @property
     def password(self) -> Optional[str]:
-        return self._password
+        return self._proxy["password"]
 
     @property
     def http(self) -> str:
         if self.username and self.password:
-            return f"http://{self._username}:{self._password}@{self._ip}:{self._port}"
-        return f"http://{self._ip}:{self._port}"
+            return f"http://{self.username}:{self.password}@{self.ip}:{self.port}"
+        return f"http://{self.ip}:{self.port}"
 
     @property
     def https(self) -> str:
         if self.username and self.password:
-            return f"https://{self._username}:{self._password}@{self._ip}:{self._port}"
-        return f"https://{self._ip}:{self._port}"
+            return f"https://{self.username}:{self.password}@{self.ip}:{self.port}"
+        return f"https://{self.ip}:{self.port}"
 
     @property
     def telegram_http(self) -> Dict[str, Any]:
-        p = {"proxy_type": 3, "addr": self._ip, "port": int(self._port)}
+        p: GeneralDict = {"proxy_type": 3, "addr": self.ip, "port": int(self.port)}
         if self.username and self.password:
             p.update({"username": self.username, "password": self.password})
         return p
 
     @property
     def telegram_socks5(self) -> Dict[str, Any]:
-        p = {"proxy_type": 2, "addr": self._ip, "port": int(self._port)}
+        p: GeneralDict = {"proxy_type": 2, "addr": self.ip, "port": int(self.port)}
         if self.username and self.password:
             p.update({"username": self.username, "password": self.password})
         return p
 
     @property
     def telegram_socks4(self) -> Dict[str, Any]:
-        p = {"proxy_type": 1, "addr": self._ip, "port": int(self._port)}
+        p: GeneralDict = {"proxy_type": 1, "addr": self.ip, "port": int(self.port)}
         if self.username and self.password:
             p.update({"username": self.username, "password": self.password})
         return p
 
     @property
     def socks5(self) -> str:
-        if self._username is not None and self._password is not None:
-            return f"socks5://{self._username}:{self._password}@{self.ip}:{self.port}"
+        if self.username is not None and self.password is not None:
+            return f"socks5://{self.username}:{self.password}@{self.ip}:{self.port}"
         return f"socks5://{self.ip}:{self.port}"
 
     @property
     def socks4(self) -> str:
-        if self._username is not None and self._password is not None:
-            return f"socks4://{self._username}:{self._password}@{self.ip}:{self.port}"
+        if self.username is not None and self.password is not None:
+            return f"socks4://{self.username}:{self.password}@{self.ip}:{self.port}"
         return f"socks4://{self.ip}:{self.port}"
 
     def __str__(self) -> str:
-        if self._username is not None and self._password is not None:
-            return f"{self._ip}:{self._port}:{self._username}:{self._password}"
-        return f"{self._ip}:{self._port}"
+        if self.username is not None and self.password is not None:
+            return f"{self.ip}:{self.port}:{self.username}:{self.password}"
+        return f"{self.ip}:{self.port}"
 
     def __repr__(self) -> str:
         return self.__str__()

proxy_reader/reader.py

@@ -1,40 +1,54 @@
-import random
-import itertools
-from .proxy import Proxy
-import aiohttp
 import asyncio
-from .logger import logger, console_handler, file_handler
+import itertools
 import os
-from aiohttp_socks import ProxyConnector
+import random
 import sys
-from typing import Optional, List, Dict, Any
-from ._types import ProxiesList, ProxyiesGen
+import tempfile
+import warnings
+from typing import Any
+
+import aiohttp
+from aiohttp_socks import ProxyConnector
+
+from ._types import ProxiesList, ProxyDictT, ProxyiesGen
+from .logs_config import logger
 from .protocols.reader import ProxiesReaderProtocol
+from .proxy import Proxy
+from .utils import parse_proxy_line
 
 
 class ProxiesReader(ProxiesReaderProtocol):
     def __init__(
         self,
-        file_path: str = "proxies.txt",
+        proxies_file: str,
+        check_proxies: bool = False,
+        proxy_checking_threads: int = 50,
+        max_response_time: int = 60,
         shuffle: bool = False,
-        debug: bool = False,
-        extra_debug: bool = False,
     ) -> None:
-        self._file_path = file_path
-        self._debug = debug
-        self._extra_debug = extra_debug
+        self._raw_proxies = open(proxies_file, encoding="utf-8", mode="r").readlines()
 
+        self._check_proxies = check_proxies
         self._shuffle = shuffle
-        self._proxies: ProxiesList = []
-        self._has_auth = False
+        self._proxies_dict_list: list[ProxyDictT] = [
+            parse_proxy_line(p) for p in self._raw_proxies
+        ]
+        self._all_proxies: ProxiesList = [Proxy(p) for p in self._proxies_dict_list]
+
         self._bad_proxies: ProxiesList = []
-        self._working_proxies: ProxiesList = []
-        self._proxies_checked = False
-        self._proxy_iterator: Optional[ProxyiesGen] = None
-        self._proxy_iterator_cycle: Optional[ProxyiesGen] = None
-        self._thread_control: asyncio.Semaphore = asyncio.Semaphore(500)
-        self._max_response_time = 60
+
+        self._working_proxies: ProxiesList = (
+            [] if self._check_proxies else self._all_proxies
+        )
+
+        self._proxy_iterator: ProxyiesGen | None = None
+        self._proxy_iterator_cycle: ProxyiesGen | None = None
+        self._thread_control: asyncio.Semaphore = asyncio.Semaphore(
+            proxy_checking_threads
+        )
+        self._max_response_time = max_response_time
         self._timeout_count = 0
+        self._proxies_checked = False
 
         self._check_urls = [
             # New
@@ -53,17 +67,39 @@ class ProxiesReader(ProxiesReaderProtocol):
             # "http://dog.ceo/api/breeds/image/random",
         ]
 
-        if not self._debug:
-            logger.removeHandler(file_handler)
-            logger.removeHandler(console_handler)
-            try:
-                os.remove(file_handler.baseFilename)
-            except Exception:
-                pass
+    @classmethod
+    def load_list(
+        cls,
+        proxies: list[str],
+        check_proxies: bool = False,
+        proxy_checking_threads: int = 50,
+        max_response_time: int = 60,
+        shuffle: bool = False,
+    ) -> "ProxiesReader":
+        """Load proxies from a list"""
+        proxies_file = tempfile.NamedTemporaryFile(
+            delete=False, suffix=".txt", mode="w+"
+        )
+        try:
+            proxies_file.write("\n".join(proxies))
+            proxies_file.flush()
+            new = cls(
+                proxies_file.name,
+                check_proxies,
+                proxy_checking_threads,
+                max_response_time,
+                shuffle,
+            )
+
+        finally:
+            proxies_file.close()
+            os.unlink(proxies_file.name)
+
+        return new
 
     @property
     def total(self) -> int:
-        return len(self._proxies)
+        return len(self._all_proxies)
 
     @property
     def total_working(self) -> int:
@@ -75,7 +111,7 @@ class ProxiesReader(ProxiesReaderProtocol):
 
     @property
     def proxies(self) -> ProxiesList:
-        return self._proxies
+        return self._all_proxies
 
     @property
     def bad_proxies(self) -> ProxiesList:
@@ -90,54 +126,56 @@ class ProxiesReader(ProxiesReaderProtocol):
         self._working_proxies = working_proxies
 
     def __str__(self) -> str:
-        return str(self._proxies)
+        return str(self._all_proxies)
 
     def __repr__(self) -> str:
         return self.__str__()
 
-    def read_raw(self) -> List[str]:
-        lines = open(self._file_path).readlines()
-        return [line.strip().replace("\n", "") for line in lines]
-
-    def random_url(self) -> str:
+    def _random_proxy_check_url(self) -> str:
         return random.choice(self._check_urls)
 
     def read_with_auth(self) -> None:
         """Format: IP:PORT:USERNAME:PASSWORD"""
-        raw_proxies = self.read_raw()
+        return warnings.warn(
+            "read_with_auth is deprecated. Please don't use it. It's not working ...",
+        )
+        raw_proxies = self._read_raw()
         for proxy in raw_proxies:
             sp_proxy = proxy.split(":")
             ip = sp_proxy[0]
             port = sp_proxy[1]
             username = sp_proxy[2]
             password = sp_proxy[3]
-            self._proxies.append(Proxy(ip, port, username, password))
+            self._all_proxies.append(Proxy(ip, port, username, password))
 
         self._has_auth = True
         if self._shuffle:
-            random.shuffle(self._proxies)
+            random.shuffle(self._all_proxies)
 
     def read_authless(self) -> None:
         """Format: IP:PORT"""
-        raw_proxies = self.read_raw()
+        return warnings.warn(
+            "read_authless is deprecated. Please don't use it. It's not working ..."
+        )
+        raw_proxies = self._read_raw()
         for proxy in raw_proxies:
             sp_proxy = proxy.split(":")
             ip = sp_proxy[0]
             port = sp_proxy[1]
-            self._proxies.append(Proxy(ip, port))
+            self._all_proxies.append(Proxy(ip, port))
         logger.debug(
-            f"Loaded total {len(self._proxies)} proxies from {self._file_path}"
+            f"Loaded total {len(self._all_proxies)} proxies from {self._file_path}"
         )
         if self._shuffle:
-            random.shuffle(self._proxies)
+            random.shuffle(self._all_proxies)
 
     async def _check_proxy(
-        self, proxy: Proxy, response_time: Optional[int] = None
+        self, proxy: Proxy, response_time: int | None = None
     ) -> bool:
         connectins_limit = 60 if "win" in sys.platform else 100
         connector = aiohttp.TCPConnector(limit=connectins_limit)
         session = aiohttp.ClientSession(connector=connector)
-        url = self.random_url()
+        url = self._random_proxy_check_url()
         p = proxy.http
 
         async with self._thread_control:
@@ -156,14 +194,17 @@ class ProxiesReader(ProxiesReaderProtocol):
                 self._timeout_count += 1
                 logger.debug(f"{p} : TIMEOUT {e}. {url}")
                 self._bad_proxies.append(proxy)
+                await connector.close()
                 await session.close()
                 return False
 
             except Exception as e:
-                logger.debug(f"Bad proxy raised. {e}", exc_info=self._extra_debug)
-                await session.close()
+                logger.debug(f"Bad proxy raised. {e}", exc_info=True)
                 return False
 
+            finally:
+                await session.close()
+
             if resp.status == 200:
                 logger.debug(f"{p}: Working")
                 self._working_proxies.append(proxy)
@@ -176,19 +217,19 @@ class ProxiesReader(ProxiesReaderProtocol):
 
     async def check_all_proxies(self, max_resp_time: int = 30) -> None:
         """Run this to check all proxies at once."""
-        tasks: List[asyncio.Task[bool]] = []
-        for proxy in self._proxies:
-            tasks.append(asyncio.create_task(self._check_proxy(proxy, max_resp_time)))
-        await asyncio.gather(*tasks)
-        self._proxies_checked = True
-        logger.debug("All proxies checked.")
+        if self._check_proxies:
+            async with asyncio.TaskGroup() as gp:
+                for proxy in self._all_proxies:
+                    gp.create_task(self._check_proxy(proxy, max_resp_time))
+            self._proxies_checked = True
+            logger.debug("All proxies checked.")
 
     async def _check_proxy_socks(
-        self, proxy: Proxy, response_time: Optional[int] = None
+        self, proxy: Proxy, response_time: int | None = None
     ) -> bool:
-        url = self.random_url()
+        url = self._random_proxy_check_url()
         socks_connector = ProxyConnector.from_url(proxy.socks5)  # type: ignore
-        session = aiohttp.ClientSession(connector=socks_connector)
+        session = aiohttp.ClientSession(connector=socks_connector)  # type: ignore
         logger.debug(f"Checking proxy {proxy} ..")
         try:
             resp = await asyncio.wait_for(session.get(url), timeout=response_time)
@@ -200,7 +241,7 @@ class ProxiesReader(ProxiesReaderProtocol):
             return False
 
         except Exception as e:
-            logger.debug(f"Bad proxy raised. {e}", exc_info=self._extra_debug)
+            logger.debug(f"Bad proxy raised. {e}", exc_info=True)
             await session.close()
             return False
 
@@ -217,8 +258,8 @@ class ProxiesReader(ProxiesReaderProtocol):
 
     async def check_all_proxies_socks5(self, max_resp_time: int = 5) -> None:
         """Run the check on all proxies at once."""
-        tasks: List[asyncio.Task[bool]] = []
-        for proxy in self._proxies:
+        tasks: list[asyncio.Task[bool]] = []
+        for proxy in self._all_proxies:
             tasks.append(
                 asyncio.create_task(self._check_proxy_socks(proxy, max_resp_time))
             )
@@ -226,8 +267,8 @@ class ProxiesReader(ProxiesReaderProtocol):
         self._proxies_checked = True
         logger.debug("All proxies checked.")
 
-    def get_working_proxies_list_http(self) -> List[str]:
-        working_list: List[str] = []
+    def get_working_proxies_list_http(self) -> list[str]:
+        working_list: list[str] = []
         for proxy in self._working_proxies:
             working_list.append(proxy.http)
         return working_list
@@ -239,28 +280,28 @@ class ProxiesReader(ProxiesReaderProtocol):
             f.write("\n".join([proxy.strip() for proxy in working_list]))
         logger.debug(f"Proxies written to: {filename}")
 
-    def get_random_http(self) -> Optional[str]:
+    def get_random_http(self) -> str | None:
         _p = None
         if len(self._working_proxies) > 0:
             proxy = random.choice(self._working_proxies)
             _p = proxy.http
         return _p
 
-    def get_random_socks5(self) -> Optional[str]:
+    def get_random_socks5(self) -> str | None:
         _p = None
         if len(self._working_proxies) > 0:
             proxy = random.choice(self._working_proxies)
             _p = proxy.socks5
         return _p
 
-    def get_random_socks5_telegram(self) -> Optional[Dict[str, Any]]:
+    def get_random_socks5_telegram(self) -> dict[str, Any] | None:
         _p = None
         if len(self._working_proxies) > 0:
             proxy = random.choice(self._working_proxies)
             _p = proxy.telegram_socks5
         return _p
 
-    def next_http_from_list(self) -> Optional[str]:
+    def next_http_from_list(self) -> str | None:
         """Get next proxy from proxies list"""
 
         def __iter() -> ProxyiesGen:
@@ -300,14 +341,14 @@ class ProxiesReader(ProxiesReaderProtocol):
             )
         return str(next(self._proxy_iterator_cycle).socks5)
 
-    def next_http_telegram_from_list(self) -> Dict[str, Any]:
+    def next_http_telegram_from_list(self) -> dict[str, Any]:
         """Get next proxy from proxies list"""
 
         if self._proxy_iterator is None:
             self._proxy_iterator = self.__proxies_gen(self._working_proxies)
         return dict(next(self._proxy_iterator).telegram_http)
 
-    def next_http_telegram_from_cycle(self) -> Dict[str, Any]:
+    def next_http_telegram_from_cycle(self) -> dict[str, Any]:
         """Get next proxy from proxies cycle"""
 
         if self._proxy_iterator is None:
@@ -316,7 +357,7 @@ class ProxiesReader(ProxiesReaderProtocol):
             )
         return dict(next(self._proxy_iterator).telegram_http)
 
-    def next_socks5_telegram_from_cycle(self) -> Dict[str, Any]:
+    def next_socks5_telegram_from_cycle(self) -> dict[str, Any]:
         """Get next proxy from proxies cycle"""
         if self._proxy_iterator_cycle is None:
             self._proxy_iterator_cycle = self.__proxies_gen(
@@ -324,7 +365,7 @@ class ProxiesReader(ProxiesReaderProtocol):
             )
         return dict(next(self._proxy_iterator_cycle).telegram_socks5)
 
-    def next_socks5_telegram_from_list(self) -> Dict[str, Any]:
+    def next_socks5_telegram_from_list(self) -> dict[str, Any]:
         """Get next proxy from proxies cycle"""
 
         if self._proxy_iterator_cycle is None:
@@ -350,7 +391,7 @@ class ProxiesReader(ProxiesReaderProtocol):
         return str(next(self._proxy_iterator_cycle).https)
 
     def __proxies_gen(
-        self, proxies_list: List[Proxy], cycle_proxies: bool = False
+        self, proxies_list: list[Proxy], cycle_proxies: bool = False
     ) -> ProxyiesGen:
         if cycle_proxies:
             for proxy in itertools.cycle(self._working_proxies):

proxy_reader/utils.py

@@ -0,0 +1,36 @@
+import re
+from typing import cast
+
+from ._types import ProxyDictT
+from .logs_config import logger
+
+
+def parse_proxy_line(proxy: str) -> ProxyDictT:
+    """
+    Detects the format of the proxy string and extracts the components.
+
+    Returns a dictionary with 'host', 'port', 'username', and 'password'.
+    """
+    logger.info("Reading the proxy format ...")
+    patterns: list[str] = [
+        # Format 1: IP/Hostname:PORT:USERNAME:PASSWORD
+        r"^(?P<host>[\w\.-]+):(?P<port>\d+):(?P<username>[^:]+):(?P<password>.+)$",
+        # Format 2: USERNAME:PASSWORD:IP/Hostname:PORT
+        r"^(?P<username>[^:]+):(?P<password>[^:]+):(?P<host>[\w\.-]+):(?P<port>\d+)$",
+        # Format 3: http://USERNAME:PASSWORD@IP/Hostname:PORT
+        r"^http:\/\/(?P<username>[^:]+):(?P<password>[^@]+)@(?P<host>[\w\.-]+):(?P<port>\d+)$",
+        # Format 4: USERNAME:PASSWORD@IP/Hostname:PORT
+        r"^(?P<username>[^:]+):(?P<password>[^@]+)@(?P<host>[\w\.-]+):(?P<port>\d+)$",
+        # Format 5: IP/Hostname:PORT (No Username/Password)
+        r"^(?P<host>[\w\.-]+):(?P<port>\d+)$",
+    ]
+
+    for pattern in patterns:
+        match = re.match(pattern, proxy.strip())
+        if match:
+            data = match.groupdict()
+            data.setdefault("username", None)  # Ensure username exists
+            data.setdefault("password", None)  # Ensure password exists
+            return cast(ProxyDictT, data)
+
+    raise ValueError(f"Invalid format: {proxy}")

proxy_reader-2.1.0.dist-info/METADATA

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: proxy-reader
+Version: 2.1.0
+Summary: Proxy reader for Python
+Project-URL: Homepage, https://github.com/runetech0/proxy-reader
+Project-URL: github, https://github.com/runetech0/proxy-reader
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.12.15
+Requires-Dist: aiohttp-socks>=0.10.1
+Requires-Dist: pytest>=8.4.1
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == "test"
+Dynamic: license-file
+
+
+
+
+# proxy-reader - A simple but useful bulk proxies reader and checker.
+
+This is useful when you are working with multiple proxies and want to bulk check
+these proxies before using them.
+It has iterators to iterate the proxies for easy reading.
+
+
+## Installation
+
+```
+pip install proxy-reader
+```
+
+## Changelogs
+
+### [v0.3.0]
+*   Add load_list class method to load proxies from list
+*   MAJOR: auto detect the proxies format
+*   Use new logging config to disable logs and prevent proxy_reader.log from creating
+*   Logs can be enabled from user-side
+*   Add option to disable proxies checking from __init__
+
+
+### [v0.2.0] - 2024-10-21
+
+*   Previous unrecorded changes
+
+
+For more info/queries Telegram: [@runetech](https://t.me/runetech)

proxy_reader-2.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+proxy_reader/__init__.py,sha256=L3-vb_-fS3dfrnunLqTxpqwIOq_ygiV8cKZpfJsXWns,45
+proxy_reader/_types.py,sha256=C285ga4m1KGJ9IREBGzXp6bdOIOm87rJKu2USQ1tZG0,488
+proxy_reader/domains.py,sha256=d4FUb2zw3Kg9bAjtaggEcxZA293WvVcRTgMKKPmYr1A,135662
+proxy_reader/logs_config.py,sha256=SXNDi0op7Bk69qxbVsYajdSAfhhw9eTVVdf6MS2v6Ts,747
+proxy_reader/proxy.py,sha256=THieTNRtZEl86ijK5nFbSqQ030alzkFFU7aSkOPr6JU,2676
+proxy_reader/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+proxy_reader/reader.py,sha256=vlehkoWcgO3QoWBV2X33_HUzCzphfIogaH-Autl-USk,13519
+proxy_reader/utils.py,sha256=LkRUug8Utm-zsje50L3n80V7DPJ8FSHjoyQKEPlUIOY,1451
+proxy_reader/protocols/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+proxy_reader/protocols/reader.py,sha256=UbQKOPhIqRwaGpgN29-zdUs1hYOaBKCyqjgb9gQHrD0,2004
+proxy_reader-2.1.0.dist-info/licenses/LICENSE,sha256=8DyHi9RsZXeM8s1DpaXubZSSG44PkzV2oskJE3E09F4,1081
+proxy_reader-2.1.0.dist-info/METADATA,sha256=gWBCI39LWS5UdC08lSQ8vmyAK0ExnkAJDv_PWNbplDQ,1229
+proxy_reader-2.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+proxy_reader-2.1.0.dist-info/top_level.txt,sha256=NIrKvLf5DF2_oEnj0yg84roFna2-MaJ7zE1jY2CIU0I,13
+proxy_reader-2.1.0.dist-info/RECORD,,

{proxy_reader-0.1.0.dist-info → proxy_reader-2.1.0.dist-info}/WHEEL

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

proxy_reader/logger.py

@@ -1,21 +0,0 @@
-
-
-import logging
-from logging.handlers import RotatingFileHandler
-
-filename = "proxy_reader.log"
-logging_format = logging.Formatter(
-    "%(levelname)s:[%(filename)s:%(lineno)s]:%(asctime)s: %(message)s")
-logger = logging.getLogger(__name__)
-console_handler = logging.StreamHandler()
-console_handler.setFormatter(logging_format)
-file_handler = RotatingFileHandler(filename, mode='a', maxBytes=5 * 1024 * 1024,
-                                   backupCount=2, encoding="utf-8", delay=False)
-file_handler.setFormatter(logging_format)
-
-logger.setLevel(logging.DEBUG)
-file_handler.setLevel(logging.DEBUG)
-console_handler.setLevel(logging.DEBUG)
-
-logger.addHandler(console_handler)
-logger.addHandler(file_handler)

proxy_reader-0.1.0.dist-info/METADATA

@@ -1,33 +0,0 @@
-Metadata-Version: 2.1
-Name: proxy-reader
-Version: 0.1.0
-Summary: Read and check bulk proxies effectively
-Author-email: Rune Tech <runetech2024@gmail.com>
-License: The MIT License (MIT)
-        Copyright © 2024 Rune Tech
-        
-        Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-        
-        The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-        
-        THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-Project-URL: Homepage, https://github.com/runetech0/proxy-reader
-Project-URL: github, https://github.com/runetech0/proxy-reader
-Keywords: proxies,proxy,reader,checker,bulk
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: aiohttp >=3.10.10
-Requires-Dist: aiohttp-socks >=0.9.0
-
-
-
-
-# proxy_reader - A simple but useful bulk proxies reader and checker.
-
-This is useful when you are working with multiple proxies and want to bulk check
-these proxies before using them.
-It has iterators to iterate the proxies for easy reading.
-
-
-## Changelogs

proxy_reader-0.1.0.dist-info/RECORD

@@ -1,14 +0,0 @@
-proxy_reader/__init__.py,sha256=8_HgszorTyU_0OJmvxgimP9S21y07s9R1n_U-wHMwTs,46
-proxy_reader/_types.py,sha256=OWAYiN91E_IWgs1myPy1Q9l-8XkVVq8uDzjLOTB_Eww,317
-proxy_reader/domains.py,sha256=d4FUb2zw3Kg9bAjtaggEcxZA293WvVcRTgMKKPmYr1A,135662
-proxy_reader/logger.py,sha256=BxaHptwZlPPGdx5mbS8vi77u0N-W6cKhcR-5lG2x93c,710
-proxy_reader/proxy.py,sha256=vkI2vonxlm0x0u3Tojq6xKaw5_7fvSbmICW8b_M4lzY,2645
-proxy_reader/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-proxy_reader/reader.py,sha256=KeaAPhxMI6moYaLmzYj7ZGcn8REXWs-1xBMkXuK2Ff0,12373
-proxy_reader/protocols/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-proxy_reader/protocols/reader.py,sha256=WscEXPpKmJuMF2R7EBqDZTheRh8BIUilukojcPRFyRg,2303
-proxy_reader-0.1.0.dist-info/LICENSE,sha256=8DyHi9RsZXeM8s1DpaXubZSSG44PkzV2oskJE3E09F4,1081
-proxy_reader-0.1.0.dist-info/METADATA,sha256=hsWGBfcZrYHMTZWKY_oQEkWBgYzisQ66sWJkt0AM5JI,1892
-proxy_reader-0.1.0.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
-proxy_reader-0.1.0.dist-info/top_level.txt,sha256=NIrKvLf5DF2_oEnj0yg84roFna2-MaJ7zE1jY2CIU0I,13
-proxy_reader-0.1.0.dist-info/RECORD,,