grpc-dc 0.32.15__tar.gz

grpc_dc-0.32.15/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: grpc-dc
+Version: 0.32.15
+Summary: gRPC over WebRTC DataChannels — dependency-free generated Python runtime
+License: Apache-2.0
+Project-URL: Homepage, https://browser-grpc.github.io/grpc-over-datachannels
+Project-URL: Repository, https://github.com/browser-grpc/grpc-over-datachannels
+Keywords: grpc,webrtc,datachannel,rpc
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# Python — grpc-dc runtime
+
+Start here if you are new to the project. The runtime in
+this directory is generated, dependency-free, and speaks
+the gRPC wire protocol over WebRTC DataChannels.
+
+## First run
+
+```sh
+    cd python && python3 -m unittest discover -s tests
+```
+
+## Use it in your project
+
+pip users: `pip install ./python` installs the `grpcdc` package from this tree (pyproject.toml included, no dependencies).
+
+## Regenerate stubs for your schema
+
+From the repository root (one wrapper per language in `bin/`):
+
+    protoc --plugin=protoc-gen-grpc-dc-python=$PWD/bin/protoc-gen-grpc-dc-python \
+           --grpc-dc-python_out=out -I . your.proto
+
+Or generate in the browser and download the zip:
+https://browser-grpc.github.io/grpc-over-datachannels/app/
+
+## Where things live
+
+- Runtime: this directory (see its generated sources).
+- Worked example: `examples/` (Echo in every method shape).
+- Tests: `tests/` — the same BDD scenarios every language runs.
+
+Full project quickstart: [`../QUICKSTART.md`](../QUICKSTART.md).

grpc_dc-0.32.15/README.md

@@ -0,0 +1,33 @@
+# Python — grpc-dc runtime
+
+Start here if you are new to the project. The runtime in
+this directory is generated, dependency-free, and speaks
+the gRPC wire protocol over WebRTC DataChannels.
+
+## First run
+
+```sh
+    cd python && python3 -m unittest discover -s tests
+```
+
+## Use it in your project
+
+pip users: `pip install ./python` installs the `grpcdc` package from this tree (pyproject.toml included, no dependencies).
+
+## Regenerate stubs for your schema
+
+From the repository root (one wrapper per language in `bin/`):
+
+    protoc --plugin=protoc-gen-grpc-dc-python=$PWD/bin/protoc-gen-grpc-dc-python \
+           --grpc-dc-python_out=out -I . your.proto
+
+Or generate in the browser and download the zip:
+https://browser-grpc.github.io/grpc-over-datachannels/app/
+
+## Where things live
+
+- Runtime: this directory (see its generated sources).
+- Worked example: `examples/` (Echo in every method shape).
+- Tests: `tests/` — the same BDD scenarios every language runs.
+
+Full project quickstart: [`../QUICKSTART.md`](../QUICKSTART.md).

grpc_dc-0.32.15/grpc_dc.egg-info/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: grpc-dc
+Version: 0.32.15
+Summary: gRPC over WebRTC DataChannels — dependency-free generated Python runtime
+License: Apache-2.0
+Project-URL: Homepage, https://browser-grpc.github.io/grpc-over-datachannels
+Project-URL: Repository, https://github.com/browser-grpc/grpc-over-datachannels
+Keywords: grpc,webrtc,datachannel,rpc
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# Python — grpc-dc runtime
+
+Start here if you are new to the project. The runtime in
+this directory is generated, dependency-free, and speaks
+the gRPC wire protocol over WebRTC DataChannels.
+
+## First run
+
+```sh
+    cd python && python3 -m unittest discover -s tests
+```
+
+## Use it in your project
+
+pip users: `pip install ./python` installs the `grpcdc` package from this tree (pyproject.toml included, no dependencies).
+
+## Regenerate stubs for your schema
+
+From the repository root (one wrapper per language in `bin/`):
+
+    protoc --plugin=protoc-gen-grpc-dc-python=$PWD/bin/protoc-gen-grpc-dc-python \
+           --grpc-dc-python_out=out -I . your.proto
+
+Or generate in the browser and download the zip:
+https://browser-grpc.github.io/grpc-over-datachannels/app/
+
+## Where things live
+
+- Runtime: this directory (see its generated sources).
+- Worked example: `examples/` (Echo in every method shape).
+- Tests: `tests/` — the same BDD scenarios every language runs.
+
+Full project quickstart: [`../QUICKSTART.md`](../QUICKSTART.md).

grpc_dc-0.32.15/grpc_dc.egg-info/SOURCES.txt

@@ -0,0 +1,34 @@
+README.md
+pyproject.toml
+grpc_dc.egg-info/PKG-INFO
+grpc_dc.egg-info/SOURCES.txt
+grpc_dc.egg-info/dependency_links.txt
+grpc_dc.egg-info/top_level.txt
+grpcdc/__init__.py
+grpcdc/channel.py
+grpcdc/codec.py
+grpcdc/dynamic.py
+grpcdc/endpoint.py
+grpcdc/http2.py
+grpcdc/loopback.py
+grpcdc/server.py
+grpcdc/sidecar.py
+grpcdc/wire_gen.py
+tests/test_async.py
+tests/test_bdd.py
+tests/test_bdd_schemas.py
+tests/test_bdd_sidecar.py
+tests/test_codec.py
+tests/test_deadline.py
+tests/test_dynamic.py
+tests/test_echo.py
+tests/test_http2_oracle.py
+tests/test_interop.py
+tests/test_interop_oracle.py
+tests/test_interop_server_oracle.py
+tests/test_oracle.py
+tests/test_otlp_tracer.py
+tests/test_pb_messages.py
+tests/test_sidecar_direct.py
+tests/test_sidecar_multi.py
+tests/test_tracing.py

grpc_dc-0.32.15/grpc_dc.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

grpc_dc-0.32.15/grpc_dc.egg-info/top_level.txt

@@ -0,0 +1 @@
+grpcdc

grpc_dc-0.32.15/grpcdc/__init__.py

@@ -0,0 +1,74 @@
+# @generated by grpc-dc codegen. DO NOT EDIT.
+# SPDX-License-Identifier: Apache-2.0
+"""grpcdc: gRPC over WebRTC DataChannels (generated runtime)."""
+
+from .channel import AsyncChannel, AsyncClientStream, Channel, ClientStream
+from .codec import (
+    CallClosed,
+    Headers,
+    StatusError,
+    decode_frame,
+    encode_frame,
+    set_tracer,
+    set_trace_filter,
+    status_name,
+    to_status,
+)
+from .endpoint import CallContext, Endpoint, Transport
+from .dynamic import (
+    DynamicClient,
+    FileModel,
+    GenericMessage,
+    parse_descriptor_set,
+    register_dynamic_service,
+)
+from .loopback import memory_transport_pair
+from .http2 import Http2Transport
+from .sidecar import SidecarTransport
+from .wire_gen import CODE_INTERNAL
+from .server import (
+    KIND_BIDI,
+    KIND_CLIENT_STREAMING,
+    KIND_SERVER_STREAMING,
+    KIND_UNARY,
+    Method,
+    RequestStream,
+    Server,
+    ServiceDesc,
+)
+
+__all__ = [
+    "CODE_INTERNAL",
+    "CallClosed",
+    "DynamicClient",
+    "FileModel",
+    "GenericMessage",
+    "CallContext",
+    "AsyncChannel",
+    "AsyncClientStream",
+    "Channel",
+    "ClientStream",
+    "Endpoint",
+    "Headers",
+    "KIND_BIDI",
+    "KIND_CLIENT_STREAMING",
+    "KIND_SERVER_STREAMING",
+    "KIND_UNARY",
+    "Method",
+    "RequestStream",
+    "Server",
+    "ServiceDesc",
+    "StatusError",
+    "Transport",
+    "decode_frame",
+    "encode_frame",
+    "SidecarTransport",
+    "Http2Transport",
+    "memory_transport_pair",
+    "parse_descriptor_set",
+    "register_dynamic_service",
+    "set_tracer",
+    "set_trace_filter",
+    "status_name",
+    "to_status",
+]

grpc_dc-0.32.15/grpcdc/channel.py

@@ -0,0 +1,322 @@
+# @generated by grpc-dc codegen. DO NOT EDIT.
+# SPDX-License-Identifier: Apache-2.0
+"""Channel: the client side of one Endpoint."""
+
+import asyncio
+
+from .codec import (
+    StatusError,
+    encode_frame,
+    encode_timeout,
+    format_traceparent,
+    get_tracer,
+    headers_frame,
+    parse_traceparent,
+    status_name,
+    trace_end,
+    trace_start,
+)
+from .endpoint import (
+    EVENT_DATA,
+    EVENT_HEADERS,
+    EVENT_RST,
+    EVENT_TRAILERS,
+    TIMEOUT,
+    Endpoint,
+    _monotonic,
+)
+from .wire_gen import (
+    CODE_DEADLINE_EXCEEDED,
+    CODE_INTERNAL,
+    CODE_UNAVAILABLE,
+    FRAME_DATA,
+    FRAME_HALF_CLOSE,
+)
+
+
+class Channel:
+    """Client side; allocates odd stream ids on a fresh Endpoint."""
+
+    def __init__(self, transport=None, endpoint=None):
+        if endpoint is not None:
+            self.endpoint = endpoint
+        else:
+            self.endpoint = Endpoint(transport, creator=True)
+        self.endpoint.start()
+
+    def _open(self, path, metadata, timeout=None):
+        deadline = None
+        trace_ctx = None
+        if timeout is not None or get_tracer() is not None:
+            merged = dict(metadata) if metadata else {}
+            if timeout is not None:
+                deadline = _monotonic() + timeout
+                merged["grpc-timeout"] = encode_timeout(timeout)
+            if get_tracer() is not None:
+                parent = parse_traceparent(merged.get("traceparent"))
+                trace_ctx = trace_start("client", path, parent)
+                if trace_ctx is not None:
+                    merged["traceparent"] = format_traceparent(
+                        trace_ctx["trace_id"], trace_ctx["span_id"]
+                    )
+            metadata = merged
+        stream_id, stream_input = self.endpoint.open_stream()
+        try:
+            self.endpoint.send_frame(headers_frame(stream_id, path, metadata))
+        except Exception:
+            self.endpoint.close_stream(stream_id)
+            trace_end("client", path, trace_ctx, "UNAVAILABLE")
+            raise
+        stream = ClientStream(self.endpoint, stream_id, stream_input)
+        stream.deadline = deadline
+        stream.trace_ctx = trace_ctx
+        stream.trace_path = path
+        return stream
+
+    def _send_message(self, stream, msg):
+        self.endpoint.send_frame(
+            encode_frame(FRAME_DATA, stream.stream_id, msg.marshal_dc())
+        )
+
+    def _half_close(self, stream):
+        self.endpoint.send_frame(encode_frame(FRAME_HALF_CLOSE, stream.stream_id, b""))
+
+    def _send_all(self, stream, reqs):
+        for req in reqs:
+            self._send_message(stream, req)
+        self._half_close(stream)
+
+    def cancel(self, stream):
+        """Abort an open ClientStream (sends RST)."""
+        self.endpoint.cancel_stream(stream.stream_id)
+
+    def unary(self, path, req, resp, metadata=None, timeout=None):
+        """Run a unary call, decoding the single response into resp.
+
+        timeout (seconds) sets a deadline: it is propagated as
+        grpc-timeout metadata and enforced locally — on expiry the
+        call is aborted with RST and DEADLINE_EXCEEDED is raised.
+        """
+        return self._unary(path, req, resp, metadata, timeout)
+
+    def _unary(self, path, req, resp, metadata, timeout=None):
+        stream = self._open(path, metadata, timeout)
+        try:
+            self._send_message(stream, req)
+            self._half_close(stream)
+            got = False
+            while True:
+                try:
+                    stream.recv(resp)
+                except EOFError:
+                    if not got:
+                        raise StatusError(
+                            CODE_INTERNAL, "call closed with no response"
+                        )
+                    return resp
+                if got:
+                    raise StatusError(
+                        CODE_INTERNAL, "unary call received more than one response"
+                    )
+                got = True
+        finally:
+            self.endpoint.close_stream(stream.stream_id)
+
+    def server_stream(self, path, req, metadata=None, timeout=None):
+        """Start a server-streaming call; returns a ClientStream."""
+        stream = self._open(path, metadata, timeout)
+        self._send_message(stream, req)
+        self._half_close(stream)
+        return stream
+
+    def unary_stream(self, path, req, metadata=None, timeout=None):
+        """Start a unary call; returns the ClientStream so
+        callers can inspect .headers/.trailers around recv."""
+        stream = self._open(path, metadata, timeout)
+        self._send_message(stream, req)
+        self._half_close(stream)
+        return stream
+
+    def client_stream(self, path, reqs, resp, metadata=None, timeout=None):
+        """Send all requests, then decode the one response into resp."""
+        stream = self._open(path, metadata, timeout)
+        try:
+            self._send_all(stream, reqs)
+            got = False
+            while True:
+                try:
+                    stream.recv(resp)
+                except EOFError:
+                    if not got:
+                        raise StatusError(
+                            CODE_INTERNAL, "call closed with no response"
+                        )
+                    return resp
+                if got:
+                    raise StatusError(
+                        CODE_INTERNAL,
+                        "client-streaming call received more than one response",
+                    )
+                got = True
+        finally:
+            self.endpoint.close_stream(stream.stream_id)
+
+    def bidi(self, path, reqs, metadata=None, timeout=None):
+        """Start a bidi call with all requests sent up front."""
+        stream = self._open(path, metadata, timeout)
+        self._send_all(stream, reqs)
+        return stream
+
+
+class ClientStream:
+    """Receives response messages of one call."""
+
+    def __init__(self, endpoint, stream_id, stream_input):
+        self._endpoint = endpoint
+        self.stream_id = stream_id
+        self._input = stream_input
+        self.headers = None
+        self.trailers = None
+        self.deadline = None
+        self.trace_ctx = None
+        self.trace_path = None
+        self._trace_ended = False
+        self._terminated = False
+
+    def _end_trace(self, status):
+        if not self._trace_ended:
+            self._trace_ended = True
+            trace_end("client", self.trace_path, self.trace_ctx, status)
+
+    def cancel(self):
+        """Abort the call (RST) unless it already terminated."""
+        if not self._terminated:
+            self._terminated = True
+            self._endpoint.cancel_stream(self.stream_id)
+
+    def _fail_deadline(self):
+        self._end_trace("DEADLINE_EXCEEDED")
+        self._terminated = True
+        self._endpoint.cancel_stream(self.stream_id)
+        raise StatusError(CODE_DEADLINE_EXCEEDED, "deadline exceeded")
+
+    def recv(self, resp):
+        """Decode the next response into resp.
+
+        Raises EOFError when the call completed OK; StatusError
+        reports the trailers status (or DEADLINE_EXCEEDED when
+        the stream's deadline passed waiting for a response).
+        """
+        while True:
+            wait = None
+            if self.deadline is not None:
+                wait = self.deadline - _monotonic()
+                if wait <= 0:
+                    self._fail_deadline()
+            event = self._input.get(timeout=wait)
+            if event is TIMEOUT:
+                self._fail_deadline()
+            if event is None:
+                self._terminated = True
+                raise StatusError(CODE_UNAVAILABLE, "data channel closed")
+            if event.kind == EVENT_HEADERS:
+                self.headers = event.headers
+            elif event.kind == EVENT_DATA:
+                resp.unmarshal_dc(event.payload)
+                return resp
+            elif event.kind == EVENT_TRAILERS:
+                self._terminated = True
+                self.trailers = event.status.trailers
+                self._end_trace(status_name(event.status.code))
+                if event.status.code != 0:
+                    raise event.status
+                raise EOFError("call completed")
+            elif event.kind == EVENT_RST:
+                self._terminated = True
+                self.trailers = event.status.trailers
+                self._end_trace(status_name(event.status.code))
+                raise event.status
+
+
+class AsyncClientStream:
+    """Asyncio receiving stream wrapping a ClientStream.
+
+    The blocking wait runs on the event loop's default executor,
+    so awaiting never stalls the loop. Cancelling the awaiting
+    task aborts the stream with RST (CODE_CANCELLED).
+    """
+
+    def __init__(self, stream):
+        self._stream = stream
+
+    @property
+    def stream_id(self):
+        return self._stream.stream_id
+
+    @property
+    def headers(self):
+        return self._stream.headers
+
+    async def recv(self, resp):
+        loop = asyncio.get_running_loop()
+        # shield: task cancellation surfaces immediately (the
+        # executor thread cannot be cancelled); we then abort
+        # the stream, which wakes that thread with RST.
+        future = loop.run_in_executor(None, self._stream.recv, resp)
+        try:
+            return await asyncio.shield(future)
+        except asyncio.CancelledError:
+            self.cancel()
+            raise
+
+    def cancel(self):
+        self._stream.cancel()
+
+
+class AsyncChannel:
+    """Asyncio client facade over Channel (mirrors grpc.aio shape).
+
+    Unary and client-streaming calls are awaited on executor
+    threads; server-streaming and bidi calls return an
+    AsyncClientStream. Construct directly over a transport or
+    wrap an existing sync Channel to share its Endpoint.
+    """
+
+    def __init__(self, channel=None, transport=None, endpoint=None):
+        if isinstance(channel, Channel):
+            self._channel = channel
+        elif channel is not None and transport is None and endpoint is None:
+            self._channel = Channel(channel)  # a bare transport
+        else:
+            self._channel = Channel(transport, endpoint)
+
+    @property
+    def channel(self):
+        return self._channel
+
+    @property
+    def endpoint(self):
+        return self._channel.endpoint
+
+    async def unary(self, path, req, resp, metadata=None, timeout=None):
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            None, lambda: self._channel.unary(path, req, resp, metadata, timeout))
+
+    async def client_stream(self, path, reqs, resp, metadata=None, timeout=None):
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(
+            None,
+            lambda: self._channel.client_stream(path, reqs, resp, metadata, timeout))
+
+    async def server_stream(self, path, req, metadata=None, timeout=None):
+        loop = asyncio.get_running_loop()
+        stream = await loop.run_in_executor(
+            None, lambda: self._channel.server_stream(path, req, metadata, timeout))
+        return AsyncClientStream(stream)
+
+    async def bidi(self, path, reqs, metadata=None, timeout=None):
+        loop = asyncio.get_running_loop()
+        stream = await loop.run_in_executor(
+            None, lambda: self._channel.bidi(path, reqs, metadata, timeout))
+        return AsyncClientStream(stream)