proxy-reader 0.1.0__tar.gz → 2.0.0__tar.gz

{proxy_reader-0.1.0/proxy_reader.egg-info → proxy_reader-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: proxy-reader
-Version: 0.1.0
+Version: 2.0.0
 Summary: Read and check bulk proxies effectively
 Author-email: Rune Tech <runetech2024@gmail.com>
 License: The MIT License (MIT)
@@ -23,11 +23,32 @@ Requires-Dist: aiohttp_socks>=0.9.0
 
 
 
-# proxy_reader - A simple but useful bulk proxies reader and checker.
+# 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.0.0/README.md

@@ -0,0 +1,32 @@
+
+
+
+# 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-0.1.0 → proxy_reader-2.0.0}/proxy_reader/__init__.py

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

{proxy_reader-0.1.0 → proxy_reader-2.0.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-2.0.0/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-2.0.0/proxy_reader/protocols/reader.py

@@ -0,0 +1,74 @@
+from typing import List, Optional, Dict, Any, Protocol
+from .._types import ProxiesList
+from ..proxy import Proxy
+
+
+class ProxiesReaderProtocol(Protocol):
+    @property
+    def total(self) -> int: ...
+
+    @property
+    def total_working(self) -> int: ...
+
+    @property
+    def total_bad(self) -> int: ...
+
+    @property
+    def proxies(self) -> ProxiesList: ...
+
+    @property
+    def bad_proxies(self) -> ProxiesList: ...
+
+    @property
+    def working_proxies(self) -> ProxiesList: ...
+
+    @working_proxies.setter
+    def working_proxies(self, working_proxies: List[Proxy]) -> None: ...
+
+    def _random_proxy_check_url(self) -> str: ...
+
+    def read_with_auth(self) -> None: ...
+
+    def read_authless(self) -> None: ...
+
+    async def _check_proxy(
+        self, proxy: Proxy, response_time: Optional[int] = None
+    ) -> bool: ...
+
+    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: ...
+
+    async def check_all_proxies_socks5(self, max_resp_time: int = 5) -> None: ...
+
+    def get_working_proxies_list_http(self) -> List[str]: ...
+
+    def write_working_proxies(self, filename: str) -> None: ...
+
+    def get_random_http(self) -> Optional[str]: ...
+
+    def get_random_socks5(self) -> Optional[str]: ...
+
+    def get_random_socks5_telegram(self) -> Optional[Dict[str, Any]]: ...
+
+    def next_http_from_list(self) -> Optional[str]: ...
+
+    def next_http_from_cycle(self) -> str: ...
+
+    def next_socks5_from_list(self) -> str: ...
+
+    def next_socks5_from_cycle(self) -> str: ...
+
+    def next_http_telegram_from_list(self) -> Dict[str, Any]: ...
+
+    def next_http_telegram_from_cycle(self) -> Dict[str, Any]: ...
+
+    def next_socks5_telegram_from_cycle(self) -> Dict[str, Any]: ...
+
+    def next_socks5_telegram_from_list(self) -> Dict[str, Any]: ...
+
+    def next_https_from_list(self) -> str: ...
+
+    def next_https_from_cycle(self) -> str: ...

proxy_reader-2.0.0/proxy_reader/proxy.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional, Dict, Any
+
+
+if TYPE_CHECKING:
+    from ._types import GeneralDict, ProxyDictT
+
+
+class Proxy:
+    def __init__(
+        self,
+        proxy: ProxyDictT,
+    ) -> None:
+        self._proxy = proxy
+
+    @property
+    def ip(self) -> str:
+        return self._proxy["host"]
+
+    @property
+    def port(self) -> str:
+        return self._proxy["port"]
+
+    @property
+    def username(self) -> Optional[str]:
+        return self._proxy["username"]
+
+    @property
+    def password(self) -> Optional[str]:
+        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}"
+
+    @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}"
+
+    @property
+    def telegram_http(self) -> Dict[str, Any]:
+        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: 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: 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}"
+        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}"
+        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}"
+
+    def __repr__(self) -> str:
+        return self.__str__()

{proxy_reader-0.1.0 → proxy_reader-2.0.0}/proxy_reader/reader.py

@@ -1,40 +1,52 @@
+import os
 import random
 import itertools
+import tempfile
+import warnings
+from .utils import parse_proxy_line
 from .proxy import Proxy
 import aiohttp
 import asyncio
-from .logger import logger, console_handler, file_handler
-import os
+from .logs_config import logger
 from aiohttp_socks import ProxyConnector
 import sys
 from typing import Optional, List, Dict, Any
-from ._types import ProxiesList, ProxyiesGen
+from ._types import ProxiesList, ProxyDictT, ProxyiesGen
 from .protocols.reader import ProxiesReaderProtocol
 
 
 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._working_proxies: ProxiesList = (
+            [] if self._check_proxies else self._all_proxies
+        )
+
         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._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 +65,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 +109,7 @@ class ProxiesReader(ProxiesReaderProtocol):
 
     @property
     def proxies(self) -> ProxiesList:
-        return self._proxies
+        return self._all_proxies
 
     @property
     def bad_proxies(self) -> ProxiesList:
@@ -90,46 +124,48 @@ 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
@@ -137,7 +173,7 @@ class ProxiesReader(ProxiesReaderProtocol):
         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 +192,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 +215,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
     ) -> 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 +239,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
 
@@ -218,7 +257,7 @@ 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:
+        for proxy in self._all_proxies:
             tasks.append(
                 asyncio.create_task(self._check_proxy_socks(proxy, max_resp_time))
             )

proxy_reader-2.0.0/proxy_reader/utils.py

@@ -0,0 +1,35 @@
+from ._types import ProxyDictT
+import re
+from typing import cast
+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 'ip_or_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<ip_or_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-0.1.0 → proxy_reader-2.0.0/proxy_reader.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: proxy-reader
-Version: 0.1.0
+Version: 2.0.0
 Summary: Read and check bulk proxies effectively
 Author-email: Rune Tech <runetech2024@gmail.com>
 License: The MIT License (MIT)
@@ -23,11 +23,32 @@ Requires-Dist: aiohttp_socks>=0.9.0
 
 
 
-# proxy_reader - A simple but useful bulk proxies reader and checker.
+# 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-0.1.0 → proxy_reader-2.0.0}/proxy_reader.egg-info/SOURCES.txt

@@ -5,10 +5,11 @@ pyproject.toml
 proxy_reader/__init__.py
 proxy_reader/_types.py
 proxy_reader/domains.py
-proxy_reader/logger.py
+proxy_reader/logs_config.py
 proxy_reader/proxy.py
 proxy_reader/py.typed
 proxy_reader/reader.py
+proxy_reader/utils.py
 proxy_reader.egg-info/PKG-INFO
 proxy_reader.egg-info/SOURCES.txt
 proxy_reader.egg-info/dependency_links.txt

{proxy_reader-0.1.0 → proxy_reader-2.0.0}/pyproject.toml

@@ -9,7 +9,7 @@ build-backend = "setuptools.build_meta"
 [project]
 
 name = "proxy-reader"
-version = "0.1.0"
+version = "2.0.0"
 description = "Read and check bulk proxies effectively"
 authors = [
     {name = "Rune Tech", email = "runetech2024@gmail.com"}
@@ -33,7 +33,7 @@ github = "https://github.com/runetech0/proxy-reader"
 
 [tool.bumpver]
 
-current_version = "0.1.0"
+current_version = "2.0.0"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message = "bump version {old_version} -> {new_version}"
 tag_message = "{new_version}"

proxy_reader-0.1.0/README.md

@@ -1,11 +0,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/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/proxy_reader/protocols/reader.py

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

proxy_reader-0.1.0/proxy_reader/proxy.py

@@ -1,78 +0,0 @@
-from typing import Optional, Dict, Any
-
-
-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
-
-    @property
-    def ip(self) -> str:
-        return self._ip
-
-    @property
-    def port(self) -> str:
-        return self._port
-
-    @property
-    def username(self) -> Optional[str]:
-        return self._username
-
-    @property
-    def password(self) -> Optional[str]:
-        return self._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}"
-
-    @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}"
-
-    @property
-    def telegram_http(self) -> Dict[str, Any]:
-        p = {"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)}
-        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)}
-        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}"
-        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}"
-        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}"
-
-    def __repr__(self) -> str:
-        return self.__str__()