xray-tools 0.1.0__tar.gz

xray_tools-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,54 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    uses: ./.github/workflows/test.yml
+
+  publish:
+    name: Publish
+    needs: test
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/xray-tools
+    permissions:
+      id-token: write
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Set version from the tag
+        run: |
+          version="${GITHUB_REF_NAME#v}"
+          sed -i "s/^__version__ = \".*\"/__version__ = \"${version}\"/" xray_tools/__init__.py
+
+      - name: Build
+        run: |
+          pip install build
+          python -m build
+
+      - name: Verify version matches the tag
+        run: |
+          version="${GITHUB_REF_NAME#v}"
+          shopt -s nullglob
+          wheels=(dist/*-"${version}"-*.whl)
+          sdists=(dist/*-"${version}".tar.gz)
+          if (( ${#wheels[@]} == 0 || ${#sdists[@]} == 0 )); then
+            echo "Expected version ${version} in dist/, got:"
+            ls -la dist
+            exit 1
+          fi
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

xray_tools-0.1.0/.github/workflows/test.yml

@@ -0,0 +1,34 @@
+name: Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_call:
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    name: Python ${{ matrix.python-version }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install Poetry
+        run: pipx install poetry
+
+      - name: Install dependencies
+        run: poetry install --with test --no-interaction --no-ansi
+
+      - name: Run tests
+        run: poetry run pytest

xray_tools-0.1.0/.gitignore

@@ -0,0 +1,35 @@
+# Byte-compiled / optimized
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribution / packaging
+build/
+dist/
+*.egg-info/
+.eggs/
+*.egg
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# Test and type-check caches
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+.coverage.*
+htmlcov/
+coverage.xml
+
+# Secrets
+.env
+.env.*
+
+# Editors and OS
+.idea/
+.vscode/
+*.swp
+.DS_Store

xray_tools-0.1.0/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.5
+Name: xray-tools
+Version: 0.1.0
+Summary: Pure Python library for Xray-core configuration
+Project-URL: Repository, https://github.com/shizacat/xray-tools
+Author: Alexey Matveev
+License-Expression: MIT
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: pydantic<3.0.0,>=2.0
+Description-Content-Type: text/markdown
+
+# Xray tools — Python library
+
+Create and manage [Xray-core](https://github.com/XTLS/Xray-core) configuration: inbounds, outbounds, routing and protocol settings. Pure Python implementation.
+
+Links:
+- https://github.com/XTLS/Xray-core
+- https://xtls.github.io/config/
+
+# Install
+
+```bash
+pip install xray-tools
+```
+
+# Development
+
+Run tests:
+```bash
+pytest
+```

xray_tools-0.1.0/README.md

@@ -0,0 +1,20 @@
+# Xray tools — Python library
+
+Create and manage [Xray-core](https://github.com/XTLS/Xray-core) configuration: inbounds, outbounds, routing and protocol settings. Pure Python implementation.
+
+Links:
+- https://github.com/XTLS/Xray-core
+- https://xtls.github.io/config/
+
+# Install
+
+```bash
+pip install xray-tools
+```
+
+# Development
+
+Run tests:
+```bash
+pytest
+```

xray_tools-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[project]
+name = "xray-tools"
+dynamic = ["version"]
+description = "Pure Python library for Xray-core configuration"
+authors = [{ name = "Alexey Matveev" }]
+license = "MIT"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "pydantic (>=2.0,<3.0.0)",
+]
+classifiers = [
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[project.urls]
+Repository = "https://github.com/shizacat/xray-tools"
+
+[tool.hatch.version]
+path = "xray_tools/__init__.py"
+
+[tool.poetry]
+package-mode = false
+
+[tool.poetry.group.dev.dependencies]
+black = "^22.10.0"
+
+[tool.poetry.group.test.dependencies]
+pytest = "^6.2.5"
+pytest-mock = "^3.6.1"
+
+[tool.black]
+target-version = ["py310"]
+
+[tool.isort]
+py_version = 310
+profile = "black"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

xray_tools-0.1.0/tests/test_config.py

@@ -0,0 +1,223 @@
+import json
+
+import pytest
+from pytest import fixture
+from pydantic import ValidationError
+
+from xray_tools import config
+from xray_tools import config as xray_config
+from xray_tools import protocols
+
+
+# --- Fixture ---
+
+@fixture
+def xray_config_ex1() -> xray_config.XRayConfig:
+    return config.XRayConfig.from_config_file("""
+        {
+            "log": {"loglevel": "error"},
+            "inbounds": [
+                {
+                    "port": 443,
+                    "protocol": "vless",
+                    "tag": "vless_tls",
+                    "settings": {
+                        "clients": [
+                            {
+                                "id": "{{ xray.uuid }}",
+                                "email": "user@{{ ansible_fqdn }}",
+                                "flow": "xtls-rprx-vision"
+                            }
+                        ],
+                        "decryption": "none"
+                    },
+                    "streamSettings": {
+                        "network": "tcp",
+                        "security": "reality",
+                        "realitySettings": {
+                            "show": false,
+                            "dest": "www.microsoft.com:443",
+                            "xver": 0,
+                            "serverNames": [
+                                "www.microsoft.com"
+                            ],
+                            "privateKey": "{{ xray.x25519_private }}",
+                            "minClientVer": "",
+                            "maxClientVer": "",
+                            "maxTimeDiff": 0,
+                            "shortIds": [
+                                "{{ xray.short_id }}"
+                            ]
+                        }
+                    },
+                    "sniffing": {
+                        "enabled": true,
+                        "destOverride": [
+                            "http",
+                            "tls"
+                        ]
+                    }
+                }
+            ]
+        }
+    """)
+
+
+# --- Tests ---
+
+
+def test_create_empty_config():
+    obj = config.XRayConfig()
+
+    # get config
+    c = obj.to_config_file()
+    assert isinstance(c, str)
+
+    # get config with indent
+    c = obj.to_config_file(indent=4)
+    assert isinstance(c, str)
+
+
+def test_config_create_from_file(xray_config_ex1: xray_config.XRayConfig):
+    """
+    Check type of config
+    """
+    assert isinstance(xray_config_ex1, config.XRayConfig)
+    assert isinstance(
+        xray_config_ex1.inbounds[0].settings, protocols.ProtocolSettingsVless)
+
+
+def test_config_to_config_file(xray_config_ex1: xray_config.XRayConfig):
+    """
+    Check as create dump
+    """
+    dump = xray_config_ex1.to_config_file()
+    assert isinstance(dump, str)
+    dump_dict = json.loads(dump)
+    assert len(dump_dict["inbounds"][0]["settings"]["clients"]) == 1
+    assert dump_dict["inbounds"][0]["settings"]["decryption"] == "none"
+
+
+def test_config_create_fill_01():
+    """
+    Создаем и заполняем конфиг
+    """
+    config = xray_config.XRayConfig(
+        inbounds=[
+            xray_config.Inbound(
+                settings=protocols.ProtocolSettingsVless(),
+            )
+        ]
+    )
+    config.inbounds[0].settings.client_add(email="test@test.ru")
+    assert isinstance(config.to_config_file(), str)
+
+
+def test_log_crete_default():
+    r = config.Log()
+    assert isinstance(r, config.Log)
+
+
+def test_stream_settings():
+    r = config.StreamSettings()
+    assert isinstance(r, config.StreamSettings)
+
+
+def test_inbound():
+    r = config.Inbound(settings=protocols.ProtocolSettingsVless())
+    assert isinstance(r, config.Inbound)
+    assert r.protocol == protocols.InboundProtocol.vless
+
+
+def test_outbound():
+    r = config.Outbound()
+    assert isinstance(r, config.Outbound)
+
+
+def test_stats():
+    r = xray_config.Stats()
+    assert isinstance(r, xray_config.Stats)
+
+    # Проверяем, что stats добавился как пустой словарь
+    obj = config.XRayConfig(stats=xray_config.Stats())
+    cfg = json.loads(obj.to_config_file())
+    assert cfg["stats"] == {}
+
+    # Check, that stats is not included in config
+    obj = config.XRayConfig()
+    cfg = json.loads(obj.to_config_file())
+    assert "stats" not in cfg
+
+
+def test_api():
+    r = xray_config.Api(tag="api")
+    assert isinstance(r, xray_config.Api)
+
+    # Проверяем, что api не включен в config
+    obj = config.XRayConfig()
+    cfg = json.loads(obj.to_config_file())
+    assert "api" not in cfg
+
+    # Проверяем, что api добавился в config
+    obj = config.XRayConfig(
+        api=xray_config.Api(
+            tag="api",
+            services=[xray_config.ApiService.StatsService]
+        )
+    )
+    cfg = json.loads(obj.to_config_file())
+    assert cfg["api"]["tag"] == "api"
+
+
+def test_policy():
+    r = xray_config.Policy()
+    assert isinstance(r, xray_config.Policy)
+
+    # Check level key format, raise ValidationError
+    with pytest.raises(ValidationError):
+        xray_config.Policy(levels={"test": {}})
+
+    # Check level key correct format
+    r = xray_config.Policy(levels={"0": xray_config.PolicyLevel()})
+    assert isinstance(r, xray_config.Policy)
+
+    # Проверяем, что policy не включен в config
+    obj = config.XRayConfig()
+    cfg = json.loads(obj.to_config_file())
+    assert "policy" not in cfg
+
+    # Проверяем, что policy добавился в config
+    obj = config.XRayConfig(
+        policy=xray_config.Policy(
+            levels={
+                "0": xray_config.PolicyLevel(
+                    statsUserUplink=True,
+                )
+            }
+        )
+    )
+    cfg = json.loads(obj.to_config_file())
+    assert cfg["policy"]["levels"]["0"]["statsUserUplink"] is True
+
+
+def test_ws_settings_roundtrip():
+    """path/host у WebSocket не теряются при разборе и сборке конфига."""
+    import json as _json
+    from xray_tools.config import XRayConfig as _XRayConfig
+
+    raw = {
+        "inbounds": [{
+            "listen": "127.0.0.1", "port": 10443, "protocol": "vless",
+            "settings": {"clients": [], "decryption": "none"},
+            "streamSettings": {
+                "network": "ws", "security": "none",
+                "wsSettings": {"path": "/media/stream/abc",
+                               "host": "cloud.example.org"},
+            },
+        }],
+    }
+    cfg = _XRayConfig.model_validate_json(_json.dumps(raw))
+    out = _json.loads(cfg.to_config_file())
+    ws = out["inbounds"][0]["streamSettings"]["wsSettings"]
+    assert ws["path"] == "/media/stream/abc"
+    assert ws["host"] == "cloud.example.org"

xray_tools-0.1.0/tests/test_protocol.py

@@ -0,0 +1,30 @@
+from xray_tools import protocols
+
+
+def test_protocol_vless_add_remove_client():
+    obj = protocols.ProtocolSettingsVless()
+
+    # Add
+    c = obj.client_add(email="test@example.com")
+    assert len(obj.clients) == 1
+    assert isinstance(c, protocols.ClientVless)
+    assert c == obj.clients[0]
+
+    # Remove
+    obj.client_remove(c.id)
+    assert len(obj.clients) == 0
+
+
+def test_protocol_vless_add_client_more_than_one():
+    """При повторном добавлении клиента не добавлять его
+    при этом не должно быть исключения
+    """
+    obj = protocols.ProtocolSettingsVless()
+
+    # Add
+    c = obj.client_add(client_id="test", email="test@example.com")
+    c = obj.client_add(client_id="test", email="test@example.com")
+    c = obj.client_add(client_id="test", email="test@example.com")
+    assert isinstance(c, protocols.ClientVless)
+    assert len(obj.clients) == 1
+    assert c == obj.clients[0]

xray_tools-0.1.0/xray_tools/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

xray_tools-0.1.0/xray_tools/base.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from typing import Dict
+
+from pydantic import BaseModel
+
+
+class BaseModelConfig(BaseModel):
+    """
+    Общая модель для всех конфигов
+    """
+
+    def model_dump(self, *args, **kwargs) -> Dict:
+        """Return dump config
+
+        Features:
+          - exclude none
+          - enum as value
+        """
+        kwargs.setdefault("exclude_none", True)
+        # Ensures enums are dumped as values in python mode
+        kwargs.setdefault("mode", "python")
+        r = super().model_dump(*args, **kwargs)
+        return r
+
+    def model_dump_json(self, *args, **kwargs) -> str:
+        """Return dump config as json"""
+        kwargs.setdefault("exclude_none", True)
+        return super().model_dump_json(*args, **kwargs)

xray_tools-0.1.0/xray_tools/config.py

@@ -0,0 +1,741 @@
+"""
+Example:
+
+{
+  "log": {
+    "loglevel": "info"
+  },
+  "routing": {
+    "rules": [],
+    "domainStrategy": "AsIs"
+  },
+  "inbounds": [
+    {
+      "port": 443,
+      "protocol": "vless",
+      "tag": "vless_tls",
+      "settings": {
+        "clients": [
+          {
+            "id": "{{ xray.uuid }}",
+            "email": "user@{{ ansible_fqdn }}",
+            "flow": "xtls-rprx-vision"
+          }
+        ],
+        "decryption": "none"
+      },
+      "streamSettings": {
+        "network": "tcp",
+        "security": "reality",
+        "realitySettings": {
+          "show": false,
+          "dest": "www.microsoft.com:443",
+          "xver": 0,
+          "serverNames": [
+            "www.microsoft.com"
+          ],
+          "privateKey": "{{ xray.x25519_private }}",
+          "minClientVer": "",
+          "maxClientVer": "",
+          "maxTimeDiff": 0,
+          "shortIds": [
+            "{{ xray.short_id }}"
+          ]
+        }
+      },
+      "sniffing": {
+        "enabled": true,
+        "destOverride": [
+          "http",
+          "tls"
+        ]
+      }
+    }
+  ],
+  "outbounds": [
+    {
+      "protocol": "freedom",
+      "tag": "direct"
+    },
+    {
+      "protocol": "blackhole",
+      "tag": "block"
+    }
+  ]
+}
+"""
+
+from __future__ import annotations
+
+import json
+from enum import Enum
+from typing import TextIO, Optional, List, Dict, Type, ClassVar, Union
+
+# from pydantic import BaseModel, Field, root_validator
+from pydantic import (
+    BaseModel,
+    Field,
+    ConfigDict,
+    RootModel,
+    field_validator,
+    model_validator,
+    constr
+)
+
+from .protocols import (
+    InboundProtocol,
+    ProtocolSettingsBase,
+    ProtocolSettingsVless,
+    ProtocolSettingsDokodemoDoor,
+)
+from .base import BaseModelConfig
+
+
+# Enums
+
+
+class LogLevel(str, Enum):
+    """
+    Log level
+    "debug" | "info" | "warning" | "error" | "none"
+    """
+
+    debug = "debug"
+    info = "info"
+    warning = "warning"
+    error = "error"
+    none = "none"
+
+
+class Network(str, Enum):
+    tcp = "tcp"
+    kcp = "kcp"
+    ws = "ws"
+    http = "http"
+    domainsocket = "domainsocket"
+    quic = "quic"
+    grpc = "grpc"
+
+
+class NetworkRoutingRule(str, Enum):
+    tcp = "tcp"
+    udp = "udp"
+    tcp_udp = "tcp,udp"
+
+
+class Security(str, Enum):
+    none = "none"
+    tls = "tls"
+    xtls = "xtls"
+    reality = "reality"
+
+
+class DomainStrategy(str, Enum):
+    """
+    DomainStrategy
+    """
+
+    AsIs = "AsIs"
+    IPIfNonMatch = "IPIfNonMatch"
+    IPOnDemand = "IPOnDemand"
+
+
+class DomainMatcher(str, Enum):
+    """
+    DomainMatcher
+    """
+
+    hybrid = "hybrid"
+    linear = "linear"
+
+
+class SniffingDest(str, Enum):
+    """
+    SniffingDest
+    """
+
+    http = "http"
+    tls = "tls"
+    quic = "quic"
+    fakedns = "fakedns"
+    fakedns_others = "fakedns+others"
+
+
+class ApiService(str, Enum):
+    """
+    ApiService
+    """
+
+    HandlerService = "HandlerService"
+    LoggerService = "LoggerService"
+    StatsService = "StatsService"
+
+
+# Classes
+
+
+class Stats(BaseModelConfig):
+    """
+    Включает сбор статистики
+    """
+
+
+class Api(BaseModelConfig):
+    """
+    API interface configuration provides a set
+    of APIs based on gRPC for remote invocation.
+
+    Example
+    {
+        "api": {
+            "tag": "api",
+            "listen": "127.0.0.1:8080",
+            "services": ["HandlerService", "LoggerService", "StatsService"]
+        }
+    }
+    """
+    tag: str = Field(
+        ..., description="The identifier of this inbound connection"
+    )
+    listen: Optional[str] = Field(
+        None,
+        description="The listening address. Example: 127.0.0.1:8080"
+    )
+    services: List[ApiService] = Field(
+        default_factory=list,
+        description=(
+            "The list of services to be enabled. "
+            "Available services: HandlerService, LoggerService, StatsService"
+        ),
+    )
+
+
+class Log(BaseModelConfig):
+    access: Optional[str] = Field(None, description="путь к файлу")
+    error: Optional[str] = Field(None, description="путь к файлу")
+    loglevel: LogLevel = Field(LogLevel.none)
+    dnsLog: bool = Field(False)
+
+
+# Ограничиваем ключи только строками, которые соответствуют числу
+PolicyLevelKey = constr(pattern=r'^\d+$')
+
+
+class PolicyLevel(BaseModelConfig):
+    """
+    Level Policy Object
+    """
+    handshake: Optional[int] = Field(
+        None, description="Handshake timeout in seconds"
+    )
+    connIdle: Optional[int] = Field(
+        None, description="Idle timeout in seconds"
+    )
+    uplinkOnly: Optional[int] = Field(
+        None, description="Uplink only timeout in seconds"
+    )
+    downlinkOnly: Optional[int] = Field(
+        None, description="Downlink only timeout in seconds"
+    )
+    statsUserUplink: Optional[bool] = Field(
+        None, description="Enable statistics collection for user uplink"
+    )
+    statsUserDownlink: Optional[bool] = Field(
+        None, description="Enable statistics collection for user downlink"
+    )
+    statsUserOnline: Optional[bool] = Field(
+        None, description="Enable statistics collection for user online"
+    )
+    bufferSize: Optional[int] = Field(
+        None, description="Buffer size in bytes"
+    )
+
+
+class PolicySystem(BaseModelConfig):
+    """Policy System"""
+    statsInboundUplink: Optional[bool] = Field(
+        None, description="Enable statistics collection for inbound uplink"
+    )
+    statsInboundDownlink: Optional[bool] = Field(
+        None, description="Enable statistics collection for inbound downlink"
+    )
+    statsOutboundUplink: Optional[bool] = Field(
+        None, description="Enable statistics collection for outbound uplink"
+    )
+    statsOutboundDownlink: Optional[bool] = Field(
+        None, description="Enable statistics collection for outbound downlink"
+    )
+
+
+class Policy(BaseModelConfig):
+    """
+    Local Policy
+    Local policy can be used to set different policy settings
+    for different user levels
+
+    {
+        "policy": {
+            "levels": {
+                "0": {
+                    "handshake": 4,
+                    "connIdle": 300,
+                    "uplinkOnly": 2,
+                    "downlinkOnly": 5,
+                    "statsUserUplink": false,
+                    "statsUserDownlink": false,
+                    "statsUserOnline": false,
+                    "bufferSize": 4
+                }
+            },
+            "system": {
+                "statsInboundUplink": false,
+                "statsInboundDownlink": false,
+                "statsOutboundUplink": false,
+                "statsOutboundDownlink": false
+            }
+        }
+    }
+    """
+    levels: Dict[PolicyLevelKey, PolicyLevel] = Field(
+        default_factory=dict,
+        description=(
+            "Local policy can be used to set different policy settings "
+            "for different user levels"
+            "Key: '0', '1', ..."
+        ),
+    )
+    system: PolicySystem = Field(
+        default_factory=PolicySystem,
+        description="System policy settings"
+    )
+
+
+class Certificate(BaseModel):
+    """
+    Certificate
+    """
+
+    ocspStapling: int = 3600
+    oneTimeLoading: bool = False
+    usage: str = "encipherment"
+    buildChain: bool = False
+    certificateFile: str = ""
+    keyFile: str = ""
+    certificate: List[str] = Field(default_factory=list)
+    key: List[str] = Field(default_factory=list)
+
+
+class TLSSettings(BaseModel):
+    """ """
+
+    serverName: str = Field(
+        "", description="Specifies the domain of the server-side certificate"
+    )
+    rejectUnknownSni: bool = Field(
+        False,
+        description=(
+            "When true, the server rejects TLS handshakes if the SNI received "
+            "does not match domains specified in the certificate. "
+        ),
+    )
+    allowInsecure: bool = Field(False)
+    alpn: List[str] = Field(
+        ["h2", "http/1.1"],
+        description=(
+            "An array of strings specifying the ALPN values used "
+            "in TLS handshakes"
+        ),
+    )
+    minVersion: str = Field("1.2")
+    maxVersion: str = Field("1.3")
+    cipherSuites: str = Field(
+        "",
+        description=(
+            "Specifies a list of supported cryptographic suites, "
+            "with names of each separated by a colon."
+        ),
+    )
+    disableSystemRoot: bool = Field(
+        False,
+        description=(
+            "Whether to disable the CA certificates provided by "
+            "the operating system."
+        ),
+    )
+    enableSessionResumption: bool = Field(
+        False,
+        description=(
+            "When false, the session_ticket extension will not be "
+            "included in ClientHello"
+        ),
+    )
+    fingerprint: str = Field(
+        "",
+        description=(
+            "Specifies the fingerprint of the TLS Client Hello message"
+        ),
+    )
+    pinnedPeerCertificateChainSha256: List[str] = Field(
+        default_factory=list,
+        description=(
+            "Specifies the SHA256 hash values of the certificate chain "
+            "of the remote server, using the standard encoding format."
+        ),
+    )
+    masterKeyLog: str = Field(
+        "", description=("Path to the (Pre-)Master-Secret log file.")
+    )
+    certificates: List[Certificate] = Field(
+        default_factory=list,
+        description=(
+            "A list of certificates, each representing a single certificate "
+            "(fullchain recommended)."
+        ),
+    )
+
+
+class TCPSettings(BaseModel):
+    acceptProxyProtocol: bool = False
+    header: Dict[str, str] = Field({"type": "none"})
+
+
+class KCPSettings(BaseModel):
+    pass
+
+
+class WSSettings(BaseModel):
+    acceptProxyProtocol: bool = False
+    path: str = Field("/", description="HTTP path of the WebSocket")
+    host: str = Field("", description="HTTP Host header sent by the client")
+    headers: Dict[str, str] = Field(default_factory=dict)
+
+
+class HttpSettings(BaseModel):
+    pass
+
+
+class GrpcSettings(BaseModel):
+    pass
+
+
+class HTTPUpgradeSettings(BaseModel):
+    pass
+
+
+class SplitHTTPSettings(BaseModel):
+    pass
+
+
+class ProxySettings(BaseModel):
+    tag: str
+
+
+class RealitySettings(BaseModel):
+    show: bool = Field(False)
+    dest: str | None = Field(None)
+    xver: int = Field(0)
+    serverName: str | None = Field(None)
+    serverNames: List[str] = Field(default_factory=list)
+    privateKey: str = Field("")
+    minClientVer: str = Field("")
+    maxClientVer: str = Field("")
+    maxTimeDiff: int = Field(0)
+    shortIds: List[str] = Field(default_factory=list)
+    shortId: str | None = Field(None)
+    fingerprint: str | None = Field(None)
+    publicKey: str | None = Field(None)
+
+
+class SockOpt(BaseModel):
+    """ """
+
+    mark: int = 0
+    tcpFastOpen: bool = False
+    tproxy: str = "off"
+    domainStrategy: str = "AsIs"
+    dialerProxy: str = ""
+    acceptProxyProtocol: bool = False
+    tcpKeepAliveInterval: int = 0
+    tcpcongestion: str = "bbr"
+    interface: str = "wg0"
+    tcpMptcp: bool = False
+    tcpNoDelay: bool = False
+
+
+class StreamSettings(BaseModelConfig):
+    """
+    StreamSettings corresponds to the streamSettings property
+    in the inbound or outbound config.
+    Each inbound or outbound can be configured with different
+    transports and can use streamSettings to specify local configs.
+
+    """
+
+    network: Network = Field(
+        Network.tcp,
+        description=(
+            "The underlying protocol of the transport "
+            "used by the data stream of the connection"
+        ),
+    )
+    security: Security = Field(
+        Security.none,
+        description="Whether to enable transport layer encryption",
+    )
+    tlsSettings: TLSSettings | None = Field(
+        None, description="Configures vanilla TLS"
+    )
+    tcpSettings: TCPSettings | None = Field(None, description="Configures TCP")
+    kcpSettings: KCPSettings | None = Field(
+        default=None, description="Configures KCP"
+    )
+    wsSettings: WSSettings | None = Field(
+        None, description="Configures WebSocket"
+    )
+    httpSettings: HttpSettings | None = Field(
+        None, description="Configures HTTP"
+    )
+    grpcSettings: GrpcSettings | None = Field(
+        None, description="Configures gRPC"
+    )
+    httpupgradeSettings: HTTPUpgradeSettings | None = Field(
+        None, description="Configures HTTP"
+    )
+    splithttpSettings: SplitHTTPSettings | None = Field(
+        None, description="Configures HTTP"
+    )
+    realitySettings: RealitySettings | None = Field(
+        None, description="Configures Reality"
+    )
+    sockopt: SockOpt | None = Field(None)
+
+
+class Sniffing(BaseModelConfig):
+    enabled: bool = True
+    destOverride: List[SniffingDest] = Field(
+        default_factory=list,
+        description=(
+            "When the traffic is of a specified type, reset the destination "
+            "of the current connection to the target address included "
+            "in the list."
+        ),
+    )
+    metadataOnly: bool = False
+    domainsExcluded: List[str] = Field(
+        default_factory=list, description="A list of domain names."
+    )
+    routeOnly: bool = False
+
+
+class Allocate(BaseModel):
+    strategy: str = "always"
+    refresh: int = 5
+    concurrency: int = 3
+
+
+class Mux(BaseModel):
+    enabled: bool = False
+    concurrency: int = 8
+
+
+class RoutingRule(BaseModelConfig):
+    domainMatcher: DomainMatcher = Field(DomainMatcher.hybrid)
+    type: str = "field"
+    domain: List[str] = Field(default_factory=list)
+    ip: List[str] = Field(default_factory=list)
+    port: Optional[str] = Field(None, description="The target port range")
+    sourcePort: Optional[str] = Field(None)
+    network: Optional[NetworkRoutingRule] = Field(None)
+    source: List[str] = Field(default_factory=list)
+    user: List[str] = Field(default_factory=list)
+    inboundTag: List[str] = Field(default_factory=list)
+    protocol: List[InboundProtocol] = Field(default_factory=list)
+    attrs: Dict[str, str] = Field(default_factory=dict)
+    outboundTag: Optional[str] = Field(None)
+    balancerTag: Optional[str] = Field(None)
+
+
+class RoutingBalancer(BaseModelConfig):
+    tag: str = Field("")
+    selector: List[str] = Field(default_factory=list)
+    fallbackTag: str = Field("")
+    strategy: Dict[str, str] = Field(default_factory=dict)
+
+
+class Routing(BaseModelConfig):
+    domainStrategy: DomainStrategy = Field(
+        DomainStrategy.AsIs, description="The domain name resolution strategy"
+    )
+    domainMatcher: DomainMatcher = Field(
+        DomainMatcher.hybrid, description="The domain name matching algorithm"
+    )
+    rules: List[RoutingRule] = Field(default_factory=list)
+    balancers: List[RoutingBalancer] = Field(default_factory=list)
+
+
+class Inbound(BaseModelConfig):
+    """
+    Inbound connections are used to receive incoming data
+    and the available protocols are listed in
+    """
+
+    _protocol_settings_map: ClassVar[
+        dict[InboundProtocol, Type[ProtocolSettingsBase]]
+    ] = {
+        InboundProtocol.vless: ProtocolSettingsVless,
+        InboundProtocol.dokodemo_door: ProtocolSettingsDokodemoDoor,
+    }
+
+    listen: str = Field(
+        "0.0.0.0",
+        description=(
+            "The listening address, "
+            "either an IP address or a Unix domain socket."
+        ),
+    )
+    port: int | str = Field(1080, description="The listening port")
+    # Fill from settings model
+    protocol: InboundProtocol = Field(
+        ..., description="The connection protocol name"
+    )
+    settings: Union[
+        ProtocolSettingsBase,
+        ProtocolSettingsVless,
+        ProtocolSettingsDokodemoDoor
+    ] = Field(
+        default_factory=ProtocolSettingsBase,
+        description=(
+            "The specific configuration content depends on the protocol"
+        ),
+    )
+    streamSettings: StreamSettings = Field(
+        default_factory=StreamSettings,
+        description=(
+            "The underlying transport method is how the current Xray node "
+            "interfaces with other nodes."
+        ),
+    )
+    tag: str | None = Field(
+        None,
+        description=(
+            "The identifier of this inbound connection, used to locate "
+            "this connection in other configurations."
+        ),
+    )
+    sniffing: Sniffing = Field(
+        default_factory=Sniffing,
+        description=(
+            "Configures sniffing, which is used to determine the protocol "
+            "of the current connection."
+        ),
+    )
+    allocate: Allocate = Field(
+        default_factory=Allocate,
+        description=(
+            "Specifies the specific settings for port allocation when "
+            "multiple ports are set up"
+        ),
+    )
+
+    @model_validator(mode="before")
+    @classmethod
+    def fill_protocol(cls, values: Dict[str, object]) -> Dict[str, object]:
+        settings = values.get("settings", {})
+        protocol = values.get("protocol")
+
+        # Apply settings class based on protocol
+        settings_class = cls._protocol_settings_map.get(protocol)
+        if settings_class and isinstance(settings, dict):
+            values["settings"] = settings_class(**settings)
+
+        # Ensure protocol is consistent
+        if isinstance(values.get("settings"), ProtocolSettingsBase):
+            values["protocol"] = values["settings"].protocol.value
+        elif isinstance(settings, dict):
+            settings["protocol"] = protocol
+
+        return values
+
+
+class Outbound(BaseModelConfig):
+    sendThrough: str = Field(
+        "0.0.0.0", description="The IP address used to send data."
+    )
+    protocol: InboundProtocol = Field(
+        InboundProtocol.freedom, description="The connection protocol name"
+    )
+    settings: Dict = Field(default_factory=dict)
+    tag: str | None = Field(
+        None,
+        description=(
+            "The identifier of this inbound connection, used to locate "
+            "this connection in other configurations."
+        ),
+    )
+    streamSettings: StreamSettings | None = Field(
+        None,
+        description=(
+            "The underlying transport method is how the current Xray node "
+            "interfaces with other nodes."
+        ),
+    )
+    proxySettings: ProxySettings | None = Field(
+        None, description="The outbound proxy configuration."
+    )
+    mux: Mux | None = Field(
+        None,
+        description=(
+            "The Mux feature distributes the data of multiple TCP connections "
+            "on a single TCP connection."
+        ),
+    )
+
+
+class XRayConfig(BaseModelConfig):
+    """
+    Содержит полную конфигурацию XRay сервера
+    """
+    stats: Optional[Stats] = Field(
+        None, description="Включает сбор статистики")
+    api: Optional[Api] = Field(
+        None, description="API interface configuration provides a set of APIs")
+    policy: Optional[Policy] = Field(
+        None,
+        description="Local policy can be used to set different policy settings"
+    )
+    log: Log = Field(default_factory=Log)
+    routing: Routing = Field(
+        default_factory=Routing,
+        description=(
+            "Configures routing. Specify rules to route connections "
+            "through different outbounds."
+        ),
+    )
+    inbounds: List[Inbound] = Field(
+        default_factory=list,
+        description=(
+            "Inbound connections are used to receive incoming data "
+            "and the available protocols are listed in"
+        ),
+    )
+    outbounds: List[Outbound] = Field(
+        default_factory=list,
+        description=("An array of outbound connection configurations."),
+    )
+
+    @classmethod
+    def from_config_file(cls, content: TextIO) -> XRayConfig:
+        """
+        Создает объект конфигурации из файла. Config format is json.
+
+        Args:
+            content: Содержимое файла конфигурации
+        """
+        return cls.model_validate_json(content)
+
+    def to_config_file(self, indent=None) -> str:
+        """
+        Возвращает отрендеренный конфигурационный файл.
+        Json dump
+        """
+        return self.model_dump_json(indent=indent, exclude_none=True)

xray_tools-0.1.0/xray_tools/protocols.py

@@ -0,0 +1,127 @@
+"""
+Describe diffent protocols
+"""
+
+from __future__ import annotations
+
+import uuid
+from enum import Enum
+from typing import TextIO, Optional, List, Dict, Any
+
+from pydantic import BaseModel, Field
+
+from .base import BaseModelConfig
+
+
+def gen_uuid() -> str:
+    return str(uuid.uuid4())
+
+
+class InboundProtocol(str, Enum):
+    """
+    Inbound connections are used to receive incoming data
+    and the available protocols are listed in
+    """
+
+    tcp = "tcp"
+    kcp = "kcp"
+    ws = "ws"
+    h2 = "h2"
+    quic = "quic"
+    grpc = "grpc"
+    dokodemo = "dokodemo"
+    dokodemo_door = "dokodemo-door"
+    freedom = "freedom"
+    blackhole = "blackhole"
+    socks = "socks"
+    http = "http"
+    mtproto = "mtproto"
+    tuic = "tuic"
+    vless = "vless"
+    vmess = "vmess"
+    trojan = "trojan"
+    shadowsocks = "shadowsocks"
+    reality = "reality"
+    wireguard = "wireguard"
+
+
+class ProtocolSettingsBase(BaseModelConfig, BaseModel):
+    """
+    Base class for protocol settings
+    """
+
+    protocol: InboundProtocol = Field(..., exclude=True, description="Protocol")
+
+    def client_add(self, client_id: Optional[str] = None, **kwargs):
+        """
+        Add a client to the protocol
+        """
+        raise NotImplementedError()
+
+    def client_remove(self, client_id: str):
+        """
+        Remove a client from the protocol
+        """
+        raise NotImplementedError()
+
+
+class VlessSettingFlow(str, Enum):
+    xtls_rprx_vision = "xtls-rprx-vision"
+
+
+class ClientVless(BaseModelConfig):
+    id: str = Field(
+        default_factory=gen_uuid, description="Unique ID of the client"
+    )
+    level: int = Field(0, description="Level of the client")
+    email: str = Field(..., description="Email of the client")
+    flow: Optional[VlessSettingFlow] = Field(
+        None, description="Flow control mode used to select the XTLS algorithm"
+    )
+
+    def __eq__(self, other: ClientVless):
+        if not isinstance(other, ClientVless):
+            return NotImplemented
+        return self.id == other.id and self.email == other.email
+
+
+class ProtocolSettingsVless(ProtocolSettingsBase):
+    protocol: InboundProtocol = Field(InboundProtocol.vless, exclude=True)
+
+    clients: List[ClientVless] = Field(
+        default_factory=list, description="List of clients"
+    )
+    decryption: str = Field("none", description="Decryption method")
+    fallbacks: List[Dict] = Field(
+        default_factory=list,
+        description=(
+            "An array that contains a series of powerful fallback "
+            "configurations"
+        ),
+    )
+
+    def client_add(self, client_id: Optional[str] = None, **kwargs):
+        """
+        Add a client to the protocol
+        """
+        if client_id is not None:
+            kwargs["id"] = client_id
+        client = ClientVless(**kwargs)
+        if client not in self.clients:
+            self.clients.append(client)
+        return client
+
+    def client_remove(self, client_id: str):
+        """
+        Remove a client from the protocol
+        """
+        self.clients = [
+            client for client in self.clients if client.id != client_id
+        ]
+
+
+class ProtocolSettingsDokodemoDoor(ProtocolSettingsBase):
+    protocol: InboundProtocol = Field(
+        InboundProtocol.dokodemo_door, exclude=True)
+
+    address: str = Field(..., description="Address to bind to")