watchmen-agent-cli 18.0.0__tar.gz

watchmen_agent_cli-18.0.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: watchmen-agent-cli
+Version: 18.0.0
+Summary: Watchmen agent friendly CLI for topic and pipeline synchronization
+Author: imma-team
+Requires-Python: >=3.12,<3.13
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: pyyaml (>=6.0.3,<7.0.0)
+Requires-Dist: requests (>=2.32.3,<3.0.0)
+Requires-Dist: typer (>=0.16.1,<0.17.0)

watchmen_agent_cli-18.0.0/pyproject.toml

@@ -0,0 +1,24 @@
+[tool.poetry]
+name = "watchmen-agent-cli"
+version = "18.0.0"
+description = "Watchmen agent friendly CLI for topic and pipeline synchronization"
+authors = ["imma-team"]
+packages = [
+    { include = "agent_cli", from = "src" }
+]
+
+[tool.poetry.dependencies]
+python = "~3.12"
+requests = "^2.32.3"
+pyyaml = "^6.0.3"
+typer = "^0.16.1"
+
+[tool.poetry.group.dev.dependencies]
+pyinstaller = "^6.19.0"
+
+[tool.poetry.scripts]
+agent-cli = "agent_cli.cli:run"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

watchmen_agent_cli-18.0.0/src/agent_cli/__init__.py

@@ -0,0 +1,3 @@
+from agent_cli.main import run
+
+__all__ = ["run"]

watchmen_agent_cli-18.0.0/src/agent_cli/__main__.py

@@ -0,0 +1,3 @@
+from agent_cli.cli import run
+
+run()

watchmen_agent_cli-18.0.0/src/agent_cli/cli.py

@@ -0,0 +1,379 @@
+from __future__ import annotations
+
+import traceback
+from argparse import Namespace
+from typing import Callable, Optional
+
+import typer
+
+from agent_cli.exceptions import AgentCliException
+from agent_cli.main import (
+    handle_config_show,
+    handle_discover,
+    handle_enum_list,
+    handle_enum_list_remote,
+    handle_enum_pull,
+    handle_enum_pull_name,
+    handle_enum_push_file,
+    handle_ingest_model_list,
+    handle_ingest_model_list_remote,
+    handle_ingest_model_pull,
+    handle_ingest_model_push_file,
+    handle_ingest_module_list,
+    handle_ingest_module_list_remote,
+    handle_ingest_module_pull,
+    handle_ingest_module_push_file,
+    handle_ingest_table_list,
+    handle_ingest_table_list_remote,
+    handle_ingest_table_pull,
+    handle_ingest_table_push_file,
+    handle_init,
+    handle_pipeline_list,
+    handle_pipeline_list_remote,
+    handle_pipeline_pull,
+    handle_pipeline_pull_name,
+    handle_pipeline_push_file,
+    handle_pull,
+    handle_push,
+    handle_tenant_info,
+    handle_topic_list,
+    handle_topic_list_remote,
+    handle_topic_pull,
+    handle_topic_pull_name,
+    handle_topic_push_file,
+    output_error,
+)
+
+app = typer.Typer(help="Watchmen Topic/Pipeline sync CLI powered by Typer")
+topic_app = typer.Typer(help="Fine-grained topic commands")
+pipeline_app = typer.Typer(help="Fine-grained pipeline commands")
+enum_app = typer.Typer(help="Fine-grained enum commands")
+ingest_app = typer.Typer(help="Ingest config YAML commands")
+ingest_table_app = typer.Typer(help="Collector table config commands")
+ingest_model_app = typer.Typer(help="Collector model config commands")
+ingest_module_app = typer.Typer(help="Collector module config commands")
+app.add_typer(topic_app, name="topic")
+app.add_typer(pipeline_app, name="pipeline")
+app.add_typer(enum_app, name="enum")
+app.add_typer(ingest_app, name="ingest")
+ingest_app.add_typer(ingest_table_app, name="table")
+ingest_app.add_typer(ingest_model_app, name="model")
+ingest_app.add_typer(ingest_module_app, name="module")
+
+
+def _namespace(**kwargs) -> Namespace:
+    return Namespace(**kwargs)
+
+
+def _run_with_guard(ctx: typer.Context, action: Callable[[], None]) -> None:
+    try:
+        action()
+    except AgentCliException as e:
+        output_error(f"{e.__class__.__name__}: {e}")
+        if ctx.obj and ctx.obj.get("debug"):
+            traceback.print_exc()
+        raise typer.Exit(getattr(e, "exit_code", 1))
+    except Exception as e:
+        output_error(f"UnexpectedError: {e}")
+        if ctx.obj and ctx.obj.get("debug"):
+            traceback.print_exc()
+        raise typer.Exit(10)
+
+
+@app.callback(invoke_without_command=True)
+def cli_callback(
+    ctx: typer.Context,
+    debug: bool = typer.Option(False, "--debug", help="Print exception traceback for debugging"),
+) -> None:
+    ctx.obj = {"debug": debug}
+    if ctx.invoked_subcommand is None:
+        typer.echo(ctx.get_help())
+        raise typer.Exit()
+
+
+@app.command("init")
+def init_command(
+    ctx: typer.Context,
+    vault: Optional[str] = typer.Option(None, "--vault"),
+    host: Optional[str] = typer.Option(None, "--host"),
+    username: Optional[str] = typer.Option(None, "--username"),
+    password: Optional[str] = typer.Option(None, "--password"),
+    pat: Optional[str] = typer.Option(None, "--pat"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_init(_namespace(vault=vault, host=host, username=username, password=password, pat=pat)))
+
+
+@app.command("pull")
+def pull_command(
+    ctx: typer.Context,
+    target: str = typer.Option("all", "--target", help="topic | pipeline | all"),
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_pull(_namespace(target=target, vault=vault)))
+
+
+@app.command("push")
+def push_command(
+    ctx: typer.Context,
+    target: str = typer.Option("all", "--target", help="topic | pipeline | all"),
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_push(_namespace(target=target, vault=vault)))
+
+
+@app.command("tenant")
+def tenant_command(
+    ctx: typer.Context,
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_tenant_info(_namespace(vault=vault)))
+
+
+@app.command("config")
+def config_command(
+    ctx: typer.Context,
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_config_show(_namespace(vault=vault)))
+
+
+@app.command("discover")
+def discover_command(ctx: typer.Context) -> None:
+    _run_with_guard(ctx, lambda: handle_discover(_namespace()))
+
+
+@topic_app.command("pull")
+def topic_pull_command(
+    ctx: typer.Context,
+    topic_id: str,
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_topic_pull(_namespace(topic_id=topic_id, vault=vault)))
+
+
+@topic_app.command("pull-name")
+def topic_pull_name_command(
+    ctx: typer.Context,
+    topic_name: str,
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_topic_pull_name(_namespace(topic_name=topic_name, vault=vault)))
+
+
+@topic_app.command("push-file")
+def topic_push_file_command(
+    ctx: typer.Context,
+    file_path: str,
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_topic_push_file(_namespace(file_path=file_path, vault=vault)))
+
+
+@topic_app.command("list")
+def topic_list_command(
+    ctx: typer.Context,
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_topic_list(_namespace(vault=vault)))
+
+
+@topic_app.command("list-remote")
+def topic_list_remote_command(
+    ctx: typer.Context,
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_topic_list_remote(_namespace(vault=vault)))
+
+
+@pipeline_app.command("pull")
+def pipeline_pull_command(
+    ctx: typer.Context,
+    pipeline_id: str,
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_pipeline_pull(_namespace(pipeline_id=pipeline_id, vault=vault)))
+
+
+@pipeline_app.command("pull-name")
+def pipeline_pull_name_command(
+    ctx: typer.Context,
+    pipeline_name: str,
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_pipeline_pull_name(_namespace(pipeline_name=pipeline_name, vault=vault)))
+
+
+@pipeline_app.command("push-file")
+def pipeline_push_file_command(
+    ctx: typer.Context,
+    file_path: str,
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_pipeline_push_file(_namespace(file_path=file_path, vault=vault)))
+
+
+@pipeline_app.command("list")
+def pipeline_list_command(
+    ctx: typer.Context,
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_pipeline_list(_namespace(vault=vault)))
+
+
+@pipeline_app.command("list-remote")
+def pipeline_list_remote_command(
+    ctx: typer.Context,
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_pipeline_list_remote(_namespace(vault=vault)))
+
+
+@enum_app.command("pull")
+def enum_pull_command(
+    ctx: typer.Context,
+    enum_id: str,
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_enum_pull(_namespace(enum_id=enum_id, vault=vault)))
+
+
+@enum_app.command("pull-name")
+def enum_pull_name_command(
+    ctx: typer.Context,
+    enum_name: str,
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_enum_pull_name(_namespace(enum_name=enum_name, vault=vault)))
+
+
+@enum_app.command("push-file")
+def enum_push_file_command(
+    ctx: typer.Context,
+    file_path: str,
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_enum_push_file(_namespace(file_path=file_path, vault=vault)))
+
+
+@enum_app.command("list")
+def enum_list_command(
+    ctx: typer.Context,
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_enum_list(_namespace(vault=vault)))
+
+
+@enum_app.command("list-remote")
+def enum_list_remote_command(
+    ctx: typer.Context,
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_enum_list_remote(_namespace(vault=vault)))
+
+
+@ingest_table_app.command("pull")
+def ingest_table_pull_command(
+    ctx: typer.Context,
+    table_name: str,
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_ingest_table_pull(_namespace(table_name=table_name, vault=vault)))
+
+
+@ingest_table_app.command("push-file")
+def ingest_table_push_file_command(
+    ctx: typer.Context,
+    file_path: str,
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_ingest_table_push_file(_namespace(file_path=file_path, vault=vault)))
+
+
+@ingest_table_app.command("list")
+def ingest_table_list_command(
+    ctx: typer.Context,
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_ingest_table_list(_namespace(vault=vault)))
+
+
+@ingest_table_app.command("list-remote")
+def ingest_table_list_remote_command(
+    ctx: typer.Context,
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_ingest_table_list_remote(_namespace(vault=vault)))
+
+
+@ingest_model_app.command("pull")
+def ingest_model_pull_command(
+    ctx: typer.Context,
+    model_name: str,
+    all: bool = typer.Option(False, "--all"),
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_ingest_model_pull(_namespace(model_name=model_name, all=all, vault=vault)))
+
+
+@ingest_model_app.command("push-file")
+def ingest_model_push_file_command(
+    ctx: typer.Context,
+    file_path: str,
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_ingest_model_push_file(_namespace(file_path=file_path, vault=vault)))
+
+
+@ingest_model_app.command("list")
+def ingest_model_list_command(
+    ctx: typer.Context,
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_ingest_model_list(_namespace(vault=vault)))
+
+
+@ingest_model_app.command("list-remote")
+def ingest_model_list_remote_command(
+    ctx: typer.Context,
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_ingest_model_list_remote(_namespace(vault=vault)))
+
+
+@ingest_module_app.command("pull")
+def ingest_module_pull_command(
+    ctx: typer.Context,
+    module_name: str,
+    all: bool = typer.Option(False, "--all"),
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_ingest_module_pull(_namespace(module_name=module_name, all=all, vault=vault)))
+
+
+@ingest_module_app.command("push-file")
+def ingest_module_push_file_command(
+    ctx: typer.Context,
+    file_path: str,
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_ingest_module_push_file(_namespace(file_path=file_path, vault=vault)))
+
+
+@ingest_module_app.command("list")
+def ingest_module_list_command(
+    ctx: typer.Context,
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_ingest_module_list(_namespace(vault=vault)))
+
+
+@ingest_module_app.command("list-remote")
+def ingest_module_list_remote_command(
+    ctx: typer.Context,
+    vault: Optional[str] = typer.Option(None, "--vault"),
+) -> None:
+    _run_with_guard(ctx, lambda: handle_ingest_module_list_remote(_namespace(vault=vault)))
+
+
+def run() -> None:
+    app(prog_name="agent-cli")

watchmen_agent_cli-18.0.0/src/agent_cli/exceptions.py

@@ -0,0 +1,14 @@
+class AgentCliException(Exception):
+    exit_code = 1
+
+
+class ConfigException(AgentCliException):
+    exit_code = 3
+
+
+class AuthenticationException(AgentCliException):
+    exit_code = 4
+
+
+class ApiException(AgentCliException):
+    exit_code = 5

watchmen_agent_cli-18.0.0/src/agent_cli/http_client.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+import requests
+
+from agent_cli.exceptions import ApiException, AuthenticationException
+
+LOGIN_URL = "/login"
+
+
+class RestClient:
+    def __init__(
+        self,
+        host: str,
+        pat: Optional[str] = None,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        timeout_seconds: int = 30,
+    ) -> None:
+        self.host = host.rstrip("/")
+        self.pat = pat
+        self.username = username
+        self.password = password
+        self.timeout_seconds = timeout_seconds
+        self._token: Optional[str] = None
+
+    def auth_header(self) -> Dict[str, str]:
+        token = self._login()
+        return {"Authorization": token}
+
+    def get_json(self, path: str, params: Optional[Dict[str, Any]] = None) -> Any:
+        url = self._url(path)
+        headers = self.auth_header()
+        try:
+            response = requests.get(url, params=params, headers=headers, timeout=self.timeout_seconds)
+        except requests.RequestException as e:
+            raise ApiException(f"GET {path} failed: {e}") from e
+        if response.status_code >= 400:
+            raise ApiException(f"GET {path} failed with {response.status_code}: {response.text}")
+        return response.json()
+
+    def post_json(self, path: str, payload: Any) -> Any:
+        url = self._url(path)
+        headers = self.auth_header()
+        headers["Content-Type"] = "application/json"
+        try:
+            response = requests.post(url, json=payload, headers=headers, timeout=self.timeout_seconds)
+        except requests.RequestException as e:
+            raise ApiException(f"POST {path} failed: {e}") from e
+        if response.status_code >= 400:
+            raise ApiException(f"POST {path} failed with {response.status_code}: {response.text}")
+        if not response.text:
+            return None
+        return response.json()
+
+    def get_text(self, path: str, params: Optional[Dict[str, Any]] = None) -> str:
+        url = self._url(path)
+        headers = self.auth_header()
+        try:
+            response = requests.get(url, params=params, headers=headers, timeout=self.timeout_seconds)
+        except requests.RequestException as e:
+            raise ApiException(f"GET {path} failed: {e}") from e
+        if response.status_code >= 400:
+            raise ApiException(f"GET {path} failed with {response.status_code}: {response.text}")
+        return response.text
+
+    def post_text(self, path: str, payload: str, content_type: str = "application/x-yaml") -> str:
+        url = self._url(path)
+        headers = self.auth_header()
+        headers["Content-Type"] = content_type
+        try:
+            response = requests.post(url, data=payload.encode('utf-8'), headers=headers, timeout=self.timeout_seconds)
+        except requests.RequestException as e:
+            raise ApiException(f"POST {path} failed: {e}") from e
+        if response.status_code >= 400:
+            raise ApiException(f"POST {path} failed with {response.status_code}: {response.text}")
+        return response.text
+
+    def get_enum(self, enum_id: str) -> Any:
+        return self.get_json("/enum", params={"id": enum_id})
+
+    def get_enum_yaml(self, enum_id: str) -> str:
+        return self.get_text("/enum/yaml", params={"id": enum_id})
+
+    def save_enum_yaml(self, yaml_content: str) -> str:
+        return self.post_text("/enum/yaml", yaml_content)
+
+    def _login(self) -> str:
+        if self._token:
+            return self._token
+        if self.pat:
+            self._token = f"pat {self.pat}"
+            return self._token
+        if not self.username or not self.password:
+            raise AuthenticationException("Need PAT or username/password")
+        try:
+            response = requests.post(
+                self._url(LOGIN_URL),
+                data={"username": self.username, "password": self.password},
+                headers={"Content-Type": "application/x-www-form-urlencoded"},
+                timeout=self.timeout_seconds,
+            )
+        except requests.RequestException as e:
+            raise AuthenticationException(f"Login failed: {e}") from e
+        if response.status_code >= 400:
+            raise AuthenticationException(f"Login failed with {response.status_code}: {response.text}")
+        payload = response.json()
+        token = payload.get("accessToken")
+        if not token:
+            raise AuthenticationException("Login response does not contain accessToken")
+        self._token = f"Bearer {token}"
+        return self._token
+
+    def _url(self, path: str) -> str:
+        if path.startswith("http://") or path.startswith("https://"):
+            return path
+        if not path.startswith("/"):
+            path = f"/{path}"
+        return f"{self.host}{path}"