gwp 0.2.0

A standalone, pure Rust gRPC wire protocol for GQL (ISO/IEC 39075)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

"""GQL connection management."""

from __future__ import annotations

import grpc

from gwp_py.catalog import CatalogClient
from gwp_py.errors import ConnectionError
from gwp_py.session import GqlSession


class GqlConnection:
    """A connection to a GWP server."""

    def __init__(self, channel: grpc.aio.Channel):
        self._channel = channel

    @classmethod
    async def connect(
        cls,
        endpoint: str,
        *,
        credentials: grpc.ChannelCredentials | None = None,
    ) -> GqlConnection:
        """Connect to a GWP server.

        Args:
            endpoint: Server address (e.g. "localhost:50051").
            credentials: Optional TLS credentials.

        Returns:
            A connected GqlConnection.

        Raises:
            ConnectionError: If the connection fails.
        """
        try:
            if credentials is not None:
                channel = grpc.aio.secure_channel(endpoint, credentials)
            else:
                channel = grpc.aio.insecure_channel(endpoint)
            return cls(channel)
        except Exception as e:
            raise ConnectionError(f"failed to connect to {endpoint}: {e}") from e

    async def create_session(self) -> GqlSession:
        """Perform handshake and return a session."""
        return await GqlSession.create(self._channel)

    def create_catalog_client(self) -> CatalogClient:
        """Create a catalog management client for schemas, graphs, and graph types."""
        return CatalogClient(self._channel)

    async def close(self) -> None:
        """Close the underlying gRPC channel."""
        await self._channel.close()

    async def __aenter__(self) -> GqlConnection:
        return self

    async def __aexit__(self, *args: object) -> None:
        await self.close()