praisonai-deploy 0.0.1__tar.gz

praisonai_deploy-0.0.1/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: praisonai-deploy
+Version: 0.0.1
+Summary: Deployment for PraisonAI — API, Docker, and cloud (AWS, Azure, GCP) deployments extracted from the praisonai wrapper.
+Author: Mervin Praison
+License: MIT
+Project-URL: Homepage, https://docs.praison.ai
+Project-URL: Repository, https://github.com/mervinpraison/PraisonAI
+Requires-Python: <3.15,>=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: praisonaiagents>=1.6.126
+Requires-Dist: rich>=13.7
+Requires-Dist: typer>=0.12.0
+Requires-Dist: click>=8.4.2
+Requires-Dist: PyYAML>=6.0
+Requires-Dist: pydantic>=2.0
+Provides-Extra: api
+Requires-Dist: flask>=3.0.0; extra == "api"
+Requires-Dist: flask-cors>=4.0.0; extra == "api"
+Provides-Extra: all
+Requires-Dist: praisonai-deploy[api]; extra == "all"
+
+# praisonai-deploy
+
+Deployment tooling for PraisonAI — API servers, Docker images, and cloud providers (AWS, Azure, GCP).
+
+## Install
+
+```bash
+pip install praisonai-deploy
+pip install "praisonai-deploy[api]"   # Flask API server generation
+pip install "praisonai[deploy]"       # full umbrella with wrapper shims
+```
+
+## CLI
+
+```bash
+praisonai deploy run --file agents.yaml
+praisonai deploy doctor --all
+praisonai deploy validate --file agents.yaml
+praisonai deploy plan --file agents.yaml
+praisonai deploy status --file agents.yaml
+praisonai deploy destroy --file agents.yaml --yes
+praisonai deploy docker agents.yaml --tag v1
+praisonai deploy aws agents.yaml --region us-east-1
+```
+
+Standalone console script:
+
+```bash
+praisonai-deploy --help
+```
+
+## Python API
+
+```python
+from praisonai_deploy import Deploy
+
+deploy = Deploy.from_yaml("agents.yaml")
+result = deploy.deploy()
+status = deploy.status()
+```
+
+Legacy import paths (`praisonai.deploy.*`) remain available when the `praisonai` wrapper is installed.
+
+## Runtime dependency (generated servers)
+
+Generated API servers and Docker images install **`praisonai`** (full wrapper) at runtime — they embed `from praisonai import PraisonAI`. The deploy package owns orchestration (generate, build, plan, doctor); containers need `pip install praisonai flask gunicorn`.
+
+## Cloud provider notes
+
+| Provider | Behaviour |
+|----------|-----------|
+| AWS ECS | Update-only path; greenfield deploy requires pre-existing VPC/service config |
+| Azure | Container Apps create/update |
+| GCP | Cloud Run create-or-update |
+
+Host CLIs required: `docker`, `aws`, `az`, `gcloud` (no boto3/Azure SDK in this package).
+
+## Monorepo development
+
+Editable install from this directory:
+
+```bash
+cd src/praisonai-deploy
+uv pip install -e .
+```
+
+Regression gates:
+
+- `scripts/check_c14_deploy_imports.sh`
+- `src/praisonai/tests/unit/test_c14_deploy_backward_compat.py`
+- `src/praisonai-deploy/tests/`

praisonai_deploy-0.0.1/README.md

@@ -0,0 +1,71 @@
+# praisonai-deploy
+
+Deployment tooling for PraisonAI — API servers, Docker images, and cloud providers (AWS, Azure, GCP).
+
+## Install
+
+```bash
+pip install praisonai-deploy
+pip install "praisonai-deploy[api]"   # Flask API server generation
+pip install "praisonai[deploy]"       # full umbrella with wrapper shims
+```
+
+## CLI
+
+```bash
+praisonai deploy run --file agents.yaml
+praisonai deploy doctor --all
+praisonai deploy validate --file agents.yaml
+praisonai deploy plan --file agents.yaml
+praisonai deploy status --file agents.yaml
+praisonai deploy destroy --file agents.yaml --yes
+praisonai deploy docker agents.yaml --tag v1
+praisonai deploy aws agents.yaml --region us-east-1
+```
+
+Standalone console script:
+
+```bash
+praisonai-deploy --help
+```
+
+## Python API
+
+```python
+from praisonai_deploy import Deploy
+
+deploy = Deploy.from_yaml("agents.yaml")
+result = deploy.deploy()
+status = deploy.status()
+```
+
+Legacy import paths (`praisonai.deploy.*`) remain available when the `praisonai` wrapper is installed.
+
+## Runtime dependency (generated servers)
+
+Generated API servers and Docker images install **`praisonai`** (full wrapper) at runtime — they embed `from praisonai import PraisonAI`. The deploy package owns orchestration (generate, build, plan, doctor); containers need `pip install praisonai flask gunicorn`.
+
+## Cloud provider notes
+
+| Provider | Behaviour |
+|----------|-----------|
+| AWS ECS | Update-only path; greenfield deploy requires pre-existing VPC/service config |
+| Azure | Container Apps create/update |
+| GCP | Cloud Run create-or-update |
+
+Host CLIs required: `docker`, `aws`, `az`, `gcloud` (no boto3/Azure SDK in this package).
+
+## Monorepo development
+
+Editable install from this directory:
+
+```bash
+cd src/praisonai-deploy
+uv pip install -e .
+```
+
+Regression gates:
+
+- `scripts/check_c14_deploy_imports.sh`
+- `src/praisonai/tests/unit/test_c14_deploy_backward_compat.py`
+- `src/praisonai-deploy/tests/`

praisonai_deploy-0.0.1/praisonai_deploy/__init__.py

@@ -0,0 +1,91 @@
+"""
+Deploy module for PraisonAI - API, Docker, and Cloud deployments.
+"""
+from typing import TYPE_CHECKING, Optional, Dict, Any
+
+from praisonai_deploy._version import __version__
+
+if TYPE_CHECKING:
+    from .models import DeployConfig, DeployResult, DeployType, CloudProvider
+    from .schema import validate_agents_yaml, generate_sample_yaml
+    from .doctor import DoctorReport, run_all_checks
+
+
+def __getattr__(name):
+    """Lazy load deploy modules."""
+    if name == 'Deploy':
+        from .main import Deploy
+        return Deploy
+    elif name == 'DeployConfig':
+        from .models import DeployConfig
+        return DeployConfig
+    elif name == 'DeployType':
+        from .models import DeployType
+        return DeployType
+    elif name == 'CloudProvider':
+        from .models import CloudProvider
+        return CloudProvider
+    elif name == 'DeployResult':
+        from .models import DeployResult
+        return DeployResult
+    elif name == 'DeployStatus':
+        from .models import DeployStatus
+        return DeployStatus
+    elif name == 'DestroyResult':
+        from .models import DestroyResult
+        return DestroyResult
+    elif name == 'ServiceState':
+        from .models import ServiceState
+        return ServiceState
+    elif name == 'validate_agents_yaml':
+        from .schema import validate_agents_yaml
+        return validate_agents_yaml
+    elif name == 'generate_sample_yaml':
+        from .schema import generate_sample_yaml
+        return generate_sample_yaml
+    elif name == 'run_all_checks':
+        from .doctor import run_all_checks
+        return run_all_checks
+    elif name == 'get_deployment_status':
+        return get_deployment_status
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def get_deployment_status(
+    deployment_name: Optional[str] = None,
+    *,
+    agents_file: str = "agents.yaml",
+) -> Dict[str, Any]:
+    """Return deployment status for MCP and tooling."""
+    from .main import Deploy
+
+    deploy = Deploy.from_yaml(agents_file)
+    status = deploy.status()
+    payload: Dict[str, Any] = {
+        "state": status.state.value if hasattr(status.state, "value") else str(status.state),
+        "message": status.message,
+        "url": status.url,
+        "service_name": status.service_name,
+        "provider": status.provider,
+        "healthy": status.healthy,
+    }
+    if deployment_name:
+        payload["deployment_name"] = deployment_name
+    return payload
+
+
+__all__ = [
+    'Deploy',
+    'DeployConfig',
+    'DeployType',
+    'CloudProvider',
+    'DeployResult',
+    'DeployStatus',
+    'DestroyResult',
+    'ServiceState',
+    'validate_agents_yaml',
+    'generate_sample_yaml',
+    'run_all_checks',
+    'get_deployment_status',
+    '__version__',
+]

praisonai_deploy-0.0.1/praisonai_deploy/__main__.py

@@ -0,0 +1,18 @@
+"""Console entry: ``praisonai-deploy``."""
+
+from __future__ import annotations
+
+import sys
+
+
+def main(argv: list[str] | None = None) -> None:
+    from praisonai_deploy.cli.app import app
+
+    args = argv if argv is not None else sys.argv[1:]
+    if not args:
+        args = ["--help"]
+    app(args=args, prog_name="praisonai-deploy")
+
+
+if __name__ == "__main__":
+    main()

praisonai_deploy-0.0.1/praisonai_deploy/_bootstrap.py

@@ -0,0 +1,37 @@
+"""Monorepo bootstrap for ``praisonai_deploy`` and optional ``praisonai_code``."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+
+def ensure_praisonai_deploy() -> None:
+    """Ensure ``praisonai_deploy`` is importable in monorepo dev layouts."""
+    try:
+        import praisonai_deploy  # noqa: F401
+        return
+    except ImportError:
+        pass
+
+    here = Path(__file__).resolve().parents[1]  # .../src/praisonai-deploy
+    if (here / "praisonai_deploy").is_dir():
+        root = str(here)
+        if root not in sys.path:
+            sys.path.insert(0, root)
+
+
+def ensure_praisonai_code() -> None:
+    """Optional code-tier imports when co-installed."""
+    try:
+        import praisonai_code  # noqa: F401
+        return
+    except ImportError:
+        pass
+
+    deploy_src = Path(__file__).resolve().parents[1]
+    code_src = deploy_src.parent / "praisonai-code"
+    if (code_src / "praisonai_code").is_dir():
+        root = str(code_src)
+        if root not in sys.path:
+            sys.path.insert(0, root)

praisonai_deploy-0.0.1/praisonai_deploy/_code_bridge.py

@@ -0,0 +1,28 @@
+"""Lazy access from praisonai-deploy to optional praisonai-code modules."""
+
+from __future__ import annotations
+
+import importlib
+from typing import Any
+
+from praisonai_deploy._bootstrap import ensure_praisonai_code
+
+
+def code_available() -> bool:
+    ensure_praisonai_code()
+    try:
+        import praisonai_code  # noqa: F401
+        return True
+    except ImportError:
+        return False
+
+
+def import_code_module(name: str) -> Any:
+    ensure_praisonai_code()
+    try:
+        return importlib.import_module(name)
+    except ImportError as exc:
+        raise ImportError(
+            f"Optional code module {name!r} requires praisonai-code. "
+            "Install with: pip install praisonai-code"
+        ) from exc

praisonai_deploy-0.0.1/praisonai_deploy/_plugin_registry.py

@@ -0,0 +1,150 @@
+"""Plugin registry base for praisonai-deploy.
+
+Prefers the shared implementation from ``praisonai-code`` when installed so the
+two packages stay in lock-step, but falls back to a self-contained
+implementation so ``praisonai-deploy`` works standalone (``pip install
+praisonai-deploy`` without ``praisonai-code``).
+"""
+
+from __future__ import annotations
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+__all__ = ["PluginRegistry", "create_lazy_getattr", "logger"]
+
+try:  # Prefer the shared praisonai-code registry when available.
+    from praisonai_deploy._code_bridge import code_available
+
+    if not code_available():
+        raise ImportError("praisonai-code not installed")
+
+    from praisonai_deploy._code_bridge import import_code_module
+
+    _registry_mod = import_code_module("praisonai_code._registry")
+    PluginRegistry = _registry_mod.PluginRegistry
+    create_lazy_getattr = _registry_mod.create_lazy_getattr
+except ImportError:
+    import threading
+    from importlib.metadata import entry_points
+    from typing import Callable, Dict, Generic, Optional, Type, TypeVar
+
+    T = TypeVar("T")
+
+    class PluginRegistry(Generic[T]):
+        """Self-contained fallback registry (builtins + entry points)."""
+
+        _default_locks_guard = threading.Lock()
+
+        def __init__(
+            self,
+            *,
+            entry_point_group: str,
+            builtins: Optional[Dict[str, Callable[[], Type[T]]]] = None,
+            discover_entry_points: bool = True,
+        ) -> None:
+            self._entry_point_group = entry_point_group
+            self._loaders: Dict[str, Callable[[], Type[T]]] = {}
+            self._items: Dict[str, Type[T]] = {}
+            self._lock = threading.RLock()
+
+            if builtins:
+                for name, loader in builtins.items():
+                    self._loaders[name.lower()] = loader
+
+            if discover_entry_points:
+                try:
+                    for ep in entry_points(group=self._entry_point_group):
+                        self._loaders[ep.name.lower()] = ep.load
+                except Exception:
+                    logger.debug(
+                        "Entry points not available for group %s",
+                        self._entry_point_group,
+                    )
+
+        def register(self, name: str, cls: Type[T]) -> None:
+            with self._lock:
+                key = name.lower()
+                self._loaders[key] = lambda: cls
+                self._items[key] = cls
+
+        def resolve(self, name: str) -> Type[T]:
+            key = name.lower()
+            with self._lock:
+                cls = self._items.get(key)
+                if cls is not None:
+                    return cls
+                loader = self._loaders.get(key)
+                if loader is None:
+                    available = sorted(self._loaders.keys())
+                    raise ValueError(
+                        f"Unknown {self._entry_point_group} plugin: {name!r}. "
+                        f"Available: {available}"
+                    )
+            try:
+                cls = loader()
+            except ImportError as exc:
+                raise ValueError(
+                    f"Plugin {name!r} is registered but its dependencies "
+                    f"are not installed: {exc}"
+                ) from exc
+            except Exception as exc:  # noqa: BLE001 -- external plugin boundary
+                raise ValueError(
+                    f"Plugin {name!r} failed to load: {exc}"
+                ) from exc
+            with self._lock:
+                if self._loaders.get(key) is loader:
+                    self._items[key] = cls
+                return cls
+
+        def create(self, name: str, *args, **kwargs) -> T:
+            return self.resolve(name)(*args, **kwargs)
+
+        def list_names(self) -> list[str]:
+            with self._lock:
+                return sorted(self._loaders.keys())
+
+        def is_available(self, name: str) -> bool:
+            try:
+                self.resolve(name)
+                return True
+            except ValueError:
+                return False
+
+        @classmethod
+        def default(cls) -> "PluginRegistry[T]":
+            cache_key = "_default_instance"
+            lock_key = "_default_instance_lock"
+            if lock_key not in cls.__dict__:
+                with PluginRegistry._default_locks_guard:
+                    if lock_key not in cls.__dict__:
+                        setattr(cls, lock_key, threading.Lock())
+            cache = cls.__dict__.get(cache_key)
+            if cache is not None:
+                return cache
+            with getattr(cls, lock_key):
+                cache = cls.__dict__.get(cache_key)
+                if cache is None:
+                    cache = cls()
+                    setattr(cls, cache_key, cache)
+                return cache
+
+    def create_lazy_getattr(registry: "PluginRegistry[T]") -> Callable[[str], T]:
+        import inspect
+
+        frame = inspect.currentframe()
+        if frame and frame.f_back:
+            module_name = frame.f_back.f_globals.get("__name__", "unknown")
+        else:
+            module_name = "unknown"
+
+        def __getattr__(name: str) -> T:
+            try:
+                return registry.resolve(name)
+            except ValueError:
+                raise AttributeError(
+                    f"module {module_name!r} has no attribute {name!r}"
+                ) from None
+
+        return __getattr__

praisonai_deploy-0.0.1/praisonai_deploy/_version.py

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

praisonai_deploy-0.0.1/praisonai_deploy/_wrapper_bridge.py

@@ -0,0 +1,31 @@
+"""Lazy access from praisonai-deploy to optional praisonai wrapper modules."""
+
+from __future__ import annotations
+
+import importlib
+from typing import Any
+
+
+def wrapper_available() -> bool:
+    try:
+        import praisonai  # noqa: F401
+        return True
+    except ImportError:
+        return False
+
+
+def import_wrapper_module(name: str) -> Any:
+    if not wrapper_available():
+        raise ImportError(
+            f"Optional wrapper module {name!r} requires the praisonai package. "
+            "Install with: pip install praisonai"
+        )
+    return importlib.import_module(name)
+
+
+def optional_wrapper_attr(module: str, attr: str, default: Any = None) -> Any:
+    try:
+        mod = import_wrapper_module(module)
+    except ImportError:
+        return default
+    return getattr(mod, attr, default)