Add files via upload

Author: arshiacomplus

examples/03_stats_viewer.py

@@ -14,7 +14,7 @@ def main():
     * Demonstrates how to run Xray with the API enabled and fetch live stats.
     """
     # ! Replace with your own REAL and WORKING VLESS URI
-    vless_uri = "vless://8b63cf90-830c-4fd8-a911-9e84fd7a5898@172.67.74.104:443?path=%2F%3FJoin---i10VPN---Join---i10VPN---Join---i10VPN---Join---i10VPN%3Fed%3D512&security=tls&encryption=none&alpn=http%2F1.1&host=s.s.google.com.b5r.ir.&fp=chrome&type=ws&sni=b5r.ir#%40i10VPN+%F0%9F%9A%80%7C+%D8%A8%D8%A7+%D9%85%D8%A7+%D9%85%D8%AA%D8%B5%D9%84+%D8%A8%D9%85%D9%88%D9%86%E2%9A%A1"
+    vless_uri = "vless://"
 
     if "YOUR_UUID" in vless_uri:
         print("! Please replace the placeholder URI in the script with your own to run this demo.")

examples/04_connection_tester.py

@@ -29,18 +29,14 @@ def main():
 
 
     test_uris = [
-        "vless://8b63cf90-830c-4fd8-a911-9e84fd7a5898@172.67.74.104:443?path=%2F%3FJoin---i10VPN---Join---i10VPN---Join---i10VPN---Join---i10VPN%3Fed%3D512&security=tls&encryption=none&alpn=http%2F1.1&host=s.s.google.com.b5r.ir.&fp=chrome&type=ws&sni=b5r.ir#vless",
-        "hy2://dongtaiwang.com@208.87.243.187:22222/?insecure=1&sni=www.bing.com#hy2",
-        "hy2://dongtaiwang.com@51.159.111.32:5355/?insecure=1&sni=www.bing.com#hy2",
-        "hy2://7GEEGxAfgQaVPQX0PGk7lIuj3I@158.41.110.234:10820/?insecure=1&sni=bing.com#hy2",
-        "vmess://eyJhZGQiOiI0NS4xMjguNTQuODQiLCJhaWQiOiIwIiwiYWxwbiI6IiIsImVjaENvbmZpZ0xpc3QiOiIiLCJlY2hGb3JjZVF1ZXJ5IjoiIiwiZWNoU2VydmVyS2V5cyI6IiIsImZha2Vob3N0X2RvbWFpbiI6IiIsImZwIjoiIiwiaG9zdCI6IiIsImlkIjoiNzJmZWI4MzMtNDE5Ni00YTcwLWEzZjUtYWViMDExZjdkNTM0IiwiaW50ZXJ2YWwiOiIiLCJsZW5ndGgiOiIiLCJtdXgiOiIiLCJtdXhDb25jdXJyZW5jeSI6IiIsIm5ldCI6InRjcCIsInBhY2tldHMiOiIiLCJwYXRoIjoiIiwicG9ydCI6IjM3MzEzIiwicHMiOiIwODQg4pyC77iPLfCfh6bwn4e/QVotKEBHaGV5Y2hpQW1vb3plc2gpIiwic2N5IjoiYXV0byIsInNuaSI6IiIsInRscyI6IiIsInR5cGUiOiJub25lIiwidiI6IjIifQ==",
-        "trojan://2ee85121-31de-4581-a492-eb00f606e392@198.46.152.83:443?mux=&security=tls&headerType=none&type=tcp&muxConcurrency=-1&sni=sj3.freeguard.org#trojan",
-        "ss://Y2hhY2hhMjAtaWV0Zi1wb2x5MTMwNTpmOGY3YUN6Y1BLYnNGOHAz@185.213.23.226:990#ss",
+        "vless:///"
         # ... Add your other real URIs here ...
     ]
 
-    fragment_settings = { "packets": "tlshello", "length": "10-30", "interval": "1-5"}
-
+    fragment_settings = { "packets": "tlshello", "length": "10-20", "interval": "10-20"}
+    # mux_settings = {"enabled": True, "concurrency": 8} # ! It's better to be flase
+    fragment_settings= None
+    mux_settings = None
     print("* Parsing all URIs...")
     parsed_configs = [p for p in (parse_uri(uri) for uri in test_uris) if p]
 
@@ -52,8 +48,11 @@ def main():
 
     tester = ConnectionTester(vendor_path=str(vendor_dir), core_engine_path=str(core_engine_dir))
 
-    results = tester.test_uris(parsed_configs, fragment_config=fragment_settings)
-
+    results = tester.test_uris(
+        parsed_params=parsed_configs,
+        fragment_config=fragment_settings,
+        mux_config=mux_settings
+    )
     print("\n" + "="*20 + " TEST RESULTS " + "="*20)
     if results:
         sorted_results = sorted(results, key=lambda x: x.get('ping_ms', 9999))

pyproject.toml

@@ -4,24 +4,39 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python_v2ray"
-version = "0.0.1"
+version = "0.1.0"
 authors = [
-  { name="Your Name", email="you@example.com" },
+  { name="Arshia", email="arshiacomplus@gmail.com" },
 ]
-description = "A powerful, high-level Python wrapper for V2Ray/Xray-core."
+description = "A powerful, high-level Python wrapper for managing and testing V2Ray/Xray-core and Hysteria clients."
 readme = "README.md"
+license = { file = "LICENSE" } 
 requires-python = ">=3.8"
+keywords = ["v2ray", "xray", "hysteria", "proxy", "tester", "api", "wrapper"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Developers",
+    "Topic :: Internet :: Proxy Servers",
+    "Topic :: System :: Networking",
+]
+
 dependencies = [
-    "grpcio",
-    "grpcio-tools",
     "requests",
+    "grpcio",
+    "protobuf",
 ]
 
 [project.urls]
 "Homepage" = "https://github.com/arshiacomplus/python_v2ray"
 "Bug Tracker" = "https://github.com/arshiacomplus/python_v2ray/issues"
 
-[tool.setuptools.packages.find]
-where = ["."]
-include = ["python_v2ray*"]
-exclude = ["examples*", "tests*", "core_engine*", "vendor*"]
+[tool.setuptools]
+packages = ["python_v2ray", "python_v2ray.protos.app.stats.command"]
+
+[tool.setuptools.package-data]
+python_v2ray = [
+    "vendor/*",
+    "core_engine/*",
+]

python_v2ray/config_parser.py

@@ -60,6 +60,14 @@ class ConfigParams:
     hy2_obfs: Optional[str] = ""
     hy2_obfs_password: Optional[str] = ""
 
+    # * Mvless Extra Fields
+    mux_enabled: bool = False
+    mux_concurrency: int = 8
+    fragment_enabled: bool = False
+    fragment_packets: Optional[str] = ""
+    fragment_length: Optional[str] = ""
+    fragment_interval: Optional[str] = ""
+
 
 def _parse_query_params(query: str) -> Dict[str, str]:
     """* A utility to parse URL query parameters into a dictionary."""
@@ -83,7 +91,7 @@ def parse_uri(config_uri: str) -> Optional[ConfigParams]:
                 return None
 
         parser_map = {
-            "vless": _parse_vless, "vmess": _parse_vmess, "trojan": _parse_trojan,
+            "vless": _parse_vless, "mvless": _parse_vless, "vmess": _parse_vmess, "trojan": _parse_trojan,
             "ss": _parse_shadowsocks, "socks": _parse_socks, "wireguard": _parse_wireguard,
             "hysteria": _parse_hysteria, "hysteria2": _parse_hysteria, "hy2": _parse_hysteria,
         }
@@ -102,8 +110,10 @@ def parse_uri(config_uri: str) -> Optional[ConfigParams]:
         elif protocol != 'vmess':
             print(f"! Could not extract host/port from URI. Skipping: {uri[:40]}...")
             return None
-
-        return parser(uri, common)
+        params = parser(uri, common)
+        if protocol == "mvless" and params:
+            _parse_mvless_extensions(params, uri)
+        return params
 
     except Exception as e:
         print(f"! CRITICAL ERROR while parsing URI '{config_uri[:30]}...': {e}")
@@ -122,6 +132,25 @@ def _parse_vless(uri: str, common: dict) -> ConfigParams:
         fp=params.get("fp", ""), alpn=params.get("alpn", ""), flow=params.get("flow", ""),
         encryption=params.get("encryption", "none"),
     )
+def _parse_mvless_extensions(params: ConfigParams, uri: str):
+    """Parses Mux and Fragment parameters specific to the Mvless protocol and modifies the ConfigParams object."""
+    try:
+        query_params = urllib.parse.parse_qs(urllib.parse.urlparse(uri).query)
+        if 'mux' in query_params and query_params['mux'][0].upper() == 'ON':
+            params.mux_enabled = True
+            if 'muxConcurrency' in query_params:
+                try:
+                    params.mux_concurrency = int(query_params['muxConcurrency'][0])
+                except (ValueError, IndexError):
+                    pass
+
+        if 'packets' in query_params and 'length' in query_params and 'interval' in query_params:
+            params.fragment_enabled = True
+            params.fragment_packets = query_params['packets'][0]
+            params.fragment_length = query_params['length'][0]
+            params.fragment_interval = query_params['interval'][0]
+    except Exception as e:
+        print(f"! Error parsing mvless extensions: {e}")
 
 def _parse_vmess(uri: str, common: dict) -> ConfigParams:
     encoded_part = uri.replace("vmess://", "")
@@ -230,18 +259,16 @@ def build_outbound_from_params(self, params: ConfigParams, fragment_config: Opti
         * The main engine. Converts ConfigParams into a complete Xray outbound dictionary.
         * Now correctly maps short protocol names to Xray's official protocol names.
         """
-        # ! =========================================================
-        # ! === THE FINAL FIX: MAP SHORT NAMES TO XRAY'S REAL NAMES ===
-        # ! =========================================================
         protocol_map = {
             "vless": "vless",
+            "mvless" : "mvless",
             "vmess": "vmess",
             "trojan": "trojan",
-            "ss": "shadowsocks", # This was the main bug
+            "ss": "shadowsocks",
             "socks": "socks",
             "wireguard": "wireguard",
         }
-        
+
         xray_protocol_name = protocol_map.get(params.protocol)
         if not xray_protocol_name:
             # This protocol is not meant for Xray (like Hysteria)
@@ -251,7 +278,11 @@ def build_outbound_from_params(self, params: ConfigParams, fragment_config: Opti
         stream_settings = self._build_stream_settings(params, fragment=use_fragment, **kwargs)
 
         protocol_settings = self._build_protocol_settings(params)
-
+        if params.protocol == "mvless" and params.mux_enabled:
+            try:
+                outbound["mux"] = {"enabled": True  if  outbound["mux"].upper() == "ON" else False , "concurrency": params.mux_concurrency}
+            except Exception:
+                print("! No mux found in mvless")
         outbound = {
             "tag": params.tag,
             "protocol": xray_protocol_name, # ! Use the correct, full protocol name
@@ -277,17 +308,28 @@ def _build_stream_settings(self, params: ConfigParams, **kwargs) -> Dict[str, An
                 stream_settings["tlsSettings"] = security_settings
 
         header_config = {"type": params.header_type if params.header_type else "none"}
-        if params.header_type == "http":
-            header_config["request"] = {"method": "GET", "path": ["/"], "headers": {"Host": [params.host], "User-Agent": ["Mozilla/5.0"], "Connection": ["keep-alive"]}}
+        host_for_header = params.host if params.host else params.sni
 
         network_map = {
             "tcp":  {"tcpSettings":  {"header": header_config}}, "kcp":  {"kcpSettings":  {"header": header_config, "seed": params.path}},
-            "ws":   {"wsSettings":   {"path": params.path, "headers": {"Host": params.host}}}, "h2":   {"httpSettings": {"host": [params.host], "path": params.path}},
-            "quic": {"quicSettings": {"security": params.host, "key": params.path, "header": header_config}}, "grpc": {"grpcSettings": {"serviceName": params.path, "multiMode": (params.mode == "multi")}},
+            "ws":   {"wsSettings":   {"path": params.path, "headers": {"Host": host_for_header}}},
+            "h2":   {"httpSettings": {"host": [host_for_header], "path": params.path}},
+            "quic": {"quicSettings": {"security": params.host, "key": params.path, "header": header_config}},
+            "grpc": {"grpcSettings": {"serviceName": params.path, "multiMode": (params.mode == "multi")}},
         }
         stream_settings.update(network_map.get(params.network, {}))
+        if params.protocol == "mvless" and params.fragment_enabled:
+             stream_settings["fragment"] = {
+                "packets": params.fragment_packets,
+                "length": params.fragment_length,
+                "interval": params.fragment_interval
+            }
+
+
+
+        if kwargs.get("fragment_config") and not params.fragment_enabled:
+             stream_settings["sockopt"] = {"dialerProxy": "fragment"}
 
-        if kwargs.get("fragment"): stream_settings["sockopt"] = {"dialerProxy": "fragment", "mark": 255}
         return stream_settings
     def add_fragment_outbound(self, fragment_config: Dict[str, Any]):
         """
@@ -314,7 +356,11 @@ def add_fragment_outbound(self, fragment_config: Dict[str, Any]):
     def _build_protocol_settings(self, params: ConfigParams) -> Dict[str, Any]:
         level = 0
         protocol = params.protocol
-        if protocol == "vless": return {"vnext": [{"address": params.address, "port": params.port, "users": [{"id": params.id, "flow": params.flow, "encryption": "none", "level": level}]}]}
+        if protocol in ["vless", "mvless"]:
+            settings = {"vnext": [{"address": params.address, "port": params.port, "users": [{"id": params.id, "flow": params.flow, "encryption": "none", "level": level}]}]}
+            if protocol == "mvless" and params.fragment_enabled:
+                pass
+            return settings
         elif protocol == "vmess": return {"vnext": [{"address": params.address, "port": params.port, "users": [{"id": params.id, "alterId": params.alter_id, "security": params.scy, "level": level}]}]}
         elif protocol == "trojan": return {"servers": [{"address": params.address, "port": params.port, "password": params.password, "level": level}]}
         elif protocol == "ss":

python_v2ray/models.py

@@ -31,12 +31,10 @@ def to_dict(self) -> Dict[str, Any]:
             "settings": self.settings,
         }
         if self.stream_settings:
-            # fixme: This needs to be expanded to handle all stream types correctly.
             stream_dict = {
                 "network": self.stream_settings.network,
                 "security": self.stream_settings.security,
             }
-            # Merge extra settings like wsSettings, grpcSettings
             stream_dict.update(self.stream_settings.extra_settings)
             data["streamSettings"] = stream_dict
 

python_v2ray/tester.py

@@ -1,4 +1,4 @@
-import subprocess, json, os, sys, time, logging
+import subprocess, json, os, sys, time, logging, socket
 from pathlib import Path
 from typing import List, Dict, Any, Optional
 
@@ -19,7 +19,7 @@ def __init__(self, vendor_path: str, core_engine_path: str):
             self.tester_exe, self.xray_exe, self.hysteria_exe = "core_engine_linux", "xray_linux", "hysteria_linux"
         if not (self.core_engine_path / self.tester_exe).is_file(): raise FileNotFoundError("Tester executable not found")
 
-    def test_uris(self, parsed_params: List[ConfigParams], fragment_config: Optional[Dict[str, Any]] = None, timeout: int = 90) -> List[Dict[str, Any]]:
+    def test_uris(self, parsed_params: List[ConfigParams], fragment_config: Optional[Dict[str, Any]] = None, mux_config: Optional[Dict[str, Any]] = None, timeout: int = 90) -> List[Dict[str, Any]]:
         """
         * Takes a list of PRE-PARSED ConfigParams objects and tests them using the correct client.
         """
@@ -28,7 +28,6 @@ def test_uris(self, parsed_params: List[ConfigParams], fragment_config: Optional
         hysteria_params = []
         xray_params = []
 
-        # ! FIX: Iterate over the list of OBJECTS, don't re-parse them.
         for params in parsed_params:
             if params.protocol in ["hysteria", "hysteria2", "hy2"]:
                 hysteria_params.append(params)
@@ -53,12 +52,34 @@ def test_uris(self, parsed_params: List[ConfigParams], fragment_config: Optional
                 inbound_port = base_port + i
                 inbound_tag = f"inbound_{i}"
 
-                outbound = builder.build_outbound_from_params(params, fragment_config=fragment_config)
-                builder.add_outbound(outbound)
+                # outbound = builder.build_outbound_from_params(params, fragment_config=fragment_config)
+                # builder.add_outbound(outbound)
+
+                # builder.add_inbound({"tag": inbound_tag, "port": inbound_port, "listen": "127.0.0.1", "protocol": "socks", "settings": {"auth": "noauth", "udp": True, "userLevel": 0}})
+                # builder.config["routing"]["rules"].append({"type": "field", "inboundTag": [inbound_tag], "outboundTag": outbound["tag"]})
+                # tests_to_run.append({"tag": outbound["tag"], "test_port": inbound_port, "listen_ip": "127.0.0.1"})
+
+                outbound = builder.build_outbound_from_params(params)
 
-                builder.add_inbound({"tag": inbound_tag, "port": inbound_port, "listen": "127.0.0.1", "protocol": "socks", "settings": {"auth": "noauth", "udp": True, "userLevel": 0}})
-                builder.config["routing"]["rules"].append({"type": "field", "inboundTag": [inbound_tag], "outboundTag": outbound["tag"]})
-                tests_to_run.append({"tag": outbound["tag"], "test_port": inbound_port, "listen_ip": "127.0.0.1"})
+                if mux_config and not params.mux_enabled:
+                    if "mux" not in outbound:
+                        outbound["mux"] = {}
+                    outbound["mux"]["enabled"] = mux_config.get("enabled", True)
+                    outbound["mux"]["concurrency"] = mux_config.get("concurrency", 8)
+
+                outbound_tag_for_routing = outbound["tag"]
+                if fragment_config and not params.fragment_enabled:
+                    outbound_tag_for_routing = "fragment"
+
+                builder.add_outbound(outbound)
+                builder.add_inbound({
+                    "tag": inbound_tag, "port": inbound_port, "listen": "127.0.0.1",
+                    "protocol": "socks", "settings": {"auth": "noauth", "udp": True, "userLevel": 0}
+                })
+                builder.config["routing"]["rules"].append({
+                    "type": "field", "inboundTag": [inbound_tag], "outboundTag": outbound_tag_for_routing
+                })
+                tests_to_run.append({"tag": params.tag, "test_port": inbound_port, "listen_ip": "127.0.0.1"})
 
             builder.add_outbound({"protocol": "freedom", "tag": "direct"})
             builder.add_outbound({"protocol": "blackhole", "tag": "block"})
@@ -73,13 +94,26 @@ def test_uris(self, parsed_params: List[ConfigParams], fragment_config: Optional
             try:
                 xray_process = subprocess.Popen([str(self.vendor_path / self.xray_exe), "-c", str(temp_config_path)])
                 logging.info(f"Merged Xray instance started (PID: {xray_process.pid}). Waiting for initialization...")
-                time.sleep(1.5)
+                last_port_to_check = base_port + len(xray_params) - 1
+                is_ready = False
+                for _ in range(20):
+                    try:
+                        with socket.create_connection(("127.0.0.1", last_port_to_check), timeout=0.25):
+                            is_ready = True
+                            logging.info("Xray instance is ready.")
+                            break
+                    except (socket.timeout, ConnectionRefusedError):
+                        time.sleep(0.25)
+
+                if not is_ready:
+                    logging.error("Xray instance failed to start up in time. Stopping test.")
+                    raise RuntimeError("Xray startup timeout")
                 logging.info(f"Sending {len(tests_to_run)} Xray test jobs to Go engine...")
                 xray_results = self._run_go_tester(tests_to_run, timeout)
                 all_results.extend(xray_results)
             finally:
                 if xray_process: xray_process.terminate(); xray_process.wait()
-                if temp_config_path.exists(): temp_config_path.unlink()
+                # if temp_config_path.exists(): temp_config_path.unlink()
 
         return all_results