sing-box-cli 0.0.25__tar.gz → 0.0.26__tar.gz

{sing_box_cli-0.0.25 → sing_box_cli-0.0.26}/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to this project will be documented in this file.
 
+## 0.0.26 - 2025-03-20
+
+### 🚜 Refactor
+
+- Validate responses using pydantic
+
 ## 0.0.25 - 2025-03-20
 
 ### 🐛 Bug Fixes

{sing_box_cli-0.0.25 → sing_box_cli-0.0.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sing-box-cli
-Version: 0.0.25
+Version: 0.0.26
 Summary: cross-platform sing-box-service manager.
 Project-URL: Homepage, https://github.com/aittcuszz/sing-box-service
 Project-URL: Issues, https://github.com/atticuszz/sing-box-service/issues
@@ -42,6 +42,7 @@ Requires-Dist: httpx>=0.28.1
 Requires-Dist: plotext>=5.3.2
 Requires-Dist: prompt-toolkit>=3.0.50
 Requires-Dist: psutil>=6.1.1
+Requires-Dist: pydantic>=2.10.6
 Requires-Dist: typer>=0.15.1
 Description-Content-Type: text/markdown
 

{sing_box_cli-0.0.25 → sing_box_cli-0.0.26}/pyproject.toml

@@ -28,6 +28,7 @@ dependencies = [
     "plotext>=5.3.2",
     "prompt-toolkit>=3.0.50",
     "psutil>=6.1.1",
+    "pydantic>=2.10.6",
     "typer>=0.15.1",
 ]
 
@@ -212,7 +213,7 @@ sort_commits = "oldest"
 
 
 [tool.bumpversion]
-current_version = "0.0.25"
+current_version = "0.0.26"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"

{sing_box_cli-0.0.25 → sing_box_cli-0.0.26}/src/sing_box_service/__init__.py

@@ -2,4 +2,4 @@ from .main import main
 
 __all__ = ["main"]
 
-__version__ = "0.0.25"
+__version__ = "0.0.26"

{sing_box_cli-0.0.25 → sing_box_cli-0.0.26}/src/sing_box_service/client.py

@@ -5,9 +5,102 @@ Provides an async client for interacting with Sing-Box HTTP API.
 
 import json
 from collections.abc import AsyncGenerator
-from typing import Any
+from typing import Any, TypeVar
 
 import httpx
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class FrozenBaseModel(BaseModel):
+    """Base model with frozen configuration."""
+
+    model_config = ConfigDict(frozen=True)
+
+
+# Define Pydantic models for API responses
+class TrafficData(FrozenBaseModel):
+    """http://base_url/traffic/"""
+
+    up: int = Field(default=0, description="Upload speed in B/s")
+    down: int = Field(default=0, description="Download speed in B/s")
+
+
+class MemoryData(FrozenBaseModel):
+    """http://base_url/memory/"""
+
+    inuse: int = Field(default=0, description="Memory in use in bytes")
+    total: int = Field(default=0, description="Total memory in bytes")
+
+
+class ConnectionMetadata(FrozenBaseModel):
+    destinationIP: str = ""
+    destinationPort: str
+    dnsMode: str
+    host: str = ""
+    network: str = Field(description="Network type")
+    processPath: str = ""
+    sourceIP: str
+    sourcePort: str
+    type: str = Field(description="Inbound type")
+
+
+class ConnectionInfo(FrozenBaseModel):
+    """https://base_url/connections/"""
+
+    id: str
+    download: int = Field(default=0, description="Download in bytes")
+    upload: int = Field(default=0, description="Upload in bytes")
+    rule: str = Field(description="Rule name => outbound")
+    start: str = Field(description="Start time")
+    chains: list[str] = Field(description="Proxy chains list")
+    metadata: ConnectionMetadata
+
+
+class ConnectionData(FrozenBaseModel):
+    uploadTotal: int = Field(default=0, description="Total upload in bytes")
+    downloadTotal: int = Field(default=0, description="Total download in bytes")
+    memory: int = Field(default=0, description="Memory usage in bytes")
+    connections: list[ConnectionInfo] = Field(description="List of active connections")
+
+
+class DelayHistory(FrozenBaseModel):
+    time: str = ""
+    delay: int = Field(default=0, description="Outbound delay in milliseconds")
+
+
+class GroupInfo(FrozenBaseModel):
+    """http://base_url/group/{group_name}/"""
+
+    type: str = Field(description="Proxy Group type")
+    name: str
+    udp: bool = Field(description="UDP support")
+    history: list[DelayHistory] = Field(
+        description="History of selected proxies", default=[]
+    )
+    now: str = Field(description="Currently selected proxy")
+    all: list[str] = Field(description="List of all outbound proxies")
+
+
+class GroupsData(FrozenBaseModel):
+    """http://base_url/group/"""
+
+    proxies: list[GroupInfo] = Field(description="List of proxies in the group")
+
+
+class DelayTestResult(FrozenBaseModel):
+    """Delay test result model."""
+
+    delay: int = Field(default=0, description="Outbound delay in milliseconds")
+
+
+class EmptyResponse(FrozenBaseModel):
+    """Empty response model."""
+
+    status_code: int
+
+
+# Generic response type for API methods
+T = TypeVar("T", bound=FrozenBaseModel)
 
 
 class SingBoxAPIClient:
@@ -45,7 +138,7 @@ class SingBoxAPIClient:
         except httpx.HTTPError:
             return False
 
-    async def _make_request(
+    async def _make_request_raw(
         self,
         method: str,
         endpoint: str,
@@ -82,12 +175,24 @@ class SingBoxAPIClient:
                 return dict(response.json())
             return {}
 
-    async def traffic_stream(self) -> AsyncGenerator[dict[str, Any], None]:
+    async def _make_request(
+        self,
+        method: str,
+        endpoint: str,
+        model_class: type[T],
+        params: dict[str, Any] | None = None,
+        data: dict[str, Any] | None = None,
+    ) -> T:
+        """Make a request and return data as a specific model."""
+        raw = await self._make_request_raw(method, endpoint, params, data)
+        return model_class.model_validate(raw)
+
+    async def traffic_stream(self) -> AsyncGenerator[TrafficData, None]:
         """
         Get traffic statistics as a stream of updates.
 
         Yields:
-            Dictionary containing traffic data (up/down in B/s)
+            TrafficData object containing traffic data (up/down in B/s)
         """
         url = f"{self.base_url}/traffic"
 
@@ -99,17 +204,18 @@ class SingBoxAPIClient:
                 async for line in response.aiter_lines():
                     if line.strip():  # Skip empty lines
                         try:
-                            yield json.loads(line)
+                            data = json.loads(line)
+                            yield TrafficData.model_validate(data)
                         except json.JSONDecodeError:
                             # Skip invalid JSON lines
                             continue
 
-    async def memory_stream(self) -> AsyncGenerator[dict[str, Any], None]:
+    async def memory_stream(self) -> AsyncGenerator[MemoryData, None]:
         """
         Get memory statistics as a stream of updates.
 
         Yields:
-            Dictionary containing memory data (inuse/total in bytes)
+            MemoryData object containing memory data (inuse/total in bytes)
         """
         url = f"{self.base_url}/memory"
 
@@ -121,19 +227,22 @@ class SingBoxAPIClient:
                 async for line in response.aiter_lines():
                     if line.strip():  # Skip empty lines
                         try:
-                            yield json.loads(line)
+                            data = json.loads(line)
+                            yield MemoryData.model_validate(data)
                         except json.JSONDecodeError:
                             # Skip invalid JSON lines
                             continue
 
-    async def get_connections(self) -> dict[str, Any]:
+    async def get_connections(self) -> ConnectionData:
         """
         Get current connections.
 
         Returns:
-            Dictionary containing active connections
+            ConnectionData object containing active connections
         """
-        return await self._make_request("GET", "/connections")
+        return await self._make_request(
+            "GET", "/connections", model_class=ConnectionData
+        )
 
     async def close_connection(self, connection_id: str) -> dict[str, Any]:
         """
@@ -145,7 +254,7 @@ class SingBoxAPIClient:
         Returns:
             Response from the API
         """
-        return await self._make_request("DELETE", f"/connections/{connection_id}")
+        return await self._make_request_raw("DELETE", f"/connections/{connection_id}")
 
     async def close_all_connections(self) -> dict[str, Any]:
         """
@@ -154,18 +263,18 @@ class SingBoxAPIClient:
         Returns:
             Response from the API
         """
-        return await self._make_request("DELETE", "/connections")
+        return await self._make_request_raw("DELETE", "/connections")
 
-    async def get_groups(self) -> dict[str, Any]:
+    async def get_groups(self) -> GroupsData:
         """
         Get all policy groups.
 
         Returns:
-            Dictionary containing policy groups information
+            GroupData object containing policy groups information
         """
-        return await self._make_request("GET", "/group")
+        return await self._make_request("GET", "/group", model_class=GroupsData)
 
-    async def get_group(self, group_name: str) -> dict[str, Any]:
+    async def get_group(self, group_name: str) -> GroupInfo:
         """
         Get information about a specific policy group.
 
@@ -173,9 +282,11 @@ class SingBoxAPIClient:
             group_name: Name of the policy group
 
         Returns:
-            Dictionary containing the policy group information
+            GroupData object containing the policy group information
         """
-        return await self._make_request("GET", f"/group/{group_name}")
+        return await self._make_request(
+            "GET", f"/group/{group_name}", model_class=GroupInfo
+        )
 
     async def test_group_delay(
         self,
@@ -188,14 +299,10 @@ class SingBoxAPIClient:
 
         Args:
             group_name: Name of the policy group
-            url: URL to test latency against
             timeout: Timeout in milliseconds
-
-        Returns:
-            Dictionary containing delay test results
         """
         params = {"url": url, "timeout": timeout}
-        return await self._make_request(
+        return await self._make_request_raw(
             "GET", f"/group/{group_name}/delay", params=params
         )
 
@@ -204,21 +311,19 @@ class SingBoxAPIClient:
         proxy_name: str,
         url: str = "https://cp.cloudflare.com/generate_204",
         timeout: int = 5000,
-    ) -> dict[str, Any]:
+    ) -> DelayTestResult:
         """
         Test delay for a specific proxy.
 
         Args:
-            proxy_name: Name of the proxy
-            url: URL to test latency against
             timeout: Timeout in milliseconds
-
-        Returns:
-            Dictionary containing delay test results
         """
         params = {"url": url, "timeout": timeout}
         return await self._make_request(
-            "GET", f"/proxies/{proxy_name}/delay", params=params
+            "GET",
+            f"/proxies/{proxy_name}/delay",
+            params=params,
+            model_class=DelayTestResult,
         )
 
     async def select_proxy(self, proxy_name: str, selected: str) -> dict[str, Any]:
@@ -228,12 +333,9 @@ class SingBoxAPIClient:
         Args:
             proxy_name: Name of the proxy selector
             selected: Name of the proxy to select
-
-        Returns:
-            Response from the API
         """
         data = {"name": selected}
-        return await self._make_request("PUT", f"/proxies/{proxy_name}", data=data)
+        return await self._make_request_raw("PUT", f"/proxies/{proxy_name}", data=data)
 
     async def get_version(self) -> dict[str, Any]:
         """
@@ -242,4 +344,4 @@ class SingBoxAPIClient:
         Returns:
             Dictionary containing version information
         """
-        return await self._make_request("GET", "/version")
+        return await self._make_request_raw("GET", "/version")

{sing_box_cli-0.0.25 → sing_box_cli-0.0.26}/src/sing_box_service/connections.py

@@ -1,5 +1,4 @@
 import asyncio
-from typing import Any
 
 from prompt_toolkit.application import Application
 from prompt_toolkit.buffer import Buffer
@@ -18,7 +17,7 @@ from rich.panel import Panel
 from rich.table import Table
 from rich.text import Text
 
-from .client import SingBoxAPIClient
+from .client import ConnectionData, ConnectionInfo, SingBoxAPIClient
 from .monitor import (
     format_bytes,
     format_chain,
@@ -30,7 +29,7 @@ from .widget import create_header_panel, render_rich_to_prompt_toolkit
 
 
 def create_connections_table(
-    connections_data: dict[str, Any],
+    connections_data: ConnectionData,
     total: int,
     highlight_index: int = -1,
     max_display: int = 20,
@@ -47,10 +46,10 @@ def create_connections_table(
     Returns:
         Rich Panel containing the connections information
     """
-    if not connections_data or "connections" not in connections_data:
+    if len(connections_data.connections) == 0:
         return Panel("No connections data available", title="Active Connections")
 
-    connections = connections_data.get("connections", [])
+    connections = connections_data.connections
 
     if not connections:
         return Panel("No active connections", title="Active Connections")
@@ -75,21 +74,21 @@ def create_connections_table(
     # Show top connections (limit to avoid overwhelming the display)
     for idx, conn in enumerate(sorted_connections[:max_display]):
         # Extract data
-        metadata = conn.get("metadata", {})
-        host = metadata.get("host", "") or metadata.get("destinationIP", "?")
+        metadata = conn.metadata
+        host = metadata.host or metadata.destinationIP
 
-        network = metadata.get("network", "?").upper()
-        upload = format_bytes(conn.get("upload", 0))
-        download = format_bytes(conn.get("download", 0))
+        network = metadata.network.upper()
+        upload = format_bytes(conn.upload)
+        download = format_bytes(conn.download)
 
         # Extract rule information
-        rule_display = format_rule(conn.get("rule", ""))
+        rule_display = format_rule(conn.rule)
 
         # Calculate duration
-        duration_str = format_duration(conn.get("start", ""))
+        duration_str = format_duration(conn.start)
 
         # Format chains (usually shows proxy names)
-        chain_str = format_chain(conn.get("chains", []))
+        chain_str = format_chain(conn.chains)
 
         # Determine if this row should be highlighted
         if idx == highlight_index:
@@ -110,8 +109,8 @@ def create_connections_table(
             )
 
     # Add summary information
-    total_upload = format_bytes(connections_data.get("uploadTotal", 0))
-    total_download = format_bytes(connections_data.get("downloadTotal", 0))
+    total_upload = format_bytes(connections_data.uploadTotal)
+    total_download = format_bytes(connections_data.downloadTotal)
 
     summary = f"Total Upload: {total_upload} | Total Download: {total_download}"
     if len(connections) > max_display:
@@ -129,8 +128,8 @@ class ConnectionsManager:
     def __init__(self, api_client: SingBoxAPIClient) -> None:
         """Initialize the connections manager."""
         self.api_client = api_client
-        self.connections: list[dict[str, Any]] = []
-        self.filtered_connections: list[dict[str, Any]] = []
+        self.connections: list[ConnectionInfo] = []
+        self.filtered_connections: list[ConnectionInfo] = []
         self.page = 0
         self.page_size = 20
         self.selected_index = 0
@@ -160,11 +159,11 @@ class ConnectionsManager:
         return Style.from_dict({"status-bar": "bg:#333333 #ffffff"})
 
     @property
-    def selected_connection(self) -> dict[str, Any]:
+    def selected_connection(self) -> ConnectionInfo:
         """Get the currently selected connection."""
         return self.filtered_connections[
             self.page * self.page_size + self.selected_index
-        ].copy()
+        ].model_copy()
 
     def setup_keybindings(self) -> None:
         """Setup keyboard shortcuts."""
@@ -177,7 +176,7 @@ class ConnectionsManager:
         @self.kb.add("c-d")
         def _(event) -> None:  # type: ignore[no-untyped-def]  # noqa: ARG001
             """Close the connection."""
-            conn_id = self.selected_connection.get("id")
+            conn_id = self.selected_connection.id
             asyncio.create_task(self.close_connection(str(conn_id)))
 
         @self.kb.add("c-c")
@@ -248,19 +247,19 @@ class ConnectionsManager:
         self.filtered_connections = []
         for conn in self.connections:
             # Check host
-            host = conn.get("metadata", {}).get("host", "").lower()
+            host = conn.metadata.host.lower()
             if self.filter_text in host:
                 self.filtered_connections.append(conn)
                 continue
 
             # Check chains
-            chains = format_chain(conn.get("chains", [])).lower()
+            chains = format_chain(conn.chains).lower()
             if self.filter_text in chains:
                 self.filtered_connections.append(conn)
                 continue
 
             # Check network
-            network = conn.get("metadata", {}).get("network", "").lower()
+            network = conn.metadata.network.lower()
             if self.filter_text in network:
                 self.filtered_connections.append(conn)
                 continue
@@ -359,11 +358,11 @@ class ConnectionsManager:
         end_idx = min(start_idx + self.page_size, len(self.filtered_connections))
 
         # Create connections data for the current page
-        page_connections = {
-            "connections": self.filtered_connections[start_idx:end_idx],
-            "uploadTotal": self.total_upload,
-            "downloadTotal": self.total_download,
-        }
+        page_connections = ConnectionData(
+            connections=self.filtered_connections[start_idx:end_idx],
+            uploadTotal=self.total_upload,
+            downloadTotal=self.total_download,
+        )
 
         # Create rich panel with highlighted row
         panel = create_connections_table(
@@ -380,7 +379,7 @@ class ConnectionsManager:
         """Close a specific connection."""
         try:
             await self.api_client.close_connection(conn_id)
-            host = self.selected_connection.get("metadata", {}).get("host", "Unknown")
+            host = self.selected_connection.metadata.host
             cnnt_info = f"Connection {host=} {conn_id=}"
             self.status_message = f"{cnnt_info} closed successfully"
             # Refresh connections after closing one
@@ -405,9 +404,9 @@ class ConnectionsManager:
         try:
             data = await self.api_client.get_connections()
             # Sort connections by time and host
-            self.connections = sort_connections(data.get("connections", []))
-            self.total_upload = data.get("uploadTotal", 0)
-            self.total_download = data.get("downloadTotal", 0)
+            self.connections = sort_connections(data.connections)
+            self.total_upload = data.uploadTotal
+            self.total_download = data.downloadTotal
             self.filter_connections()  # Apply current filter
         except Exception as e:
             self.status_message = f"Error refreshing connections: {str(e)}"

{sing_box_cli-0.0.25 → sing_box_cli-0.0.26}/src/sing_box_service/monitor.py

@@ -4,7 +4,6 @@ import statistics
 from collections import deque
 from datetime import datetime
 from enum import Enum
-from typing import Any
 
 import plotext as plt  # type: ignore
 from rich.console import Console
@@ -14,7 +13,7 @@ from rich.panel import Panel
 from rich.table import Table
 from rich.text import Text
 
-from .client import SingBoxAPIClient
+from .client import ConnectionInfo, MemoryData, SingBoxAPIClient, TrafficData
 from .widget import RichPlotMixin, create_header_panel
 
 
@@ -69,7 +68,7 @@ def format_speed(bytes_per_sec_i: int | float) -> str:
 
 
 def calculate_averages(
-    data_history: deque[dict[str, int]], key: str
+    data_history: deque[TrafficData] | deque[MemoryData], key: str
 ) -> tuple[float, float]:
     """
     Calculate 5s and 10s averages for a specific metric.
@@ -88,7 +87,7 @@ def calculate_averages(
         list(data_history)[-5:] if history_len >= 5 else list(data_history)
     )
     five_sec_avg = (
-        statistics.mean(item.get(key, 0) for item in five_sec_samples)
+        statistics.mean(getattr(item, key) for item in five_sec_samples)
         if five_sec_samples
         else 0
     )
@@ -98,7 +97,7 @@ def calculate_averages(
         list(data_history)[-10:] if history_len >= 10 else list(data_history)
     )
     ten_sec_avg = (
-        statistics.mean(item.get(key, 0) for item in ten_sec_samples)
+        statistics.mean(getattr(item, key) for item in ten_sec_samples)
         if ten_sec_samples
         else 0
     )
@@ -106,7 +105,7 @@ def calculate_averages(
     return five_sec_avg, ten_sec_avg
 
 
-def sort_connections(connections: list[dict[str, Any]]) -> list[dict[str, Any]]:
+def sort_connections(connections: list[ConnectionInfo]) -> list[ConnectionInfo]:
     """
     Sort connections by time in descending order.
 
@@ -120,9 +119,7 @@ def sort_connections(connections: list[dict[str, Any]]) -> list[dict[str, Any]]:
     Returns:
         list[dict[str, Any]]: The sorted list of connection dictionaries.
     """
-    return sorted(
-        connections, key=lambda x: (x.get("start", ""), x.get("host", "")), reverse=True
-    )
+    return sorted(connections, key=lambda x: (x.start, x.metadata.host), reverse=True)
 
 
 def format_rule(rule: str) -> str:
@@ -369,7 +366,7 @@ class TrafficGraph(RichPlotMixin):
         # Number of points to generate during inte= 5
         self.interp_factor = 5
 
-    def update_from_traffic_data(self, traffic_data: dict[str, Any]) -> None:
+    def update_from_traffic_data(self, traffic_data: TrafficData) -> None:
         """
         Update the graph with new traffic data.
 
@@ -378,8 +375,8 @@ class TrafficGraph(RichPlotMixin):
         """
 
         # Update the graph with new data
-        self.upload_speeds.append(traffic_data.get("up", 0))
-        self.download_speeds.append(traffic_data.get("down", 0))
+        self.upload_speeds.append(traffic_data.up)
+        self.download_speeds.append(traffic_data.down)
 
     def make_plot(self, width: int, height: int, tension: float = 0.8) -> str:
         """
@@ -478,22 +475,22 @@ class ResourceVisualizer:
         self.console = Console()
 
         # For averages calculation
-        self.traffic_data_history: deque[dict[str, int]] = deque(maxlen=10)
-        self.memory_data_history: deque[dict[str, int]] = deque(maxlen=10)
+        self.traffic_data_history: deque[TrafficData] = deque(maxlen=10)
+        self.memory_data_history: deque[MemoryData] = deque(maxlen=10)
 
         # For traffic graph
         self.traffic_graph = TrafficGraph(
             max_points=60  # Store 1 minutes of data
         )
 
-    def create_traffic_table(self, traffic_data: dict[str, Any]) -> Table:
+    def create_traffic_table(self, traffic_data: TrafficData) -> Table:
         """Create a table displaying traffic statistics with averages."""
         # Add current data to history
-        self.traffic_data_history.append(traffic_data.copy())
+        self.traffic_data_history.append(traffic_data.model_copy())
 
         # Get the raw values
-        up_bytes = traffic_data.get("up", 0)
-        down_bytes = traffic_data.get("down", 0)
+        up_bytes = traffic_data.up
+        down_bytes = traffic_data.down
 
         # Calculate averages
         up_5s_avg, up_10s_avg = calculate_averages(self.traffic_data_history, "up")
@@ -523,14 +520,14 @@ class ResourceVisualizer:
         )
         return table
 
-    def create_memory_table(self, memory_data: dict[str, Any]) -> Table:
+    def create_memory_table(self, memory_data: MemoryData) -> Table:
         """Create a table displaying memory usage statistics with averages."""
         # Add current data to history
-        self.memory_data_history.append(memory_data.copy())
+        self.memory_data_history.append(memory_data.model_copy())
 
         # Extract current memory values
-        inuse = memory_data.get("inuse", 0)
-        total = memory_data.get("total", 0)
+        inuse = memory_data.inuse
+        total = memory_data.total
 
         # Calculate averages
         inuse_5s_avg, inuse_10s_avg = calculate_averages(
@@ -577,7 +574,7 @@ class ResourceVisualizer:
         return table
 
     def create_resources_layout(
-        self, traffic_data: dict[str, Any], memory_data: dict[str, Any]
+        self, traffic_data: TrafficData, memory_data: MemoryData
     ) -> Layout:
         """Create the main layout with all resource components."""
         layout = Layout()
@@ -640,8 +637,8 @@ class ResourceMonitor:
         self.api_client = api_client
         self.visualizer = visualizer
         self.running = False
-        self.current_traffic = {"up": 0, "down": 0}  # in bytes
-        self.current_memory = {"inuse": 0, "total": 0}  # in bytes
+        self.current_traffic = TrafficData(up=0, down=0)  # in bytes
+        self.current_memory = MemoryData(inuse=0, total=0)  # in bytes
         # 1.0 fix interval for avoiding repeated data
         self.task_interval = RefreshRate.SLOW.value
 

{sing_box_cli-0.0.25 → sing_box_cli-0.0.26}/src/sing_box_service/policy.py

@@ -1,5 +1,4 @@
 import asyncio
-from typing import Any
 
 from prompt_toolkit.application import Application
 from prompt_toolkit.formatted_text import FormattedText
@@ -11,31 +10,27 @@ from rich.panel import Panel
 from rich.table import Table
 from rich.text import Text
 
-from .client import SingBoxAPIClient
+from .client import GroupInfo, SingBoxAPIClient
 from .widget import create_header_panel, render_rich_to_prompt_toolkit
 
 
 def create_policy_group_table(
-    group_data: dict[str, Any],
+    group_data: GroupInfo | None,
     delay_cache: dict[str, int] | None = None,
     selected_index: int = -1,
 ) -> Panel:
     """Create a table to display policy group information."""
-    if not group_data or "all" not in group_data:
+    if group_data is None:
         return Panel("No policy group data available", title="Policy Group")
 
-    name = group_data.get("name", "Unknown")
-    type_info = group_data.get("type", "Unknown")
-    current = group_data.get("now", "")
-    proxies = group_data.get("all", [])
-
+    name = group_data.name
+    type_info = group_data.type
+    current = group_data.now
+    proxies = group_data.all
     # Get delay information, prioritizing the cache
-    history = group_data.get("history", [])
-    history_dict = (
-        {item.get("time", ""): item.get("delay", 0) for item in history}
-        if history
-        else {}
-    )
+    # TODO: no sure if this is the best way to handle this
+    history = group_data.history
+    history_dict = {item.time: item.delay for item in history} if history else {}
 
     # Create table for proxies
     table = Table(expand=True, show_header=True)
@@ -92,10 +87,10 @@ class PolicyGroupManager:
     def __init__(self, api_client: SingBoxAPIClient) -> None:
         """Initialize the policy group manager."""
         self.api_client = api_client
-        self.groups: list[dict[str, Any]] = []
+        self.groups: list[GroupInfo] = []
         self.selected_group_index = 0
         self.selected_proxy_index = 0
-        self.current_group: dict[str, Any] | None = None
+        self.current_group: GroupInfo | None = None
         self.status_message = "Loading policy groups..."
         self.running = False
 
@@ -142,8 +137,8 @@ class PolicyGroupManager:
                     self.selected_group_index += 1
                     asyncio.create_task(self.load_selected_group())
             else:
-                if self.current_group and "all" in self.current_group:
-                    proxies = self.current_group["all"]
+                if self.current_group:
+                    proxies = self.current_group.all
                     if self.selected_proxy_index < len(proxies) - 1:
                         self.selected_proxy_index += 1
 
@@ -163,8 +158,8 @@ class PolicyGroupManager:
             """Select a group or a proxy."""
             if not self.focus_on_groups and self.current_group:
                 # Select proxy
-                group_name = self.current_group.get("name", "")
-                proxies = self.current_group.get("all", [])
+                group_name = self.current_group.name
+                proxies = self.current_group.all
                 if proxies and self.selected_proxy_index < len(proxies):
                     selected_proxy = proxies[self.selected_proxy_index]
                     asyncio.create_task(self.select_proxy(group_name, selected_proxy))
@@ -173,7 +168,7 @@ class PolicyGroupManager:
         def _(event) -> None:  # type: ignore[no-untyped-def] # noqa: ARG001
             """Test delay for selected proxy."""
             if not self.focus_on_groups and self.current_group:
-                proxies = self.current_group.get("all", [])
+                proxies = self.current_group.all
                 if proxies and self.selected_proxy_index < len(proxies):
                     selected_proxy = proxies[self.selected_proxy_index]
                     asyncio.create_task(self.test_proxy_delay(selected_proxy))
@@ -182,7 +177,7 @@ class PolicyGroupManager:
         def _(event) -> None:  # type: ignore[no-untyped-def] # noqa: ARG001
             """Test delay for all proxies in the group."""
             if self.current_group:
-                group_name = self.current_group.get("name", "")
+                group_name = self.current_group.name
                 asyncio.create_task(self.test_group_delay(group_name))
 
     def create_layout(self) -> PTLayout:
@@ -251,7 +246,7 @@ class PolicyGroupManager:
         table.add_column("Policy Groups")
 
         for i, group in enumerate(self.groups):
-            name = group.get("name", "Unknown")
+            name = group.name
             if i == self.selected_group_index:
                 style = "bold white on blue"
                 text = Text(f"{name}", style=style)
@@ -268,7 +263,7 @@ class PolicyGroupManager:
         if not self.current_group:
             return Panel("No policy group selected", title="Proxies")
 
-        group_name = self.current_group.get("name", "")
+        group_name = self.current_group.name
         group_delay_cache = self.delay_cache.get(group_name, {})
 
         return create_policy_group_table(
@@ -283,7 +278,7 @@ class PolicyGroupManager:
         """Load all policy groups."""
         try:
             data = await self.api_client.get_groups()
-            self.groups = data.get("proxies", [])
+            self.groups = data.proxies
             if self.groups:
                 # Load the first group
                 await self.load_selected_group()
@@ -299,28 +294,27 @@ class PolicyGroupManager:
             return
 
         try:
-            group_name = self.groups[self.selected_group_index].get("name", "")
+            group_name = self.groups[self.selected_group_index].name
             self.status_message = f"Loading group: {group_name}..."
 
             data = await self.api_client.get_group(group_name)
 
             # Make sure we have the history data
-            if "history" not in data and "now" in data:
-                # Try to fetch delay data if not present
-                try:
-                    await self.api_client.test_group_delay(group_name)
-                    # Fetch the group data again to get updated delay information
-                    data = await self.api_client.get_group(group_name)
-                except Exception:
-                    # If testing fails, continue with existing data
-                    pass
+            # Try to fetch delay data if not present
+            try:
+                await self.api_client.test_group_delay(group_name)
+                # Fetch the group data again to get updated delay information
+                data = await self.api_client.get_group(group_name)
+            except Exception:
+                # If testing fails, continue with existing data
+                pass
 
             self.current_group = data
             self.selected_proxy_index = 0
 
             # Find the index of the currently selected proxy
-            current = data.get("now", "")
-            proxies = data.get("all", [])
+            current = data.now
+            proxies = data.all
             if current in proxies:
                 self.selected_proxy_index = proxies.index(current)
 
@@ -343,14 +337,14 @@ class PolicyGroupManager:
         if not self.current_group:
             return
 
-        group_name = self.current_group.get("name", "")
+        group_name = self.current_group.name
 
         try:
             self.status_message = f"Testing proxy delay: {proxy_name}..."
             result = await self.api_client.test_proxy_delay(proxy_name)
 
             # Extract delay information
-            delay = result.get("delay", 0)
+            delay = result.delay
 
             # Update our delay cache
             if group_name not in self.delay_cache:
@@ -367,7 +361,7 @@ class PolicyGroupManager:
         if not self.current_group:
             return
 
-        proxies = self.current_group.get("all", [])
+        proxies = self.current_group.all
         if not proxies:
             return
 
@@ -379,10 +373,11 @@ class PolicyGroupManager:
                 self.delay_cache[group_name] = {}
 
             # Test each proxy individually to ensure we get all results
+            # TODO: Consider batching these requests
             for proxy in proxies:
                 try:
                     result = await self.api_client.test_proxy_delay(proxy)
-                    delay = result.get("delay", 0)
+                    delay = result.delay
                     self.delay_cache[group_name][proxy] = delay
                 except Exception:
                     # If one proxy test fails, continue with others
@@ -398,7 +393,6 @@ class PolicyGroupManager:
 
         # Initial load of groups
         await self.load_groups()
-
         # Setup periodic refresh task
         refresh_task = asyncio.create_task(self.periodic_refresh())
 

{sing_box_cli-0.0.25 → sing_box_cli-0.0.26}/uv.lock

@@ -623,6 +623,7 @@ dependencies = [
     { name = "plotext", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
     { name = "prompt-toolkit", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
     { name = "psutil", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
+    { name = "pydantic", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
     { name = "typer", marker = "sys_platform == 'linux' or sys_platform == 'win32'" },
 ]
 
@@ -645,6 +646,7 @@ requires-dist = [
     { name = "plotext", specifier = ">=5.3.2" },
     { name = "prompt-toolkit", specifier = ">=3.0.50" },
     { name = "psutil", specifier = ">=6.1.1" },
+    { name = "pydantic", specifier = ">=2.10.6" },
     { name = "typer", specifier = ">=0.15.1" },
 ]