appmesh 1.6.12__tar.gz

appmesh-1.6.12/PKG-INFO

@@ -0,0 +1,164 @@
+Metadata-Version: 2.4
+Name: appmesh
+Version: 1.6.12
+Summary: Client SDK for App Mesh
+Home-page: https://github.com/laoshanxi/app-mesh
+Author: laoshanxi
+Author-email: 178029200@qq.com
+License: MIT
+Keywords: appmesh AppMesh app-mesh
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+Requires-Dist: msgpack
+Requires-Dist: requests_toolbelt
+Requires-Dist: aniso8601
+Requires-Dist: PyJWT
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+[![language.badge]][language.url] [![standard.badge]][standard.url] [![unittest.badge]][unittest.url] [![docker.badge]][docker.url] [![cockpit.badge]][cockpit.url]
+[![Documentation Status](https://readthedocs.org/projects/app-mesh/badge/?version=latest)](https://app-mesh.readthedocs.io/en/latest/?badge=latest) [![Join the chat at https://gitter.im/app-mesh/community](https://badges.gitter.im/app-mesh/community.svg)](https://gitter.im/app-mesh/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+<a href="https://scan.coverity.com/projects/laoshanxi-app-mesh">
+  <img alt="Coverity Scan Build Status"
+       src="https://img.shields.io/coverity/scan/21528.svg"/>
+</a>
+[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/laoshanxi/app-mesh/badge)](https://api.securityscorecards.dev/projects/github.com/laoshanxi/app-mesh)
+[![release.badge]][release.url] [![pypi.badge]][pypi.url] [![npm.badge]][npm.url]
+
+# App Mesh: Advanced Application Management Platform
+
+<div align=center><img src="https://github.com/laoshanxi/picture/raw/master/appmesh/whatis.gif" align=center /></div>
+App Mesh is an open-source, multi-tenant application management platform designed for cloud-native environments. It efficiently manages, schedules, and monitors both microservices and traditional applications, offering a lightweight alternative to Kubernetes. App Mesh bridges the gap between simple process managers and complex container orchestration systems, making it ideal for organizations seeking to modernize their infrastructure without adopting full container-native complexity. Supporting both containerized and native applications, it provides a versatile solution for diverse enterprise needs.
+
+<div align=center><img src="https://github.com/laoshanxi/picture/raw/master/appmesh/diagram.png" align=center /></div>
+
+## Features
+
+Feature | Description
+---|---
+Application management | 🧩 <b>Application Management (CURD) with Full Remote Control</b> – including cgroup, OS user, environment variables, Docker, stdin, and stdout – along with comprehensive monitoring (start counts, exit codes, error messages, health checks). <br> 🧩 <b>Fine-Grained Application Behavior Control & Scheduling</b> – supports long- and short-running tasks, periodic jobs, cron schedules, custom timings, and robust error handling. <br> 🧩 <b>Multi-Tenancy</b> –  built-in user ownership model and access controls. <br> 🧩 <b>Unified Access Interface</b> – interact via [CLI](https://app-mesh.readthedocs.io/en/latest/CLI.html), [REST](https://app-mesh.readthedocs.io/en/latest/Development.html#rest-apis), [SDK](https://github.com/laoshanxi/app-mesh/tree/main/src/sdk) or [WebGUI](https://github.com/laoshanxi/app-mesh-ui).<br>
+Security |  🔐 Authentication: [LDAP](https://app-mesh.readthedocs.io/en/latest/LDAP.html), [OAuth](src/sdk/python/test/test_oauth2.py), [2FA](https://app-mesh.readthedocs.io/en/latest/MFA.html), YAML-based storage (local file or Consul for clustering) <br> 🔐 Authorization: [JWT](https://app-mesh.readthedocs.io/en/latest/JWT.html), [RBAC](https://app-mesh.readthedocs.io/en/latest/USER_ROLE.html), multi-tenant isolation <br> 🔐 Protection: SSL/TLS for TCP/HTTP, CSRF tokens, HMAC with PSK for non-token verification
+Cloud native | Schedule cloud-level applications to run on multiple hosts with resource size requests. <br> 🌩️ [Prometheus Exporter (build-in)](https://app-mesh.readthedocs.io/en/latest/PROMETHEUS.html) <br> 🌩️ [Grafana SimpleJson datasource](https://app-mesh.readthedocs.io/en/latest/GrafanaDataSource.html) <br> 🌩️ [Grafana Loki](https://app-mesh.readthedocs.io/en/latest/Loki.html) <br>🌩️ [Dockerfile](https://github.com/laoshanxi/app-mesh/blob/main/Dockerfile)
+Micro service application | 🧱 [Consul micro-service cluster management](https://app-mesh.readthedocs.io/en/latest/CONSUL.html)
+Extra Features | Collect host/app resource usage <br> Remote shell command execution <br> File upload/download interface <br> Hot-update support `systemctl reload appmesh` <br> Bash completion <br> Reverse proxy <br> 🌐[Web GUI](https://github.com/laoshanxi/app-mesh-ui)
+Platform support | X86_64 <br> ARM32 <br> ARM64
+SDK | [Python](https://app-mesh.readthedocs.io/en/latest/api/appmesh.html#module-appmesh.client_http) <br> [Golang](https://github.com/laoshanxi/app-mesh/blob/main/src/sdk/go/client_http.go) <br> [JavaScript](https://www.npmjs.com/package/appmesh) <br> [Java](https://github.com/laoshanxi/app-mesh/packages/2227502) <br> [Swagger OpenAPI Specification](https://petstore.swagger.io/?url=https://raw.githubusercontent.com/laoshanxi/app-mesh/main/src/daemon/rest/openapi.yaml)
+
+## Getting started
+
+Refer to the [Installation doc](https://app-mesh.readthedocs.io/en/latest/Install.html) to learn how to install App Mesh via Docker Compose or natively and set up an App Mesh cluster.
+
+## Documentation
+
+- [Read the Docs](https://app-mesh.readthedocs.io/)
+- [REST API](https://app-mesh.readthedocs.io/en/latest/Development.html#rest-apis)
+- [Command lines](https://app-mesh.readthedocs.io/en/latest/CLI.html)
+- [Security](https://app-mesh.readthedocs.io/en/latest/Security.html)
+
+## Comparison
+
+### Standalone mode
+
+| Feature                  | App Mesh | [Supervisor](http://supervisord.org/) | [crontab](https://crontab.guru/) |
+| ------------------------ | -------- | ------------------------------------- | -------------------------------- |
+| Accuracy                 | Seconds  | Seconds                               | Minutes                          |
+| Language                 | C++11    | Python                                | C                                |
+| Web GUI                  | √        | √                                     |
+| Command lines            | √        | √                                     | √                                |
+| SDK                      | √        |                                       |
+| Cron schedule expression | √        |                                       | √                                |
+| Manage daemon process    |          |                                       | √                                |
+| Manage docker app        | √        |                                       |
+| Start check (avoid leak) | √        | √                                     |
+| Session login            |          |                                       |
+| Manage stdout/stderr     | √        | √                                     |
+| Health check             | √        |                                       |
+| Rich control options     | √        |                                       |
+| Authentication           | √        | √                                     |
+| Multi-tenant             | √        |                                       | √                                |
+
+### Cluster mode
+
+| Feature           | App Mesh | Kubernetes |
+| ----------------- | -------- | ---------- |
+| Easy deploy       | √        |
+| More features     |          | √          |
+| Non-container app | √        |
+| Service expose    | √        | √          |
+| Scheduler         | √        | √          |
+| Definition file   | YAML     | YAML       |
+| GUI               | √        | √          |
+| Virtual Network   |          | √          |
+| Monitor tools     | √        | √          |
+| [Remote task](https://app-mesh.readthedocs.io/en/latest/RemoteTask.html)   | √        |            |
+
+---
+
+### Mind diagram
+
+![mind-diagram](https://github.com/laoshanxi/picture/raw/master/appmesh/mind.png)
+
+---
+
+## Success
+
+- [Build a powerful monitor system with Grafana/Prometheus/Loki](https://app-mesh.readthedocs.io/en/latest/success/build_powerful_monitor_system_with_Grafana_Prometheus_Loki.html)
+- [Customize application start behavior](https://app-mesh.readthedocs.io/en/latest/success/customize_app_startup_behavior.html)
+- [Open service broker support local PV for Kubernetes](https://app-mesh.readthedocs.io/en/latest/success/open_service_broker_support_local_pv_for_K8S.html)
+- [Promote native application to microservice application](https://app-mesh.readthedocs.io/en/latest/success/promote_native_app_to_microservice_app.html)
+- [Secure REST file server](https://app-mesh.readthedocs.io/en/latest/success/secure_REST_file_server.html)
+- [Standalone JWT server](https://app-mesh.readthedocs.io/en/latest/success/standalone_JWT_server.html)
+- [Kubernetes run none-container applications](https://app-mesh.readthedocs.io/en/latest/success/kubernetes_run_native_application.html)
+- [Remote execute](https://app-mesh.readthedocs.io/en/latest/success/remote_run_cli_and_python.html)
+- [Python parallel run](https://app-mesh.readthedocs.io/en/latest/success/python_parallel_run.html)
+- [Secure consul cluster](https://app-mesh.readthedocs.io/en/latest/success/secure_consul_cluster.html)
+- [JWT service with REST and UI](https://github.com/laoshanxi/app-mesh/blob/main/script/docker-compose-auth-service.yaml)
+- [Remote task execute](https://app-mesh.readthedocs.io/en/latest/RemoteTask.html)
+
+---
+
+## Library dependency
+
+- [MessagePack](https://msgpack.org/)
+- [boostorg/boost](https://github.com/boostorg/boost)
+- [ACE_TAO/ACE](https://github.com/DOCGroup/ACE_TAO)
+- [Thalhammer/jwt-cpp](https://github.com/Thalhammer/jwt-cpp)
+- [nlohmann/json](https://json.nlohmann.me)
+- [yaml-cpp](https://github.com/jbeder/yaml-cpp)
+- [nfpm](https://github.com/goreleaser/nfpm)
+- [jupp0r/prometheus-cpp](https://github.com/jupp0r/prometheus-cpp)
+- [zemasoft/wildcards](https://github.com/zemasoft/wildcards)
+- [mariusbancila/croncpp](https://github.com/mariusbancila/croncpp)
+- [log4cpp](http://log4cpp.sourceforge.net)
+- [Crypto++](https://www.cryptopp.com)
+- [ldap-cpp](https://github.com/AndreyBarmaley/ldap-cpp)
+
+[language.url]:   https://isocpp.org/
+[language.badge]: https://img.shields.io/badge/language-C++-blue.svg
+[standard.url]:   https://en.wikipedia.org/wiki/C%2B%2B#Standardization
+[standard.badge]: https://img.shields.io/badge/C%2B%2B-11%2F14%2F17-blue.svg
+[release.url]:    https://github.com/laoshanxi/app-mesh/releases
+[release.badge]:  https://img.shields.io/github/v/release/laoshanxi/app-mesh?label=Github%20package
+[docker.url]:     https://hub.docker.com/repository/docker/laoshanxi/appmesh
+[docker.badge]:   https://img.shields.io/docker/pulls/laoshanxi/appmesh.svg
+[cockpit.url]:    https://github.com/laoshanxi/app-mesh-ui
+[cockpit.badge]:  https://img.shields.io/badge/Cockpit-app--mesh--ui-blue?logo=appveyor
+[unittest.url]:   https://github.com/catchorg/Catch2
+[unittest.badge]: https://img.shields.io/badge/UnitTest-Catch2-blue?logo=appveyor
+[pypi.badge]: https://img.shields.io/pypi/v/appmesh?label=PyPI%3Aappmesh
+[pypi.url]: https://pypi.org/project/appmesh/
+[npm.badge]: https://img.shields.io/npm/v/appmesh?label=npm%3Aappmesh
+[npm.url]: https://www.npmjs.com/package/appmesh

appmesh-1.6.12/appmesh/__init__.py

@@ -0,0 +1,74 @@
+# __init__.py
+"""
+App Mesh SDK package initializer with lazy loading support.
+
+Example:
+    from appmesh import AppMeshClient
+    client = AppMeshClient()
+"""
+
+import sys
+from types import ModuleType
+from typing import TYPE_CHECKING
+from importlib import import_module
+
+__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
+    "AppMeshClientTCP": ("client_tcp", "AppMeshClientTCP"),  # from .client_tcp import AppMeshClientTCP
+    "AppMeshClientOAuth": ("client_http_oauth", "AppMeshClientOAuth"),  # from .client_http_oauth import AppMeshClientOAuth
+    "AppMeshServer": ("server_http", "AppMeshServer"),  # from .server_http import AppMeshServer
+    "AppMeshServerTCP": ("server_tcp", "AppMeshServerTCP"),  # from .server_tcp import AppMeshServerTCP
+}
+
+if TYPE_CHECKING:
+    # 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
+    from .client_http_oauth import AppMeshClientOAuth  # noqa: F401
+    from .server_http import AppMeshServer  # noqa: F401
+    from .server_tcp import AppMeshServerTCP  # noqa: F401
+
+
+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_module(f".{module_name}", __name__)
+        globals()[name] = getattr(module, attr_name)
+        return globals()[name]
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
+
+
+def __dir__():
+    """Provide tab-completion support for lazy-loaded attributes."""
+    return sorted(__all__ + list(globals().keys()))
+
+
+if sys.version_info >= (3, 7):
+    __getattr__ = _lazy_import
+else:
+    # 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-1.6.12/appmesh/app.py

@@ -0,0 +1,252 @@
+# app.py
+"""Application definition"""
+
+import json
+import copy
+from datetime import datetime
+from typing import Optional, Any, Dict
+from enum import Enum, unique
+
+
+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
+
+
+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
+
+    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])
+
+
+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])
+
+
+class App:
+    """
+    An application in App Mesh, include all the process attributes,
+    resource limitations, behaviors, and permissions.
+    """
+
+    @unique
+    class Permission(Enum):
+        """Application permission levels."""
+
+        DENY = "1"
+        READ = "2"
+        WRITE = "3"
+
+    class Behavior:
+        """
+        Application error handling behavior, including exit and control behaviors.
+        """
+
+        @unique
+        class Action(Enum):
+            """Actions for application exit behaviors."""
+
+            RESTART = "restart"
+            STANDBY = "standby"
+            KEEPALIVE = "keepalive"
+            REMOVE = "remove"
+
+        def __init__(self, data: Optional[dict] = None) -> None:
+            if isinstance(data, (str, bytes, bytearray)):
+                data = json.loads(data)
+
+            self.exit = _get_str(data, "exit")
+            """Default exit behavior, options: 'restart', 'standby', 'keepalive', 'remove'."""
+
+            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:
+            """Set default behavior for application exit."""
+            self.exit = action.value
+
+        def set_control_behavior(self, control_code: int, action: "App.Behavior.Action") -> None:
+            """Define behavior for specific exit codes."""
+            self.control[str(control_code)] = action.value
+
+    class DailyLimitation:
+        """
+        Application availability within a daily time range.
+        """
+
+        def __init__(self, data: Optional[dict] = None) -> None:
+            if isinstance(data, (str, bytes, bytearray)):
+                data = json.loads(data)
+
+            self.daily_start = _get_int(data, "daily_start")
+            """Start time for application availability (e.g., 09:00:00+08)."""
+
+            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:
+            """Set the valid daily start and end times."""
+            self.daily_start = int(start.timestamp())
+            self.daily_end = int(end.timestamp())
+
+    class ResourceLimitation:
+        """
+        Application resource limits, such as CPU and memory usage.
+        """
+
+        def __init__(self, data: Optional[dict] = None) -> None:
+            if isinstance(data, (str, bytes, bytearray)):
+                data = json.loads(data)
+
+            self.cpu_shares = _get_int(data, "cpu_shares")
+            """CPU shares, relative weight of CPU usage."""
+
+            self.memory_mb = _get_int(data, "memory_mb")
+            """Physical memory limit in MB."""
+
+            self.memory_virt_mb = _get_int(data, "memory_virt_mb")
+            """Virtual memory limit in MB."""
+
+    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)
+
+        # Application configuration
+        self.name = _get_str(data, "name")
+        """application name (unique)"""
+        self.command = _get_str(data, "command")
+        """full command line with arguments"""
+        self.shell = _get_bool(data, "shell")
+        """use shell mode, cmd can be more shell commands with string format"""
+        self.session_login = _get_bool(data, "session_login")
+        """app run in session login mode"""
+        self.description = _get_str(data, "description")
+        """application description string"""
+        self.metadata = _get_item(data, "metadata")
+        """metadata string/JSON (input for application, pass to process stdin)"""
+        self.working_dir = _get_str(data, "working_dir")
+        """working directory"""
+        self.status = _get_int(data, "status")
+        """initial application status (true is enable, false is disabled)"""
+        self.docker_image = _get_str(data, "docker_image")
+        """docker image which used to run command line (for docker container application)"""
+        self.stdout_cache_num = _get_int(data, "stdout_cache_num")
+        """stdout file cache number"""
+        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 = _get_int(data, "end_time")
+        """end date time for app (ISO8601 time format, e.g., '2020-10-11T10:22:05')"""
+        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 = _get_bool(data, "cron")
+        """indicate interval parameter use cron expression or not"""
+        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 = _get_str(data, "health_check_cmd")
+        """health check script command (e.g., sh -x 'curl host:port/health', return 0 is health)"""
+        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(_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 = _get_int(data, "pid")
+        """process id used to attach to the running process"""
+        self.resource_limit = App.ResourceLimitation(_get_item(data, "resource_limit"))
+
+        # Read-only attributes
+        self.owner = _get_str(data, "owner")
+        """owner name"""
+        self.user = _get_str(data, "pid_user")
+        """process user name"""
+        self.pstree = _get_str(data, "pstree")
+        """process tree"""
+        self.container_id = _get_str(data, "container_id")
+        """container id"""
+        self.memory = _get_int(data, "memory")
+        """memory usage"""
+        self.cpu = _get_int(data, "cpu")
+        """cpu usage"""
+        self.fd = _get_int(data, "fd")
+        """file descriptor usage"""
+        self.last_start_time = _get_int(data, "last_start_time")
+        """last start time"""
+        self.last_exit_time = _get_int(data, "last_exit_time")
+        """last exit time"""
+        self.health = _get_int(data, "health")
+        """health status"""
+        self.version = _get_int(data, "version")
+        """version number"""
+        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: 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."""
+        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."""
+        self.permission = int(group_user.value + others_user.value)
+
+    def __str__(self) -> str:
+        """Return a JSON string representation of the application."""
+        return json.dumps(self.json())
+
+    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__
+
+        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-1.6.12/appmesh/app_output.py

@@ -0,0 +1,28 @@
+# app_output.py
+"""Application output information."""
+
+from dataclasses import dataclass
+from http import HTTPStatus
+from typing import Optional
+
+
+@dataclass(frozen=True)
+class AppOutput:
+    """
+    Output information returned by the `app_output()` API.
+
+    Includes the application's stdout, current read position,
+    HTTP status code, and process exit code.
+    """
+
+    status_code: HTTPStatus
+    """HTTP status code from the `app_output()` API request."""
+
+    output: str
+    """Captured stdout content of the application."""
+
+    out_position: Optional[int]
+    """Current read position in stdout stream, or None if not applicable."""
+
+    exit_code: Optional[int]
+    """Exit code of the application, or None if still running."""

appmesh-1.6.12/appmesh/app_run.py

@@ -0,0 +1,54 @@
+# app_run.py
+"""Application run object for remote application execution."""
+
+from contextlib import contextmanager
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from .client_http import AppMeshClient
+
+
+class AppRun:
+    """
+    Application run object for monitoring and retrieving results
+    of a remote application run initiated by `run_async()`.
+    """
+
+    def __init__(self, client: "AppMeshClient", app_name: str, process_id: str):
+        self.app_name = app_name
+        """Name of the application associated with this run."""
+
+        self.proc_uid = process_id
+        """Unique process ID from `run_async()`."""
+
+        self._client = client
+        self._forward_to = client.forward_to
+
+    @contextmanager
+    def forward_to(self):
+        """
+        Context manager to temporarily override the client's `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
+        try:
+            yield
+        finally:
+            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.
+
+        Args:
+            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.
+        """
+        with self.forward_to():
+            return self._client.wait_for_async_run(self, stdout_print, timeout)

appmesh-1.6.12/appmesh/appmesh_client.py

@@ -0,0 +1,10 @@
+# appmesh_client.py
+
+# Legacy Compatibility Layer
+# These imports provide backward compatibility for older code that relies on
+# AppMeshClient, App, and AppOutput classes. The updated implementation can be found
+# in client_http.py, where these classes are now primarily maintained.
+
+from .client_http import AppMeshClient
+from .app import App
+from .app_output import AppOutput