liyagent 0.2.0__py3-none-any.whl

liyagent/__init__.py

@@ -0,0 +1,15 @@
+"""Liyagent's Python SDK: agents, runs, evals, knowledge, approvals and
+solution templates over the public API.
+
+    from liyagent import Client
+    liya = Client("https://acme.liyagent.com", token="svc/ci:...")
+"""
+
+from . import models
+from ._transport import LiyagentError
+from ._version import __version__
+from .client import Client, missing_operations
+from .resources import OPERATIONS
+
+__all__ = ["Client", "LiyagentError", "OPERATIONS", "missing_operations", "models",
+           "__version__"]

liyagent/_transport.py

@@ -0,0 +1,225 @@
+"""The one HTTP path every SDK call takes: credentials, errors, the server's
+OpenAPI document.
+
+The behaviour is the `liya` CLI's (ticketiq/cli/client.py and tiq.py), kept
+in step by a test that runs both over the same responses
+(tests/unit/test_sdk_python.py) rather than by importing them: the SDK is
+installed on its own, by people who never install the server.
+
+* Credentials, highest first: ``token=`` (or ``LIYA_TOKEN`` /
+  ``TICKETIQ_TOKEN``), then ``username=``/``password=`` (a console sign-in).
+  A service account's client credentials, ``svc/<name>:<secret>``, are
+  exchanged for a one-hour session (POST /api/service-accounts/token) on
+  first use, and again when that session expires (a 401 on a session the
+  SDK minted is retried once on a new one, as is a sign-in's); any other
+  token is sent as a bearer as it is.
+* ``api_key=`` is the instance API key or an inbound client's token, sent as
+  X-API-Key, for the machine surface (POST /api/answer).
+* A refusal is a LiyagentError carrying the status, the server's reason —
+  a bundle's or a template's {message, at} kept whole — and its kind: 401
+  and 403 told apart, as the CLI tells them apart.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import Any
+from urllib.parse import quote
+
+from ._version import __version__
+
+USER_AGENT = f"liyagent-python/{__version__}"
+
+
+class LiyagentError(RuntimeError):
+    """A request the server refused, or could not be made.
+
+    `status` is the HTTP status (0 when the server was not reached), `detail`
+    the server's own answer (a string, or an object such as {message, at}),
+    and `kind` one of: "auth" (401: sign in again), "forbidden" (403: a
+    permission is missing), "not_found", "invalid" (400, 422), "conflict"
+    (409, 412), "unreachable" or "error"."""
+
+    def __init__(self, message: str, *, status: int = 0, detail: Any = None,
+                 kind: str = "error") -> None:
+        super().__init__(message)
+        self.status = status
+        self.detail = detail
+        self.kind = kind
+
+
+def detail_of(response: Any) -> str:
+    """The server's reason as one line. A bundle's or a template's refusal
+    is {message, at} — where in the document it was — and both halves are
+    the point, so neither is dropped (tiq._detail)."""
+    try:
+        detail = response.json().get("detail", "")
+    except Exception:
+        return response.text[:200]
+    if isinstance(detail, dict):
+        msg = str(detail.get("message") or json.dumps(detail, sort_keys=True))
+        return msg + (f" (at {detail['at']})" if detail.get("at") else "")
+    return str(detail)
+
+
+def _kind(status: int) -> str:
+    return {401: "auth", 403: "forbidden", 404: "not_found", 400: "invalid", 422: "invalid",
+            409: "conflict", 412: "conflict"}.get(status, "error")
+
+
+def checked(response: Any, path: str) -> Any:
+    """The JSON of a successful response, or the LiyagentError it is."""
+    status = response.status_code
+    if status < 400:
+        if status == 204 or not response.content:
+            return {}
+        try:
+            return response.json()
+        except ValueError:
+            return response.text
+    try:
+        raw = response.json().get("detail")
+    except Exception:
+        raw = response.text[:200]
+    if status == 401:
+        msg = (f"{path}: not signed in — the session or token was refused (expired, or its "
+               "service account deleted?)")
+    elif status == 403:
+        why = detail_of(response)
+        msg = f"{path}: this account lacks the permission for it" + (f" ({why})" if why else "")
+    else:
+        msg = f"{path} failed ({status}): {detail_of(response)}"
+    raise LiyagentError(msg, status=status, detail=raw, kind=_kind(status))
+
+
+def segment(value: Any) -> str:
+    """One path segment, quoted whole."""
+    return quote(str(value), safe="")
+
+
+class Transport:
+    """An httpx client with the caller's credentials on it, made on first
+    use. `http` is the seam: hand in any httpx.Client (or a FastAPI
+    TestClient) and the SDK talks through it instead of a socket."""
+
+    def __init__(self, base_url: str = "", *, token: str = "", username: str = "",
+                 password: str = "", api_key: str = "", timeout: float = 60.0,
+                 http: Any = None) -> None:
+        self.base_url = (base_url or os.environ.get("LIYA_URL")
+                         or "http://127.0.0.1:8787").rstrip("/")
+        self.token = token or os.environ.get("LIYA_TOKEN") or os.environ.get(
+            "TICKETIQ_TOKEN", "")
+        self.username, self.password = username, password
+        self.api_key = api_key or os.environ.get("LIYA_API_KEY", "")
+        self.timeout = timeout
+        self._http = http
+        self._owned = http is None
+        self._bearer: str | None = None
+        self._openapi: dict[str, Any] | None = None
+
+    @property
+    def http(self) -> Any:
+        if self._http is None:
+            import httpx
+            self._http = httpx.Client(base_url=self.base_url, timeout=self.timeout,
+                                      headers={"User-Agent": USER_AGENT})
+        return self._http
+
+    def close(self) -> None:
+        if self._http is not None and self._owned:
+            self._http.close()
+            self._http = None
+
+    # ---- credentials ----
+
+    def _exchange(self, token: str) -> str:
+        """A bearer for `token`: a service account's svc/<name>:<secret>
+        exchanged for a session, anything else as it is (tiq._bearer)."""
+        client_id, sep, secret = token.partition(":")
+        if not (sep and client_id.startswith("svc/")):
+            return token
+        r = self._send("POST", "/api/service-accounts/token", json={
+            "grant_type": "client_credentials", "client_id": client_id,
+            "client_secret": secret})
+        if r.status_code != 200:
+            raise LiyagentError(
+                f"the service account {client_id!r} was refused ({r.status_code}) — a wrong or "
+                "expired secret, a deleted service account, or its account disabled",
+                status=r.status_code, kind="auth")
+        return r.json()["access_token"]
+
+    def _login(self) -> str:
+        r = self._send("POST", "/api/login",
+                       json={"username": self.username, "password": self.password})
+        if r.status_code != 200:
+            raise LiyagentError(f"sign-in failed for {self.username!r} ({r.status_code})",
+                                status=r.status_code, kind="auth")
+        return str((r.json() or {}).get("token") or "")
+
+    def _minted(self) -> bool:
+        """Whether the bearer is a session the SDK minted itself — from a
+        service account's client credentials, or a sign-in — and so one it
+        can mint again when it expires. A token given as it is cannot be."""
+        if self.token:
+            client_id, sep, _ = self.token.partition(":")
+            return bool(sep and client_id.startswith("svc/"))
+        return bool(self.username and self.password)
+
+    def bearer(self) -> str:
+        if self._bearer is None:
+            if self.token:
+                self._bearer = self._exchange(self.token)
+            elif self.username and self.password:
+                self._bearer = self._login()
+            else:
+                raise LiyagentError("no credentials — pass token= (or set LIYA_TOKEN), or "
+                                    "username= and password=", kind="auth")
+        return self._bearer
+
+    # ---- requests ----
+
+    def _send(self, method: str, path: str, *, params: dict | None = None, json: Any = None,
+              headers: dict | None = None) -> Any:
+        try:
+            return self.http.request(method, path, params=params or None, json=json,
+                                     headers=headers)
+        except LiyagentError:
+            raise
+        except Exception as e:
+            raise LiyagentError(f"cannot reach {self.base_url}: {e.__class__.__name__}: {e}",
+                                kind="unreachable") from None
+
+    def request(self, method: str, path: str, *, params: dict | None = None,
+                json: Any = None, auth: str = "bearer") -> Any:
+        """`auth` is "bearer" (a person or a service account), "api_key"
+        (X-API-Key, the machine surface) or "none"."""
+        headers: dict[str, str] = {}
+        if auth == "bearer":
+            headers["Authorization"] = f"Bearer {self.bearer()}"
+        elif auth == "api_key":
+            if self.api_key:
+                headers["X-API-Key"] = self.api_key
+            else:
+                headers["Authorization"] = f"Bearer {self.bearer()}"
+        # A parameter left unset is left off rather than sent empty.
+        query = {k: v for k, v in (params or {}).items() if v not in (None, "", [])}
+        response = self._send(method, path, params=query, json=json, headers=headers)
+        if response.status_code == 401 and "Authorization" in headers and self._minted():
+            # A session the SDK minted lasts an hour (a service account's) or
+            # until it is signed out, and a Client may outlive it. A 401 is
+            # answered before the route runs, so the request is sent again —
+            # once — on a session minted afresh; refused again, it is the
+            # caller's 401.
+            self._bearer = None
+            headers["Authorization"] = f"Bearer {self.bearer()}"
+            response = self._send(method, path, params=query, json=json, headers=headers)
+        return checked(response, path)
+
+    # ---- what the server serves ----
+
+    def openapi(self) -> dict[str, Any]:
+        if self._openapi is None:
+            r = self._send("GET", "/openapi.json")
+            self._openapi = r.json() if r.status_code == 200 else {}
+        return self._openapi

liyagent/_version.py

@@ -0,0 +1,3 @@
+"""The package version: one place, read by pyproject.toml and the User-Agent."""
+
+__version__ = "0.2.0"

liyagent/client.py

@@ -0,0 +1,78 @@
+"""The Client: one object per Liyagent instance, a namespace per resource.
+
+    from liyagent import Client
+
+    with Client("https://acme.liyagent.com", token="svc/ci:...") as liya:
+        for t in liya.templates.list(solution="itsm"):
+            print(t["key"], t["version"])
+        plan = liya.templates.preview("it-ticket-triage", agent_id="desk-triage")
+        if plan["valid"]:
+            liya.templates.install("it-ticket-triage", agent_id="desk-triage")
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from ._transport import Transport
+from .resources import (OPERATIONS, Agents, Approvals, Evals, Knowledge, Runs, Templates)
+
+
+def _matches(template: str, served: str) -> bool:
+    """Whether two OpenAPI path templates name one route: the same segments,
+    a placeholder matching a placeholder whatever its name."""
+    a, b = template.strip("/").split("/"), served.strip("/").split("/")
+    var = re.compile(r"^\{[^}]+\}$")
+    return len(a) == len(b) and all(x == y or (var.match(x) and var.match(y))
+                                    for x, y in zip(a, b))
+
+
+def missing_operations(spec: dict[str, Any]) -> list[str]:
+    """The SDK operations an OpenAPI document does not serve, as
+    "METHOD /path" — empty when the server has every one."""
+    paths = spec.get("paths") or {}
+    out = []
+    for method, template in OPERATIONS:
+        if not any(_matches(template, p) and method.lower() in ops
+                   for p, ops in paths.items()):
+            out.append(f"{method} {template}")
+    return out
+
+
+class Client:
+    """A Liyagent instance. Credentials as Transport takes them: `token`
+    (a session, or a service account's svc/<name>:<secret>), or `username`
+    and `password`; `api_key` for the machine surface (knowledge.answer).
+    `http` is any httpx.Client to talk through instead of a socket."""
+
+    def __init__(self, base_url: str = "", *, token: str = "", username: str = "",
+                 password: str = "", api_key: str = "", timeout: float = 60.0,
+                 http: Any = None) -> None:
+        self.transport = Transport(base_url, token=token, username=username,
+                                   password=password, api_key=api_key, timeout=timeout,
+                                   http=http)
+        self.agents = Agents(self.transport)
+        self.runs = Runs(self.transport)
+        self.evals = Evals(self.transport)
+        self.knowledge = Knowledge(self.transport)
+        self.approvals = Approvals(self.transport)
+        self.templates = Templates(self.transport)
+
+    def request(self, method: str, path: str, **kw: Any) -> Any:
+        """Any other route, with the same credentials and errors."""
+        return self.transport.request(method, path, **kw)
+
+    def check_server(self) -> list[str]:
+        """The operations this SDK uses that the server does not serve (an
+        older release): empty when every call here will find its route."""
+        return missing_operations(self.transport.openapi())
+
+    def close(self) -> None:
+        self.transport.close()
+
+    def __enter__(self) -> "Client":
+        return self
+
+    def __exit__(self, *exc: Any) -> None:
+        self.close()

liyagent/models.py

@@ -0,0 +1,147 @@
+"""Typed request bodies for the Liyagent API.
+
+Generated by sdk/scripts/generate_models.py from the server's OpenAPI document.
+Do not edit by hand.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Literal, TypedDict
+
+
+class AnswerBody(TypedDict, total=False):
+    query: str
+    top_k: int | None
+    requester: str
+    conversation_id: str
+
+
+class ApprovalDecisionBody(TypedDict, total=False):
+    reason: str
+    digest: str
+
+
+class BundleApplyBody(TypedDict, total=False):
+    bundle: dict[str, Any]  # required
+    dry_run: bool
+    reason: str
+
+
+class EvalDatasetBody(TypedDict, total=False):
+    name: str  # required
+    kind: str  # required
+    items: list[Any] | None
+    jsonl: str | None
+    description: str | None
+    append: bool
+
+
+class EvalOfflineRunBody(TypedDict, total=False):
+    dataset: str  # required
+    version: int | None
+    agent: str
+    split: str
+    evaluators: list[Any] | None
+    baseline: str
+    allowed_drop: float | None
+    allowed_drops: dict[str, float] | None
+    variant: dict[str, Any] | None
+    model: str
+
+
+class GatewayAgentBody(TypedDict, total=False):
+    label: str | None
+    about: str | None
+    enabled: bool | None
+    tags: list[str] | None
+    prompt: str | None
+    runtime: str | None
+    reason: str | None
+    exchange_only: bool | None
+    uid: str | None
+    display_name: str | None
+    description: str | None
+    managed: dict[str, Any] | None
+    update_mask: list[str] | str | None
+    invoke_access: list[str] | None
+
+
+class KBRejectBody(TypedDict, total=False):
+    reason: str
+
+
+class PlaygroundBody(TypedDict, total=False):
+    message: str
+    system: str
+    session: str
+    ticket: str
+    provider: str
+    model: str
+    effort: str
+    files: list[str]
+    support_grant: str
+
+
+class ReasonBody(TypedDict, total=False):
+    reason: str
+
+
+class RunResumeBody(TypedDict, total=False):
+    answer: Any
+
+
+class TemplateDocBody(TypedDict, total=False):
+    template: dict[str, Any]  # required
+
+
+class TemplateFromAgentBody(TypedDict, total=False):
+    agent: str  # required
+    workflow: str
+    key: str
+    title: str
+    solution: str
+    version: str
+
+
+class TemplateInstallBody(TypedDict, total=False):
+    agent_id: str
+    provider: str
+    model: str
+    tags: list[str]
+    enable_triggers: bool
+    reason: str
+    params: dict[str, Any]
+
+
+class TemplateUninstallBody(TypedDict, total=False):
+    reason: str
+    keep_guardrails: bool
+    dry_run: bool
+
+
+class WorkflowRunBody(TypedDict, total=False):
+    input: dict[str, Any]
+    version: int | None
+
+
+# The body each operation takes, by (method, path) as OPERATIONS lists it.
+REQUEST_BODIES: dict[tuple[str, str], str] = {
+    ("PUT", "/api/gateway/agents/{agent_id}"): "GatewayAgentBody",
+    ("DELETE", "/api/gateway/agents/{agent_id}"): "ReasonBody",
+    ("POST", "/api/agents/apply"): "BundleApplyBody",
+    ("POST", "/api/agents/{key}/playground"): "PlaygroundBody",
+    ("POST", "/api/agents/{key}/workflows/{name}/runs"): "WorkflowRunBody",
+    ("POST", "/api/runs/{run_id}/resume"): "RunResumeBody",
+    ("POST", "/api/evals/datasets"): "EvalDatasetBody",
+    ("POST", "/api/evals/runs"): "EvalOfflineRunBody",
+    ("POST", "/api/answer"): "AnswerBody",
+    ("POST", "/api/kb/articles/{article_id}/reject"): "KBRejectBody",
+    ("POST", "/api/approvals/{approval_id}/approve"): "ApprovalDecisionBody",
+    ("POST", "/api/approvals/{approval_id}/reject"): "ApprovalDecisionBody",
+    ("POST", "/api/templates/{key}/preview"): "TemplateInstallBody",
+    ("POST", "/api/templates/{key}/install"): "TemplateInstallBody",
+    ("DELETE", "/api/template-installs/{agent}"): "TemplateUninstallBody",
+    ("POST", "/api/template-authoring/validate"): "TemplateDocBody",
+    ("POST", "/api/template-authoring/from-agent"): "TemplateFromAgentBody",
+    ("PUT", "/api/template-authoring/{key}/versions/{version}"): "TemplateDocBody",
+}

liyagent/resources.py

@@ -0,0 +1,338 @@
+"""The resources a Client exposes, one class each, over the public API.
+
+Every method is one request (Evals.wait polls one), named for what it does,
+and returns the server's JSON as it is: the SDK adds no model of its own
+that could drift from the server's. The (method, path) each one uses is in
+OPERATIONS, which a test checks against the server's OpenAPI document and
+Client.check_server() checks against a live one.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Iterator
+
+from ._transport import LiyagentError, Transport, segment as q
+from .models import TemplateFromAgentBody, TemplateInstallBody
+
+# Every operation the SDK calls: (method, path template). Kept beside the
+# methods that use them, and checked against the server's OpenAPI document,
+# so a route renamed on the server fails a test rather than a customer.
+OPERATIONS: tuple[tuple[str, str], ...] = (
+    ("GET", "/api/gateway/agents"),
+    ("GET", "/api/gateway/agents/{agent_id}"),
+    ("PUT", "/api/gateway/agents/{agent_id}"),
+    ("DELETE", "/api/gateway/agents/{agent_id}"),
+    ("GET", "/api/agents/{key}/export"),
+    ("POST", "/api/agents/apply"),
+    ("POST", "/api/agents/{key}/playground"),
+    ("POST", "/api/agents/{key}/start"),
+    ("POST", "/api/agents/{key}/stop"),
+    ("GET", "/api/agents/{key}/workflows"),
+    ("POST", "/api/agents/{key}/workflows/{name}/runs"),
+    ("GET", "/api/agents/{key}/workflow-runs/{run_id}"),
+    ("GET", "/api/runs"),
+    ("GET", "/api/runs/{run_id}/checkpoint"),
+    ("POST", "/api/runs/{run_id}/resume"),
+    ("GET", "/api/evals/datasets"),
+    ("POST", "/api/evals/datasets"),
+    ("GET", "/api/evals/datasets/{name}"),
+    ("POST", "/api/evals/runs"),
+    ("GET", "/api/evals/runs"),
+    ("GET", "/api/evals/runs/{run_id}"),
+    ("GET", "/api/evals/runs/{run_id}/compare"),
+    ("POST", "/api/answer"),
+    ("GET", "/api/collections"),
+    ("GET", "/api/kb/articles"),
+    ("POST", "/api/kb/articles/{article_id}/approve"),
+    ("POST", "/api/kb/articles/{article_id}/reject"),
+    ("GET", "/api/approvals"),
+    ("GET", "/api/approvals/{approval_id}"),
+    ("POST", "/api/approvals/{approval_id}/approve"),
+    ("POST", "/api/approvals/{approval_id}/reject"),
+    ("GET", "/api/templates"),
+    ("GET", "/api/templates/{key}"),
+    ("POST", "/api/templates/{key}/preview"),
+    ("POST", "/api/templates/{key}/install"),
+    ("GET", "/api/template-installs"),
+    ("DELETE", "/api/template-installs/{agent}"),
+    ("GET", "/api/template-authoring"),
+    ("GET", "/api/template-authoring/{key}"),
+    ("POST", "/api/template-authoring/validate"),
+    ("POST", "/api/template-authoring/from-agent"),
+    ("PUT", "/api/template-authoring/{key}/versions/{version}"),
+    ("POST", "/api/template-authoring/{key}/versions/{version}/publish"),
+    ("DELETE", "/api/template-authoring/{key}/versions/{version}"),
+    ("DELETE", "/api/template-authoring/{key}"),
+)
+
+
+class _Resource:
+    def __init__(self, t: Transport) -> None:
+        self._t = t
+
+
+class Agents(_Resource):
+    """Agents in the registry: list, read, create or change, delete; their
+    bundle (agents as code); ask one a question; run one of its workflows."""
+
+    def list(self, *, filter: str = "", page_size: int = 100) -> Iterator[dict[str, Any]]:
+        """Every agent the caller may see, following the pages. `filter` is
+        the server's AIP-160 filter (e.g. 'runtime = "managed"')."""
+        token = ""
+        while True:
+            page = self._t.request("GET", "/api/gateway/agents", params={
+                "filter": filter, "page_size": page_size, "page_token": token})
+            yield from page.get("agents") or []
+            token = page.get("next_page_token") or ""
+            if not token:
+                return
+
+    def get(self, agent_id: str) -> dict[str, Any]:
+        return self._t.request("GET", f"/api/gateway/agents/{q(agent_id)}")
+
+    def put(self, agent_id: str, **fields: Any) -> dict[str, Any]:
+        """Create the agent, or change the fields given (label, about, tags,
+        runtime, enabled...)."""
+        return self._t.request("PUT", f"/api/gateway/agents/{q(agent_id)}", json=fields)
+
+    def delete(self, agent_id: str, *, reason: str = "") -> dict[str, Any]:
+        return self._t.request("DELETE", f"/api/gateway/agents/{q(agent_id)}",
+                               json={"reason": reason})
+
+    def export(self, agent_id: str, *, sections: list[str] | None = None) -> dict[str, Any]:
+        """The agent as a bundle: what POST /agents/apply takes back."""
+        return self._t.request("GET", f"/api/agents/{q(agent_id)}/export",
+                               params={"sections": ",".join(sections or [])})
+
+    def apply(self, bundle: dict[str, Any], *, dry_run: bool = False,
+              reason: str = "") -> dict[str, Any]:
+        """Apply a bundle (or an AgentBundleList): the plan per section, and
+        with dry_run nothing written."""
+        return self._t.request("POST", "/api/agents/apply",
+                               json={"bundle": bundle, "dry_run": dry_run, "reason": reason})
+
+    def ask(self, agent_id: str, message: str, *, session: str = "",
+            **options: Any) -> dict[str, Any]:
+        """One prompt through the agent as production runs it — its
+        guardrails, tools, approvals and budget — and its answer."""
+        return self._t.request("POST", f"/api/agents/{q(agent_id)}/playground",
+                               json={"message": message, "session": session, **options})
+
+    def start(self, agent_id: str) -> dict[str, Any]:
+        return self._t.request("POST", f"/api/agents/{q(agent_id)}/start")
+
+    def stop(self, agent_id: str) -> dict[str, Any]:
+        return self._t.request("POST", f"/api/agents/{q(agent_id)}/stop")
+
+    def workflows(self, agent_id: str) -> list[dict[str, Any]]:
+        return self._t.request("GET", f"/api/agents/{q(agent_id)}/workflows")["workflows"]
+
+    def run_workflow(self, agent_id: str, name: str, input: dict[str, Any] | None = None, *,
+                     version: int | None = None) -> dict[str, Any]:
+        """Run a workflow to its end or its first wait (an approval)."""
+        return self._t.request("POST", f"/api/agents/{q(agent_id)}/workflows/{q(name)}/runs",
+                               json={"input": input or {}, "version": version})
+
+    def workflow_run(self, agent_id: str, run_id: str) -> dict[str, Any]:
+        return self._t.request("GET", f"/api/agents/{q(agent_id)}/workflow-runs/{q(run_id)}")
+
+
+class Runs(_Resource):
+    """Agent runs: the recent ones, a suspended one's checkpoint, resuming it."""
+
+    def list(self, *, limit: int = 50) -> list[dict[str, Any]]:
+        return self._t.request("GET", "/api/runs", params={"limit": limit})["runs"]
+
+    def checkpoint(self, run_id: str) -> dict[str, Any]:
+        return self._t.request("GET", f"/api/runs/{q(run_id)}/checkpoint")
+
+    def resume(self, run_id: str, answer: Any = None) -> dict[str, Any]:
+        """Resume a run waiting for input (`answer`) or a connection."""
+        return self._t.request("POST", f"/api/runs/{q(run_id)}/resume",
+                               json={"answer": answer} if answer is not None else {})
+
+
+class Evals(_Resource):
+    """Eval datasets (versioned, immutable) and the runs scored on them."""
+
+    def datasets(self, *, kind: str = "") -> list[dict[str, Any]]:
+        return self._t.request("GET", "/api/evals/datasets", params={"kind": kind})["datasets"]
+
+    def dataset(self, name: str, *, version: int | None = None,
+                items: bool = True) -> dict[str, Any]:
+        return self._t.request("GET", f"/api/evals/datasets/{q(name)}",
+                               params={"version": version, "items": str(items).lower()})
+
+    def create_dataset(self, name: str, kind: str, items: list[dict[str, Any]], *,
+                       description: str | None = None, append: bool = False) -> dict[str, Any]:
+        """Write the dataset's next version (version 1 of a new one); items
+        equal to the latest version's write nothing (`unchanged`)."""
+        body: dict[str, Any] = {"name": name, "kind": kind, "items": items, "append": append}
+        if description is not None:
+            body["description"] = description
+        return self._t.request("POST", "/api/evals/datasets", json=body)
+
+    def start_run(self, dataset: str, agent: str = "", *, version: int | None = None,
+                  split: str = "", evaluators: list[str] | None = None,
+                  baseline: str = "", allowed_drop: float | None = None) -> dict[str, Any]:
+        """Score a dataset version, as a background job; poll with run() or
+        wait()."""
+        body: dict[str, Any] = {"dataset": dataset, "agent": agent, "version": version,
+                                "split": split, "evaluators": evaluators,
+                                "baseline": baseline, "allowed_drop": allowed_drop}
+        return self._t.request("POST", "/api/evals/runs",
+                               json={k: v for k, v in body.items() if v not in (None, "")})
+
+    def runs(self, *, dataset: str = "", agent: str = "", limit: int = 50
+             ) -> list[dict[str, Any]]:
+        return self._t.request("GET", "/api/evals/runs",
+                               params={"dataset": dataset, "agent": agent, "limit": limit})["runs"]
+
+    def run(self, run_id: str) -> dict[str, Any]:
+        return self._t.request("GET", f"/api/evals/runs/{q(run_id)}")
+
+    def compare(self, run_id: str, *, baseline: str = "pinned") -> dict[str, Any]:
+        return self._t.request("GET", f"/api/evals/runs/{q(run_id)}/compare",
+                               params={"baseline": baseline})
+
+    def wait(self, run_id: str, *, timeout: float = 600.0, every: float = 2.0
+             ) -> dict[str, Any]:
+        """Poll a run until it is no longer queued or running."""
+        deadline = time.monotonic() + timeout
+        while True:
+            got = self.run(run_id)
+            if str(got.get("status") or "") not in ("queued", "running", "pending"):
+                return got
+            if time.monotonic() >= deadline:
+                raise LiyagentError(f"eval run {run_id} still {got.get('status')} after "
+                                    f"{timeout:.0f}s", kind="error")
+            time.sleep(every)
+
+
+class Knowledge(_Resource):
+    """The knowledge base: answers from it, its collections, and the
+    articles drafted from resolved work that wait for a person."""
+
+    def answer(self, query: str, *, top_k: int | None = None,
+               conversation_id: str = "") -> dict[str, Any]:
+        """The closest known answers to a question, without filing a ticket.
+        The machine surface: the API key (api_key=) or a client token."""
+        return self._t.request("POST", "/api/answer", auth="api_key", json={
+            "query": query, "top_k": top_k, "conversation_id": conversation_id})
+
+    def collections(self) -> Any:
+        return self._t.request("GET", "/api/collections")
+
+    def articles(self, *, status: str = "", limit: int = 50) -> Any:
+        return self._t.request("GET", "/api/kb/articles",
+                               params={"status": status, "limit": limit})
+
+    def approve_article(self, article_id: str) -> dict[str, Any]:
+        return self._t.request("POST", f"/api/kb/articles/{q(article_id)}/approve")
+
+    def reject_article(self, article_id: str) -> dict[str, Any]:
+        return self._t.request("POST", f"/api/kb/articles/{q(article_id)}/reject")
+
+
+class Approvals(_Resource):
+    """The approval queue: agent calls held for a person's decision."""
+
+    def list(self, *, status: str = "", mine: bool = False, limit: int = 100
+             ) -> list[dict[str, Any]]:
+        return self._t.request("GET", "/api/approvals", params={
+            "status": status, "mine": "true" if mine else "", "limit": limit})["approvals"]
+
+    def get(self, approval_id: str) -> dict[str, Any]:
+        return self._t.request("GET", f"/api/approvals/{q(approval_id)}")
+
+    def approve(self, approval_id: str, *, reason: str = "", digest: str = "") -> dict[str, Any]:
+        """Approve once; the held call runs as it was asked for. `digest`,
+        given, refuses the decision if the request was edited since."""
+        return self._t.request("POST", f"/api/approvals/{q(approval_id)}/approve",
+                               json={"reason": reason, "digest": digest})
+
+    def reject(self, approval_id: str, *, reason: str = "", digest: str = "") -> dict[str, Any]:
+        return self._t.request("POST", f"/api/approvals/{q(approval_id)}/reject",
+                               json={"reason": reason, "digest": digest})
+
+
+class Templates(_Resource):
+    """Solution templates: install an agent with its guardrails, workflow,
+    triggers, eval set and budget in one step."""
+
+    def list(self, *, solution: str = "") -> list[dict[str, Any]]:
+        return self._t.request("GET", "/api/templates",
+                               params={"solution": solution})["templates"]
+
+    def get(self, key: str, *, agent_id: str = "") -> dict[str, Any]:
+        """The template whole, and what installing it as `agent_id` writes."""
+        return self._t.request("GET", f"/api/templates/{q(key)}",
+                               params={"agent_id": agent_id})
+
+    def preview(self, key: str, **options: Any) -> dict[str, Any]:
+        """Every write of an install made and rolled back: the plan, and
+        whether (and where) it would be refused. Options as install()."""
+        return self._t.request("POST", f"/api/templates/{q(key)}/preview", json=options)
+
+    def install(self, key: str, *, agent_id: str = "", provider: str = "", model: str = "",
+                tags: list[str] | None = None, enable_triggers: bool = False,
+                reason: str = "", params: dict[str, Any] | None = None) -> dict[str, Any]:
+        """Install (or, over the agent it installed, upgrade) a template.
+        `params` are values for the template's parameters."""
+        body: TemplateInstallBody = {
+            "agent_id": agent_id, "provider": provider, "model": model,
+            "tags": list(tags or []), "enable_triggers": enable_triggers, "reason": reason,
+            "params": dict(params or {})}
+        return self._t.request("POST", f"/api/templates/{q(key)}/install", json=body)
+
+    def installs(self) -> list[dict[str, Any]]:
+        return self._t.request("GET", "/api/template-installs")["installs"]
+
+    def uninstall(self, agent_id: str, *, reason: str = "", keep_guardrails: bool = False,
+                  dry_run: bool = False) -> dict[str, Any]:
+        return self._t.request("DELETE", f"/api/template-installs/{q(agent_id)}", json={
+            "reason": reason, "keep_guardrails": keep_guardrails, "dry_run": dry_run})
+
+    # ---- the tenant's own templates (needs templates.write) ----
+
+    def authored(self) -> list[dict[str, Any]]:
+        """The tenant's own templates, one row per key with its versions."""
+        return self._t.request("GET", "/api/template-authoring")["templates"]
+
+    def authored_versions(self, key: str) -> list[dict[str, Any]]:
+        """Every version of one, newest first, each with its document."""
+        return self._t.request("GET", f"/api/template-authoring/{q(key)}")["versions"]
+
+    def validate(self, template: dict[str, Any]) -> dict[str, Any]:
+        """{ok, problem} against the template schema; nothing is saved."""
+        return self._t.request("POST", "/api/template-authoring/validate",
+                               json={"template": template})
+
+    def draft_from_agent(self, agent: str, *, workflow: str = "", key: str = "",
+                         title: str = "", solution: str = "",
+                         version: str = "1.0.0") -> dict[str, Any]:
+        """A template document drafted from an agent the tenant runs. Not saved."""
+        body: TemplateFromAgentBody = {"agent": agent, "workflow": workflow, "key": key,
+                                       "title": title, "solution": solution,
+                                       "version": version}
+        return self._t.request("POST", "/api/template-authoring/from-agent", json=body)
+
+    def save_draft(self, template: dict[str, Any]) -> dict[str, Any]:
+        """Save (or rewrite) the draft version the document names."""
+        return self._t.request(
+            "PUT", f"/api/template-authoring/{q(template['key'])}/versions/"
+                   f"{q(template['version'])}", json={"template": template})
+
+    def publish(self, key: str, version: str) -> dict[str, Any]:
+        """Publish a draft version to the tenant's gallery (immutable after)."""
+        return self._t.request(
+            "POST", f"/api/template-authoring/{q(key)}/versions/{q(version)}/publish")
+
+    def delete_draft(self, key: str, version: str) -> dict[str, Any]:
+        return self._t.request(
+            "DELETE", f"/api/template-authoring/{q(key)}/versions/{q(version)}")
+
+    def withdraw(self, key: str) -> dict[str, Any]:
+        """Every version out of the gallery; installed agents keep running."""
+        return self._t.request("DELETE", f"/api/template-authoring/{q(key)}")

liyagent-0.2.0.dist-info/METADATA

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: liyagent
+Version: 0.2.0
+Summary: Python SDK for Liyagent: agents, runs, evals, knowledge, approvals and solution templates
+Author: Liyagent
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://liyagent.com
+Keywords: liyagent,ai agents,agent platform,itsm,sdk
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.25
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Dynamic: license-file
+
+# Liyagent Python SDK
+
+A small client for Liyagent's public API: agents, runs, evals, knowledge,
+approvals and solution templates. It depends only on `httpx` and returns the
+server's JSON as it is.
+
+```bash
+pip install liyagent          # from PyPI, once released
+pip install ./sdk/python      # from this repository
+```
+
+Python 3.10+. Versioned with the package (`liyagent.__version__`); see
+`CHANGELOG.md`.
+
+## Sign in
+
+```python
+from liyagent import Client
+
+# A service account (what a pipeline uses): exchanged for a one-hour session,
+# and for a new one when it expires.
+liya = Client("https://acme.liyagent.com", token="svc/ci-deployer:...")
+
+# A person, as the console signs in.
+liya = Client("https://acme.liyagent.com", username="ana", password="...")
+
+# The machine surface (knowledge.answer): the instance API key or a client token.
+liya = Client("https://acme.liyagent.com", api_key="...")
+```
+
+`LIYA_URL`, `LIYA_TOKEN` (or `TICKETIQ_TOKEN`) and `LIYA_API_KEY` are read
+when the arguments are left out, as the `liya` CLI reads them.
+
+## What it covers
+
+| Namespace | Calls |
+| --- | --- |
+| `liya.agents` | `list`, `get`, `put`, `delete`, `export`, `apply` (agents as code), `ask`, `start`, `stop`, `workflows`, `run_workflow`, `workflow_run` |
+| `liya.runs` | `list`, `checkpoint`, `resume` |
+| `liya.evals` | `datasets`, `dataset`, `create_dataset`, `start_run`, `runs`, `run`, `compare`, `wait` |
+| `liya.knowledge` | `answer`, `collections`, `articles`, `approve_article`, `reject_article` |
+| `liya.approvals` | `list`, `get`, `approve`, `reject` |
+| `liya.templates` | `list`, `get`, `preview`, `install` (with `params`), `installs`, `uninstall` |
+| `liya.templates` (authoring, `templates.write`) | `authored`, `authored_versions`, `validate`, `draft_from_agent`, `save_draft`, `publish`, `delete_draft`, `withdraw` |
+
+Anything else: `liya.request("GET", "/api/...")`, with the same credentials
+and errors.
+
+## Types
+
+Request bodies are typed: `liyagent.models` holds a `TypedDict` per body
+(`TemplateInstallBody`, `BundleApplyBody`, …) and `REQUEST_BODIES` maps each
+operation to its body. They are generated from the server's OpenAPI document
+by `sdk/scripts/generate_models.py`, and the server's test suite fails when
+the committed file differs from what the document says. The package ships
+`py.typed`, so mypy and pyright read them. Responses are the server's JSON
+as it is.
+
+## Your own templates
+
+```python
+doc = liya.templates.draft_from_agent("desk-helper", key="desk-answers")["template"]
+doc["params"] = [{"name": "team", "label": "Escalation team", "required": True}]
+doc["agent"]["instructions"] += "\nEscalate to {{ params.team }}."
+assert liya.templates.validate(doc)["ok"]
+liya.templates.save_draft(doc)
+liya.templates.publish("desk-answers", doc["version"])
+liya.templates.install("desk-answers", agent_id="desk-two", params={"team": "Network"})
+```
+
+## Errors
+
+A refusal raises `LiyagentError` with `status`, the server's `detail` (for a
+bundle or template refusal, `{message, at}`: where in the document it was)
+and a `kind`: `auth` (401, sign in again), `forbidden` (403, a permission is
+missing), `not_found`, `invalid` (400, 422), `conflict` (409, 412),
+`unreachable` or `error`.
+
+## Check the server
+
+`liya.check_server()` lists the operations this SDK uses that the server
+does not serve, so a pipeline can stop before it calls a route an older
+release does not have. The same list (`liyagent.OPERATIONS`) is checked
+against the server's OpenAPI document in the server's test suite
+(`tests/unit/test_sdk_python.py`).
+
+## Examples
+
+- `examples/install_template.py` — preview a template, stop if any part would
+  be refused, install it.
+- `examples/eval_gate.py` — score an agent on its eval set and fail a build
+  that is worse than the pinned baseline.
+- `examples/approvals_queue.py` — work the approval queue from a terminal.
+
+## Releasing
+
+See `sdk/RELEASING.md`: a tag `sdk-py-vX.Y.Z` builds and publishes this
+package to PyPI from GitHub Actions (`.github/workflows/sdk-release.yml`)
+by trusted publishing.

liyagent-0.2.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+liyagent/__init__.py,sha256=MLqGWZ9K4GA825A3W_b_fmclp31WNBldcztwGY3Ctvc,502
+liyagent/_transport.py,sha256=C7EmD0naaliNt4wt-xWhte4QQoo84CWiC9eUq7BPzvc,9795
+liyagent/_version.py,sha256=lTSvLyQ7UAUF5D-8qqh4U3TYyN4CSl8S4zOauv1Mn-M,104
+liyagent/client.py,sha256=PH7rB5zYwpKeOkLO8ecGlPo8KONMgA5ibSAPPnSy_bI,3198
+liyagent/models.py,sha256=Z0JABNL71soLUZdqbJ0TwhQ4oQ0PRk8QWzsx4snXmZw,3891
+liyagent/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+liyagent/resources.py,sha256=I5alsX5BSGJNBBeFQKh05_yWSr7AM-1Z1mSqNnE-YJE,17148
+liyagent-0.2.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+liyagent-0.2.0.dist-info/METADATA,sha256=rtUkfSY83rHhEU3uk1jTdurg5_zWsZYgQALvBT911v0,5083
+liyagent-0.2.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+liyagent-0.2.0.dist-info/top_level.txt,sha256=FjwpGt3cMCag6lgG3lA6rKNBs0bGM8xzWbbwbvBgPK4,9
+liyagent-0.2.0.dist-info/RECORD,,

liyagent-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

liyagent-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

liyagent-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+liyagent