proxycheck-cli 0.1.0__py3-none-any.whl

proxycheck_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: proxycheck-cli
+Version: 0.1.0
+Summary: CLI tool to check HTTP/HTTPS/SOCKS5 proxies — liveness, latency, exit IP, speed, geo, rotation, blacklist
+Author: proxy-checker contributors
+License: MIT
+Project-URL: Homepage, https://github.com/anomalyco/Proxy-checker
+Project-URL: Bug Tracker, https://github.com/anomalyco/Proxy-checker/issues
+Project-URL: Source, https://github.com/anomalyco/Proxy-checker
+Keywords: proxy,checker,socks5,http-proxy,cli
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: Proxy Servers
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx[socks]>=0.27
+Requires-Dist: typer>=0.12
+Requires-Dist: rich>=13
+Requires-Dist: pydantic>=2
+Dynamic: license-file
+
+# proxy-checker
+
+CLI tool to check HTTP/HTTPS/SOCKS5 proxies — liveness, latency, exit IP, speed, geo enrichment, rotation detection, and DNSBL blacklist checks.
+
+![CLI screenshot](https://via.placeholder.com/800x400?text=Screenshot)
+
+## Install
+
+```bash
+pip install proxycheck-cli
+```
+
+Requires Python 3.11+.
+
+## Quick start
+
+```bash
+# Check proxies from file
+proxycheck check proxies.txt
+
+# Single proxy
+proxycheck check http://user:pass@localhost:8888
+
+# With geo, speed & blacklist
+proxycheck check proxies.txt --geo --speed --blacklist
+
+# Export results
+proxycheck check proxies.txt -o results.json -f json
+```
+
+## Options
+
+| Flag | Default | Description |
+|------|---------|-------------|
+| `SOURCE` | (required) | Proxy file path or inline proxy string |
+| `-c`, `--concurrency` | 50 | Concurrent checks |
+| `-t`, `--timeout` | 10 | Request timeout (s) |
+| `--retries` | 1 | Retries per proxy on network error |
+| `--rotations` | — | Rotation mode — makes N requests to detect exit IP changes |
+| `--speed` | off | Measure download speed (Mbps) |
+| `--geo` / `--no-geo` | on | Enrich with country, city, ASN via ip-api.com |
+| `--expect-country` | — | Expected country code (e.g. US, RU) |
+| `--expect-type` | — | Expected proxy type: residential, datacenter, mobile |
+| `--blacklist` | off | Check exit IPs against public DNSBL blacklists |
+| `-o`, `--output` | — | Export path |
+| `-f`, `--format` | table | Output: table, csv, json |
+| `-q`, `--quiet` | off | Only show final summary |
+
+## Metrics per proxy
+
+- **Status** — alive / dead
+- **Latency** — response time in ms
+- **Exit IP** — detected exit IP address
+- **Country / City / ASN** — via ip-api.com (when `--geo`)
+- **Proxy type** — residential, datacenter, mobile (when `--geo`)
+- **Speed** — download speed in Mbps (when `--speed`)
+- **Blacklisted** — status per DNSBL provider (when `--blacklist`)
+- **Matches** — ✓ if exit IP matches expected country/type, ✗ if mismatch
+
+## Input formats
+
+One proxy per line. Comments (`#`) and blank lines are ignored.
+
+```
+host:port
+user:pass@host:port
+http://host:port
+http://user:pass@host:port
+https://host:port
+socks5://host:port
+```
+
+## Privacy
+
+Passwords are masked (`user:***@host:port`) in all output — table, CSV, and JSON.
+
+## DNSBL providers
+
+- `zen.spamhaus.org`
+- `bl.blocklist.de`
+- `dnsbl.dronebl.org`
+
+## Contributing
+
+PRs welcome. Run tests before submitting:
+
+```bash
+pip install -e ".[dev]"
+ruff check
+ruff format --check
+python -m pytest
+```
+
+## License
+
+MIT

proxycheck_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+proxycheck_cli-0.1.0.dist-info/licenses/LICENSE,sha256=noDTdVcAh8fHe3SpxGaodS1Wuc4I1zM6dejbyhN41Oc,1070
+proxychecker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+proxychecker/blacklist.py,sha256=Vodf0pMg-4_Y9E4puHz55mMPIU7TY8Rne2Ywx_W1d5U,1136
+proxychecker/checker.py,sha256=NSSk7uRbT94l8YAlOaz8QRXlj8cX9uaatz2Fs4pM8iY,6389
+proxychecker/cli.py,sha256=yrUgnH04IiaFTdgigpQOERFZvFGGdJGDCwWaPp_YA4A,4895
+proxychecker/enrich.py,sha256=9Tdo1mi4bHgTunL5qFDYt36qypErbLnrPbsQ4fnXBHA,3218
+proxychecker/models.py,sha256=Ar-D7nMMzC7lJnxheMU1dW3NjQvO52w3DXKDSBhZZVI,1528
+proxychecker/parser.py,sha256=fbRpmslmGmWPaUt7KdlUVygIiypVIG1EQaCOul4Vcto,2527
+proxychecker/report.py,sha256=831baiH5id84Nd8ByTzp0rGl95prKG90F15kUwk2va8,6323
+proxychecker/speed.py,sha256=MJGvfbWRXGmIt-yItslZB1MUSIaHWTNfxxcV6frppQQ,1068
+proxycheck_cli-0.1.0.dist-info/METADATA,sha256=sSACk7qHe7aOugqvFRlVv9iX2Qy_xIfUxt5otcJtj7I,3753
+proxycheck_cli-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+proxycheck_cli-0.1.0.dist-info/entry_points.txt,sha256=SV6f0De33CM3A1B8_3Lj3VNE-FE4fpJP1Sx5VVfTLL8,92
+proxycheck_cli-0.1.0.dist-info/top_level.txt,sha256=jgmWwP7qej_AHt_QNZ1PhNUNKd6h-JlVbFDUMYzj37I,13
+proxycheck_cli-0.1.0.dist-info/RECORD,,

proxycheck_cli-0.1.0.dist-info/WHEEL

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

proxycheck_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+proxycheck = proxychecker.cli:main
+proxycheck-cli = proxychecker.cli:main

proxycheck_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 proxy-checker
+
+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.

proxycheck_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+proxychecker

proxychecker/blacklist.py

@@ -0,0 +1,49 @@
+import asyncio
+import socket
+
+DNSBL_PROVIDERS = [
+    "zen.spamhaus.org",
+    "bl.blocklist.de",
+    "dnsbl.dronebl.org",
+]
+
+
+def _ip_to_reversed(ip: str) -> str:
+    return ".".join(reversed(ip.split(".")))
+
+
+def _check_single(ip: str, provider: str) -> bool | None:
+    hostname = f"{_ip_to_reversed(ip)}.{provider}"
+    try:
+        socket.getaddrinfo(hostname, 0)
+        return True
+    except socket.gaierror:
+        return False
+    except OSError:
+        return None
+
+
+async def check_blacklist(
+    ip: str,
+    providers: list[str] | None = None,
+) -> dict[str, bool | None]:
+    if providers is None:
+        providers = DNSBL_PROVIDERS
+
+    result: dict[str, bool | None] = {}
+
+    for provider in providers:
+        listed = await asyncio.to_thread(_check_single, ip, provider)
+        result[provider] = listed
+
+    return result
+
+
+async def check_blacklist_many(
+    ips: list[str],
+    providers: list[str] | None = None,
+) -> dict[str, dict[str, bool | None]]:
+    result: dict[str, dict[str, bool | None]] = {}
+    for ip in ips:
+        result[ip] = await check_blacklist(ip, providers=providers)
+    return result

proxychecker/checker.py

@@ -0,0 +1,195 @@
+import asyncio
+import json
+import time
+from collections import Counter
+from statistics import median
+
+import httpx
+
+from .blacklist import check_blacklist_many
+from .enrich import enrich_ips
+from .models import CheckResult, ParsedProxy, RotationResult
+from .speed import measure_speed
+
+IP_SERVICES = [
+    "https://api.ipify.org?format=json",
+    "https://ifconfig.me/all.json",
+    "https://icanhazip.com",
+]
+
+
+def _extract_ip(text: str) -> str | None:
+    try:
+        data = json.loads(text)
+        if isinstance(data, dict):
+            for key in ("ip", "ip_addr", "remote_host"):
+                if key in data:
+                    return data[key]
+    except (json.JSONDecodeError, TypeError):
+        pass
+    text = text.strip()
+    if text and " " not in text and "\n" not in text:
+        return text
+    return None
+
+
+async def check_single(
+    proxy: ParsedProxy,
+    timeout: float = 10,
+    retries: int = 1,
+    do_speed: bool = False,
+) -> CheckResult:
+    latencies: list[float] = []
+    exit_ip: str | None = None
+    last_error: str | None = None
+    proxy_url = proxy.url
+
+    try:
+        async with httpx.AsyncClient(proxy=proxy_url, timeout=timeout) as client:
+            for service_url in IP_SERVICES:
+                attempt_latencies: list[float] = []
+                for _ in range(1 + retries):
+                    try:
+                        start = time.monotonic()
+                        resp = await client.get(service_url)
+                        elapsed = (time.monotonic() - start) * 1000
+                        if resp.status_code == 200:
+                            ip = _extract_ip(resp.text)
+                            if ip:
+                                exit_ip = ip
+                                attempt_latencies.append(elapsed)
+                                if len(attempt_latencies) >= 3:
+                                    break
+                            else:
+                                last_error = "proxy error: no IP in response"
+                        else:
+                            last_error = f"proxy error: HTTP {resp.status_code}"
+                    except httpx.ProxyError as e:
+                        last_error = f"proxy error: {e}"
+                    except httpx.ConnectError:
+                        last_error = "connection refused"
+                    except httpx.ConnectTimeout:
+                        last_error = "timeout"
+                    except httpx.RemoteProtocolError:
+                        last_error = "protocol error"
+                    except Exception as e:
+                        last_error = str(e)
+
+                if attempt_latencies:
+                    latencies = attempt_latencies
+                    break
+    except Exception as e:
+        last_error = str(e)
+
+    if not latencies:
+        return CheckResult(proxy=proxy, status="dead", error=last_error or "all endpoints failed")
+
+    result = CheckResult(
+        proxy=proxy,
+        status="alive",
+        exit_ip=exit_ip,
+        latency_ms=round(median(latencies), 1),
+    )
+
+    if do_speed:
+        result.speed = await measure_speed(proxy_url)
+
+    return result
+
+
+async def check_many(
+    proxies: list[ParsedProxy],
+    concurrency: int = 50,
+    timeout: float = 10,
+    retries: int = 1,
+    do_speed: bool = False,
+    do_geo: bool = True,
+    do_blacklist: bool = False,
+    expect_country: str | None = None,
+    expect_type: str | None = None,
+    progress_callback=None,
+) -> list[CheckResult]:
+    sem = asyncio.Semaphore(concurrency)
+    collected: list[CheckResult] = []
+
+    async def _check_one(proxy: ParsedProxy) -> CheckResult:
+        async with sem:
+            result = await check_single(proxy, timeout=timeout, retries=retries, do_speed=do_speed)
+            collected.append(result)
+            if progress_callback:
+                progress_callback(result)
+            return result
+
+    tasks = [_check_one(p) for p in proxies]
+    await asyncio.gather(*tasks)
+
+    if do_geo:
+        ips = [r.exit_ip for r in collected if r.exit_ip and r.status == "alive"]
+        if ips:
+            geo_map = await enrich_ips(list(set(ips)))
+            for r in collected:
+                if r.exit_ip and r.exit_ip in geo_map:
+                    r.geo = geo_map[r.exit_ip]
+
+    for r in collected:
+        if r.geo:
+            mismatches = []
+            if expect_country and r.geo.country_code != expect_country:
+                mismatches.append(f"country: expected {expect_country}, got {r.geo.country_code}")
+            if expect_type and r.geo.proxy_type != expect_type:
+                mismatches.append(f"type: expected {expect_type}, got {r.geo.proxy_type}")
+            if mismatches:
+                r.mismatch = True
+                r.mismatch_reason = "; ".join(mismatches)
+
+    if do_blacklist:
+        ips = list({r.exit_ip for r in collected if r.exit_ip and r.status == "alive"})
+        if ips:
+            bl_map = await check_blacklist_many(ips)
+            for r in collected:
+                if r.exit_ip and r.exit_ip in bl_map:
+                    r.blacklist_results = bl_map[r.exit_ip]
+                    r.blacklisted = any(v is True for v in bl_map[r.exit_ip].values())
+
+    return collected
+
+
+async def check_rotation(
+    proxy: ParsedProxy,
+    rotations: int,
+    timeout: float = 10,
+) -> RotationResult:
+    exit_ips: list[str] = []
+    proxy_url = proxy.url
+
+    async with httpx.AsyncClient(proxy=proxy_url, timeout=timeout) as client:
+        for _ in range(rotations):
+            try:
+                resp = await client.get(IP_SERVICES[0])
+                if resp.status_code == 200:
+                    ip = _extract_ip(resp.text)
+                    if ip:
+                        exit_ips.append(ip)
+            except httpx.RequestError:
+                pass
+
+    total_ok = len(exit_ips)
+    unique_ips = len(set(exit_ips))
+    uniqueness_ratio = unique_ips / total_ok if total_ok else 0.0
+    counter = Counter(exit_ips)
+    repeats = sum(1 for v in counter.values() if v > 1)
+
+    if uniqueness_ratio > 0.9:
+        behavior = "rotating"
+    elif uniqueness_ratio < 0.2:
+        behavior = "sticky"
+    else:
+        behavior = "mixed"
+
+    return RotationResult(
+        total_ok=total_ok,
+        unique_ips=unique_ips,
+        uniqueness_ratio=round(uniqueness_ratio, 3),
+        repeats=repeats,
+        behavior=behavior,
+    )

proxychecker/cli.py

@@ -0,0 +1,153 @@
+import asyncio
+
+import typer
+from rich.console import Console
+
+from .checker import check_many, check_rotation
+from .parser import parse_source
+from .report import (
+    export_csv,
+    export_json,
+    make_progress,
+    print_report,
+    print_rotation_report,
+)
+
+app = typer.Typer(
+    name="proxycheck",
+    help="Check HTTP/HTTPS/SOCKS5 proxies — liveness, latency, exit IP.",
+)
+
+console = Console()
+
+
+@app.command("check")
+def check(
+    source: str = typer.Argument(..., help="Path to proxy file or inline proxy string"),
+    concurrency: int = typer.Option(50, "--concurrency", "-c", help="Number of concurrent checks"),
+    timeout: int = typer.Option(10, "--timeout", "-t", help="Request timeout in seconds"),
+    retries: int = typer.Option(
+        1, "--retries", help="Number of retries per proxy on network error"
+    ),
+    rotations: int = typer.Option(
+        None,
+        "--rotations",
+        help="Rotation mode: make N requests per endpoint to detect IP rotation",
+    ),
+    speed: bool = typer.Option(
+        False, "--speed", help="Measure download speed (Mbps) for alive proxies"
+    ),
+    geo: bool = typer.Option(True, "--geo/--no-geo", help="Enrich with country, city, ASN"),
+    expect_country: str = typer.Option(
+        None, "--expect-country", help="Expected country ISO code (e.g. US, RU)"
+    ),
+    expect_type: str = typer.Option(
+        None, "--expect-type", help="Expected proxy type: residential, datacenter, mobile"
+    ),
+    blacklist: bool = typer.Option(
+        False, "--blacklist", help="Check exit IPs against public DNSBL blacklists"
+    ),
+    output: str = typer.Option(None, "--output", "-o", help="Export path for results"),
+    fmt: str = typer.Option("table", "--format", "-f", help="Output format: table, csv, json"),
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="Only show final summary"),
+):
+    """
+    Check proxies for liveness, measure latency, and detect exit IP.
+
+    SOURCE can be a path to a file with one proxy per line, or an inline proxy string.
+
+    \b
+    Examples:
+    proxycheck check proxies.txt
+    proxycheck check http://localhost:8888
+    proxycheck check proxies.txt -c 100 -t 5
+    proxycheck check proxies.txt --speed --geo
+    proxycheck check http://rotating.proxy:8080 --rotations 30
+    proxycheck check proxies.txt -o results.json -f json
+    proxycheck check proxies.txt --expect-country US --expect-type residential
+    proxycheck check proxies.txt --blacklist --geo
+    """
+    proxies, errors = parse_source(source)
+
+    if not proxies:
+        console.print("[red]No valid proxies found.[/red]")
+        raise typer.Exit(1)
+
+    if errors:
+        console.print(f"[yellow]Parse errors ({len(errors)}):[/yellow]")
+        for e in errors:
+            console.print(f"  Line {e.line_number}: {e.reason}")
+        console.print()
+
+    if rotations:
+        if len(proxies) > 1:
+            console.print("[yellow]Rotation mode: only the first proxy will be used.[/yellow]")
+        rotation_result = asyncio.run(
+            check_rotation(proxies[0], rotations=rotations, timeout=timeout)
+        )
+        print_rotation_report(proxies[0].masked(), rotation_result)
+        return
+
+    running_results: list = []
+    progress = None if quiet else make_progress(len(proxies))
+
+    def progress_callback(result):
+        nonlocal running_results
+        running_results.append(result)
+        if progress:
+            progress.update(progress.task_ids[0], advance=1)
+
+    async def run():
+        return await check_many(
+            proxies,
+            concurrency=concurrency,
+            timeout=timeout,
+            retries=retries,
+            do_speed=speed,
+            do_geo=geo,
+            do_blacklist=blacklist,
+            expect_country=expect_country,
+            expect_type=expect_type,
+            progress_callback=progress_callback,
+        )
+
+    results: list = []
+    try:
+        if quiet:
+            results = asyncio.run(run())
+        else:
+            with progress:
+                results = asyncio.run(run())
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Interrupted. Showing partial results...[/yellow]")
+        results = list(running_results)
+        if not results:
+            console.print("No results collected yet.")
+            raise typer.Exit(0)
+
+    if fmt == "csv":
+        out = export_csv(results)
+    elif fmt == "json":
+        out = export_json(results)
+    else:
+        out = None
+
+    if out:
+        if output:
+            with open(output, "w", encoding="utf-8") as f:
+                f.write(out)
+            console.print(f"[green]Exported to {output}[/green]")
+        else:
+            console.print(out)
+    else:
+        print_report(results)
+
+    if output and fmt == "table":
+        print_report(results)
+
+
+def main():
+    import typer.main
+
+    group = typer.main.get_group(app)
+    group.main()

proxychecker/enrich.py

@@ -0,0 +1,113 @@
+import asyncio
+import json
+
+import httpx
+
+from .models import GeoData
+
+BATCH_URL = "http://ip-api.com/batch"
+FIELDS = "status,message,country,countryCode,city,as,org,mobile,proxy,hosting,query"
+BATCH_LIMIT = 100
+RATE_LIMIT = 15  # requests per minute
+MIN_INTERVAL = 60.0 / RATE_LIMIT
+
+
+def _detect_proxy_type(data: dict) -> str:
+    if data.get("hosting"):
+        return "datacenter"
+    if data.get("mobile"):
+        return "mobile"
+    if data.get("proxy"):
+        return "residential"
+    return "residential"
+
+
+def _parse_record(record: dict) -> GeoData | None:
+    if record.get("status") != "success":
+        return None
+    return GeoData(
+        country=record.get("country", "unknown"),
+        country_code=record.get("countryCode", "unknown"),
+        city=record.get("city", "unknown"),
+        org=record.get("org", "unknown"),
+        asn=record.get("as", "unknown"),
+        proxy_type=_detect_proxy_type(record),
+    )
+
+
+async def enrich_ips(
+    ips: list[str],
+    client: httpx.AsyncClient | None = None,
+    semaphore: asyncio.Semaphore | None = None,
+) -> dict[str, GeoData]:
+    if not ips:
+        return {}
+
+    result: dict[str, GeoData] = {}
+    own_client = client is None
+    own_sem = semaphore is None and not own_client
+
+    if own_client:
+        client = httpx.AsyncClient(timeout=10)
+        await client.__aenter__()
+
+    if own_sem:
+        semaphore = asyncio.Semaphore(1)
+
+    try:
+        for i in range(0, len(ips), BATCH_LIMIT):
+            batch = ips[i : i + BATCH_LIMIT]
+            data = await _enrich_batch(batch, client, semaphore)
+            result.update(data)
+    finally:
+        if own_client:
+            await client.__aexit__(None, None, None)
+
+    return result
+
+
+async def _enrich_batch(
+    batch_ips: list[str],
+    client: httpx.AsyncClient,
+    semaphore: asyncio.Semaphore | None,
+) -> dict[str, GeoData]:
+    if semaphore:
+        async with semaphore:
+            return await _do_batch_request(batch_ips, client)
+    return await _do_batch_request(batch_ips, client)
+
+
+async def _do_batch_request(
+    batch_ips: list[str],
+    client: httpx.AsyncClient,
+) -> dict[str, GeoData]:
+    result: dict[str, GeoData] = {}
+    for attempt in range(3):
+        try:
+            resp = await client.post(
+                BATCH_URL,
+                params={"fields": FIELDS},
+                content=json.dumps(batch_ips),
+                headers={"Content-Type": "application/json"},
+            )
+            if resp.status_code == 429:
+                ttl = int(resp.headers.get("X-Ttl", 5))
+                await asyncio.sleep(ttl)
+                continue
+            if resp.status_code != 200:
+                return result
+            records = resp.json()
+            if not isinstance(records, list):
+                return result
+            for record in records:
+                geo = _parse_record(record)
+                ip = record.get("query") or ""
+                if geo and ip:
+                    result[ip] = geo
+            return result
+        except (httpx.RequestError, json.JSONDecodeError):
+            if attempt < 2:
+                await asyncio.sleep(1)
+                continue
+            return result
+    return result

proxychecker/models.py

@@ -0,0 +1,62 @@
+from pydantic import BaseModel
+
+
+class ProxyCredentials(BaseModel):
+    username: str
+    password: str
+
+
+class ParsedProxy(BaseModel):
+    host: str
+    port: int
+    scheme: str = "http"
+    credentials: ProxyCredentials | None = None
+
+    def masked(self) -> str:
+        if self.credentials:
+            return f"{self.credentials.username}:***@{self.host}:{self.port}"
+        return f"{self.host}:{self.port}"
+
+    @property
+    def url(self) -> str:
+        auth = ""
+        if self.credentials:
+            auth = f"{self.credentials.username}:{self.credentials.password}@"
+        return f"{self.scheme}://{auth}{self.host}:{self.port}"
+
+
+class GeoData(BaseModel):
+    country: str = "unknown"
+    country_code: str = "unknown"
+    city: str = "unknown"
+    org: str = "unknown"
+    asn: str = "unknown"
+    proxy_type: str = "unknown"
+
+
+class SpeedResult(BaseModel):
+    bps: float | None = None
+    elapsed_s: float | None = None
+    error: str | None = None
+
+
+class RotationResult(BaseModel):
+    total_ok: int = 0
+    unique_ips: int = 0
+    uniqueness_ratio: float = 0.0
+    repeats: int = 0
+    behavior: str = "unknown"
+
+
+class CheckResult(BaseModel):
+    proxy: ParsedProxy
+    status: str
+    exit_ip: str | None = None
+    latency_ms: float | None = None
+    error: str | None = None
+    geo: GeoData | None = None
+    speed: SpeedResult | None = None
+    mismatch: bool = False
+    mismatch_reason: str | None = None
+    blacklisted: bool = False
+    blacklist_results: dict[str, bool | None] | None = None

proxychecker/parser.py

@@ -0,0 +1,95 @@
+import os
+import re
+from dataclasses import dataclass
+from urllib.parse import urlparse
+
+from .models import ParsedProxy, ProxyCredentials
+
+RE_COLON_FORMAT = re.compile(r"^(.+):(\d+):(.+):(.+)$")
+RE_AT_FORMAT = re.compile(r"^(.+):(.+)@(.+):(\d+)$")
+RE_HOST_PORT = re.compile(r"^(.+):(\d+)$")
+
+
+@dataclass
+class ParseError:
+    line_number: int
+    raw: str
+    reason: str
+
+
+def parse_line(raw: str) -> ParsedProxy | None:
+    stripped = raw.strip()
+    if not stripped or stripped.startswith("#"):
+        return None
+
+    if "://" in stripped:
+        parsed = urlparse(stripped)
+        host = parsed.hostname
+        port = parsed.port
+        if not host or not port:
+            raise ValueError(f"Invalid proxy URL: {stripped}")
+        scheme = parsed.scheme or "http"
+        credentials = None
+        if parsed.username:
+            credentials = ProxyCredentials(
+                username=parsed.username,
+                password=parsed.password or "",
+            )
+        return ParsedProxy(
+            host=host,
+            port=port,
+            scheme=scheme,
+            credentials=credentials,
+        )
+
+    m = RE_AT_FORMAT.match(stripped)
+    if m:
+        return ParsedProxy(
+            host=m.group(3),
+            port=int(m.group(4)),
+            credentials=ProxyCredentials(
+                username=m.group(1),
+                password=m.group(2),
+            ),
+        )
+
+    m = RE_COLON_FORMAT.match(stripped)
+    if m:
+        return ParsedProxy(
+            host=m.group(1),
+            port=int(m.group(2)),
+            credentials=ProxyCredentials(
+                username=m.group(3),
+                password=m.group(4),
+            ),
+        )
+
+    m = RE_HOST_PORT.match(stripped)
+    if m:
+        return ParsedProxy(
+            host=m.group(1),
+            port=int(m.group(2)),
+        )
+
+    raise ValueError(f"Unrecognized format: {stripped}")
+
+
+def parse_source(source: str) -> tuple[list[ParsedProxy], list[ParseError]]:
+    if os.path.isfile(source):
+        with open(source, encoding="utf-8") as f:
+            lines = f.readlines()
+    else:
+        lines = source.split("\n")
+
+    proxies: list[ParsedProxy] = []
+    errors: list[ParseError] = []
+
+    for i, line in enumerate(lines, 1):
+        try:
+            result = parse_line(line)
+            if result is not None:
+                proxies.append(result)
+        except ValueError as e:
+            errors.append(ParseError(line_number=i, raw=line.rstrip("\n\r"), reason=str(e)))
+
+    return proxies, errors

proxychecker/report.py

@@ -0,0 +1,196 @@
+import csv
+import io
+import json
+
+from rich.console import Console
+from rich.progress import BarColumn, Progress, SpinnerColumn, TaskProgressColumn, TextColumn
+from rich.table import Table
+
+from .models import CheckResult, RotationResult, SpeedResult
+
+
+def _alive_style(r: CheckResult) -> str:
+    if r.blacklisted:
+        return "yellow"
+    if r.mismatch:
+        return "yellow"
+    return "green" if r.status == "alive" else "red"
+
+
+def build_table(results: list[CheckResult]) -> Table:
+    table = Table(title="Proxy Check Results")
+    table.add_column("#", style="dim")
+    table.add_column("Proxy")
+    table.add_column("Status")
+    table.add_column("Exit IP")
+    table.add_column("Latency")
+    table.add_column("Speed")
+    table.add_column("Country")
+    table.add_column("Type")
+    table.add_column("Flags")
+
+    for i, r in enumerate(results, 1):
+        latency = f"{r.latency_ms:.0f} ms" if r.latency_ms else "—"
+        speed = _format_speed(r.speed) if r.speed else "—"
+        country = r.geo.country if r.geo else "—"
+        ptype = r.geo.proxy_type if r.geo else "—"
+        flags = ""
+        if r.blacklisted:
+            flags = "blacklisted"
+        elif r.mismatch:
+            flags = "mismatch"
+        elif r.status == "alive":
+            flags = "ok"
+        table.add_row(
+            str(i),
+            r.proxy.masked(),
+            r.status,
+            r.exit_ip or "—",
+            latency,
+            speed,
+            country,
+            ptype,
+            flags,
+            style=_alive_style(r),
+        )
+    return table
+
+
+def _format_speed(speed) -> str:
+    if speed.bps is None:
+        return "—"
+    bps = speed.bps
+    if bps >= 1_000_000:
+        return f"{bps / 1_000_000:.1f} Mbps"
+    if bps >= 1_000:
+        return f"{bps / 1_000:.0f} Kbps"
+    return f"{bps:.0f} bps"
+
+
+def print_rotation_report(
+    proxy_masked: str,
+    rotation: RotationResult,
+):
+    console = Console()
+    console.print(f"\nRotation results for {proxy_masked}")
+    console.print(f"  Successful:   {rotation.total_ok}")
+    console.print(f"  Unique IPs:   {rotation.unique_ips}")
+    console.print(f"  Uniqueness:   {rotation.uniqueness_ratio:.1%}")
+    console.print(f"  Repeats:      {rotation.repeats}")
+    console.print(f"  Behavior:     {rotation.behavior}")
+
+
+def print_report(results: list[CheckResult]):
+    console = Console()
+    table = build_table(results)
+    console.print(table)
+
+    alive = [r for r in results if r.status == "alive"]
+    if alive:
+        latencies = sorted(r.latency_ms for r in alive if r.latency_ms is not None)
+        median_lat = latencies[len(latencies) // 2] if latencies else 0
+        speeds = [r.speed.bps for r in alive if r.speed and r.speed.bps is not None]
+        median_speed = sorted(speeds)[len(speeds) // 2] if speeds else 0
+        mismatches = [r for r in results if r.mismatch]
+        datacenters = [r for r in alive if r.geo and r.geo.proxy_type == "datacenter"]
+
+        console.print(f"\nChecked {len(results)} proxies")
+        pct = len(alive) / len(results) * 100
+        console.print(f"\nAlive:            {len(alive)} / {len(results)} ({pct:.1f}%)")
+        unique_ips = len({r.exit_ip for r in alive if r.exit_ip})
+        console.print(f"Unique exit IPs:  {unique_ips}")
+        if latencies:
+            console.print(f"Median latency:   {median_lat:.0f} ms")
+        if speeds:
+            console.print(f"Median speed:     {_format_speed(SpeedResult(bps=median_speed))}")
+        if mismatches:
+            console.print(f"Geo mismatches:   {len(mismatches)}")
+        if datacenters:
+            console.print(f"Datacenter IPs:   {len(datacenters)}")
+        blacklisted_count = len([r for r in results if r.blacklisted])
+        if blacklisted_count:
+            console.print(f"Blacklisted:      {blacklisted_count}")
+    else:
+        console.print(f"\nAlive: 0 / {len(results)} (0%)")
+
+
+def export_csv(results: list[CheckResult]) -> str:
+    output = io.StringIO()
+    writer = csv.writer(output)
+    writer.writerow(
+        [
+            "proxy",
+            "status",
+            "exit_ip",
+            "latency_ms",
+            "speed_bps",
+            "country",
+            "country_code",
+            "city",
+            "org",
+            "asn",
+            "proxy_type",
+            "mismatch",
+            "mismatch_reason",
+            "blacklisted",
+            "error",
+        ]
+    )
+    for r in results:
+        writer.writerow(
+            [
+                r.proxy.masked(),
+                r.status,
+                r.exit_ip or "",
+                r.latency_ms or "",
+                r.speed.bps if r.speed and r.speed.bps else "",
+                r.geo.country if r.geo else "",
+                r.geo.country_code if r.geo else "",
+                r.geo.city if r.geo else "",
+                r.geo.org if r.geo else "",
+                r.geo.asn if r.geo else "",
+                r.geo.proxy_type if r.geo else "",
+                "yes" if r.mismatch else "",
+                r.mismatch_reason or "",
+                "yes" if r.blacklisted else "",
+                r.error or "",
+            ]
+        )
+    return output.getvalue()
+
+
+def export_json(results: list[CheckResult]) -> str:
+    data = []
+    for r in results:
+        entry = {
+            "proxy": r.proxy.masked(),
+            "status": r.status,
+            "exit_ip": r.exit_ip,
+            "latency_ms": r.latency_ms,
+            "error": r.error,
+        }
+        if r.geo:
+            entry["geo"] = r.geo.model_dump()
+        if r.speed and r.speed.bps:
+            entry["speed_bps"] = r.speed.bps
+        if r.mismatch:
+            entry["mismatch"] = True
+            entry["mismatch_reason"] = r.mismatch_reason
+        if r.blacklisted:
+            entry["blacklisted"] = True
+            entry["blacklist_providers"] = [
+                k for k, v in (r.blacklist_results or {}).items() if v is True
+            ]
+        data.append(entry)
+    return json.dumps(data, indent=2, ensure_ascii=False)
+
+
+def make_progress(total: int) -> Progress:
+    progress = Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TaskProgressColumn(),
+    )
+    progress.add_task("Checking proxies...", total=total)
+    return progress

proxychecker/speed.py

@@ -0,0 +1,33 @@
+import time
+
+import httpx
+
+from .models import SpeedResult
+
+SPEED_TEST_URL = "http://speedtest.tele2.net/1MB.zip"
+SPEED_TIMEOUT = 30
+
+
+async def measure_speed(
+    proxy_url: str,
+    timeout: float = SPEED_TIMEOUT,
+) -> SpeedResult:
+    try:
+        async with httpx.AsyncClient(proxy=proxy_url, timeout=timeout) as client:
+            start = time.monotonic()
+            resp = await client.get(SPEED_TEST_URL)
+            elapsed = time.monotonic() - start
+            if resp.status_code != 200:
+                return SpeedResult(error=f"HTTP {resp.status_code}")
+            data = resp.content
+            bits = len(data) * 8
+            bps = bits / elapsed
+            return SpeedResult(bps=round(bps, 0), elapsed_s=round(elapsed, 2))
+    except httpx.TimeoutException:
+        return SpeedResult(error="timeout")
+    except httpx.ProxyError as e:
+        return SpeedResult(error=f"proxy error: {e}")
+    except httpx.ConnectError:
+        return SpeedResult(error="connection refused")
+    except Exception as e:
+        return SpeedResult(error=str(e))