betterproto2-compiler 0.0.3__py3-none-any.whl → 0.1.1__py3-none-any.whl

betterproto2_compiler/enum.py

@@ -1,180 +0,0 @@
-from __future__ import annotations
-
-from enum import (
-    EnumMeta,
-    IntEnum,
-)
-from types import MappingProxyType
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Dict,
-    Optional,
-    Tuple,
-)
-
-if TYPE_CHECKING:
-    from collections.abc import (
-        Generator,
-        Mapping,
-    )
-
-    from typing_extensions import (
-        Never,
-        Self,
-    )
-
-
-def _is_descriptor(obj: object) -> bool:
-    return hasattr(obj, "__get__") or hasattr(obj, "__set__") or hasattr(obj, "__delete__")
-
-
-class EnumType(EnumMeta if TYPE_CHECKING else type):
-    _value_map_: Mapping[int, Enum]
-    _member_map_: Mapping[str, Enum]
-
-    def __new__(mcs, name: str, bases: Tuple[type, ...], namespace: Dict[str, Any]) -> Self:
-        value_map = {}
-        member_map = {}
-
-        new_mcs = type(
-            f"{name}Type",
-            tuple(
-                dict.fromkeys([base.__class__ for base in bases if base.__class__ is not type] + [EnumType, type])
-            ),  # reorder the bases so EnumType and type are last to avoid conflicts
-            {"_value_map_": value_map, "_member_map_": member_map},
-        )
-
-        members = {
-            name: value for name, value in namespace.items() if not _is_descriptor(value) and not name.startswith("__")
-        }
-
-        cls = type.__new__(
-            new_mcs,
-            name,
-            bases,
-            {key: value for key, value in namespace.items() if key not in members},
-        )
-        # this allows us to disallow member access from other members as
-        # members become proper class variables
-
-        for name, value in members.items():
-            member = value_map.get(value)
-            if member is None:
-                member = cls.__new__(cls, name=name, value=value)  # type: ignore
-                value_map[value] = member
-            member_map[name] = member
-            type.__setattr__(new_mcs, name, member)
-
-        return cls
-
-    if not TYPE_CHECKING:
-
-        def __call__(cls, value: int) -> Enum:
-            try:
-                return cls._value_map_[value]
-            except (KeyError, TypeError):
-                raise ValueError(f"{value!r} is not a valid {cls.__name__}") from None
-
-        def __iter__(cls) -> Generator[Enum, None, None]:
-            yield from cls._member_map_.values()
-
-        def __reversed__(cls) -> Generator[Enum, None, None]:
-            yield from reversed(cls._member_map_.values())
-
-        def __getitem__(cls, key: str) -> Enum:
-            return cls._member_map_[key]
-
-        @property
-        def __members__(cls) -> MappingProxyType[str, Enum]:
-            return MappingProxyType(cls._member_map_)
-
-    def __repr__(cls) -> str:
-        return f"<enum {cls.__name__!r}>"
-
-    def __len__(cls) -> int:
-        return len(cls._member_map_)
-
-    def __setattr__(cls, name: str, value: Any) -> Never:
-        raise AttributeError(f"{cls.__name__}: cannot reassign Enum members.")
-
-    def __delattr__(cls, name: str) -> Never:
-        raise AttributeError(f"{cls.__name__}: cannot delete Enum members.")
-
-    def __contains__(cls, member: object) -> bool:
-        return isinstance(member, cls) and member.name in cls._member_map_
-
-
-class Enum(IntEnum if TYPE_CHECKING else int, metaclass=EnumType):
-    """
-    The base class for protobuf enumerations, all generated enumerations will
-    inherit from this. Emulates `enum.IntEnum`.
-    """
-
-    name: Optional[str]
-    value: int
-
-    if not TYPE_CHECKING:
-
-        def __new__(cls, *, name: Optional[str], value: int) -> Self:
-            self = super().__new__(cls, value)
-            super().__setattr__(self, "name", name)
-            super().__setattr__(self, "value", value)
-            return self
-
-    def __str__(self) -> str:
-        return self.name or "None"
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}.{self.name}"
-
-    def __setattr__(self, key: str, value: Any) -> Never:
-        raise AttributeError(f"{self.__class__.__name__} Cannot reassign a member's attributes.")
-
-    def __delattr__(self, item: Any) -> Never:
-        raise AttributeError(f"{self.__class__.__name__} Cannot delete a member's attributes.")
-
-    def __copy__(self) -> Self:
-        return self
-
-    def __deepcopy__(self, memo: Any) -> Self:
-        return self
-
-    @classmethod
-    def try_value(cls, value: int = 0) -> Self:
-        """Return the value which corresponds to the value.
-
-        Parameters
-        -----------
-        value: :class:`int`
-            The value of the enum member to get.
-
-        Returns
-        -------
-        :class:`Enum`
-            The corresponding member or a new instance of the enum if
-            ``value`` isn't actually a member.
-        """
-        try:
-            return cls._value_map_[value]
-        except (KeyError, TypeError):
-            return cls.__new__(cls, name=None, value=value)
-
-    @classmethod
-    def from_string(cls, name: str) -> Self:
-        """Return the value which corresponds to the string name.
-
-        Parameters
-        -----------
-        name: :class:`str`
-            The name of the enum member to get.
-
-        Raises
-        -------
-        :exc:`ValueError`
-            The member was not found in the Enum.
-        """
-        try:
-            return cls._member_map_[name]
-        except KeyError as e:
-            raise ValueError(f"Unknown value {name} for enum {cls.__name__}") from e

betterproto2_compiler/grpc/grpclib_client.py

@@ -1,172 +0,0 @@
-import asyncio
-from abc import ABC
-from typing import (
-    TYPE_CHECKING,
-    AsyncIterable,
-    AsyncIterator,
-    Collection,
-    Iterable,
-    Mapping,
-    Optional,
-    Tuple,
-    Type,
-    Union,
-)
-
-import grpclib.const
-
-if TYPE_CHECKING:
-    from grpclib.client import Channel
-    from grpclib.metadata import Deadline
-
-    from .._types import (
-        IProtoMessage,
-        T,
-    )
-
-
-Value = Union[str, bytes]
-MetadataLike = Union[Mapping[str, Value], Collection[Tuple[str, Value]]]
-MessageSource = Union[Iterable["IProtoMessage"], AsyncIterable["IProtoMessage"]]
-
-
-class ServiceStub(ABC):
-    """
-    Base class for async gRPC clients.
-    """
-
-    def __init__(
-        self,
-        channel: "Channel",
-        *,
-        timeout: Optional[float] = None,
-        deadline: Optional["Deadline"] = None,
-        metadata: Optional[MetadataLike] = None,
-    ) -> None:
-        self.channel = channel
-        self.timeout = timeout
-        self.deadline = deadline
-        self.metadata = metadata
-
-    def __resolve_request_kwargs(
-        self,
-        timeout: Optional[float],
-        deadline: Optional["Deadline"],
-        metadata: Optional[MetadataLike],
-    ):
-        return {
-            "timeout": self.timeout if timeout is None else timeout,
-            "deadline": self.deadline if deadline is None else deadline,
-            "metadata": self.metadata if metadata is None else metadata,
-        }
-
-    async def _unary_unary(
-        self,
-        route: str,
-        request: "IProtoMessage",
-        response_type: Type["T"],
-        *,
-        timeout: Optional[float] = None,
-        deadline: Optional["Deadline"] = None,
-        metadata: Optional[MetadataLike] = None,
-    ) -> "T":
-        """Make a unary request and return the response."""
-        async with self.channel.request(
-            route,
-            grpclib.const.Cardinality.UNARY_UNARY,
-            type(request),
-            response_type,
-            **self.__resolve_request_kwargs(timeout, deadline, metadata),
-        ) as stream:
-            await stream.send_message(request, end=True)
-            response = await stream.recv_message()
-        assert response is not None
-        return response
-
-    async def _unary_stream(
-        self,
-        route: str,
-        request: "IProtoMessage",
-        response_type: Type["T"],
-        *,
-        timeout: Optional[float] = None,
-        deadline: Optional["Deadline"] = None,
-        metadata: Optional[MetadataLike] = None,
-    ) -> AsyncIterator["T"]:
-        """Make a unary request and return the stream response iterator."""
-        async with self.channel.request(
-            route,
-            grpclib.const.Cardinality.UNARY_STREAM,
-            type(request),
-            response_type,
-            **self.__resolve_request_kwargs(timeout, deadline, metadata),
-        ) as stream:
-            await stream.send_message(request, end=True)
-            async for message in stream:
-                yield message
-
-    async def _stream_unary(
-        self,
-        route: str,
-        request_iterator: MessageSource,
-        request_type: Type["IProtoMessage"],
-        response_type: Type["T"],
-        *,
-        timeout: Optional[float] = None,
-        deadline: Optional["Deadline"] = None,
-        metadata: Optional[MetadataLike] = None,
-    ) -> "T":
-        """Make a stream request and return the response."""
-        async with self.channel.request(
-            route,
-            grpclib.const.Cardinality.STREAM_UNARY,
-            request_type,
-            response_type,
-            **self.__resolve_request_kwargs(timeout, deadline, metadata),
-        ) as stream:
-            await stream.send_request()
-            await self._send_messages(stream, request_iterator)
-            response = await stream.recv_message()
-        assert response is not None
-        return response
-
-    async def _stream_stream(
-        self,
-        route: str,
-        request_iterator: MessageSource,
-        request_type: Type["IProtoMessage"],
-        response_type: Type["T"],
-        *,
-        timeout: Optional[float] = None,
-        deadline: Optional["Deadline"] = None,
-        metadata: Optional[MetadataLike] = None,
-    ) -> AsyncIterator["T"]:
-        """
-        Make a stream request and return an AsyncIterator to iterate over response
-        messages.
-        """
-        async with self.channel.request(
-            route,
-            grpclib.const.Cardinality.STREAM_STREAM,
-            request_type,
-            response_type,
-            **self.__resolve_request_kwargs(timeout, deadline, metadata),
-        ) as stream:
-            await stream.send_request()
-            sending_task = asyncio.ensure_future(self._send_messages(stream, request_iterator))
-            try:
-                async for response in stream:
-                    yield response
-            except:
-                sending_task.cancel()
-                raise
-
-    @staticmethod
-    async def _send_messages(stream, messages: MessageSource):
-        if isinstance(messages, AsyncIterable):
-            async for message in messages:
-                await stream.send_message(message)
-        else:
-            for message in messages:
-                await stream.send_message(message)
-        await stream.end()

betterproto2_compiler/grpc/grpclib_server.py

@@ -1,32 +0,0 @@
-from abc import ABC
-from collections.abc import AsyncIterable
-from typing import (
-    Any,
-    Callable,
-)
-
-import grpclib
-import grpclib.server
-
-
-class ServiceBase(ABC):
-    """
-    Base class for async gRPC servers.
-    """
-
-    async def _call_rpc_handler_server_stream(
-        self,
-        handler: Callable,
-        stream: grpclib.server.Stream,
-        request: Any,
-    ) -> None:
-        response_iter = handler(request)
-        # check if response is actually an AsyncIterator
-        # this might be false if the method just returns without
-        # yielding at least once
-        # in that case, we just interpret it as an empty iterator
-        if isinstance(response_iter, AsyncIterable):
-            async for response_message in response_iter:
-                await stream.send_message(response_message)
-        else:
-            response_iter.close()

betterproto2_compiler/grpc/util/async_channel.py

@@ -1,190 +0,0 @@
-import asyncio
-from typing import (
-    AsyncIterable,
-    AsyncIterator,
-    Iterable,
-    Optional,
-    TypeVar,
-    Union,
-)
-
-T = TypeVar("T")
-
-
-class ChannelClosed(Exception):
-    """
-    An exception raised on an attempt to send through a closed channel
-    """
-
-
-class ChannelDone(Exception):
-    """
-    An exception raised on an attempt to send receive from a channel that is both closed
-    and empty.
-    """
-
-
-class AsyncChannel(AsyncIterable[T]):
-    """
-    A buffered async channel for sending items between coroutines with FIFO ordering.
-
-    This makes decoupled bidirectional steaming gRPC requests easy if used like:
-
-    .. code-block:: python
-        client = GeneratedStub(grpclib_chan)
-        request_channel = await AsyncChannel()
-        # We can start be sending all the requests we already have
-        await request_channel.send_from([RequestObject(...), RequestObject(...)])
-        async for response in client.rpc_call(request_channel):
-            # The response iterator will remain active until the connection is closed
-            ...
-            # More items can be sent at any time
-            await request_channel.send(RequestObject(...))
-            ...
-            # The channel must be closed to complete the gRPC connection
-            request_channel.close()
-
-    Items can be sent through the channel by either:
-    - providing an iterable to the send_from method
-    - passing them to the send method one at a time
-
-    Items can be received from the channel by either:
-    - iterating over the channel with a for loop to get all items
-    - calling the receive method to get one item at a time
-
-    If the channel is empty then receivers will wait until either an item appears or the
-    channel is closed.
-
-    Once the channel is closed then subsequent attempt to send through the channel will
-    fail with a ChannelClosed exception.
-
-    When th channel is closed and empty then it is done, and further attempts to receive
-    from it will fail with a ChannelDone exception
-
-    If multiple coroutines receive from the channel concurrently, each item sent will be
-    received by only one of the receivers.
-
-    :param source:
-        An optional iterable will items that should be sent through the channel
-        immediately.
-    :param buffer_limit:
-        Limit the number of items that can be buffered in the channel, A value less than
-        1 implies no limit. If the channel is full then attempts to send more items will
-        result in the sender waiting until an item is received from the channel.
-    :param close:
-        If set to True then the channel will automatically close after exhausting source
-        or immediately if no source is provided.
-    """
-
-    def __init__(self, *, buffer_limit: int = 0, close: bool = False):
-        self._queue: asyncio.Queue[T] = asyncio.Queue(buffer_limit)
-        self._closed = False
-        self._waiting_receivers: int = 0
-        # Track whether flush has been invoked so it can only happen once
-        self._flushed = False
-
-    def __aiter__(self) -> AsyncIterator[T]:
-        return self
-
-    async def __anext__(self) -> T:
-        if self.done():
-            raise StopAsyncIteration
-        self._waiting_receivers += 1
-        try:
-            result = await self._queue.get()
-            if result is self.__flush:
-                raise StopAsyncIteration
-            return result
-        finally:
-            self._waiting_receivers -= 1
-            self._queue.task_done()
-
-    def closed(self) -> bool:
-        """
-        Returns True if this channel is closed and no-longer accepting new items
-        """
-        return self._closed
-
-    def done(self) -> bool:
-        """
-        Check if this channel is done.
-
-        :return: True if this channel is closed and and has been drained of items in
-        which case any further attempts to receive an item from this channel will raise
-        a ChannelDone exception.
-        """
-        # After close the channel is not yet done until there is at least one waiting
-        # receiver per enqueued item.
-        return self._closed and self._queue.qsize() <= self._waiting_receivers
-
-    async def send_from(self, source: Union[Iterable[T], AsyncIterable[T]], close: bool = False) -> "AsyncChannel[T]":
-        """
-        Iterates the given [Async]Iterable and sends all the resulting items.
-        If close is set to True then subsequent send calls will be rejected with a
-        ChannelClosed exception.
-        :param source: an iterable of items to send
-        :param close:
-            if True then the channel will be closed after the source has been exhausted
-
-        """
-        if self._closed:
-            raise ChannelClosed("Cannot send through a closed channel")
-        if isinstance(source, AsyncIterable):
-            async for item in source:
-                await self._queue.put(item)
-        else:
-            for item in source:
-                await self._queue.put(item)
-        if close:
-            # Complete the closing process
-            self.close()
-        return self
-
-    async def send(self, item: T) -> "AsyncChannel[T]":
-        """
-        Send a single item over this channel.
-        :param item: The item to send
-        """
-        if self._closed:
-            raise ChannelClosed("Cannot send through a closed channel")
-        await self._queue.put(item)
-        return self
-
-    async def receive(self) -> Optional[T]:
-        """
-        Returns the next item from this channel when it becomes available,
-        or None if the channel is closed before another item is sent.
-        :return: An item from the channel
-        """
-        if self.done():
-            raise ChannelDone("Cannot receive from a closed channel")
-        self._waiting_receivers += 1
-        try:
-            result = await self._queue.get()
-            if result is self.__flush:
-                return None
-            return result
-        finally:
-            self._waiting_receivers -= 1
-            self._queue.task_done()
-
-    def close(self):
-        """
-        Close this channel to new items
-        """
-        self._closed = True
-        asyncio.ensure_future(self._flush_queue())
-
-    async def _flush_queue(self):
-        """
-        To be called after the channel is closed. Pushes a number of self.__flush
-        objects to the queue to ensure no waiting consumers get deadlocked.
-        """
-        if not self._flushed:
-            self._flushed = True
-            deadlocked_receivers = max(0, self._waiting_receivers - self._queue.qsize())
-            for _ in range(deadlocked_receivers):
-                await self._queue.put(self.__flush)
-
-    # A special signal object for flushing the queue when the channel is closed
-    __flush = object()