appmesh 1.6.15__tar.gz → 1.6.16__tar.gz

{appmesh-1.6.15 → appmesh-1.6.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: appmesh
-Version: 1.6.15
+Version: 1.6.16
 Summary: Client SDK for App Mesh
 Home-page: https://github.com/laoshanxi/app-mesh
 Author: laoshanxi

{appmesh-1.6.15 → appmesh-1.6.16}/appmesh/client_http.py

@@ -115,35 +115,35 @@ class AppMeshClient(metaclass=abc.ABCMeta):
     """
 
     # Duration constants
-    DURATION_ONE_WEEK_ISO = "P1W"
-    DURATION_TWO_DAYS_ISO = "P2D"
-    DURATION_TWO_DAYS_HALF_ISO = "P2DT12H"
-    TOKEN_REFRESH_INTERVAL = 300  # 5 min to refresh token
-    TOKEN_REFRESH_OFFSET = 30  # 30s before token expire to refresh token
+    _DURATION_ONE_WEEK_ISO = "P1W"
+    _DURATION_TWO_DAYS_ISO = "P2D"
+    _DURATION_TWO_DAYS_HALF_ISO = "P2DT12H"
+    _TOKEN_REFRESH_INTERVAL = 300  # 5 min to refresh token
+    _TOKEN_REFRESH_OFFSET = 30  # 30s before token expire to refresh token
 
     # Platform-aware default SSL paths
     _DEFAULT_SSL_DIR = Path("c:/local/appmesh/ssl" if os.name == "nt" else "/opt/appmesh/ssl")
-    DEFAULT_SSL_CA_CERT_PATH = str(_DEFAULT_SSL_DIR / "ca.pem")
-    DEFAULT_SSL_CLIENT_CERT_PATH = str(_DEFAULT_SSL_DIR / "client.pem")
-    DEFAULT_SSL_CLIENT_KEY_PATH = str(_DEFAULT_SSL_DIR / "client-key.pem")
+    _DEFAULT_SSL_CA_CERT_PATH = str(_DEFAULT_SSL_DIR / "ca.pem")
+    _DEFAULT_SSL_CLIENT_CERT_PATH = str(_DEFAULT_SSL_DIR / "client.pem")
+    _DEFAULT_SSL_CLIENT_KEY_PATH = str(_DEFAULT_SSL_DIR / "client-key.pem")
 
     # JWT constants
-    DEFAULT_JWT_AUDIENCE = "appmesh-service"
+    _DEFAULT_JWT_AUDIENCE = "appmesh-service"
 
     # HTTP headers and constants
-    JSON_KEY_MESSAGE = "message"
-    HTTP_USER_AGENT = "appmesh/python"
-    HTTP_HEADER_KEY_AUTH = "Authorization"
-    HTTP_HEADER_KEY_USER_AGENT = "User-Agent"
-    HTTP_HEADER_KEY_X_TARGET_HOST = "X-Target-Host"
-    HTTP_HEADER_KEY_X_FILE_PATH = "X-File-Path"
-    HTTP_HEADER_JWT_SET_COOKIE = "X-Set-Cookie"
-    HTTP_HEADER_NAME_CSRF_TOKEN = "X-CSRF-Token"
-    COOKIE_TOKEN = "appmesh_auth_token"
-    COOKIE_CSRF_TOKEN = "appmesh_csrf_token"
+    _JSON_KEY_MESSAGE = "message"
+    _HTTP_USER_AGENT = "appmesh/python"
+    _HTTP_HEADER_KEY_AUTH = "Authorization"
+    _HTTP_HEADER_KEY_USER_AGENT = "User-Agent"
+    _HTTP_HEADER_KEY_X_TARGET_HOST = "X-Target-Host"
+    _HTTP_HEADER_KEY_X_FILE_PATH = "X-File-Path"
+    _HTTP_HEADER_JWT_SET_COOKIE = "X-Set-Cookie"
+    _HTTP_HEADER_NAME_CSRF_TOKEN = "X-CSRF-Token"
+    _COOKIE_TOKEN = "appmesh_auth_token"
+    _COOKIE_CSRF_TOKEN = "appmesh_csrf_token"
 
     @unique
-    class Method(Enum):
+    class _Method(Enum):
         """REST methods"""
 
         GET = "GET"
@@ -152,7 +152,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         DELETE = "DELETE"
         POST_STREAM = "POST_STREAM"
 
-    class EncodingResponse(requests.Response):
+    class _EncodingResponse(requests.Response):
         """Response subclass that handles encoding conversion on Windows."""
 
         def __init__(self, response: requests.Response):
@@ -195,8 +195,8 @@ class AppMeshClient(metaclass=abc.ABCMeta):
     def __init__(
         self,
         rest_url: str = "https://127.0.0.1:6060",
-        rest_ssl_verify: Union[bool, str] = DEFAULT_SSL_CA_CERT_PATH,
-        rest_ssl_client_cert: Optional[Union[str, Tuple[str, str]]] = (DEFAULT_SSL_CLIENT_CERT_PATH, DEFAULT_SSL_CLIENT_KEY_PATH),
+        rest_ssl_verify: Union[bool, str] = _DEFAULT_SSL_CA_CERT_PATH,
+        rest_ssl_client_cert: Optional[Union[str, Tuple[str, str]]] = (_DEFAULT_SSL_CLIENT_CERT_PATH, _DEFAULT_SSL_CLIENT_KEY_PATH),
         rest_timeout: Tuple[float, float] = (60, 300),
         jwt_token: Optional[str] = None,
         rest_cookie_file: Optional[str] = None,
@@ -235,7 +235,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         self.session = requests.Session()
         self.cookie_file = rest_cookie_file
         loaded = self._load_cookies(rest_cookie_file)
-        cookie_token = self._get_cookie_value(self.session.cookies, self.COOKIE_TOKEN) if loaded else None
+        cookie_token = self._get_cookie_value(self.session.cookies, self._COOKIE_TOKEN) if loaded else None
 
         # Set property last after all dependencies are initialized to setup refresh timer
         self.jwt_token = jwt_token or cookie_token
@@ -246,6 +246,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         if not logging.root.handlers:
             logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s", datefmt="%Y-%m-%d %H:%M:%S")
 
+    # @abc.abstractmethod
     def _get_access_token(self) -> str:
         """Get the current access token."""
         return self.jwt_token or ""
@@ -305,7 +306,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
             expiry = decoded_token.get("exp", 0)
             current_time = time.time()
             time_to_expiry = expiry - current_time
-            needs_refresh = time_to_expiry < self.TOKEN_REFRESH_OFFSET
+            needs_refresh = time_to_expiry < self._TOKEN_REFRESH_OFFSET
 
         # Refresh token if needed
         if needs_refresh:
@@ -328,15 +329,15 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
         try:
             # Default to checking after 60 seconds
-            check_interval = self.TOKEN_REFRESH_INTERVAL
+            check_interval = self._TOKEN_REFRESH_INTERVAL
 
             # Calculate more precise check time if expiry is known
             if time_to_expiry is not None:
-                if time_to_expiry <= self.TOKEN_REFRESH_OFFSET:  # Expires within 5 minutes
+                if time_to_expiry <= self._TOKEN_REFRESH_OFFSET:  # Expires within 5 minutes
                     check_interval = 1  # Almost immediate refresh
                 else:
                     # Check at earlier of 5 minutes before expiry or regular interval
-                    check_interval = max(1, min(time_to_expiry - self.TOKEN_REFRESH_OFFSET, self.TOKEN_REFRESH_INTERVAL))
+                    check_interval = max(1, min(time_to_expiry - self._TOKEN_REFRESH_OFFSET, self._TOKEN_REFRESH_INTERVAL))
 
             # Create timer to execute refresh check
             self._token_refresh_timer = threading.Timer(check_interval, self._check_and_refresh_token)
@@ -346,6 +347,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         except Exception as e:
             logging.error("Auto-refresh: Failed to schedule token refresh: %s", e)
 
+    # @abc.abstractmethod
     def close(self):
         """Close the session and release resources."""
         # Cancel token refresh timer
@@ -434,7 +436,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         user_name: str,
         user_pwd: str,
         totp_code: Optional[str] = "",
-        timeout_seconds: Union[str, int] = DURATION_ONE_WEEK_ISO,
+        timeout_seconds: Union[str, int] = _DURATION_ONE_WEEK_ISO,
         audience: Optional[str] = None,
     ) -> str:
         """Login with user name and password.
@@ -454,18 +456,18 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
         credentials = f"{user_name}:{user_pwd}".encode()
         headers = {
-            self.HTTP_HEADER_KEY_AUTH: f"Basic {base64.b64encode(credentials).decode()}",
+            self._HTTP_HEADER_KEY_AUTH: f"Basic {base64.b64encode(credentials).decode()}",
             "X-Expire-Seconds": str(self._parse_duration(timeout_seconds)),
         }
         if audience:
             headers["X-Audience"] = audience
         if self.cookie_file:
-            headers[self.HTTP_HEADER_JWT_SET_COOKIE] = "true"
+            headers[self._HTTP_HEADER_JWT_SET_COOKIE] = "true"
         # if totp_code:
         #    headers["X-Totp-Code"] = totp_code
 
         resp = self._request_http(
-            AppMeshClient.Method.POST,
+            AppMeshClient._Method.POST,
             path="/appmesh/login",
             header=headers,
         )
@@ -484,14 +486,14 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
         return self.jwt_token
 
-    def validate_totp(self, username: str, challenge: str, code: str, timeout: Union[int, str] = DURATION_ONE_WEEK_ISO) -> str:
+    def validate_totp(self, username: str, challenge: str, code: str, timeout: Union[int, str] = _DURATION_ONE_WEEK_ISO) -> str:
         """Validate TOTP challenge and obtain a new JWT token.
 
         Args:
             username: Username to validate.
             challenge: Challenge string from server.
             code: TOTP code to validate.
-            timeout: Token expiration duration, defaults to `DURATION_ONE_WEEK_ISO` (1 week).
+            timeout: Token expiration duration, defaults to `_DURATION_ONE_WEEK_ISO` (1 week).
                 Accepts either:
                   - **ISO 8601 duration string** (e.g., `'P1Y2M3DT4H5M6S'`, `'P1W'`)
                   - **Numeric value (seconds)** for simpler cases.
@@ -506,10 +508,10 @@ class AppMeshClient(metaclass=abc.ABCMeta):
             "expire_seconds": self._parse_duration(timeout),
         }
 
-        headers = {self.HTTP_HEADER_JWT_SET_COOKIE: "true"} if self.cookie_file else {}
+        headers = {self._HTTP_HEADER_JWT_SET_COOKIE: "true"} if self.cookie_file else {}
 
         resp = self._request_http(
-            AppMeshClient.Method.POST,
+            AppMeshClient._Method.POST,
             path="/appmesh/totp/validate",
             body=body,
             header=headers,
@@ -525,7 +527,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         if not self.jwt_token or not isinstance(self.jwt_token, str):
             return False
 
-        resp = self._request_http(AppMeshClient.Method.POST, path="/appmesh/self/logoff")
+        resp = self._request_http(AppMeshClient._Method.POST, path="/appmesh/self/logoff")
         self.jwt_token = None
         return resp.status_code == HTTPStatus.OK
 
@@ -556,7 +558,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         if permission:
             headers["X-Permission"] = permission
 
-        resp = self._request_http(AppMeshClient.Method.POST, path="/appmesh/auth", header=headers)
+        resp = self._request_http(AppMeshClient._Method.POST, path="/appmesh/auth", header=headers)
 
         if resp.status_code != HTTPStatus.OK:
             self.jwt_token = old_token
@@ -564,7 +566,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
         return True
 
-    def renew_token(self, timeout: Union[int, str] = DURATION_ONE_WEEK_ISO) -> str:
+    def renew_token(self, timeout: Union[int, str] = _DURATION_ONE_WEEK_ISO) -> str:
         """Renew the current token.
 
         Args:
@@ -580,7 +582,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
             raise Exception("Unsupported token format")
 
         resp = self._request_http(
-            AppMeshClient.Method.POST,
+            AppMeshClient._Method.POST,
             path="/appmesh/token/renew",
             header={"X-Expire-Seconds": str(self._parse_duration(timeout))},
         )
@@ -597,7 +599,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
     def get_totp_secret(self) -> str:
         """Generate TOTP secret for the current user."""
-        resp = self._request_http(method=AppMeshClient.Method.POST, path="/appmesh/totp/secret")
+        resp = self._request_http(method=AppMeshClient._Method.POST, path="/appmesh/totp/secret")
 
         if resp.status_code != HTTPStatus.OK:
             raise Exception(resp.text)
@@ -619,7 +621,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
             The new JWT token if setup succeeds.
         """
         resp = self._request_http(
-            method=AppMeshClient.Method.POST,
+            method=AppMeshClient._Method.POST,
             path="/appmesh/totp/setup",
             header={"X-Totp-Code": totp_code},
         )
@@ -634,7 +636,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
     def disable_totp(self, user: str = "self") -> None:
         """Disable 2FA for the specified user."""
         resp = self._request_http(
-            method=AppMeshClient.Method.POST,
+            method=AppMeshClient._Method.POST,
             path=f"/appmesh/totp/{user}/disable",
         )
 
@@ -662,7 +664,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
     ########################################
     def view_app(self, app_name: str) -> App:
         """Get information about a specific application."""
-        resp = self._request_http(AppMeshClient.Method.GET, path=f"/appmesh/app/{app_name}")
+        resp = self._request_http(AppMeshClient._Method.GET, path=f"/appmesh/app/{app_name}")
 
         if resp.status_code != HTTPStatus.OK:
             raise Exception(resp.text)
@@ -671,7 +673,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
     def view_all_apps(self) -> list:
         """Get information about all applications."""
-        resp = self._request_http(AppMeshClient.Method.GET, path="/appmesh/applications")
+        resp = self._request_http(AppMeshClient._Method.GET, path="/appmesh/applications")
 
         if resp.status_code != HTTPStatus.OK:
             raise Exception(resp.text)
@@ -694,7 +696,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
             AppOutput object.
         """
         resp = self._request_http(
-            AppMeshClient.Method.GET,
+            AppMeshClient._Method.GET,
             path=f"/appmesh/app/{app_name}/output",
             query={
                 "stdout_position": str(stdout_position),
@@ -712,7 +714,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
     def check_app_health(self, app_name: str) -> bool:
         """Check the health status of an application."""
-        resp = self._request_http(AppMeshClient.Method.GET, path=f"/appmesh/app/{app_name}/health")
+        resp = self._request_http(AppMeshClient._Method.GET, path=f"/appmesh/app/{app_name}/health")
 
         if resp.status_code != HTTPStatus.OK:
             raise Exception(resp.text)
@@ -725,7 +727,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
     def add_app(self, app: App) -> App:
         # type: (App) -> App
         """Register a new application."""
-        resp = self._request_http(AppMeshClient.Method.PUT, path=f"/appmesh/app/{app.name}", body=app.json())
+        resp = self._request_http(AppMeshClient._Method.PUT, path=f"/appmesh/app/{app.name}", body=app.json())
 
         if resp.status_code != HTTPStatus.OK:
             raise Exception(resp.text)
@@ -734,7 +736,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
     def delete_app(self, app_name: str) -> bool:
         """Remove an application."""
-        resp = self._request_http(AppMeshClient.Method.DELETE, path=f"/appmesh/app/{app_name}")
+        resp = self._request_http(AppMeshClient._Method.DELETE, path=f"/appmesh/app/{app_name}")
 
         if resp.status_code == HTTPStatus.OK:
             return True
@@ -745,14 +747,14 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
     def enable_app(self, app_name: str) -> None:
         """Enable an application."""
-        resp = self._request_http(AppMeshClient.Method.POST, path=f"/appmesh/app/{app_name}/enable")
+        resp = self._request_http(AppMeshClient._Method.POST, path=f"/appmesh/app/{app_name}/enable")
 
         if resp.status_code != HTTPStatus.OK:
             raise Exception(resp.text)
 
     def disable_app(self, app_name: str) -> None:
         """Disable an application."""
-        resp = self._request_http(AppMeshClient.Method.POST, path=f"/appmesh/app/{app_name}/disable")
+        resp = self._request_http(AppMeshClient._Method.POST, path=f"/appmesh/app/{app_name}/disable")
 
         if resp.status_code != HTTPStatus.OK:
             raise Exception(resp.text)
@@ -762,7 +764,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
     ########################################
     def view_host_resources(self) -> dict:
         """Get a report of host resources including CPU, memory, and disk."""
-        resp = self._request_http(AppMeshClient.Method.GET, path="/appmesh/resources")
+        resp = self._request_http(AppMeshClient._Method.GET, path="/appmesh/resources")
 
         if resp.status_code != HTTPStatus.OK:
             raise Exception(resp.text)
@@ -771,7 +773,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
     def view_config(self) -> dict:
         """Get the App Mesh configuration in JSON format."""
-        resp = self._request_http(AppMeshClient.Method.GET, path="/appmesh/config")
+        resp = self._request_http(AppMeshClient._Method.GET, path="/appmesh/config")
 
         if resp.status_code != HTTPStatus.OK:
             raise Exception(resp.text)
@@ -780,7 +782,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
     def set_config(self, config_json: dict) -> dict:
         """Update the configuration."""
-        resp = self._request_http(AppMeshClient.Method.POST, path="/appmesh/config", body=config_json)
+        resp = self._request_http(AppMeshClient._Method.POST, path="/appmesh/config", body=config_json)
 
         if resp.status_code != HTTPStatus.OK:
             raise Exception(resp.text)
@@ -789,7 +791,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
     def set_log_level(self, level: str = "DEBUG") -> str:
         """Update the log level."""
-        resp = self._request_http(AppMeshClient.Method.POST, path="/appmesh/config", body={"BaseConfig": {"LogLevel": level}})
+        resp = self._request_http(AppMeshClient._Method.POST, path="/appmesh/config", body={"BaseConfig": {"LogLevel": level}})
 
         if resp.status_code != HTTPStatus.OK:
             raise Exception(resp.text)
@@ -807,7 +809,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         }
 
         resp = self._request_http(
-            method=AppMeshClient.Method.POST,
+            method=AppMeshClient._Method.POST,
             path=f"/appmesh/user/{user_name}/passwd",
             body=body,
         )
@@ -818,7 +820,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
     def add_user(self, user_name: str, user_json: dict) -> None:
         """Add a new user."""
         resp = self._request_http(
-            method=AppMeshClient.Method.PUT,
+            method=AppMeshClient._Method.PUT,
             path=f"/appmesh/user/{user_name}",
             body=user_json,
         )
@@ -828,7 +830,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
     def delete_user(self, user_name: str):
         """Delete a user."""
         resp = self._request_http(
-            method=AppMeshClient.Method.DELETE,
+            method=AppMeshClient._Method.DELETE,
             path=f"/appmesh/user/{user_name}",
         )
         if resp.status_code != HTTPStatus.OK:
@@ -837,7 +839,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
     def lock_user(self, user_name: str) -> None:
         """Lock a user."""
         resp = self._request_http(
-            method=AppMeshClient.Method.POST,
+            method=AppMeshClient._Method.POST,
             path=f"/appmesh/user/{user_name}/lock",
         )
 
@@ -847,7 +849,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
     def unlock_user(self, user_name: str) -> None:
         """Unlock a user."""
         resp = self._request_http(
-            method=AppMeshClient.Method.POST,
+            method=AppMeshClient._Method.POST,
             path=f"/appmesh/user/{user_name}/unlock",
         )
 
@@ -856,7 +858,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
     def view_users(self) -> dict:
         """Get information about all users."""
-        resp = self._request_http(method=AppMeshClient.Method.GET, path="/appmesh/users")
+        resp = self._request_http(method=AppMeshClient._Method.GET, path="/appmesh/users")
 
         if resp.status_code != HTTPStatus.OK:
             raise Exception(resp.text)
@@ -865,7 +867,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
     def view_self(self) -> dict:
         """Get information about the current user."""
-        resp = self._request_http(method=AppMeshClient.Method.GET, path="/appmesh/user/self")
+        resp = self._request_http(method=AppMeshClient._Method.GET, path="/appmesh/user/self")
 
         if resp.status_code != HTTPStatus.OK:
             raise Exception(resp.text)
@@ -874,7 +876,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
     def view_groups(self) -> list:
         """Get information about all user groups."""
-        resp = self._request_http(method=AppMeshClient.Method.GET, path="/appmesh/user/groups")
+        resp = self._request_http(method=AppMeshClient._Method.GET, path="/appmesh/user/groups")
 
         if resp.status_code != HTTPStatus.OK:
             raise Exception(resp.text)
@@ -883,7 +885,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
     def view_permissions(self) -> list:
         """Get information about all available permissions."""
-        resp = self._request_http(method=AppMeshClient.Method.GET, path="/appmesh/permissions")
+        resp = self._request_http(method=AppMeshClient._Method.GET, path="/appmesh/permissions")
 
         if resp.status_code != HTTPStatus.OK:
             raise Exception(resp.text)
@@ -892,7 +894,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
     def view_user_permissions(self) -> list:
         """Get information about the permissions of the current user."""
-        resp = self._request_http(method=AppMeshClient.Method.GET, path="/appmesh/user/permissions")
+        resp = self._request_http(method=AppMeshClient._Method.GET, path="/appmesh/user/permissions")
 
         if resp.status_code != HTTPStatus.OK:
             raise Exception(resp.text)
@@ -901,7 +903,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
     def view_roles(self) -> list:
         """Get information about all roles with permission definitions."""
-        resp = self._request_http(method=AppMeshClient.Method.GET, path="/appmesh/roles")
+        resp = self._request_http(method=AppMeshClient._Method.GET, path="/appmesh/roles")
 
         if resp.status_code != HTTPStatus.OK:
             raise Exception(resp.text)
@@ -910,7 +912,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
     def update_role(self, role_name: str, role_permission_json: dict) -> None:
         """Update or add a role with defined permissions."""
-        resp = self._request_http(method=AppMeshClient.Method.POST, path=f"/appmesh/role/{role_name}", body=role_permission_json)
+        resp = self._request_http(method=AppMeshClient._Method.POST, path=f"/appmesh/role/{role_name}", body=role_permission_json)
 
         if resp.status_code != HTTPStatus.OK:
             raise Exception(resp.text)
@@ -918,7 +920,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
     def delete_role(self, role_name: str) -> None:
         """Delete a user role."""
         resp = self._request_http(
-            method=AppMeshClient.Method.DELETE,
+            method=AppMeshClient._Method.DELETE,
             path=f"/appmesh/role/{role_name}",
         )
 
@@ -931,7 +933,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
     def add_tag(self, tag_name: str, tag_value: str) -> None:
         """Add a new label."""
         resp = self._request_http(
-            AppMeshClient.Method.PUT,
+            AppMeshClient._Method.PUT,
             query={"value": tag_value},
             path=f"/appmesh/label/{tag_name}",
         )
@@ -941,14 +943,14 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
     def delete_tag(self, tag_name: str) -> None:
         """Delete a label."""
-        resp = self._request_http(AppMeshClient.Method.DELETE, path=f"/appmesh/label/{tag_name}")
+        resp = self._request_http(AppMeshClient._Method.DELETE, path=f"/appmesh/label/{tag_name}")
 
         if resp.status_code != HTTPStatus.OK:
             raise Exception(resp.text)
 
     def view_tags(self) -> dict:
         """Get information about all labels."""
-        resp = self._request_http(AppMeshClient.Method.GET, path="/appmesh/labels")
+        resp = self._request_http(AppMeshClient._Method.GET, path="/appmesh/labels")
 
         if resp.status_code != HTTPStatus.OK:
             raise Exception(resp.text)
@@ -960,7 +962,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
     ########################################
     def get_metrics(self) -> str:
         """Get Prometheus metrics."""
-        resp = self._request_http(AppMeshClient.Method.GET, path="/appmesh/metrics")
+        resp = self._request_http(AppMeshClient._Method.GET, path="/appmesh/metrics")
 
         if resp.status_code != HTTPStatus.OK:
             raise Exception(resp.text)
@@ -972,7 +974,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
     ########################################
     def download_file(self, remote_file: str, local_file: str, preserve_permissions: bool = True) -> None:
         """Download a remote file to the local system."""
-        resp = self._request_http(AppMeshClient.Method.GET, path="/appmesh/file/download", header={self.HTTP_HEADER_KEY_X_FILE_PATH: remote_file})
+        resp = self._request_http(AppMeshClient._Method.GET, path="/appmesh/file/download", header={self._HTTP_HEADER_KEY_X_FILE_PATH: remote_file})
         resp.raise_for_status()
 
         # Write the file content locally
@@ -1004,19 +1006,19 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         with local_path.open("rb") as fp:
             encoder = MultipartEncoder(fields={"filename": os.path.basename(remote_file), "file": ("filename", fp, "application/octet-stream")})
 
-            header = {self.HTTP_HEADER_KEY_X_FILE_PATH: parse.quote(remote_file), "Content-Type": encoder.content_type}
+            header = {self._HTTP_HEADER_KEY_X_FILE_PATH: parse.quote(remote_file), "Content-Type": encoder.content_type}
 
             # Include file attributes if requested
             if preserve_permissions:
                 file_stat = local_path.stat()
-                header["X-File-Mode"] = str(file_stat.st_mode & 0o777) # Mask to keep only permission bits
+                header["X-File-Mode"] = str(file_stat.st_mode & 0o777)  # Mask to keep only permission bits
                 header["X-File-User"] = str(file_stat.st_uid)
                 header["X-File-Group"] = str(file_stat.st_gid)
 
             # Upload file with or without attributes
             # https://stackoverflow.com/questions/22567306/python-requests-file-upload
             resp = self._request_http(
-                AppMeshClient.Method.POST_STREAM,
+                AppMeshClient._Method.POST_STREAM,
                 path="/appmesh/file/upload",
                 header=header,
                 body=encoder,
@@ -1050,7 +1052,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
             str: The HTTP response body returned by the remote application/service.
         """
         resp = self._request_http(
-            AppMeshClient.Method.POST,
+            AppMeshClient._Method.POST,
             path=f"/appmesh/app/{app_name}/task",
             body=data,
             query={"timeout": str(timeout)},
@@ -1071,7 +1073,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
             bool: Task exist and cancled status.
         """
         resp = self._request_http(
-            AppMeshClient.Method.DELETE,
+            AppMeshClient._Method.DELETE,
             path=f"/appmesh/app/{app_name}/task",
         )
         return resp.status_code == HTTPStatus.OK
@@ -1079,8 +1081,8 @@ class AppMeshClient(metaclass=abc.ABCMeta):
     def run_app_async(
         self,
         app: Union[App, str],
-        max_time_seconds: Union[int, str] = DURATION_TWO_DAYS_ISO,
-        life_cycle_seconds: Union[int, str] = DURATION_TWO_DAYS_HALF_ISO,
+        max_time_seconds: Union[int, str] = _DURATION_TWO_DAYS_ISO,
+        life_cycle_seconds: Union[int, str] = _DURATION_TWO_DAYS_HALF_ISO,
     ) -> AppRun:
         """Run an application asynchronously on a remote system without blocking the API.
 
@@ -1103,7 +1105,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
             app = App({"command": app, "shell": True})
 
         resp = self._request_http(
-            AppMeshClient.Method.POST,
+            AppMeshClient._Method.POST,
             body=app.json(),
             path="/appmesh/app/run",
             query={
@@ -1165,8 +1167,8 @@ class AppMeshClient(metaclass=abc.ABCMeta):
         self,
         app: Union[App, str],
         stdout_print: bool = True,
-        max_time_seconds: Union[int, str] = DURATION_TWO_DAYS_ISO,
-        life_cycle_seconds: Union[int, str] = DURATION_TWO_DAYS_HALF_ISO,
+        max_time_seconds: Union[int, str] = _DURATION_TWO_DAYS_ISO,
+        life_cycle_seconds: Union[int, str] = _DURATION_TWO_DAYS_HALF_ISO,
     ) -> Tuple[Union[int, None], str]:
         """Synchronously run an application remotely, blocking until completion, and return the result.
 
@@ -1190,7 +1192,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
             app = App({"command": app, "shell": True})
 
         resp = self._request_http(
-            AppMeshClient.Method.POST,
+            AppMeshClient._Method.POST,
             body=app.json(),
             path="/appmesh/app/syncrun",
             query={
@@ -1210,7 +1212,7 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
         return exit_code, resp.text
 
-    def _request_http(self, method: Method, path: str, query: Optional[dict] = None, header: Optional[dict] = None, body=None) -> requests.Response:
+    def _request_http(self, method: _Method, path: str, query: Optional[dict] = None, header: Optional[dict] = None, body=None) -> requests.Response:
         """Make an HTTP request."""
         rest_url = parse.urljoin(self.auth_server_url, path)
 
@@ -1219,23 +1221,23 @@ class AppMeshClient(metaclass=abc.ABCMeta):
 
         if self.cookie_file:
             # Cookie-based token
-            csrf_token = self._get_cookie_value(self.session.cookies, self.COOKIE_CSRF_TOKEN)
+            csrf_token = self._get_cookie_value(self.session.cookies, self._COOKIE_CSRF_TOKEN)
             if csrf_token:
-                headers[self.HTTP_HEADER_NAME_CSRF_TOKEN] = csrf_token
+                headers[self._HTTP_HEADER_NAME_CSRF_TOKEN] = csrf_token
         else:
             # Api-based token
             access_token = self._get_access_token()
             if access_token:
-                headers[self.HTTP_HEADER_KEY_AUTH] = f"Bearer {access_token}"
+                headers[self._HTTP_HEADER_KEY_AUTH] = f"Bearer {access_token}"
 
         if self.forward_to:
             target_host = self.forward_to
             if ":" not in target_host:
                 port = parse.urlsplit(self.auth_server_url).port
                 target_host = f"{target_host}:{port}"
-            headers[self.HTTP_HEADER_KEY_X_TARGET_HOST] = target_host
+            headers[self._HTTP_HEADER_KEY_X_TARGET_HOST] = target_host
 
-        headers[self.HTTP_HEADER_KEY_USER_AGENT] = self.HTTP_USER_AGENT
+        headers[self._HTTP_HEADER_KEY_USER_AGENT] = self._HTTP_USER_AGENT
 
         # Convert body to JSON string if it's a dict or list
         if isinstance(body, (dict, list)):
@@ -1251,21 +1253,21 @@ class AppMeshClient(metaclass=abc.ABCMeta):
                 "timeout": self.rest_timeout,
             }
 
-            if method == AppMeshClient.Method.GET:
+            if method == AppMeshClient._Method.GET:
                 resp = self.session.get(params=query, **request_kwargs)
-            elif method == AppMeshClient.Method.POST:
+            elif method == AppMeshClient._Method.POST:
                 resp = self.session.post(params=query, data=body, **request_kwargs)
-            elif method == AppMeshClient.Method.POST_STREAM:
+            elif method == AppMeshClient._Method.POST_STREAM:
                 resp = self.session.post(params=query, data=body, stream=True, **request_kwargs)
-            elif method == AppMeshClient.Method.DELETE:
+            elif method == AppMeshClient._Method.DELETE:
                 resp = self.session.delete(**request_kwargs)
-            elif method == AppMeshClient.Method.PUT:
+            elif method == AppMeshClient._Method.PUT:
                 resp = self.session.put(params=query, data=body, **request_kwargs)
             else:
                 raise Exception("Invalid http method", method)
 
             # Wrap the response for encoding handling
-            return AppMeshClient.EncodingResponse(resp)
+            return AppMeshClient._EncodingResponse(resp)
 
         except requests.exceptions.RequestException as e:
             raise Exception(f"HTTP request failed: {e}") from e

{appmesh-1.6.15 → appmesh-1.6.16}/appmesh/client_http_oauth.py

@@ -1,8 +1,7 @@
 # client_http_oauth.py
 # pylint: disable=line-too-long,broad-exception-caught,too-many-lines, import-outside-toplevel, protected-access
-import os
 import logging
-from typing import Optional, Union
+from typing import Optional, Union, Tuple
 from keycloak import KeycloakOpenID
 from .client_http import AppMeshClient
 
@@ -18,10 +17,10 @@ class AppMeshClientOAuth(AppMeshClient):
         self,
         oauth2: dict,  # Required for Keycloak
         rest_url: str = "https://127.0.0.1:6060",
-        rest_ssl_verify=AppMeshClient.DEFAULT_SSL_CA_CERT_PATH,
-        rest_ssl_client_cert=AppMeshClient.DEFAULT_SSL_CLIENT_CERT_PATH,
-        rest_timeout=(60, 300),
-        jwt_token=None,  # Keycloak dict
+        rest_ssl_verify: Union[bool, str] = AppMeshClient._DEFAULT_SSL_CA_CERT_PATH,
+        rest_ssl_client_cert: Optional[Union[str, Tuple[str, str]]] = None,
+        rest_timeout: Tuple[float, float] = (60, 300),
+        jwt_token: Optional[dict] = None,  # Keycloak dict
         auto_refresh_token: bool = True,  # Default to True for Keycloak
     ):
         """Initialize an App Mesh HTTP client with Keycloak support.
@@ -63,7 +62,6 @@ class AppMeshClientOAuth(AppMeshClient):
         user_name: str,
         user_pwd: str,
         totp_code: Optional[str] = "",
-        timeout_seconds: Union[str, int] = AppMeshClient.DURATION_ONE_WEEK_ISO,
     ) -> dict:
         """Login with user name and password using Keycloak.
         Args:

{appmesh-1.6.15 → appmesh-1.6.16}/appmesh/client_tcp.py

@@ -44,15 +44,15 @@ class AppMeshClientTCP(AppMeshClient):
     """
 
     # TLS-optimized chunk size, leaves room for TLS overhead within the 16 KB limit
-    TCP_BLOCK_SIZE = 16 * 1024 - 128
-    ENCODING_UTF8 = "utf-8"
-    HTTP_USER_AGENT_TCP = "appmesh/python/tcp"
-    HTTP_HEADER_KEY_X_SEND_FILE_SOCKET = "X-Send-File-Socket"
-    HTTP_HEADER_KEY_X_RECV_FILE_SOCKET = "X-Recv-File-Socket"
+    _TCP_BLOCK_SIZE = 16 * 1024 - 128
+    _ENCODING_UTF8 = "utf-8"
+    _HTTP_USER_AGENT_TCP = "appmesh/python/tcp"
+    _HTTP_HEADER_KEY_X_SEND_FILE_SOCKET = "X-Send-File-Socket"
+    _HTTP_HEADER_KEY_X_RECV_FILE_SOCKET = "X-Recv-File-Socket"
 
     def __init__(
         self,
-        rest_ssl_verify: Union[bool, str] = AppMeshClient.DEFAULT_SSL_CA_CERT_PATH,
+        rest_ssl_verify: Union[bool, str] = AppMeshClient._DEFAULT_SSL_CA_CERT_PATH,
         rest_ssl_client_cert: Optional[Union[str, Tuple[str, str]]] = None,
         jwt_token: Optional[str] = None,
         tcp_address: Tuple[str, int] = ("127.0.0.1", 6059),
@@ -100,14 +100,14 @@ class AppMeshClientTCP(AppMeshClient):
             return body
 
         if isinstance(body, str):
-            return body.encode(self.ENCODING_UTF8)
+            return body.encode(self._ENCODING_UTF8)
 
         if isinstance(body, (dict, list)):
-            return json.dumps(body).encode(self.ENCODING_UTF8)
+            return json.dumps(body).encode(self._ENCODING_UTF8)
 
         raise TypeError(f"Unsupported body type: {type(body)}")
 
-    def _request_http(self, method: AppMeshClient.Method, path: str, query: Optional[dict] = None, header: Optional[dict] = None, body=None) -> requests.Response:
+    def _request_http(self, method: AppMeshClient._Method, path: str, query: Optional[dict] = None, header: Optional[dict] = None, body=None) -> requests.Response:
         """Send HTTP request over TCP transport.
 
         Args:
@@ -134,12 +134,12 @@ class AppMeshClientTCP(AppMeshClient):
         appmesh_request.http_method = method.value
         appmesh_request.request_uri = path
         appmesh_request.client_addr = socket.gethostname()
-        appmesh_request.headers[self.HTTP_HEADER_KEY_USER_AGENT] = self.HTTP_USER_AGENT_TCP
+        appmesh_request.headers[self._HTTP_HEADER_KEY_USER_AGENT] = self._HTTP_USER_AGENT_TCP
 
         # Add authentication token
         token = self._get_access_token()
         if token:
-            appmesh_request.headers[self.HTTP_HEADER_KEY_AUTH] = token
+            appmesh_request.headers[self._HTTP_HEADER_KEY_AUTH] = token
 
         # Add custom headers
         if header:
@@ -171,17 +171,17 @@ class AppMeshClientTCP(AppMeshClient):
         response.headers = appmesh_resp.headers
 
         # Set response content
-        # response.encoding = self.ENCODING_UTF8 # only need when charset not in appmesh_resp.body_msg_type
+        # response.encoding = self._ENCODING_UTF8 # only need when charset not in appmesh_resp.body_msg_type
         if isinstance(appmesh_resp.body, bytes):
             response._content = appmesh_resp.body
         else:
-            response._content = str(appmesh_resp.body).encode(self.ENCODING_UTF8)
+            response._content = str(appmesh_resp.body).encode(self._ENCODING_UTF8)
 
         # Set content type
         if appmesh_resp.body_msg_type:
             response.headers["Content-Type"] = appmesh_resp.body_msg_type
 
-        return AppMeshClient.EncodingResponse(response)
+        return AppMeshClient._EncodingResponse(response)
 
     def _apply_file_attributes(self, local_file: str, headers: dict) -> None:
         """Apply file attributes from headers to local file."""
@@ -232,15 +232,15 @@ class AppMeshClientTCP(AppMeshClient):
             preserve_permissions: Apply remote file permissions/ownership locally.
         """
         header = {
-            AppMeshClient.HTTP_HEADER_KEY_X_FILE_PATH: remote_file,
-            self.HTTP_HEADER_KEY_X_RECV_FILE_SOCKET: "true",
+            AppMeshClient._HTTP_HEADER_KEY_X_FILE_PATH: remote_file,
+            self._HTTP_HEADER_KEY_X_RECV_FILE_SOCKET: "true",
         }
 
-        resp = self._request_http(AppMeshClient.Method.GET, path="/appmesh/file/download", header=header)
+        resp = self._request_http(AppMeshClient._Method.GET, path="/appmesh/file/download", header=header)
         resp.raise_for_status()
 
-        if self.HTTP_HEADER_KEY_X_RECV_FILE_SOCKET not in resp.headers:
-            raise ValueError(f"Server did not respond with socket transfer option: " f"{self.HTTP_HEADER_KEY_X_RECV_FILE_SOCKET}")
+        if self._HTTP_HEADER_KEY_X_RECV_FILE_SOCKET not in resp.headers:
+            raise ValueError(f"Server did not respond with socket transfer option: " f"{self._HTTP_HEADER_KEY_X_RECV_FILE_SOCKET}")
 
         # Download file chunks
         with open(local_file, "wb") as fp:
@@ -267,9 +267,9 @@ class AppMeshClientTCP(AppMeshClient):
 
         # Prepare headers
         header = {
-            AppMeshClient.HTTP_HEADER_KEY_X_FILE_PATH: remote_file,
+            AppMeshClient._HTTP_HEADER_KEY_X_FILE_PATH: remote_file,
             "Content-Type": "text/plain",
-            self.HTTP_HEADER_KEY_X_SEND_FILE_SOCKET: "true",
+            self._HTTP_HEADER_KEY_X_SEND_FILE_SOCKET: "true",
         }
 
         # Add file attributes if requested
@@ -277,16 +277,16 @@ class AppMeshClientTCP(AppMeshClient):
             header.update(self._get_file_attributes(local_file))
 
         # Initiate upload
-        resp = self._request_http(AppMeshClient.Method.POST, path="/appmesh/file/upload", header=header)
+        resp = self._request_http(AppMeshClient._Method.POST, path="/appmesh/file/upload", header=header)
         resp.raise_for_status()
 
-        if self.HTTP_HEADER_KEY_X_SEND_FILE_SOCKET not in resp.headers:
-            raise ValueError(f"Server did not respond with socket transfer option: " f"{self.HTTP_HEADER_KEY_X_SEND_FILE_SOCKET}")
+        if self._HTTP_HEADER_KEY_X_SEND_FILE_SOCKET not in resp.headers:
+            raise ValueError(f"Server did not respond with socket transfer option: " f"{self._HTTP_HEADER_KEY_X_SEND_FILE_SOCKET}")
 
         # Upload file chunks
         with open(local_file, "rb") as fp:
             while True:
-                chunk_data = fp.read(self.TCP_BLOCK_SIZE)
+                chunk_data = fp.read(self._TCP_BLOCK_SIZE)
                 if not chunk_data:
                     self.tcp_transport.send_message([])  # EOF signal
                     break

{appmesh-1.6.15 → appmesh-1.6.16}/appmesh/server_http.py

@@ -40,7 +40,7 @@ class AppMeshServer(metaclass=abc.ABCMeta):
     def __init__(
         self,
         rest_url: str = "https://127.0.0.1:6060",
-        rest_ssl_verify: Union[bool, str] = AppMeshClient.DEFAULT_SSL_CA_CERT_PATH,
+        rest_ssl_verify: Union[bool, str] = AppMeshClient._DEFAULT_SSL_CA_CERT_PATH,
         rest_ssl_client_cert: Optional[Union[str, Tuple[str, str]]] = None,
         rest_timeout: Tuple[float, float] = (60, 300),
         *,
@@ -81,7 +81,7 @@ class AppMeshServer(metaclass=abc.ABCMeta):
 
         while True:
             resp = self._client._request_http(
-                AppMeshClient.Method.GET,
+                AppMeshClient._Method.GET,
                 path=path,
                 query=query_params,
             )
@@ -106,7 +106,7 @@ class AppMeshServer(metaclass=abc.ABCMeta):
         query_params = {"process_key": pkey}
 
         resp = self._client._request_http(
-            AppMeshClient.Method.PUT,
+            AppMeshClient._Method.PUT,
             path=path,
             query=query_params,
             body=result,

{appmesh-1.6.15 → appmesh-1.6.16}/appmesh/server_tcp.py

@@ -18,7 +18,7 @@ class AppMeshServerTCP(AppMeshServer):
 
     def __init__(
         self,
-        rest_ssl_verify: Union[bool, str] = AppMeshClient.DEFAULT_SSL_CA_CERT_PATH,
+        rest_ssl_verify: Union[bool, str] = AppMeshClient._DEFAULT_SSL_CA_CERT_PATH,
         rest_ssl_client_cert: Optional[Union[str, Tuple[str, str]]] = None,
         tcp_address: Tuple[str, int] = ("127.0.0.1", 6059),
         *,

{appmesh-1.6.15 → appmesh-1.6.16}/appmesh/tcp_messages.py

@@ -1,4 +1,5 @@
 """TCP message classes for HTTP-like communication."""
+__all__ = []
 
 # Standard library imports
 from dataclasses import dataclass, field

{appmesh-1.6.15 → appmesh-1.6.16}/appmesh/tcp_transport.py

@@ -1,5 +1,6 @@
 # tcp_transport.py
 """TCP Transport layer handling socket connections."""
+__all__ = []
 
 import socket
 import ssl

{appmesh-1.6.15 → appmesh-1.6.16}/appmesh.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: appmesh
-Version: 1.6.15
+Version: 1.6.16
 Summary: Client SDK for App Mesh
 Home-page: https://github.com/laoshanxi/app-mesh
 Author: laoshanxi

{appmesh-1.6.15 → appmesh-1.6.16}/setup.py

@@ -1,6 +1,5 @@
 import io
 import os
-import sys
 import setuptools
 
 readme_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), "../../../README.md")
@@ -10,7 +9,7 @@ with io.open(os.path.abspath(readme_path), mode="r", encoding="utf-8") as fh:
 
 def get_version():
     """PyPI package version"""
-    return "1.6.15"
+    return "1.6.16"
 
 
 # Dependencies