jiff-geo-cli 0.1.1__py3-none-any.whl

geo_cli/__init__.py

@@ -0,0 +1,4 @@
+from geo_cli.cli import app
+
+if __name__ == "__main__":
+    app()

geo_cli/api/__init__.py

@@ -0,0 +1 @@
+"""Resource-specific Geo API clients."""

geo_cli/api/article.py

@@ -0,0 +1,229 @@
+"""Browser publish service client for article account and job workflows."""
+
+from typing import Any
+
+import httpx
+
+from geo_cli.config import (
+    get_article_api_key,
+    get_article_base_url,
+    get_article_group_id,
+    get_article_group_text,
+)
+
+
+def require_group_id() -> str:
+    group_id = get_article_group_id()
+    if not group_id:
+        raise ValueError("ARTICLE_GROUP_ID 未配置")
+    return group_id
+
+
+def _headers() -> dict[str, str]:
+    api_key = get_article_api_key()
+    if not api_key:
+        raise ValueError("ARTICLE_API_KEY 未配置")
+    return {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {api_key}",
+    }
+
+
+def _url(path: str) -> str:
+    return f"{get_article_base_url().rstrip('/')}{path}"
+
+
+def _request(
+    method: str,
+    path: str,
+    *,
+    params: dict[str, Any] | None = None,
+    json_body: dict[str, Any] | None = None,
+    timeout: float = 60.0,
+) -> dict[str, Any]:
+    response = httpx.request(
+        method,
+        _url(path),
+        params={key: value for key, value in (params or {}).items() if value is not None},
+        json=json_body,
+        headers=_headers(),
+        timeout=timeout,
+    )
+    try:
+        data = response.json()
+    except Exception:
+        data = {"detail": response.text}
+    if response.status_code >= 400:
+        return {"code": response.status_code, "msg": data}
+    return data
+
+
+def list_platforms() -> dict[str, Any]:
+    return _request("GET", "/api/v1/platforms")
+
+
+def create_login_session(platform: str) -> dict[str, Any]:
+    return _request("POST", "/api/v1/login-sessions", json_body={"platform": platform})
+
+
+def get_login_session(session_id: str) -> dict[str, Any]:
+    return _request("GET", f"/api/v1/login-sessions/{session_id}")
+
+
+def cancel_login_session(session_id: str) -> dict[str, Any]:
+    return _request("DELETE", f"/api/v1/login-sessions/{session_id}")
+
+
+def list_accounts(
+    platform: str | None = None,
+    status: str | None = None,
+    include_channel: bool = False,
+    include_runtime: bool = False,
+    limit: int = 100,
+    offset: int = 0,
+) -> dict[str, Any]:
+    return _request(
+        "GET",
+        "/api/v1/accounts/all",
+        params={
+            "group_id": require_group_id(),
+            "group_text": get_article_group_text() or None,
+            "platform": platform,
+            "status": status,
+            "include_channel": include_channel,
+            "include_runtime": include_runtime,
+            "limit": limit,
+            "offset": offset,
+        },
+    )
+
+
+def list_available_accounts(
+    platform: str | None = None,
+    include_channel: bool = False,
+    include_runtime: bool = False,
+    limit: int = 100,
+    offset: int = 0,
+) -> dict[str, Any]:
+    return _request(
+        "GET",
+        "/api/v1/accounts/available",
+        params={
+            "group_id": require_group_id(),
+            "group_text": get_article_group_text() or None,
+            "platform": platform,
+            "include_channel": include_channel,
+            "include_runtime": include_runtime,
+            "limit": limit,
+            "offset": offset,
+        },
+    )
+
+
+def get_account(
+    platform: str,
+    phone: str,
+    include_channel: bool = True,
+    include_runtime: bool = False,
+) -> dict[str, Any]:
+    return _request(
+        "GET",
+        f"/api/v1/accounts/{platform}/{phone}",
+        params={
+            "group_id": require_group_id(),
+            "include_channel": include_channel,
+            "include_runtime": include_runtime,
+        },
+    )
+
+
+def bind_account(
+    platform: str,
+    phone: str,
+    channel_id: str,
+    status: str = "normal",
+    reset_failures: bool = True,
+    consecutive_failures: int = 0,
+) -> dict[str, Any]:
+    return _request(
+        "PUT",
+        f"/api/v1/accounts/{platform}/{phone}",
+        json_body={
+            "group_id": require_group_id(),
+            "group_text": get_article_group_text(),
+            "channel_id": channel_id,
+            "status": status,
+            "reset_failures": reset_failures,
+            "consecutive_failures": consecutive_failures,
+        },
+    )
+
+
+def update_account(
+    platform: str,
+    phone: str,
+    group_text: str | None = None,
+    new_phone: str | None = None,
+    status: str | None = None,
+    reset_failures: bool | None = None,
+    consecutive_failures: int | None = None,
+) -> dict[str, Any]:
+    return _request(
+        "PATCH",
+        f"/api/v1/accounts/{platform}/{phone}",
+        json_body={
+            "group_id": require_group_id(),
+            "group_text": group_text,
+            "new_phone": new_phone,
+            "status": status,
+            "reset_failures": reset_failures,
+            "consecutive_failures": consecutive_failures,
+        },
+    )
+
+
+def delete_account(
+    platform: str,
+    phone: str,
+    force: bool = False,
+    delete_channel: bool = True,
+) -> dict[str, Any]:
+    return _request(
+        "DELETE",
+        f"/api/v1/accounts/{platform}/{phone}",
+        params={
+            "group_id": require_group_id(),
+            "force": force,
+            "delete_channel": delete_channel,
+        },
+    )
+
+
+def create_job(
+    channel_id: str,
+    title: str,
+    content: str,
+    cover_image_url: str | None = None,
+) -> dict[str, Any]:
+    return _request(
+        "POST",
+        "/api/v1/jobs",
+        json_body={
+            "channel_id": channel_id,
+            "title": title,
+            "content": content,
+            "cover_image_url": cover_image_url,
+        },
+    )
+
+
+def get_job(job_id: str) -> dict[str, Any]:
+    return _request("GET", f"/api/v1/jobs/{job_id}")
+
+
+def save_job_cookie(job_id: str) -> dict[str, Any]:
+    return _request("POST", f"/api/v1/jobs/{job_id}/save-cookie")
+
+
+def cancel_job(job_id: str) -> dict[str, Any]:
+    return _request("POST", f"/api/v1/jobs/{job_id}/cancel")

geo_cli/api/auto_job.py

@@ -0,0 +1,20 @@
+from typing import Any
+
+from geo_cli.core.http import normalize_list, post
+
+
+def get_auto_job_by_brand(brand_id: int) -> dict[str, Any]:
+    return post("/api/v1/auto-job/get-by-brand", {"brand_id": brand_id})
+
+
+def update_auto_job(
+    brand_id: int,
+    enable: int | None = None,
+    platforms: list[str] | None = None,
+) -> dict[str, Any]:
+    body: dict[str, Any] = {"brand_id": brand_id}
+    if enable is not None:
+        body["enable"] = enable
+    if platforms is not None:
+        body["platforms"] = normalize_list(platforms)
+    return post("/api/v1/auto-job/update", body)

geo_cli/api/brand.py

@@ -0,0 +1,45 @@
+from typing import Any
+
+from geo_cli.core.http import normalize_list, post
+
+
+def create_brand(
+    name: str,
+    description: str,
+    platforms: list[str],
+    aliases: list[str] | None = None,
+    service_type: str | None = None,
+) -> dict[str, Any]:
+    body: dict[str, Any] = {
+        "name": name,
+        "description": description,
+        "platforms": normalize_list(platforms),
+    }
+    if aliases is not None:
+        body["aliases"] = aliases
+    if service_type is not None:
+        body["service_type"] = service_type
+    return post("/api/v1/brand/create", body)
+
+
+def list_brands(page: int = 1, page_size: int = 20) -> dict[str, Any]:
+    return post("/api/v1/brand/list-by-current-user", {"page": page, "page_size": page_size})
+
+
+def update_brand(
+    brand_id: int,
+    name: str | None = None,
+    description: str | None = None,
+    aliases: list[str] | None = None,
+    service_type: str | None = None,
+) -> dict[str, Any]:
+    body: dict[str, Any] = {"brand_id": brand_id}
+    if name is not None:
+        body["name"] = name
+    if description is not None:
+        body["description"] = description
+    if aliases is not None:
+        body["aliases"] = aliases
+    if service_type is not None:
+        body["service_type"] = service_type
+    return post("/api/v1/brand/update", body)

geo_cli/api/eval_job.py

@@ -0,0 +1,38 @@
+from typing import Any
+
+from geo_cli.core.http import normalize_list, post
+
+
+def create_eval_job(
+    brand_id: int,
+    eval_job_name: str,
+    query_ids: list[int],
+    platforms: list[str],
+) -> dict[str, Any]:
+    return post(
+        "/api/v1/eval-job/create",
+        {
+            "brand_id": brand_id,
+            "eval_job_name": eval_job_name,
+            "query_ids": query_ids,
+            "platforms": normalize_list(platforms),
+        },
+    )
+
+
+def get_eval_job_status(brand_id: int, eval_job_id: str) -> dict[str, Any]:
+    return post(
+        "/api/v1/eval-job/status",
+        {"brand_id": brand_id, "eval_job_id": eval_job_id},
+    )
+
+
+def list_eval_jobs_by_brand(
+    brand_id: int,
+    page: int = 1,
+    page_size: int = 20,
+) -> dict[str, Any]:
+    return post(
+        "/api/v1/eval-job/list-by-brand",
+        {"brand_id": brand_id, "page": page, "page_size": page_size},
+    )

geo_cli/api/metrics.py

@@ -0,0 +1,305 @@
+import json
+from typing import Any
+
+import httpx
+
+from geo_cli.config import (
+    get_report_agent_api_key,
+    get_report_agent_base_url,
+    get_report_agent_id,
+)
+from geo_cli.core.http import clean_params, get, post
+
+
+def query_evaluated_metrics(brand_id: int, eval_job_id: str) -> dict[str, Any]:
+    return post(
+        "/api/v1/eval-job/query_evaluated_metrics",
+        {"brand_id": brand_id, "eval_job_id": eval_job_id},
+    )
+
+
+def _get_geo_metrics(
+    path: str,
+    brand_id: str,
+    start_date: str | None = None,
+    end_date: str | None = None,
+    platform: str | None = None,
+    country: str | None = None,
+    lang: str | None = None,
+    regions: list[str] | None = None,
+    key_strengths: list[str] | None = None,
+    target_people: list[str] | None = None,
+    scenarios: list[str] | None = None,
+) -> dict[str, Any]:
+    return get(
+        path,
+        clean_params(
+            {
+                "brand_id": brand_id,
+                "start_date": start_date,
+                "end_date": end_date,
+                "platform": platform,
+                "country": country,
+                "lang": lang,
+                "regions": regions,
+                "key_strengths": key_strengths,
+                "target_people": target_people,
+                "scenarios": scenarios,
+            }
+        ),
+    )
+
+
+def get_my_brand_stats(
+    brand_id: str,
+    start_date: str | None = None,
+    end_date: str | None = None,
+    platform: str | None = None,
+    country: str | None = None,
+    lang: str | None = None,
+    regions: list[str] | None = None,
+    key_strengths: list[str] | None = None,
+    target_people: list[str] | None = None,
+    scenarios: list[str] | None = None,
+) -> dict[str, Any]:
+    return _get_geo_metrics(
+        "/api/v1/etl-dashboard/geo/my-brand-stats",
+        brand_id,
+        start_date,
+        end_date,
+        platform,
+        country,
+        lang,
+        regions,
+        key_strengths,
+        target_people,
+        scenarios,
+    )
+
+
+def get_all_brands_stats(
+    brand_id: str,
+    start_date: str | None = None,
+    end_date: str | None = None,
+    platform: str | None = None,
+    country: str | None = None,
+    lang: str | None = None,
+    regions: list[str] | None = None,
+    key_strengths: list[str] | None = None,
+    target_people: list[str] | None = None,
+    scenarios: list[str] | None = None,
+) -> dict[str, Any]:
+    return _get_geo_metrics(
+        "/api/v1/etl-dashboard/geo/all-brands-stats",
+        brand_id,
+        start_date,
+        end_date,
+        platform,
+        country,
+        lang,
+        regions,
+        key_strengths,
+        target_people,
+        scenarios,
+    )
+
+
+def get_my_prompt_stats(
+    brand_id: str,
+    start_date: str | None = None,
+    end_date: str | None = None,
+    platform: str | None = None,
+    country: str | None = None,
+    lang: str | None = None,
+    regions: list[str] | None = None,
+    key_strengths: list[str] | None = None,
+    target_people: list[str] | None = None,
+    scenarios: list[str] | None = None,
+) -> dict[str, Any]:
+    return _get_geo_metrics(
+        "/api/v1/etl-dashboard/geo/my-prompt-stats",
+        brand_id,
+        start_date,
+        end_date,
+        platform,
+        country,
+        lang,
+        regions,
+        key_strengths,
+        target_people,
+        scenarios,
+    )
+
+
+def get_domain_stats(
+    brand_id: str,
+    start_date: str | None = None,
+    end_date: str | None = None,
+    platform: str | None = None,
+    country: str | None = None,
+    lang: str | None = None,
+    regions: list[str] | None = None,
+    key_strengths: list[str] | None = None,
+    target_people: list[str] | None = None,
+    scenarios: list[str] | None = None,
+) -> dict[str, Any]:
+    return _get_geo_metrics(
+        "/api/v1/etl-dashboard/geo/domain-stats",
+        brand_id,
+        start_date,
+        end_date,
+        platform,
+        country,
+        lang,
+        regions,
+        key_strengths,
+        target_people,
+        scenarios,
+    )
+
+
+def get_domain_brand_stats(
+    brand_id: str,
+    start_date: str | None = None,
+    end_date: str | None = None,
+    platform: str | None = None,
+    country: str | None = None,
+    lang: str | None = None,
+    regions: list[str] | None = None,
+    key_strengths: list[str] | None = None,
+    target_people: list[str] | None = None,
+    scenarios: list[str] | None = None,
+) -> dict[str, Any]:
+    return _get_geo_metrics(
+        "/api/v1/etl-dashboard/geo/domain-brand-stats",
+        brand_id,
+        start_date,
+        end_date,
+        platform,
+        country,
+        lang,
+        regions,
+        key_strengths,
+        target_people,
+        scenarios,
+    )
+
+
+def get_url_stats(
+    brand_id: str,
+    start_date: str | None = None,
+    end_date: str | None = None,
+    platform: str | None = None,
+    country: str | None = None,
+    lang: str | None = None,
+    regions: list[str] | None = None,
+    key_strengths: list[str] | None = None,
+    target_people: list[str] | None = None,
+    scenarios: list[str] | None = None,
+) -> dict[str, Any]:
+    return _get_geo_metrics(
+        "/api/v1/etl-dashboard/geo/url-stats",
+        brand_id,
+        start_date,
+        end_date,
+        platform,
+        country,
+        lang,
+        regions,
+        key_strengths,
+        target_people,
+        scenarios,
+    )
+
+
+def get_qa_details(
+    chat_date: str,
+    brand_id: str,
+    platform: str,
+    question_id: str | None = None,
+    question: str | None = None,
+) -> dict[str, Any]:
+    return get(
+        "/api/v1/etl-dashboard/geo/qa-details",
+        clean_params(
+            {
+                "chat_date": chat_date,
+                "brand_id": brand_id,
+                "platform": platform,
+                "question_id": question_id,
+                "question": question,
+            }
+        ),
+    )
+
+
+def _iter_sse_data(response: httpx.Response):
+    for line in response.iter_lines():
+        if isinstance(line, bytes):
+            line = line.decode("utf-8")
+        if not line or not line.startswith("data: "):
+            continue
+        yield json.loads(line[6:])
+
+
+def analyze_report(
+    brand_id: str,
+    message: str,
+    session_id: str | None = None,
+) -> dict[str, Any]:
+    api_key = get_report_agent_api_key()
+    if not api_key:
+        return {"code": -1, "msg": "REPORT_AGENT_API_KEY 未配置"}
+
+    payload: dict[str, Any] = {
+        "message": message,
+        "user_id": "geo-cli",
+        "stream": False,
+        "return_thinking": False,
+        "verbose_mode": False,
+        "input_params": {"brand_id": brand_id},
+    }
+    if session_id:
+        payload["session_id"] = session_id
+
+    url = (
+        f"{get_report_agent_base_url().rstrip('/')}"
+        f"/api/v1/chat/{get_report_agent_id()}"
+    )
+    response = httpx.post(
+        url,
+        json=payload,
+        headers={
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {api_key}",
+        },
+        timeout=1800.0,
+    )
+    try:
+        response.raise_for_status()
+    except httpx.HTTPStatusError as exc:
+        return {"code": response.status_code, "msg": response.text or str(exc)}
+
+    content_parts: list[str] = []
+    done: dict[str, Any] = {}
+    errors: list[str] = []
+    for event in _iter_sse_data(response):
+        event_type = event.get("type")
+        if event_type == "message":
+            content_parts.append(str(event.get("content", "")))
+        elif event_type == "done":
+            done = event
+        elif event_type == "error":
+            errors.append(str(event.get("message", "")))
+
+    if errors:
+        return {"code": -1, "msg": "\n".join(error for error in errors if error)}
+
+    return {
+        "code": 0,
+        "data": {
+            "content": "".join(content_parts),
+            "session_id": done.get("session_id"),
+            "request_id": done.get("request_id"),
+        },
+    }