subscription-2vless 1.0.0__tar.gz

subscription_2vless-1.0.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: subscription-2vless
+Version: 1.0.0
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: httpx<1,>=0.28.1
+
+# subscription-2vless

subscription_2vless-1.0.0/README.md

@@ -0,0 +1 @@
+# subscription-2vless

subscription_2vless-1.0.0/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "subscription-2vless"
+version = "1.0.0"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "httpx>=0.28.1,<1"
+]
+
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project.scripts]
+subscription-2vless = "subscription_2vless.cli:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+include = ["subscription_2vless*"]

subscription_2vless-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

subscription_2vless-1.0.0/src/subscription_2vless/__init__.py

@@ -0,0 +1,39 @@
+from subscription_2vless.schemas import (
+    Http,
+    Https,
+    Hysteria,
+    Hysteria2,
+    Shadowsocks,
+    ShadowsocksR,
+    Socks,
+    Trojan,
+    Tuic,
+    Vless,
+    Vmess,
+    VPNType,
+    WireGuard,
+    parse_type_link,
+)
+from subscription_2vless.subscription import (
+    SubscriptionHeaders,
+    get_vpn_links_from_subscription,
+)
+
+__all__ = [
+    "Http",
+    "Https",
+    "Hysteria",
+    "Hysteria2",
+    "Shadowsocks",
+    "ShadowsocksR",
+    "Socks",
+    "SubscriptionHeaders",
+    "Trojan",
+    "Tuic",
+    "VPNType",
+    "Vless",
+    "Vmess",
+    "WireGuard",
+    "get_vpn_links_from_subscription",
+    "parse_type_link",
+]

subscription_2vless-1.0.0/src/subscription_2vless/cli.py

@@ -0,0 +1,140 @@
+import argparse
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+
+import httpx
+
+from subscription_2vless.subscription import get_vpn_links_from_subscription
+
+_DEFAULT_OUTPUT_FILE = Path("links.txt")
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="subscription-2vless",
+        description=(
+            "Fetch a VPN subscription, display all supported connection URLs, "
+            "and optionally save them to a text file"
+        ),
+    )
+    parser.add_argument(
+        "url",
+        nargs="?",
+        help="Subscription URL. If omitted, the CLI asks for it interactively",
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        type=Path,
+        metavar="FILE",
+        help="Save all discovered URLs to FILE without asking for a filename",
+    )
+    parser.add_argument(
+        "--no-save",
+        action="store_true",
+        help="Do not offer to save the discovered URLs",
+    )
+    parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Overwrite the output file if it already exists (requires --output)",
+    )
+    return parser
+
+
+def _ask_to_save() -> bool:
+    try:
+        answer = input("\nSave all URLs to a file? [y/N]: ").strip().casefold()
+    except EOFError:
+        return False
+    return answer in {"y", "yes"}
+
+
+def _ask_for_output_path() -> Path | None:
+    try:
+        value = input(f"Output file [{_DEFAULT_OUTPUT_FILE}]: ").strip()
+    except EOFError:
+        return None
+    return Path(value) if value else _DEFAULT_OUTPUT_FILE
+
+
+def _write_urls(urls: Sequence[str], output: Path, *, force: bool) -> int:
+    if output.exists() and not force:
+        try:
+            answer = (
+                input(f"File '{output}' already exists. Overwrite it? [y/N]: ")
+                .strip()
+                .casefold()
+            )
+        except EOFError:
+            answer = ""
+        if answer not in {"y", "yes"}:
+            print("File was not changed.")
+            return 0
+
+    try:
+        output.write_text("\n".join(urls) + "\n", encoding="utf-8")
+    except OSError as exc:
+        print(f"Could not write '{output}': {exc}", file=sys.stderr)
+        return 1
+
+    print(f"Saved {len(urls)} URL(s) to '{output}'.")
+    return 0
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+
+    if args.force and args.output is None:
+        parser.error("--force can only be used together with --output")
+    if args.no_save and args.output is not None:
+        parser.error("--no-save cannot be used together with --output")
+
+    url = args.url
+    if url is None:
+        try:
+            url = input("Subscription URL: ").strip()
+        except EOFError:
+            url = ""
+
+    if not url:
+        print("A subscription URL is required.", file=sys.stderr)
+        return 2
+
+    print("Fetching subscription...")
+    try:
+        links = get_vpn_links_from_subscription(url)
+    except (httpx.HTTPError, httpx.InvalidURL, ValueError, UnicodeError) as exc:
+        print(f"Failed to fetch or parse the subscription: {exc}", file=sys.stderr)
+        return 1
+
+    if not links:
+        print("No supported VPN URLs were found.")
+        return 0
+
+    urls = [str(link) for link in links]
+    print(f"\nFound {len(urls)} VPN URL(s):\n")
+    for index, item in enumerate(urls, start=1):
+        print(f"{index:>3}. {item}")
+
+    if args.no_save:
+        return 0
+
+    if args.output is not None:
+        return _write_urls(urls, args.output, force=args.force)
+
+    if not _ask_to_save():
+        print("No file was created.")
+        return 0
+
+    output = _ask_for_output_path()
+    if output is None:
+        print("No file was created.")
+        return 0
+    return _write_urls(urls, output, force=False)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

subscription_2vless-1.0.0/src/subscription_2vless/schemas.py

@@ -0,0 +1,128 @@
+import base64
+import json
+from typing import Any, ClassVar, Self
+
+
+class VPNType(str):
+    schemes: ClassVar[tuple[str, ...]] = ()
+
+    def __new__(cls, value: str) -> Self:
+        value = value.strip()
+        scheme, separator, _ = value.partition("://")
+        if not separator:
+            raise ValueError(f"Missing URL scheme: {value[:30]!r}")
+        if scheme.lower() not in cls.schemes:
+            raise ValueError(f"{cls.__name__}: unsupported scheme {scheme!r}")
+        return super().__new__(cls, value)
+
+    @property
+    def scheme(self) -> str:
+        return str(self).partition("://")[0].lower()
+
+    @property
+    def fragment(self) -> str:
+        return str(self).partition("#")[2]
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}({str.__repr__(self)})"
+
+
+class Vless(VPNType):
+    schemes = ("vless",)
+
+
+class Vmess(VPNType):
+    schemes = ("vmess",)
+
+    @property
+    def payload(self) -> dict[str, Any]:
+        encoded = str(self)[8:].partition("#")[0]
+        encoded += "=" * (-len(encoded) % 4)
+        payload = json.loads(base64.urlsafe_b64decode(encoded))
+        if not isinstance(payload, dict):
+            raise TypeError("VMess payload must be a JSON object")
+        return payload
+
+
+class Shadowsocks(VPNType):
+    schemes = ("ss",)
+
+    @property
+    def method_and_password(self) -> tuple[str, str]:
+        body = str(self)[5:].partition("#")[0]
+        encoded, separator, _ = body.partition("@")
+        if not separator:
+            encoded = body
+        encoded += "=" * (-len(encoded) % 4)
+        decoded = base64.urlsafe_b64decode(encoded).decode().partition("@")[0]
+        method, separator, password = decoded.partition(":")
+        if not separator:
+            raise ValueError("SS payload is missing the method:password separator")
+        return method, password
+
+
+class ShadowsocksR(VPNType):
+    schemes = ("ssr",)
+
+
+class Trojan(VPNType):
+    schemes = ("trojan",)
+
+
+class Hysteria(VPNType):
+    schemes = ("hysteria",)
+
+
+class Hysteria2(VPNType):
+    schemes = ("hysteria2", "hy2")
+
+
+class Tuic(VPNType):
+    schemes = ("tuic",)
+
+
+class WireGuard(VPNType):
+    schemes = ("wireguard", "wg")
+
+
+class Socks(VPNType):
+    schemes = ("socks", "socks4", "socks5")
+
+
+class Http(VPNType):
+    schemes = ("http",)
+
+
+class Https(VPNType):
+    schemes = ("https",)
+
+
+_REGISTRY = {
+    scheme: cls
+    for cls in (
+        Vless,
+        Vmess,
+        Shadowsocks,
+        ShadowsocksR,
+        Trojan,
+        Hysteria,
+        Hysteria2,
+        Tuic,
+        WireGuard,
+        Socks,
+        Http,
+        Https,
+    )
+    for scheme in cls.schemes
+}
+
+
+def parse_type_link(value: str) -> VPNType:
+    value = value.strip()
+    scheme, separator, _ = value.partition("://")
+    if not separator:
+        raise ValueError(f"Not a valid connection URL: {value[:30]!r}")
+    try:
+        return _REGISTRY[scheme.lower()](value)
+    except KeyError:
+        raise ValueError(f"Unknown protocol: {scheme!r}") from None

subscription_2vless-1.0.0/src/subscription_2vless/subscription.py

@@ -0,0 +1,48 @@
+import base64
+import binascii
+import uuid
+
+import httpx
+from httpx import Headers
+
+from subscription_2vless.schemas import VPNType, parse_type_link
+
+
+class SubscriptionHeaders(Headers):
+    def __init__(
+        self,
+        *,
+        HWID: str | None = None,
+        user_agent: str = "Incy/1.2.0 (Android; 14)",
+    ) -> None:
+        super().__init__(
+            {
+                "X-HWID": HWID or str(uuid.uuid4()),
+                "User-Agent": user_agent,
+            }
+        )
+
+
+def get_vpn_links_from_subscription(
+    url: str,
+    headers: SubscriptionHeaders | None = None,
+) -> list[VPNType]:
+    request_headers = headers if headers else SubscriptionHeaders()
+    with httpx.Client(timeout=10.0, follow_redirects=True) as session:
+        response = session.get(str(url), headers=request_headers)
+
+    response.raise_for_status()
+    content = response.content
+
+    try:
+        text = base64.b64decode(content, validate=True).decode()
+    except (binascii.Error, UnicodeDecodeError):
+        text = content.decode()
+
+    links = []
+    for item in text.split():
+        try:
+            links.append(parse_type_link(item))
+        except ValueError:
+            pass
+    return links

subscription_2vless-1.0.0/src/subscription_2vless.egg-info/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: subscription-2vless
+Version: 1.0.0
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: httpx<1,>=0.28.1
+
+# subscription-2vless

subscription_2vless-1.0.0/src/subscription_2vless.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+src/subscription_2vless/__init__.py
+src/subscription_2vless/cli.py
+src/subscription_2vless/schemas.py
+src/subscription_2vless/subscription.py
+src/subscription_2vless.egg-info/PKG-INFO
+src/subscription_2vless.egg-info/SOURCES.txt
+src/subscription_2vless.egg-info/dependency_links.txt
+src/subscription_2vless.egg-info/entry_points.txt
+src/subscription_2vless.egg-info/requires.txt
+src/subscription_2vless.egg-info/top_level.txt

subscription_2vless-1.0.0/src/subscription_2vless.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

subscription_2vless-1.0.0/src/subscription_2vless.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+subscription-2vless = subscription_2vless.cli:main

subscription_2vless-1.0.0/src/subscription_2vless.egg-info/requires.txt

@@ -0,0 +1 @@
+httpx<1,>=0.28.1

subscription_2vless-1.0.0/src/subscription_2vless.egg-info/top_level.txt

@@ -0,0 +1 @@
+subscription_2vless