bevor-sdk 0.1.0__py3-none-any.whl

bevor_sdk/__init__.py

@@ -0,0 +1,6 @@
+from bevor_sdk._async.client import BevorClient as AsyncBevorClient
+from bevor_sdk._async.graph import Graph as AsyncGraph
+from bevor_sdk._sync.client import BevorClient
+from bevor_sdk._sync.graph import Graph
+
+__all__ = ["BevorClient", "AsyncBevorClient", "Graph", "AsyncGraph"]

bevor_sdk/_async/client.py

@@ -0,0 +1,97 @@
+from typing import Any, Dict, Mapping, Self
+
+import httpx
+
+from bevor_sdk._shared import _BaseClient
+
+from .resources import (
+    AnalysisResources,
+    AnalysisSummaryResources,
+    AnalysisVersionsResources,
+    ChatResources,
+    CodesResources,
+    FindingResources,
+    ProjectResources,
+    TransitionResources,
+)
+
+DEFAULT_TIMEOUT = httpx.Timeout(120.0, connect=30.0)
+
+
+class BevorClient(_BaseClient):
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str | None = None,
+        default_headers: Mapping[str, str] | None = None,
+        timeout: httpx.Timeout | None = None,
+    ):
+        super().__init__(
+            api_key=api_key, base_url=base_url, default_headers=default_headers, timeout=timeout
+        )
+        self._http: httpx.AsyncClient | None = None
+
+        self.codes = CodesResources(self)
+        self.chats = ChatResources(self)
+        self.analyses = AnalysisResources(self)
+        self.transitions = TransitionResources(self)
+        self.analysis_versions = AnalysisVersionsResources(self)
+        self.summary = AnalysisSummaryResources(self)
+        self.findings = FindingResources(self)
+        self.projects = ProjectResources(self)
+
+    def _transport(self, client: httpx.AsyncClient | None) -> httpx.AsyncClient:
+        if client is not None:
+            return client
+        if self._http is None:
+            self._http = httpx.AsyncClient(timeout=self._timeout)
+        return self._http
+
+    async def _aclose(self) -> None:
+        if self._closed:
+            return
+        self._closed = True
+        if self._http is not None:
+            await self._http.aclose()
+            self._http = None
+
+    async def __aenter__(self) -> Self:
+        return self
+
+    async def __aexit__(self, *args: Any) -> None:
+        await self._aclose()
+
+    async def request_json(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: Mapping[str, Any] | None = None,
+        json: Any = None,
+        content: httpx._types.RequestContent | None = None,
+        data: httpx._types.RequestData | None = None,
+        files: httpx._types.RequestFiles | None = None,
+        client: httpx.AsyncClient | None = None,
+        headers: Dict[str, str] | None = None,
+    ) -> Any:
+        self._ensure_open()
+        url = self._url(path)
+        http = self._transport(client)
+        payload: Any = json
+        if isinstance(json, dict):
+            payload = self._prune_json_body(json)
+        resp = await http.request(
+            method,
+            url,
+            params=self._prune_query_params(params),
+            json=payload,
+            content=content,
+            data=data,
+            files=files,
+            headers=self._merge_headers(headers),
+        )
+        has_content = self._handle_http_error(resp)
+        if not has_content:
+            return None
+        return resp.json()

bevor_sdk/_async/graph.py

@@ -0,0 +1,76 @@
+import asyncio
+from typing import List
+
+from bevor_sdk import AsyncBevorClient
+from bevor_sdk._shared import _BaseGraph
+from bevor_sdk.types import ID
+from bevor_sdk.types.responses.graph import GraphSnapshotEdge, GraphSnapshotFile, GraphSnapshotNode
+
+
+class Graph(_BaseGraph):
+    """
+    Language-agnostic graph view for one code version, backed by HTTP only.
+
+    Call :meth:`build` after construction (or use :meth:`from_snapshot` for offline snapshots).
+    """
+
+    def __init__(self, client: AsyncBevorClient, code_id: ID) -> None:
+        super().__init__(code_id=code_id)
+        self._client: AsyncBevorClient = client
+
+    @classmethod
+    def from_snapshot(
+        cls,
+        client: AsyncBevorClient,
+        code_id: ID,
+        nodes: List[GraphSnapshotNode],
+        edges: List[GraphSnapshotEdge],
+        files: List[GraphSnapshotFile],
+    ) -> "Graph":
+        core = cls(client=client, code_id=code_id)
+        core._ingest_snapshot(nodes=nodes, edges=edges, files=files)
+        return core
+
+    async def build(self) -> None:
+        """Fetch snapshot via client (nodes + edges + files)."""
+        if self._is_built:
+            return
+        node_res, edge_res, file_res = await asyncio.gather(
+            self._client.codes.nodes.list(self.code_id),
+            self._client.codes.edges(self.code_id),
+            self._client.codes.files.list(self.code_id),
+        )
+        self._ingest_snapshot(nodes=node_res.results, edges=edge_res.results, files=file_res.results)
+        self._is_built = True
+
+    async def get_file_content(self, file_id: ID) -> str:
+        if file_id in self._lazy_file_text:
+            return self._lazy_file_text[file_id]
+
+        text = await self._client.codes.files.content(file_id=file_id, code_id=self.code_id)
+        self._lazy_file_text[file_id] = text
+        return text
+
+    async def reconstruct_chunk(self, node_id: ID, *, with_docstring: bool = False) -> str:
+        self._ensure_built()
+        node = self.get_node(node_id)
+        text = await self.get_file_content(node.file_id)
+        source_bytes = text.encode("utf-8")
+
+        docstring_use = None
+        if with_docstring and node.docstring:
+            if "@inheritdoc" not in node.docstring:
+                docstring_use = node.docstring
+            else:
+                natspecs = self.get_edges_for_node(
+                    node_id, direction="out", edge_type="has_ref_comment"
+                )
+                if natspecs:
+                    natspec = natspecs[0]
+                    assert natspec.dst_id
+                    natspec_node = self.get_node(natspec.dst_id)
+                    docstring_use = natspec_node.docstring
+                else:
+                    docstring_use = node.docstring
+
+        return Graph.reconstruct(node=node, source=source_bytes, docstring_use=docstring_use)

bevor_sdk/_async/resources/__init__.py

@@ -0,0 +1,24 @@
+from .chat import ChatResources
+from .graph import CodesResources, FileResources, NodeResources
+from .manage import ProjectResources, ProjectUserResources
+from .security import (
+    AnalysisResources,
+    AnalysisSummaryResources,
+    AnalysisVersionsResources,
+    FindingResources,
+    TransitionResources,
+)
+
+__all__ = [
+    "ProjectResources",
+    "AnalysisResources",
+    "FindingResources",
+    "ChatResources",
+    "CodesResources",
+    "AnalysisVersionsResources",
+    "FileResources",
+    "NodeResources",
+    "AnalysisSummaryResources",
+    "TransitionResources",
+    "ProjectUserResources",
+]

bevor_sdk/_async/resources/_modules/__init__.py

@@ -0,0 +1,4 @@
+from .events import EventResource
+from .pagination import PaginatedResource
+
+__all__ = ["PaginatedResource", "EventResource"]

bevor_sdk/_async/resources/_modules/events.py

@@ -0,0 +1,88 @@
+from typing import TYPE_CHECKING, AsyncIterator, Awaitable, Callable, Generic, TypeVar
+
+import httpx
+from pydantic import BaseModel
+
+from bevor_sdk._shared import SSEEvent, _BaseSSEParser
+from bevor_sdk.exceptions import ServerException
+
+if TYPE_CHECKING:
+    from bevor_sdk._async.client import BevorClient
+
+T = TypeVar("T", bound=BaseModel)
+EventT = TypeVar("EventT", bound=BaseModel)
+
+
+class SSEParser(_BaseSSEParser):
+    async def events(self, lines: AsyncIterator[str]) -> AsyncIterator[SSEEvent]:
+        async for line in lines:
+            event = self.feed(line)
+            if event is not None:
+                yield event
+
+
+class EventResource(Generic[T, EventT]):
+    """generic wrapper for streaming async responses"""
+
+    def __init__(
+        self,
+        data: T,
+        refresh_data: Callable[[], Awaitable[T]],
+        is_completed: Callable[[T], Awaitable[bool]],
+        handle_event: Callable[[SSEEvent], Awaitable[EventT | None]],
+        *,
+        _client: "BevorClient",
+        _timeout: httpx.Timeout | None = None,
+    ) -> None:
+        self._data = data
+        self._refresh_data = refresh_data
+        self._is_completed = is_completed
+        self._handle_event = handle_event
+        self._timeout = _timeout or httpx.Timeout(300.0, connect=30.0)
+        self._client = _client
+
+    @property
+    def data(self) -> T:
+        return self._data
+
+    async def _get_token(self, client: httpx.AsyncClient | None = None) -> str:
+        data = await self._client.request_json(
+            "POST",
+            "/v1/events/auth",
+            client=client,
+        )
+        token = data.get("token")
+        if not token:
+            raise ServerException()
+        return token
+
+    async def stream_completion(
+        self, client: httpx.AsyncClient | None = None
+    ) -> AsyncIterator[EventT]:
+        if await self._is_completed(self._data):
+            return
+        self._client._ensure_open()
+        token = await self._get_token(client)
+
+        url = self._client._url("/v1/events/handler")
+        http = self._client._transport(client)
+
+        async with http.stream(
+            "GET",
+            url,
+            params={"token": token},
+            headers=self._client._default_headers,
+            timeout=self._timeout,
+        ) as response:
+            response.raise_for_status()
+            parser = SSEParser()
+            async for event in parser.events(response.aiter_lines()):
+                if relevant_event := await self._handle_event(event):
+                    yield relevant_event
+                    self._data = await self._refresh_data()
+                    if await self._is_completed(self._data):
+                        await response.aclose()
+                        break
+
+
+__all__ = ["EventResource"]

bevor_sdk/_async/resources/_modules/pagination.py

@@ -0,0 +1,50 @@
+from typing import Awaitable, Callable, Generic, List, TypeVar
+
+from pydantic import BaseModel
+
+from bevor_sdk.types.responses._shared import Pagination
+
+T = TypeVar("T", bound=BaseModel)
+
+
+class PaginatedResource(Generic[T]):
+    """generic wrapper for incrementally building paginated data"""
+
+    def __init__(
+        self,
+        data: Pagination[T],
+        *,
+        fetch_page: Callable[[int], Awaitable[Pagination[T]]],
+    ) -> None:
+        self._results = list(data.results)
+        self._current = data
+        self._fetch_page = fetch_page
+
+    @property
+    def results(self) -> List[T]:
+        return self._results
+
+    @property
+    def current(self) -> Pagination[T]:
+        return self._current
+
+    @property
+    def has_more(self) -> bool:
+        return self._current.more
+
+    async def fetch_next(self) -> None:
+        if not self.has_more:
+            raise ValueError("No more pages to fetch. check .has_more")
+        nxt = await self._fetch_page(self._current.page + 1)
+        self._results.extend(nxt.results)
+        self._current = nxt
+
+
+"""
+## Expanded Types
+
+Certain resources support a `with_pagination` or `with_streaming` argument. If `True` is provided, then the responses extend the standard
+API responses for added functionality.
+
+`with_pagination` will return a `PaginatedResource` type
+"""

bevor_sdk/_async/resources/chat/__init__.py

@@ -0,0 +1,3 @@
+from .chats import ChatResources
+
+__all__ = ["ChatResources"]

bevor_sdk/_async/resources/chat/chats.py

@@ -0,0 +1,253 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, AsyncGenerator, Dict, Literal, overload
+
+import httpx
+
+from bevor_sdk._async.resources._modules import PaginatedResource
+from bevor_sdk.types import ID
+from bevor_sdk.types.requests.chat import ChatMessageBodyDict, ChatsQueryParams
+from bevor_sdk.types.responses import Pagination, ResultsResponse
+from bevor_sdk.types.responses.chat import (
+    ChatMessageSchema,
+    ChatSchema,
+    StreamedMessageType,
+)
+
+if TYPE_CHECKING:
+    from bevor_sdk._async.client import BevorClient
+
+
+class ChatResources:
+    def __init__(self, client: BevorClient) -> None:
+        self._client = client
+
+    def __call__(self, chat_id: ID) -> BoundChatResources:
+        return BoundChatResources(self, chat_id)
+
+    async def create_for_analysis(
+        self,
+        *,
+        version_id: ID,
+        client: httpx.AsyncClient | None = None,
+        headers: Dict[str, str] | None = None,
+    ) -> ChatSchema:
+        """POST ``/v1/chats``."""
+        data = await self._client.request_json(
+            "POST",
+            "/v1/chats",
+            json={"version_id": version_id, "scope": "analysis"},
+            client=client,
+            headers=headers,
+        )
+        return ChatSchema.model_validate(data)
+
+    async def create_for_code(
+        self,
+        *,
+        code_id: ID,
+        client: httpx.AsyncClient | None = None,
+        headers: Dict[str, str] | None = None,
+    ) -> ChatSchema:
+        """POST ``/v1/chats``."""
+        data = await self._client.request_json(
+            "POST",
+            "/v1/chats",
+            json={"code_id": code_id, "scope": "code"},
+            client=client,
+            headers=headers,
+        )
+        return ChatSchema.model_validate(data)
+
+    @overload
+    async def list(
+        self,
+        options: ChatsQueryParams | None = None,
+        *,
+        with_pagination: Literal[True],
+        client: httpx.AsyncClient | None = None,
+        headers: Dict[str, str] | None = None,
+    ) -> PaginatedResource[ChatSchema]: ...
+    @overload
+    async def list(
+        self,
+        options: ChatsQueryParams | None = None,
+        *,
+        with_pagination: Literal[False] = False,
+        client: httpx.AsyncClient | None = None,
+        headers: Dict[str, str] | None = None,
+    ) -> Pagination[ChatSchema]: ...
+    async def list(
+        self,
+        options: ChatsQueryParams | None = None,
+        *,
+        with_pagination: bool = False,
+        client: httpx.AsyncClient | None = None,
+        headers: Dict[str, str] | None = None,
+    ) -> PaginatedResource[ChatSchema] | Pagination[ChatSchema]:
+        """GET ``/v1/chats``."""
+        opts = options or ChatsQueryParams()
+
+        async def fetch_page(p: int) -> Pagination[ChatSchema]:
+            opts["page"] = p
+            data = await self._client.request_json(
+                "GET",
+                "/v1/chats",
+                params=opts,
+                client=client,
+                headers=headers,
+            )
+            return Pagination[ChatSchema].model_validate(data)
+
+        first = await fetch_page(opts["page"] or 0 if "page" in opts else 0)
+        if not with_pagination:
+            return first
+
+        return PaginatedResource[ChatSchema](first, fetch_page=fetch_page)
+
+    async def get(
+        self,
+        chat_id: ID,
+        *,
+        client: httpx.AsyncClient | None = None,
+        headers: Dict[str, str] | None = None,
+    ) -> ChatSchema:
+        """GET ``/v1/chats/{chat_id}``."""
+        data = await self._client.request_json(
+            "GET", f"/v1/chats/{chat_id}", client=client, headers=headers
+        )
+        return ChatSchema.model_validate(data)
+
+    async def messages(
+        self,
+        chat_id: ID,
+        *,
+        client: httpx.AsyncClient | None = None,
+        headers: Dict[str, str] | None = None,
+    ) -> ResultsResponse[ChatMessageSchema]:
+        """GET ``/v1/chats/{chat_id}/messages``."""
+        data = await self._client.request_json(
+            "GET", f"/v1/chats/{chat_id}/messages", client=client, headers=headers
+        )
+        return ResultsResponse[ChatMessageSchema].model_validate(data)
+
+    async def sync(
+        self,
+        chat_id: ID,
+        body: ChatMessageBodyDict,
+        *,
+        client: httpx.AsyncClient | None = None,
+        headers: Dict[str, str] | None = None,
+    ) -> ChatMessageSchema:
+        """POST ``/v1/chats/{chat_id}/sync``."""
+        data = await self._client.request_json(
+            "POST",
+            f"/v1/chats/{chat_id}/sync",
+            json=body,
+            client=client,
+            headers=headers,
+        )
+        return ChatMessageSchema.model_validate(data)
+
+    async def session_token(
+        self,
+        chat_id: ID,
+        *,
+        client: httpx.AsyncClient | None = None,
+        headers: Dict[str, str] | None = None,
+    ) -> str:
+        data = await self._client.request_json(
+            "POST",
+            f"/v1/chats/{chat_id}/session-token",
+            client=client,
+            headers=headers,
+        )
+        assert isinstance(data, dict) and "token" in data
+        return str(data["token"])
+
+    async def stream(
+        self,
+        chat_id: ID,
+        session_token: str,
+        body: ChatMessageBodyDict,
+        *,
+        client: httpx.AsyncClient | None = None,
+        headers: Dict[str, str] | None = None,
+    ) -> AsyncGenerator[StreamedMessageType]:
+        """POST ``/v1/chats/{chat_id}/stream``. Use session_token() for initial request"""
+        self._client._ensure_open()
+
+        url = self._client._url(f"/v1/chats/{chat_id}/stream")
+        http = self._client._transport(client)
+        async with http.stream(
+            "POST",
+            url,
+            json=self._client._prune_json_body({**body, "token": session_token}),
+            headers=self._client._merge_headers(headers),
+        ) as resp:
+            resp.raise_for_status()
+            async for line in resp.aiter_lines():
+                if not line:
+                    continue
+                try:
+                    yield StreamedMessageType.model_validate_json(line)
+                except Exception:
+                    pass
+
+
+class BoundChatResources:
+    __slots__ = ("_parent", "_chat_id")
+
+    def __init__(self, parent: ChatResources, chat_id: ID) -> None:
+        self._parent = parent
+        self._chat_id = chat_id
+
+    async def get(
+        self,
+        *,
+        client: httpx.AsyncClient | None = None,
+        headers: Dict[str, str] | None = None,
+    ) -> ChatSchema:
+        """GET ``/v1/chats/{chat_id}``."""
+        return await self._parent.get(self._chat_id, client=client, headers=headers)
+
+    async def messages(
+        self,
+        *,
+        client: httpx.AsyncClient | None = None,
+        headers: Dict[str, str] | None = None,
+    ) -> ResultsResponse[ChatMessageSchema]:
+        """GET ``/v1/chats/{chat_id}/messages``."""
+        return await self._parent.messages(self._chat_id, client=client, headers=headers)
+
+    async def sync(
+        self,
+        body: ChatMessageBodyDict,
+        *,
+        client: httpx.AsyncClient | None = None,
+        headers: Dict[str, str] | None = None,
+    ) -> ChatMessageSchema:
+        """POST ``/v1/chats/{chat_id}/sync``."""
+        return await self._parent.sync(
+            self._chat_id,
+            body,
+            client=client,
+            headers=headers,
+        )
+
+    async def stream(
+        self,
+        session_token: str,
+        body: ChatMessageBodyDict,
+        *,
+        client: httpx.AsyncClient | None = None,
+        headers: Dict[str, str] | None = None,
+    ) -> AsyncGenerator[StreamedMessageType]:
+        """POST ``/v1/chats/{chat_id}/stream``. Use session_token() for initial request"""
+        return self._parent.stream(
+            self._chat_id,
+            session_token,
+            body,
+            client=client,
+            headers=headers,
+        )

bevor_sdk/_async/resources/graph/__init__.py

@@ -0,0 +1,5 @@
+from .codes import CodesResources
+from .files import FileResources
+from .nodes import NodeResources
+
+__all__ = ["CodesResources", "FileResources", "NodeResources"]