appmesh 1.6.11__py3-none-any.whl → 1.6.13__py3-none-any.whl

appmesh/__init__.py

@@ -1,8 +1,6 @@
 # __init__.py
 """
-App Mesh SDK package initializer.
-
-This module exports the main client classes used to interact with the App Mesh API.
+App Mesh SDK package initializer with lazy loading support.
 
 Example:
     from appmesh import AppMeshClient
@@ -12,9 +10,18 @@ Example:
 import sys
 from types import ModuleType
 from typing import TYPE_CHECKING
+from importlib import import_module
 
-__all__ = ["App", "AppMeshClient", "AppMeshClientTCP", "AppMeshClientOAuth", "AppMeshServer", "AppMeshServerTCP"]
+__all__ = [
+    "App",
+    "AppMeshClient",
+    "AppMeshClientTCP",
+    "AppMeshClientOAuth",
+    "AppMeshServer",
+    "AppMeshServerTCP",
+]
 
+# Lazy import configuration
 _LAZY_IMPORTS = {
     "App": ("app", "App"),  # from .app import App
     "AppMeshClient": ("client_http", "AppMeshClient"),  # from .client_http import AppMeshClient
@@ -24,10 +31,8 @@ _LAZY_IMPORTS = {
     "AppMeshServerTCP": ("server_tcp", "AppMeshServerTCP"),  # from .server_tcp import AppMeshServerTCP
 }
 
-
 if TYPE_CHECKING:
-    # Provide explicit imports for static analyzers and type checkers
-    # These imports are only executed during type checking and won't affect runtime.
+    # Type checking imports (not executed at runtime)
     from .app import App  # noqa: F401
     from .client_http import AppMeshClient  # noqa: F401
     from .client_tcp import AppMeshClientTCP  # noqa: F401
@@ -36,25 +41,34 @@ if TYPE_CHECKING:
     from .server_tcp import AppMeshServerTCP  # noqa: F401
 
 
-def _lazy_import(name):
-    """Helper function for lazy importing."""
+def _lazy_import(name: str):
+    """
+    Internal helper for lazy import resolution using PEP 562.
+    Only imports modules when accessed, improving startup time.
+    """
     if name in _LAZY_IMPORTS:
         module_name, attr_name = _LAZY_IMPORTS[name]
-        module = __import__(f"{__name__}.{module_name}", fromlist=[attr_name])
-        return getattr(module, attr_name)
+        module = import_module(f".{module_name}", __name__)
+        globals()[name] = getattr(module, attr_name)
+        return globals()[name]
     raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
 
 
-if sys.version_info >= (3, 7):
+def __dir__():
+    """Provide tab-completion support for lazy-loaded attributes."""
+    return sorted(__all__ + list(globals().keys()))
 
-    def __getattr__(name):
-        return _lazy_import(name)
 
+if sys.version_info >= (3, 7):
+    __getattr__ = _lazy_import
 else:
-    # Python 3.6 compatibility
+    # Python 3.6 compatibility via module replacement
     class _LazyModule(ModuleType):
         def __getattr__(self, name):
             return _lazy_import(name)
 
+        def __dir__(self):
+            return sorted(__all__ + list(globals().keys()))
+
     sys.modules[__name__] = _LazyModule(__name__)
     sys.modules[__name__].__dict__.update(globals())

appmesh/app.py

@@ -3,49 +3,55 @@
 
 import json
 import copy
-
 from datetime import datetime
-from typing import Optional, Any
+from typing import Optional, Any, Dict
 from enum import Enum, unique
 
-# pylint: disable=line-too-long
 
+def _get_str(data: Optional[dict], key: str) -> Optional[str]:
+    """Retrieve a string value from a dictionary by key, if it exists and is a valid string."""
+    if not data or key not in data:
+        return None
+    value = data[key]
+    return value if value and isinstance(value, str) else None
 
-class App:
-    """
-    An application in App Mesh, include all the process attributes, resource limitations, behaviors, and permissions.
-    """
 
-    @staticmethod
-    def _get_str_item(data: dict, key: str) -> Optional[str]:
-        """Retrieve a string value from a dictionary by key, if it exists and is a valid string."""
-        return data[key] if (data and key in data and data[key] and isinstance(data[key], str)) else None
+def _get_int(data: Optional[dict], key: str) -> Optional[int]:
+    """Retrieve an integer value from a dictionary by key, if it exists and is a valid integer."""
+    if not data or key not in data or data[key] is None:
+        return None
 
-    @staticmethod
-    def _get_int_item(data: dict, key: str) -> Optional[int]:
-        """Retrieve an integer value from a dictionary by key, if it exists and is a valid integer."""
-        if data and key in data and data[key] is not None:
-            if isinstance(data[key], int):
-                return data[key]
-            elif isinstance(data[key], str) and data[key].isdigit():
-                return int(data[key])
+    value = data[key]
+    if isinstance(value, int):
+        return value
+    if isinstance(value, str) and value.isdigit():
+        return int(value)
+    return None
+
+
+def _get_bool(data: Optional[dict], key: str) -> Optional[bool]:
+    """Retrieve a boolean value from a dictionary by key, if it exists and is boolean-like."""
+    if not data or key not in data or data[key] is None:
         return None
+    return bool(data[key])
 
-    @staticmethod
-    def _get_bool_item(data: dict, key: str) -> Optional[bool]:
-        """Retrieve a boolean value from a dictionary by key, if it exists and is boolean-like."""
-        if data and key in data and data[key] is not None:
-            return bool(data[key])
+
+def _get_item(data: Optional[dict], key: str) -> Optional[Any]:
+    """Retrieve a deep copy of a value from a dictionary by key, if it exists."""
+    if not data or key not in data or data[key] is None:
         return None
+    return copy.deepcopy(data[key])
 
-    @staticmethod
-    def _get_native_item(data: dict, key: str) -> Optional[Any]:
-        """Retrieve a deep copy of a value from a dictionary by key, if it exists."""
-        return copy.deepcopy(data[key]) if (data and key in data and data[key] is not None) else None
+
+class App:
+    """
+    An application in App Mesh, include all the process attributes,
+    resource limitations, behaviors, and permissions.
+    """
 
     @unique
     class Permission(Enum):
-        """Defines application permission levels."""
+        """Application permission levels."""
 
         DENY = "1"
         READ = "2"
@@ -53,26 +59,26 @@ class App:
 
     class Behavior:
         """
-        Manages application error handling behavior, including exit and control behaviors.
+        Application error handling behavior, including exit and control behaviors.
         """
 
         @unique
         class Action(Enum):
-            """Defines actions for application exit behaviors."""
+            """Actions for application exit behaviors."""
 
             RESTART = "restart"
             STANDBY = "standby"
             KEEPALIVE = "keepalive"
             REMOVE = "remove"
 
-        def __init__(self, data=None) -> None:
+        def __init__(self, data: Optional[dict] = None) -> None:
             if isinstance(data, (str, bytes, bytearray)):
                 data = json.loads(data)
 
-            self.exit = App._get_str_item(data, "exit")
+            self.exit = _get_str(data, "exit")
             """Default exit behavior, options: 'restart', 'standby', 'keepalive', 'remove'."""
 
-            self.control = App._get_native_item(data, "control") or {}
+            self.control = _get_item(data, "control") or {}
             """Exit code specific behavior (e.g, --control 0:restart --control 1:standby), higher priority than default exit behavior"""
 
         def set_exit_behavior(self, action: "App.Behavior.Action") -> None:
@@ -85,17 +91,17 @@ class App:
 
     class DailyLimitation:
         """
-        Defines application availability within a daily time range.
+        Application availability within a daily time range.
         """
 
-        def __init__(self, data=None) -> None:
+        def __init__(self, data: Optional[dict] = None) -> None:
             if isinstance(data, (str, bytes, bytearray)):
                 data = json.loads(data)
 
-            self.daily_start = App._get_int_item(data, "daily_start")
+            self.daily_start = _get_int(data, "daily_start")
             """Start time for application availability (e.g., 09:00:00+08)."""
 
-            self.daily_end = App._get_int_item(data, "daily_end")
+            self.daily_end = _get_int(data, "daily_end")
             """End time for application availability (e.g., 09:00:00+08)."""
 
         def set_daily_range(self, start: datetime, end: datetime) -> None:
@@ -105,106 +111,112 @@ class App:
 
     class ResourceLimitation:
         """
-        Defines application resource limits, such as CPU and memory usage.
+        Application resource limits, such as CPU and memory usage.
         """
 
-        def __init__(self, data=None) -> None:
+        def __init__(self, data: Optional[dict] = None) -> None:
             if isinstance(data, (str, bytes, bytearray)):
                 data = json.loads(data)
 
-            self.cpu_shares = App._get_int_item(data, "cpu_shares")
+            self.cpu_shares = _get_int(data, "cpu_shares")
             """CPU shares, relative weight of CPU usage."""
 
-            self.memory_mb = App._get_int_item(data, "memory_mb")
+            self.memory_mb = _get_int(data, "memory_mb")
             """Physical memory limit in MB."""
 
-            self.memory_virt_mb = App._get_int_item(data, "memory_virt_mb")
+            self.memory_virt_mb = _get_int(data, "memory_virt_mb")
             """Virtual memory limit in MB."""
 
-    def __init__(self, data=None) -> None:
+    def __init__(self, data: Optional[dict] = None) -> None:
         """Initialize an App instance with optional configuration data."""
         if isinstance(data, (str, bytes, bytearray)):
             data = json.loads(data)
 
-        self.name = App._get_str_item(data, "name")
+        # Application configuration
+        self.name = _get_str(data, "name")
         """application name (unique)"""
-        self.command = App._get_str_item(data, "command")
+        self.command = _get_str(data, "command")
         """full command line with arguments"""
-        self.shell = App._get_bool_item(data, "shell")
+        self.shell = _get_bool(data, "shell")
         """use shell mode, cmd can be more shell commands with string format"""
-        self.session_login = App._get_bool_item(data, "session_login")
+        self.session_login = _get_bool(data, "session_login")
         """app run in session login mode"""
-        self.description = App._get_str_item(data, "description")
+        self.description = _get_str(data, "description")
         """application description string"""
-        self.metadata = App._get_native_item(data, "metadata")
+        self.metadata = _get_item(data, "metadata")
         """metadata string/JSON (input for application, pass to process stdin)"""
-        self.working_dir = App._get_str_item(data, "working_dir")
+        self.working_dir = _get_str(data, "working_dir")
         """working directory"""
-        self.status = App._get_int_item(data, "status")
+        self.status = _get_int(data, "status")
         """initial application status (true is enable, false is disabled)"""
-        self.docker_image = App._get_str_item(data, "docker_image")
+        self.docker_image = _get_str(data, "docker_image")
         """docker image which used to run command line (for docker container application)"""
-        self.stdout_cache_num = App._get_int_item(data, "stdout_cache_num")
+        self.stdout_cache_num = _get_int(data, "stdout_cache_num")
         """stdout file cache number"""
-        self.start_time = App._get_int_item(data, "start_time")
+        self.start_time = _get_int(data, "start_time")
         """start date time for app (ISO8601 time format, e.g., '2020-10-11T09:22:05')"""
-        self.end_time = App._get_int_item(data, "end_time")
+        self.end_time = _get_int(data, "end_time")
         """end date time for app (ISO8601 time format, e.g., '2020-10-11T10:22:05')"""
-        self.interval = App._get_int_item(data, "interval")
+        self.interval = _get_int(data, "interval")
         """start interval seconds for short running app, support ISO 8601 durations and cron expression (e.g., 'P1Y2M3DT4H5M6S' 'P5W' '* */5 * * * *')"""
-        self.cron = App._get_bool_item(data, "cron")
+        self.cron = _get_bool(data, "cron")
         """indicate interval parameter use cron expression or not"""
-        self.daily_limitation = App.DailyLimitation(App._get_native_item(data, "daily_limitation"))
-        self.retention = App._get_str_item(data, "retention")
+        self.daily_limitation = App.DailyLimitation(_get_item(data, "daily_limitation"))
+        self.retention = _get_str(data, "retention")
         """extra timeout seconds for stopping current process, support ISO 8601 durations (e.g., 'P1Y2M3DT4H5M6S' 'P5W')."""
-        self.health_check_cmd = App._get_str_item(data, "health_check_cmd")
+        self.health_check_cmd = _get_str(data, "health_check_cmd")
         """health check script command (e.g., sh -x 'curl host:port/health', return 0 is health)"""
-        self.permission = App._get_int_item(data, "permission")
+        self.permission = _get_int(data, "permission")
         """application user permission, value is 2 bit integer: [group & other], each bit can be deny:1, read:2, write: 3."""
-        self.behavior = App.Behavior(App._get_native_item(data, "behavior"))
+        self.behavior = App.Behavior(_get_item(data, "behavior"))
 
         self.env = data.get("env", {}) if data else {}
         """environment variables (e.g., -e env1=value1 -e env2=value2, APP_DOCKER_OPTS is used to input docker run parameters)"""
         self.sec_env = data.get("sec_env", {}) if data else {}
         """security environment variables, encrypt in server side with application owner's cipher"""
-        self.pid = App._get_int_item(data, "pid")
+        self.pid = _get_int(data, "pid")
         """process id used to attach to the running process"""
-        self.resource_limit = App.ResourceLimitation(App._get_native_item(data, "resource_limit"))
+        self.resource_limit = App.ResourceLimitation(_get_item(data, "resource_limit"))
 
         # Read-only attributes
-        self.owner = App._get_str_item(data, "owner")
+        self.owner = _get_str(data, "owner")
         """owner name"""
-        self.user = App._get_str_item(data, "pid_user")
+        self.user = _get_str(data, "pid_user")
         """process user name"""
-        self.pstree = App._get_str_item(data, "pstree")
+        self.pstree = _get_str(data, "pstree")
         """process tree"""
-        self.container_id = App._get_str_item(data, "container_id")
+        self.container_id = _get_str(data, "container_id")
         """container id"""
-        self.memory = App._get_int_item(data, "memory")
+        self.memory = _get_int(data, "memory")
         """memory usage"""
-        self.cpu = App._get_int_item(data, "cpu")
+        self.cpu = _get_int(data, "cpu")
         """cpu usage"""
-        self.fd = App._get_int_item(data, "fd")
+        self.fd = _get_int(data, "fd")
         """file descriptor usage"""
-        self.last_start_time = App._get_int_item(data, "last_start_time")
+        self.last_start_time = _get_int(data, "last_start_time")
         """last start time"""
-        self.last_exit_time = App._get_int_item(data, "last_exit_time")
+        self.last_exit_time = _get_int(data, "last_exit_time")
         """last exit time"""
-        self.health = App._get_int_item(data, "health")
+        self.health = _get_int(data, "health")
         """health status"""
-        self.version = App._get_int_item(data, "version")
+        self.version = _get_int(data, "version")
         """version number"""
-        self.return_code = App._get_int_item(data, "return_code")
+        self.return_code = _get_int(data, "return_code")
         """last exit code"""
+        self.task_id = _get_int(data, "task_id")
+        """current task id"""
+        self.task_status = _get_str(data, "task_status")
+        """task status"""
 
-    def set_valid_time(self, start: datetime, end: datetime) -> None:
+    def set_valid_time(self, start: Optional[datetime], end: Optional[datetime]) -> None:
         """Define the valid time window for the application."""
         self.start_time = int(start.timestamp()) if start else None
         self.end_time = int(end.timestamp()) if end else None
 
     def set_env(self, key: str, value: str, secure: bool = False) -> None:
         """Set an environment variable, marking it secure if specified."""
-        (self.sec_env if secure else self.env)[key] = value
+        target = self.sec_env if secure else self.env
+        target[key] = value
 
     def set_permission(self, group_user: Permission, others_user: Permission) -> None:
         """Define application permissions based on user roles."""
@@ -214,23 +226,27 @@ class App:
         """Return a JSON string representation of the application."""
         return json.dumps(self.json())
 
-    def json(self) -> dict:
+    def json(self) -> Dict[str, Any]:
         """Convert the application data into a JSON-compatible dictionary, removing empty items."""
         output = copy.deepcopy(self.__dict__)
         output["behavior"] = self.behavior.__dict__
         output["daily_limitation"] = self.daily_limitation.__dict__
         output["resource_limit"] = self.resource_limit.__dict__
 
-        def clean_empty(data: dict) -> None:
-            keys_to_delete = []
-            for key, value in data.items():
-                if isinstance(value, dict) and key != "metadata":
-                    clean_empty(value)  # Recursive call (without checking user metadata)
-                if data[key] in [None, "", {}]:
-                    keys_to_delete.append(key)  # Mark keys for deletion
-
-            for key in keys_to_delete:  # Delete keys after the loop to avoid modifying dict during iteration
-                del data[key]
-
-        clean_empty(output)
+        self._clean_empty(output)
         return output
+
+    @staticmethod
+    def _clean_empty(data: dict) -> None:
+        """Recursively remove None, empty string, and empty dict values from nested dictionaries (except 'metadata')."""
+        keys_to_delete = []
+        for key, value in data.items():
+            if isinstance(value, dict) and key != "metadata":
+                App._clean_empty(value)
+                if not value:
+                    keys_to_delete.append(key)
+            elif value in (None, "", {}):
+                keys_to_delete.append(key)
+
+        for key in keys_to_delete:
+            del data[key]

appmesh/app_output.py

@@ -1,27 +1,28 @@
 # app_output.py
-# pylint: disable=line-too-long
-"""Application output information"""
+"""Application output information."""
 
-# Standard library imports
+from dataclasses import dataclass
 from http import HTTPStatus
 from typing import Optional
 
 
-class AppOutput(object):
+@dataclass(frozen=True)
+class AppOutput:
     """
-    Represents the output information returned by the `app_output()` API.
-    including the application's stdout , current read position, http status code, and process exit code.
+    Output information returned by the `app_output()` API.
+
+    Includes the application's stdout, current read position,
+    HTTP status code, and process exit code.
     """
 
-    def __init__(self, status_code: HTTPStatus, output: str, out_position: Optional[int], exit_code: Optional[int]) -> None:
-        self.status_code = status_code
-        """HTTP status code from the `app_output()` API request, indicating the http status."""
+    status_code: HTTPStatus
+    """HTTP status code from the `app_output()` API request."""
 
-        self.output = output
-        """Captured stdout content of the application as returned by the `app_output()` API."""
+    output: str
+    """Captured stdout content of the application."""
 
-        self.out_position = out_position
-        """Current read position in the application's stdout stream, or `None` if not applicable."""
+    out_position: Optional[int]
+    """Current read position in stdout stream, or None if not applicable."""
 
-        self.exit_code = exit_code
-        """Exit code of the application, or `None` if the process is still running or hasn't exited."""
+    exit_code: Optional[int]
+    """Exit code of the application, or None if still running."""

appmesh/app_run.py

@@ -2,18 +2,19 @@
 """Application run object for remote application execution."""
 
 from contextlib import contextmanager
-from typing import Optional
+from typing import TYPE_CHECKING, Optional
 
-# pylint: disable=line-too-long
+if TYPE_CHECKING:
+    from .client_http import AppMeshClient
 
 
 class AppRun:
     """
-    Represents an application run object initiated by `run_async()` for monitoring and retrieving
-    the result of a remote application run.
+    Application run object for monitoring and retrieving results
+    of a remote application run initiated by `run_async()`.
     """
 
-    def __init__(self, client, app_name: str, process_id: str):
+    def __init__(self, client: "AppMeshClient", app_name: str, process_id: str):
         self.app_name = app_name
         """Name of the application associated with this run."""
 
@@ -21,20 +22,15 @@ class AppRun:
         """Unique process ID from `run_async()`."""
 
         self._client = client
-        """Instance of `AppMeshClient` used to manage this application run."""
-
         self._forward_to = client.forward_to
-        """Target server for the application run, used for forwarding."""
 
     @contextmanager
     def forward_to(self):
-        """Context manager to temporarily override the client's `forward_to` setting.
-
-        This ensures that operations during this run use the correct target server,
-        then restores the original setting when done.
+        """
+        Context manager to temporarily override the client's `forward_to` setting.
 
-        Yields:
-            None: Context for the overridden forward_to setting.
+        Ensures operations during this run use the correct target server,
+        then restores the original setting.
         """
         original_value = self._client.forward_to
         self._client.forward_to = self._forward_to
@@ -44,15 +40,15 @@ class AppRun:
             self._client.forward_to = original_value
 
     def wait(self, stdout_print: bool = True, timeout: int = 0) -> Optional[int]:
-        """Wait for the asynchronous run to complete.
+        """
+        Wait for the asynchronous run to complete.
 
         Args:
-            stdout_print: If `True`, prints remote stdout to local console. Defaults to `True`.
-            timeout: Maximum time to wait in seconds. If `0`, waits indefinitely until completion.
-                    Defaults to `0`.
+            stdout_print: If True, prints remote stdout to local console.
+            timeout: Maximum time to wait in seconds. 0 means wait indefinitely.
 
         Returns:
-            Exit code if the process finishes successfully, or `None` on timeout or exception.
+            Exit code if the process finishes successfully, or None on timeout.
         """
         with self.forward_to():
             return self._client.wait_for_async_run(self, stdout_print, timeout)

appmesh/tcp_messages.py

@@ -1,72 +1,69 @@
-# tcp_messages.py
+"""TCP message classes for HTTP-like communication."""
 
 # Standard library imports
-from typing import get_type_hints
+from dataclasses import dataclass, field
+from typing import Any, Dict, Type, get_type_hints
 
 # Third-party imports
 import msgpack
 
 
+@dataclass
 class RequestMessage:
-    """TCP request message for HTTP-like communication"""
+    """TCP request message for HTTP-like communication."""
 
-    def __init__(self):
-        self.uuid: str = ""
-        self.request_uri: str = ""
-        self.http_method: str = ""
-        self.client_addr: str = ""
-        self.body: bytes = b""
-        self.headers: dict = {}
-        self.query: dict = {}
+    uuid: str = ""
+    request_uri: str = ""
+    http_method: str = ""
+    client_addr: str = ""
+    body: bytes = b""
+    headers: Dict[str, str] = field(default_factory=dict)
+    query: Dict[str, str] = field(default_factory=dict)
 
     def serialize(self) -> bytes:
-        """Serialize request message to bytes"""
-        return msgpack.dumps(vars(self), use_bin_type=True)
+        """Serialize request message to bytes."""
+        return msgpack.packb(self.__dict__, use_bin_type=True)
 
 
+@dataclass
 class ResponseMessage:
-    """TCP response message for HTTP-like communication"""
-
-    uuid: str
-    request_uri: str
-    http_status: int
-    body_msg_type: str
-    body: bytes
-    headers: dict
-
-    def __init__(self):
-        self.uuid = ""
-        self.request_uri = ""
-        self.http_status = 0
-        self.body_msg_type = ""
-        self.body = b""
-        self.headers = {}
-
-    def deserialize(self, buf: bytes):
+    """TCP response message for HTTP-like communication."""
+
+    uuid: str = ""
+    request_uri: str = ""
+    http_status: int = 0
+    body_msg_type: str = ""
+    body: bytes = b""
+    headers: Dict[str, str] = field(default_factory=dict)
+
+    def deserialize(self, buf: bytes) -> "ResponseMessage":
         """Deserialize TCP msgpack buffer with proper type conversion."""
-        dic = msgpack.unpackb(buf, raw=False)
+        data = msgpack.unpackb(buf, raw=False)
         hints = get_type_hints(self.__class__)
 
-        for k, v in dic.items():
-            if k not in hints:
-                continue  # Skip unknown fields
-
-            # handle all types (int, bytes, dict, str)
-            t = hints[k]
-            if t is str:
-                if isinstance(v, bytes):
-                    v = v.decode("utf-8", errors="replace")
-                elif v is None:
-                    v = ""
-                else:
-                    v = str(v)
-            elif t is bytes:
-                if isinstance(v, str):
-                    v = v.encode("utf-8")  # handle accidental str
-                elif v is None:
-                    v = b""
-            elif t is int:
-                v = int(v or 0)
-            setattr(self, k, v)
+        for key, value in data.items():
+            if key in hints:
+                setattr(self, key, self._convert_type(value, hints[key]))
 
         return self
+
+    @staticmethod
+    def _convert_type(value: Any, expected_type: Type) -> Any:
+        """Convert value to expected type."""
+        if value is None:
+            return {
+                str: "",
+                bytes: b"",
+                int: 0,
+            }.get(expected_type, None)
+
+        if expected_type is str:
+            return value.decode("utf-8", errors="replace") if isinstance(value, bytes) else str(value)
+
+        if expected_type is bytes:
+            return value.encode("utf-8") if isinstance(value, str) else value
+
+        if expected_type is int:
+            return int(value or 0)
+
+        return value

appmesh/tcp_transport.py

@@ -1,71 +1,100 @@
 # tcp_transport.py
+"""TCP Transport layer handling socket connections."""
 
-# Standard library imports
-import os
 import socket
 import ssl
 import struct
-from typing import Optional, Tuple, Union
+from pathlib import Path
+from typing import Optional, Union, Tuple
 
 
 class TCPTransport:
-    """TCP Transport layer handling socket connections"""
+    """TCP Transport layer with TLS support."""
 
     # Number of bytes used for the message length header
     # Must match the C++ service implementation which uses uint32_t (4 bytes)
     # Format: Big-endian unsigned 32-bit integer
     TCP_MESSAGE_HEADER_LENGTH = 8
     TCP_MESSAGE_MAGIC = 0x07C707F8  # Magic number
-    TCP_MAX_BLOCK_SIZE = 1024 * 1024 * 100  # 100 MB message size limit
-
-    def __init__(self, address: Tuple[str, int], ssl_verify: Union[bool, str], ssl_client_cert: Union[str, Tuple[str, str]]):
-        """Construct an TCPTransport object to send and recieve TCP data.
+    TCP_MAX_BLOCK_SIZE = 100 * 1024 * 1024  # 100 MB
+
+    def __init__(
+        self,
+        address: Tuple[str, int],
+        ssl_verify: Union[bool, str],
+        ssl_client_cert: Optional[Union[str, Tuple[str, str]]] = None,
+    ):
+        """
+        Initialize TCP transport with TLS configuration.
 
         Args:
-            ssl_verify (Union[bool, str], optional): Specifies SSL certificate verification behavior. Can be:
-                - `True`: Uses the system's default CA certificates to verify the server's identity.
-                - `False`: Disables SSL certificate verification (insecure, intended for development).
-                - `str`: Specifies a custom CA bundle or directory for server certificate verification. If a string is provided,
-                it should either be a file path to a custom CA certificate (CA bundle) or a directory path containing multiple
-                certificates (CA directory).
-
-                **Note**: Unlike HTTP requests, TCP connections cannot automatically retrieve intermediate or public CA certificates.
-                When `rest_ssl_verify` is a path, it explicitly identifies a CA issuer to ensure certificate validation.
-
-            ssl_client_cert (Union[str, Tuple[str, str]], optional): Path to the SSL client certificate and key. Can be:
-                - `str`: A path to a single PEM file containing both the client certificate and private key.
-                - `tuple`: A pair of paths (`cert_file`, `key_file`), where `cert_file` is the client certificate file path and `key_file` is the private key file path.
-
-            tcp_address (Tuple[str, int], optional): Address and port for establishing a TCP connection to the server.
-                Defaults to `("127.0.0.1", 6059)`.
+            address: Server address as (host, port) tuple.
+
+            ssl_verify: SSL server verification mode:
+                - True: Use system CA certificates
+                - False:  Disable verification (insecure)
+                - str: Path to custom CA bundle or directory
+
+            ssl_client_cert: SSL client certificate:
+                - str: Path to PEM file with cert and key
+                - tuple: (cert_path, key_path)
+
+        Note:
+            TCP connections require an explicit full-chain CA specification for certificate validation,
+            unlike HTTP, which can retrieve intermediate certificates automatically.
         """
-        self.tcp_address = address
+        self.address = address
         self.ssl_verify = ssl_verify
         self.ssl_client_cert = ssl_client_cert
-        self._socket = None
+        self._socket: Optional[ssl.SSLSocket] = None
 
     def __enter__(self):
-        """Context manager entry"""
+        """Context manager entry."""
         if not self.connected():
             self.connect()
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        """Context manager exit"""
+        """Context manager exit."""
         self.close()
 
-    def __del__(self) -> None:
-        """De-construction"""
-        self.close()
+    def __del__(self):
+        try:
+            self.close()
+        except Exception:
+            pass  # suppress all exceptions
 
     def connect(self) -> None:
-        """Establish tcp connection"""
+        """Establish TLS connection to server."""
+        context = self._create_ssl_context()
+        # Create a TCP socket
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.setblocking(True)
+        # sock.settimeout(30)  # Connection timeout set to 30 seconds
+
+        try:
+            # Wrap the socket with SSL/TLS
+            ssl_socket = context.wrap_socket(sock, server_hostname=self.address[0])
+            ssl_socket.connect(self.address)
+            # Disable Nagle's algorithm
+            ssl_socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+            # After connecting, set separate timeout for recv/send
+            # ssl_socket.settimeout(20)  # 20 seconds for recv/send
+            self._socket = ssl_socket
+        except (socket.error, ssl.SSLError) as e:
+            sock.close()
+            raise RuntimeError(f"Failed to connect to {self.address}: {e}") from e
+
+    def _create_ssl_context(self) -> ssl.SSLContext:
+        """Create and configure SSL context."""
         context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
+
         # Set minimum TLS version
         if hasattr(context, "minimum_version"):
             context.minimum_version = ssl.TLSVersion.TLSv1_2
         else:
             context.options |= ssl.OP_NO_TLSv1 | ssl.OP_NO_TLSv1_1
+
         # Configure SSL verification
         if not self.ssl_verify:
             context.check_hostname = False
@@ -73,46 +102,30 @@ class TCPTransport:
         else:
             context.verify_mode = ssl.CERT_REQUIRED  # Require certificate verification
             context.load_default_certs()  # Load system's default CA certificates
+
             if isinstance(self.ssl_verify, str):
-                if os.path.isfile(self.ssl_verify):
+                path = Path(self.ssl_verify)
+                if path.is_file():
                     # Load custom CA certificate file
-                    context.load_verify_locations(cafile=self.ssl_verify)
-                elif os.path.isdir(self.ssl_verify):
+                    context.load_verify_locations(cafile=str(path))
+                elif path.is_dir():
                     # Load CA certificates from directory
-                    context.load_verify_locations(capath=self.ssl_verify)
+                    context.load_verify_locations(capath=str(path))
                 else:
-                    raise ValueError(f"ssl_verify path '{self.ssl_verify}' is neither a file nor a directory")
+                    raise ValueError(f"ssl_verify path '{self.ssl_verify}' is invalid")
 
-        if self.ssl_client_cert is not None:
-            # Load client-side certificate and private key
-            if isinstance(self.ssl_client_cert, tuple) and len(self.ssl_client_cert) == 2:
+        # Load client certificate if provided
+        if self.ssl_client_cert:
+            if isinstance(self.ssl_client_cert, tuple):
+                # Separate cert and key files
                 context.load_cert_chain(certfile=self.ssl_client_cert[0], keyfile=self.ssl_client_cert[1])
-            elif isinstance(self.ssl_client_cert, str):
-                # Handle case where cert and key are in the same file
-                context.load_cert_chain(certfile=self.ssl_client_cert)
             else:
-                raise ValueError("ssl_client_cert must be a string filepath or a tuple of (cert_file, key_file)")
+                # Cert and key in the same PEM file
+                context.load_cert_chain(certfile=self.ssl_client_cert)
 
-        # Create a TCP socket
-        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        sock.setblocking(True)
-        # sock.settimeout(30)  # Connection timeout set to 30 seconds
-        try:
-            # Wrap the socket with SSL/TLS
-            ssl_socket = context.wrap_socket(sock, server_hostname=self.tcp_address[0])
-            # Connect to the server
-            ssl_socket.connect(self.tcp_address)
-            # Disable Nagle's algorithm
-            ssl_socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
-            # After connecting, set separate timeout for recv/send
-            # ssl_socket.settimeout(20)  # 20 seconds for recv/send
-            self._socket = ssl_socket
-        except (socket.error, ssl.SSLError) as e:
-            sock.close()
-            raise RuntimeError(f"Failed to connect to {self.tcp_address}: {e}") from e
+        return context
 
     def close(self) -> None:
-        """Close socket connection"""
         if self._socket:
             try:
                 self._socket.close()
@@ -122,18 +135,24 @@ class TCPTransport:
                 self._socket = None
 
     def connected(self) -> bool:
-        """Check whether socket is connected"""
         return self._socket is not None
 
-    def send_message(self, data) -> None:
-        """Send a message with a prefixed header indicating its length"""
-        if self._socket is None:
+    def send_message(self, data: Union[bytes, bytearray, list]) -> None:
+        """
+        Send a message with prefixed header.
+
+        Args:
+            data: Message data to send, or empty list for EOF signal.
+        """
+        if not self._socket:
             raise RuntimeError("Cannot send message: not connected")
 
         try:
-            length = len(data)
+            length = len(data) if data else 0
             # Pack the header into 8 bytes using big-endian format
-            self._socket.sendall(struct.pack("!II", self.TCP_MESSAGE_MAGIC, length))
+            header = struct.pack("!II", self.TCP_MESSAGE_MAGIC, length)
+            self._socket.sendall(header)
+
             if length > 0:
                 self._socket.sendall(data)
         except (socket.error, ssl.SSLError) as e:
@@ -141,62 +160,69 @@ class TCPTransport:
             raise RuntimeError(f"Error sending message: {e}") from e
 
     def receive_message(self) -> Optional[bytearray]:
-        """Receive a message with a prefixed header indicating its length and validate it"""
-        if self._socket is None:
+        """
+        Receive a message with prefixed header.
+
+        Returns:
+            Message data, or None for EOF signal.
+        """
+        if not self._socket:
             raise RuntimeError("Cannot receive message: not connected")
 
         try:
             # Unpack the data (big-endian format)
             magic, length = struct.unpack("!II", self._recvall(self.TCP_MESSAGE_HEADER_LENGTH))
+
             if magic != self.TCP_MESSAGE_MAGIC:
-                raise ValueError(f"Invalid message: incorrect magic number 0x{magic:X}.")
+                raise ValueError(f"Invalid magic number: 0x{magic:X}")
+
             if length > self.TCP_MAX_BLOCK_SIZE:
-                raise ValueError(f"Message size {length} exceeds the maximum allowed size of {self.TCP_MAX_BLOCK_SIZE} bytes.")
-            if length > 0:
-                return self._recvall(length)
-            return None
+                raise ValueError(f"Message size {length} exceeds maximum {self.TCP_MAX_BLOCK_SIZE}")
+
+            return self._recvall(length) if length > 0 else None
+
         except (socket.error, ssl.SSLError) as e:
             self.close()
             raise RuntimeError(f"Error receiving message: {e}") from e
 
     def _recvall(self, length: int) -> bytes:
-        """Receive exactly `length` bytes from the socket.
-           https://stackoverflow.com/questions/64466530/using-a-custom-socket-recvall-function-works-only-if-thread-is-put-to-sleep
+        """
+        Receive exactly `length` bytes from socket.
+        https://stackoverflow.com/questions/64466530/using-a-custom-socket-recvall-function-works-only-if-thread-is-put-to-sleep
 
         Args:
-            length (int): Number of bytes to receive.
+            length: Number of bytes to receive.
 
         Returns:
-            bytes: Received data.
+            Received data.
 
         Raises:
             EOFError: If connection closes before receiving all data.
             ValueError: If length is not positive.
-            socket.timeout: If socket operation times out.
         """
         if length <= 0:
             raise ValueError(f"Invalid length: {length}")
 
         # Pre-allocate buffer
         buffer = bytearray(length)
-        mv = memoryview(buffer)
+        view = memoryview(buffer)
         bytes_received = 0
 
         while bytes_received < length:
             try:
                 # Receive directly into buffer
                 remaining = length - bytes_received
-                chunk_size = self._socket.recv_into(mv, remaining)
+                chunk_size = self._socket.recv_into(view, remaining)
 
                 if chunk_size == 0:
                     raise EOFError("Connection closed by peer")
 
-                mv = mv[chunk_size:]  # advance memoryview
+                view = view[chunk_size:]  # advance memoryview
                 bytes_received += chunk_size
 
             except InterruptedError:
                 continue
             except socket.timeout as e:
-                raise socket.timeout(f"Socket operation timed out after receiving {bytes_received}/{length} bytes") from e
+                raise socket.timeout(f"Socket timed out after receiving {bytes_received}/{length} bytes") from e
 
-        return bytes(buffer)  # safer than bytearray
+        return bytes(buffer)

{appmesh-1.6.11.dist-info → appmesh-1.6.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: appmesh
-Version: 1.6.11
+Version: 1.6.13
 Summary: Client SDK for App Mesh
 Home-page: https://github.com/laoshanxi/app-mesh
 Author: laoshanxi
@@ -8,7 +8,7 @@ Author-email: 178029200@qq.com
 License: MIT
 Keywords: appmesh AppMesh app-mesh
 Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.6
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3
 Description-Content-Type: text/markdown
@@ -17,6 +17,7 @@ Requires-Dist: msgpack
 Requires-Dist: requests_toolbelt
 Requires-Dist: aniso8601
 Requires-Dist: PyJWT
+Requires-Dist: dataclasses; python_version < "3.7"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

appmesh-1.6.13.dist-info/RECORD

@@ -0,0 +1,16 @@
+appmesh/__init__.py,sha256=on6GmTTwo6mrRbw_XUuf8sZdl5zBYsGT4CSf8l__NnI,2488
+appmesh/app.py,sha256=5kzQCvGH3LRRUTHsI2_MKEPD3M2qs8kvTxLhbNUqit4,10601
+appmesh/app_output.py,sha256=s6eqevFxETTVXSPTJX6JyGNpHHILv4ZyM7YWvlkuqQs,741
+appmesh/app_run.py,sha256=m3ihaacx84o1rl2Oc3EbnppW8D-PTxdehftbWRe8rPk,1732
+appmesh/appmesh_client.py,sha256=ywB2222PtJUffdfdxZcBfdhZs1KYyc7JvzMxwuK2qyI,378
+appmesh/client_http.py,sha256=FXCldfTZVU_5RSuSknlH1K2UiC6gOeotj-4NDQzdEhY,60752
+appmesh/client_http_oauth.py,sha256=1d51o0JX_xtB8d2bEuM7_XJHcwMnhcjkbIq7GE1Zxm8,6120
+appmesh/client_tcp.py,sha256=RX3T3OG4iOAju8ZPOnTjI_y97Y23_kWoNDjmKjtrBeU,11524
+appmesh/server_http.py,sha256=wfyiIa2zC-uJR2ZNTGMjYWheqAfSRl0aAv5b_GYcwpE,4343
+appmesh/server_tcp.py,sha256=J65kmN7DJftyW1LlF--S3keQ6VGmqXb778E79I1R0_k,1488
+appmesh/tcp_messages.py,sha256=E0cKWUta7NjuLoTGk-Z9CvbdZyakwG7hO8st_07E5L4,1991
+appmesh/tcp_transport.py,sha256=oUpcBXOaJhG5Hs6yqt9UG8_eENu0cEdNZIyC87LqI7Q,8165
+appmesh-1.6.13.dist-info/METADATA,sha256=BJJB6M94Sz2yytdr9WRxCf56q1-LCzQ-2zQAfP5_1eU,11814
+appmesh-1.6.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+appmesh-1.6.13.dist-info/top_level.txt,sha256=-y0MNQOGJxUzLdHZ6E_Rfv5_LNCkV-GTmOBME_b6pg8,8
+appmesh-1.6.13.dist-info/RECORD,,

appmesh-1.6.11.dist-info/RECORD

@@ -1,16 +0,0 @@
-appmesh/__init__.py,sha256=uJ5LOadwZW2nOXkSuPOy2S3WH9Bx0BUn5wUvPBeFzoc,2217
-appmesh/app.py,sha256=crD4DRFZJuHtZMfSsz7C-EwvjPmGZbFXYXvA_wCdvdI,10734
-appmesh/app_output.py,sha256=N8BihWhuUgPUyqZabZMKhQylk8nTHXKk6kMIdidEkGM,1061
-appmesh/app_run.py,sha256=aYq852a29OThIi32Xtx5s0sTXZ97T0lHD5WXH8yfPoc,2018
-appmesh/appmesh_client.py,sha256=ywB2222PtJUffdfdxZcBfdhZs1KYyc7JvzMxwuK2qyI,378
-appmesh/client_http.py,sha256=FXCldfTZVU_5RSuSknlH1K2UiC6gOeotj-4NDQzdEhY,60752
-appmesh/client_http_oauth.py,sha256=1d51o0JX_xtB8d2bEuM7_XJHcwMnhcjkbIq7GE1Zxm8,6120
-appmesh/client_tcp.py,sha256=RX3T3OG4iOAju8ZPOnTjI_y97Y23_kWoNDjmKjtrBeU,11524
-appmesh/server_http.py,sha256=wfyiIa2zC-uJR2ZNTGMjYWheqAfSRl0aAv5b_GYcwpE,4343
-appmesh/server_tcp.py,sha256=J65kmN7DJftyW1LlF--S3keQ6VGmqXb778E79I1R0_k,1488
-appmesh/tcp_messages.py,sha256=YB_AiMOSzN9j8oSrF0V9gD184Ugbsff-ZnezExwmvtk,1928
-appmesh/tcp_transport.py,sha256=FCfTBHb9FLwMUIxZejOuH_NocHQFGaNDge57IUTJvgs,8973
-appmesh-1.6.11.dist-info/METADATA,sha256=gHUSXnQdxvG61jPEUWcJBSJlrmR_PIHZ_qyyaYwTuIc,11764
-appmesh-1.6.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-appmesh-1.6.11.dist-info/top_level.txt,sha256=-y0MNQOGJxUzLdHZ6E_Rfv5_LNCkV-GTmOBME_b6pg8,8
-appmesh-1.6.11.dist-info/RECORD,,