protoplasm6 6.1.0__py3-none-any.whl

protoplasm6/__init__.py

@@ -0,0 +1,5 @@
+__version__ = '6.1.0'
+
+__author__ = 'Thordur Matthiasson <doddi79@gmail.com>'
+__license__ = 'MIT License'
+__copyright__ = 'Copyright 2026 - Thordur Matthiasson, Copyright 2019-2024 - CCP Games ehf'

protoplasm6/bases/__init__.py

@@ -0,0 +1,3 @@
+from .dataclass_bases import *
+from .grpc_bases import *
+from ._exwrap import *

protoplasm6/bases/_client.py

@@ -0,0 +1,83 @@
+__all__ = [
+    'BaseGrpcClientImplementation',
+]
+import grpc  # noqa
+
+from protoplasm6.structs import *
+from ._remotewrap import *
+from ._metadata import *
+from .dataclass_bases import *
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class BaseGrpcClientImplementation:
+    def __init__(self, service_stub_cls: Type, grpc_host='localhost:50051',
+                 credentials: Optional[Union[bool, grpc.ChannelCredentials]] = None,
+                 options: Optional[Dict] = None, metadata: MetadataSpec = None, *args, **kwargs):
+        """
+        credentials:
+        - None -> Automatic... will use `grpc.ssl_channel_credentials()` and secure_channel if port is 443
+        - True -> Will use `grpc.ssl_channel_credentials()` and secure_channel
+        - False -> Will use insecure_channel and no creds
+        - grpc.ChannelCredentials -> Will use given creds and secure_channel
+
+        metadata:
+        - Metadata (i.e. headers, e.g. for authorization) added to every call
+          made by this client, either as a dict, an iterable of (key, value)
+          pairs or a callable returning either of those (which gets called for
+          every call, e.g. to fetch a fresh access token). It can also be set
+          (or changed) later via the `metadata` attribute.
+        - See also `call_metadata()` for adding metadata to calls within a
+          `with` block.
+        """
+        self.metadata: MetadataSpec = metadata
+        options = options or {}
+        if 'grpc.enable_http_proxy' not in options:
+            options['grpc.enable_http_proxy'] = 0
+        option_tuple = tuple(options.items())
+
+        # Backwards compatibility
+        if kwargs:
+            if not credentials and 'credential' in kwargs:
+                credentials = kwargs.pop('credential')
+                log.warning('Deprecated keyword "credential" used when initiating BaseGrpcClient.'
+                            ' Please use "credentials" instead!')
+
+        # This keeps happening...!
+        if ':' not in grpc_host:
+            if credentials:
+                log.warning('No port used in host... adding 443 by default (cause this is a secure connection)!')
+                grpc_host = f'{grpc_host}:443'
+            else:
+                log.warning('No port used in host... adding 50051 by default!')
+                grpc_host = f'{grpc_host}:50051'
+
+        if credentials is None:
+            if grpc_host.endswith(':443'):
+                credentials = grpc.ssl_channel_credentials()
+        elif credentials is True:
+            credentials = grpc.ssl_channel_credentials()
+
+        if credentials:
+            self.grpc_channel: grpc.Channel = grpc.secure_channel(grpc_host, credentials, options=option_tuple)
+        else:
+            self.grpc_channel: grpc.Channel = grpc.insecure_channel(grpc_host, options=option_tuple)
+
+        self.stub = service_stub_cls(self.grpc_channel)
+
+    def call_metadata(self, metadata: MetadataSpec = None, **kwargs: Union[str, bytes]):
+        """Context manager that adds the given metadata to every call made by
+        this client (only) within its block (in the current thread/context).
+
+        ```python
+        with orders.call_metadata({'authorization': f'Bearer {token}'}):
+            orders.get_order('o1')
+        ```
+        """
+        return call_metadata(metadata, _client=self, **kwargs)
+
+    def _forward_to_grpc(self, request_cls: Type[T_DCB], stub_method: Callable,
+                         *args, **kwargs) -> Optional[Union[Any, Tuple[Any], Iterable[T_DCB]]]:
+        return RemoteMethodWrapper(self, request_cls, stub_method, *args, **kwargs).call()

protoplasm6/bases/_exwrap.py

@@ -0,0 +1,113 @@
+__all__ = [
+    'GrpcExceptionWrapper',
+]
+
+import grpc
+from typing import *
+from protoplasm6 import errors
+
+_STATUS_CODE_TO_EXCEPTION_MAP = {
+    grpc.StatusCode.UNKNOWN: errors.api.Unknown,
+    grpc.StatusCode.NOT_FOUND: errors.api.NotFound,
+    grpc.StatusCode.INVALID_ARGUMENT: errors.api.InvalidArgument,
+    grpc.StatusCode.UNIMPLEMENTED: errors.api.Unimplemented,
+    grpc.StatusCode.PERMISSION_DENIED: errors.api.PermissionDenied,
+    grpc.StatusCode.UNAUTHENTICATED: errors.api.Unauthenticated,
+    grpc.StatusCode.UNAVAILABLE: errors.api.Unavailable,
+    grpc.StatusCode.DEADLINE_EXCEEDED: errors.api.DeadlineExceeded,
+    grpc.StatusCode.ALREADY_EXISTS: errors.api.AlreadyExists,
+    grpc.StatusCode.FAILED_PRECONDITION: errors.api.FailedPrecondition,
+    grpc.StatusCode.DATA_LOSS: errors.api.DataLoss,
+    grpc.StatusCode.RESOURCE_EXHAUSTED: errors.api.ResourceExhausted,
+    grpc.StatusCode.OUT_OF_RANGE: errors.api.OutOfRange,
+    grpc.StatusCode.INTERNAL: errors.api.Internal,
+    grpc.StatusCode.CANCELLED: errors.api.Cancelled,
+    grpc.StatusCode.ABORTED: errors.api.Aborted,
+}
+
+
+class GrpcExceptionWrapper(object):
+    def __init__(self, ex: grpc.RpcError):
+        self.ex = ex
+        self._code = False
+        self._debug_error_string = False
+        self._details = False
+        self._initial_metadata = False
+        self._traceback = False
+        self._trailing_metadata = False
+
+    @property
+    def code(self) -> Optional[grpc.StatusCode]:
+        if self._code is False:
+            self._code = None
+            code_call = getattr(self.ex, 'code', None)
+            if code_call and hasattr(code_call, '__call__'):
+                self._code = code_call()
+        return self._code
+
+    @property
+    def debug_error_string(self) -> str:
+        if self._debug_error_string is False:
+            self._debug_error_string = ''
+            code_call = getattr(self.ex, 'debug_error_string', None)
+            if code_call and hasattr(code_call, '__call__'):
+                self._debug_error_string = code_call()
+        return self._debug_error_string
+
+    @property
+    def details(self) -> str:
+        if self._details is False:
+            self._details = ''
+            code_call = getattr(self.ex, 'details', None)
+            if code_call and hasattr(code_call, '__call__'):
+                self._details = code_call()
+        return self._details
+
+    @property
+    def initial_metadata(self) -> dict:
+        if self._initial_metadata is False:
+            self._initial_metadata = {}
+            code_call = getattr(self.ex, 'initial_metadata', None)
+            if code_call and hasattr(code_call, '__call__'):
+                for k, v in code_call():
+                    k = k.lower()
+                    if k not in self._initial_metadata:
+                        self._initial_metadata[k] = v
+                    else:
+                        if not isinstance(self._initial_metadata[k], list):
+                            self._initial_metadata[k] = [self._initial_metadata[k]]
+                        self._initial_metadata[k].append(v)
+        return self._initial_metadata
+
+    @property
+    def traceback(self):
+        if self._traceback is False:
+            self._traceback = None
+            code_call = getattr(self.ex, 'traceback', None)
+            if code_call and hasattr(code_call, '__call__'):
+                self._traceback = code_call()
+        return self._traceback
+
+    @property
+    def trailing_metadata(self) -> dict:
+        if self._trailing_metadata is False:
+            self._trailing_metadata = {}
+            code_call = getattr(self.ex, 'trailing_metadata', None)
+            if code_call and hasattr(code_call, '__call__'):
+                for k, v in code_call():
+                    k = k.lower()
+                    if k not in self._trailing_metadata:
+                        self._trailing_metadata[k] = v
+                    else:
+                        if not isinstance(self._trailing_metadata[k], list):
+                            self._trailing_metadata[k] = [self._trailing_metadata[k]]
+                        self._trailing_metadata[k].append(v)
+        return self._trailing_metadata
+
+    def get_reraise(self):
+        return _STATUS_CODE_TO_EXCEPTION_MAP.get(self.code, errors.api.Unknown)(self.details,
+                                                                                ref_code=self.trailing_metadata.get('ref_code', None))
+
+
+
+

protoplasm6/bases/_metadata.py

@@ -0,0 +1,89 @@
+"""Custom call metadata (i.e. HTTP/2 headers, e.g. for authorization) for gRPC
+calls made by protoplasm6 clients.
+"""
+__all__ = [
+    'MetadataSpec',
+    'call_metadata',
+    'normalize_metadata',
+    'resolve_metadata',
+]
+import contextlib
+import contextvars
+
+from protoplasm6.structs import *
+
+MetadataValue = Union[str, bytes]
+MetadataPairs = Union[Mapping[str, MetadataValue], Iterable[Tuple[str, MetadataValue]]]
+MetadataSpec = Union[MetadataPairs, Callable[[], Optional[MetadataPairs]], None]
+"""Metadata can be given as a dict, an iterable of (key, value) pairs or a
+callable (taking no arguments) returning either of those, which gets called
+for every single call (e.g. to fetch a fresh access token)."""
+
+# Stack of (client or None for "all clients", metadata spec)
+_CONTEXT: contextvars.ContextVar[Tuple[Tuple[Any, MetadataSpec], ...]] = contextvars.ContextVar(
+    'protoplasm6_call_metadata', default=())
+
+
+def normalize_metadata(metadata: MetadataSpec) -> List[Tuple[str, MetadataValue]]:
+    """Turns a metadata spec into a list of (key, value) tuples with lower case
+    keys (as gRPC requires).
+    """
+    if metadata is None:
+        return []
+    if callable(metadata):
+        metadata = metadata()
+        if metadata is None:
+            return []
+    if isinstance(metadata, Mapping):
+        metadata = metadata.items()
+    pairs = []
+    for key, value in metadata:
+        key = str(key).lower()
+        if not key.endswith('-bin') and not isinstance(value, str):
+            value = str(value)
+        pairs.append((key, value))
+    return pairs
+
+
+@contextlib.contextmanager
+def call_metadata(metadata: MetadataSpec = None, *, _client: Any = None, **kwargs: MetadataValue):
+    """Context manager that adds the given metadata (e.g. authorization
+    headers) to every gRPC call made by protoplasm6 clients within its block
+    (in the current thread/context only).
+
+    ```python
+    from protoplasm6 import plasm
+
+    with plasm.call_metadata({'authorization': f'Bearer {token}'}):
+        orders.get_order('o1')
+
+    with plasm.call_metadata(x_request_id='abc123'):  # Underscores become dashes in keywords
+        orders.get_order('o1')
+    ```
+
+    These can be nested and combined with the client's own metadata (see
+    `BaseGrpcClientImplementation`). Use `client.call_metadata(...)` to only
+    add metadata to the calls of a single client.
+    """
+    entries = []
+    if metadata is not None:
+        entries.append((_client, metadata))
+    if kwargs:
+        entries.append((_client, {k.replace('_', '-'): v for k, v in kwargs.items()}))
+    token = _CONTEXT.set(_CONTEXT.get() + tuple(entries))
+    try:
+        yield
+    finally:
+        _CONTEXT.reset(token)
+
+
+def resolve_metadata(client: Any) -> Optional[List[Tuple[str, MetadataValue]]]:
+    """Returns all the metadata for a call made by the given client: The
+    client's own metadata followed by any metadata added via `call_metadata()`
+    (for all clients or for this one) in the order it was added.
+    """
+    pairs = normalize_metadata(getattr(client, 'metadata', None))
+    for target, spec in _CONTEXT.get():
+        if target is None or target is client:
+            pairs.extend(normalize_metadata(spec))
+    return pairs or None

protoplasm6/bases/_methwrap.py

@@ -0,0 +1,220 @@
+__all__ = [
+    'PlasmMethodWrapper',
+]
+
+import grpc
+import json
+import uuid
+
+from batutils.tpu import casting as typeutils_casting
+
+from protoplasm6 import casting
+from protoplasm6 import errors
+from protoplasm6.bases.dataclass_bases import *
+from protoplasm6.structs import *
+
+if TYPE_CHECKING:
+    from .grpc_bases import BaseGrpcServicer
+
+import logging
+log = logging.getLogger(__name__)
+
+
+class PlasmMethodWrapper:
+    JSON_SERIALIZER = typeutils_casting.JsonSafeSerializer()
+
+    __slots__ = ('servicer', 'data_cls', 'impl_method', 'request', 'request_iterator', 'context', 'request_dc',
+                 'unpacked_args', 'raw_response_iterable', 'raw_response', 'response_dc', 'response_proto',
+                 '_ref_code', 'method_io')
+
+    def __init__(self, servicer: 'BaseGrpcServicer', data_cls: Type[T_DCB], impl_method: Callable,
+                 request_or_iterator: Union[GeneratedProtocolMessageType, Iterable[GeneratedProtocolMessageType]],
+                 context: grpc.ServicerContext, method_io: MethodIoType):
+        """Container and worker for processing Servicer (i.e. Server Side)
+        requests and responses, packing, unpacking, casting and so on as well as
+        handling errors and log-dumping and all that bulky noisy jass that just
+        clutters up the actual servicer code.
+        """
+        self.servicer: 'BaseGrpcServicer' = servicer
+        self.data_cls: Type[DataclassBase] = data_cls
+        self.impl_method: Callable = impl_method
+
+        self.request: Optional[GeneratedProtocolMessageType] = None
+        self.request_iterator: Optional[Iterable[GeneratedProtocolMessageType]] = None
+
+        self.context: grpc.ServicerContext = context
+        self.method_io: MethodIoType = method_io
+
+        if self.method_io.is_input_stream():
+            self.request_iterator = request_or_iterator
+        else:
+            self.request = request_or_iterator
+
+        self.request_dc: Optional[DataclassBase] = None
+        self.unpacked_args: Optional[Dict] = None
+        self.raw_response_iterable: Optional[Iterable[Any]] = None
+        self.raw_response: Any = None
+        self.response_dc: Optional[DataclassBase] = None
+        self.response_proto: Optional[GeneratedProtocolMessageType] = None
+        self._ref_code: str = ''
+
+    @property
+    def request_dc_iterator(self) -> Iterable[T_DCB]:
+        for raw_req in self.request_iterator:
+            self.request = raw_req
+            self._p2d()
+            yield self.request_dc
+
+    @property
+    def ref_code(self) -> str:
+        if not self._ref_code:
+            self._ref_code = str(uuid.uuid4())
+        return self._ref_code
+
+    def _get_dump(self, **kwargs) -> dict:
+        d = {
+            'ref_code': self.ref_code,
+            'class': str(self.servicer.__class__),
+            'data_cls': str(self.data_cls),
+            'impl_method': str(self.impl_method),
+            'request': str(self.request),
+            'method_io': self.method_io,
+        }
+
+        if self.context:
+            try:
+                d['invocation_metadata'] = dict(self.context.invocation_metadata())  # noqa
+            except Exception:
+                d['invocation_metadata'] = 'FAILED TO FETCH METADATA!'
+
+        if self.request_dc:
+            d['request_dc'] = repr(self.request_dc)
+        if self.unpacked_args:
+            d['unpacked_args'] = self.unpacked_args
+        if self.raw_response:
+            d['raw_response'] = repr(self.raw_response)
+        if self.response_dc:
+            d['response_dc'] = repr(self.response_dc)
+        if self.response_proto:
+            d['response_proto'] = repr(self.response_proto)
+
+        if kwargs:
+            d.update(kwargs)
+
+        return d
+
+    def _get_json_dump(self, **kwargs) -> str:
+        return json.dumps(self.JSON_SERIALIZER.serialize(self._get_dump(**kwargs)), indent=4)
+
+    def _abort(self, message: str, error_code, ex):
+        self.context.set_trailing_metadata([('ref_code', self.ref_code)])
+        log.exception(f'{message}::{ex!r}\n---\n{self._get_json_dump(details=repr(ex))}')
+        return self.context.abort(error_code, f'{ex!r};\nref_code={self.ref_code}')
+
+    def _abort_internal(self, ex: errors.ServiceApiException):
+        details = [ex.details]
+        if ex.should_log:
+            details.append(f'ref_code={self.ref_code}')
+            self.context.set_trailing_metadata([('ref_code', self.ref_code)])
+            log.exception(f'Logging ServiceApiException::{ex!r}\n---\n'
+                          f'{self._get_json_dump(status_code=ex.status_code, details=ex.details)}')
+        return self.context.abort(ex.status_code, ';\n'.join(details))
+
+    def _p2d(self):
+        try:
+            self.request_dc = casting.proto_to_dataclass(self.request)
+        except Exception as ex:
+            return self._abort('pre_request_error;Error while casting proto to dataclass',
+                               grpc.StatusCode.FAILED_PRECONDITION, ex)
+
+    def _unpack(self):
+        try:
+            if self.method_io.is_input_stream():
+                self.unpacked_args = {'request_iterator': self.request_dc_iterator}
+            else:
+                self.unpacked_args = self.request_dc.unpack()
+        except Exception as ex:
+            return self._abort('pre_request_error;Error while unpacking arguments',
+                               grpc.StatusCode.FAILED_PRECONDITION, ex)
+
+    def _add_ctx(self):
+        try:
+            ctx_name = getattr(self.impl_method, '__takes_context_as__', False)
+            if ctx_name:
+                self.unpacked_args[ctx_name] = GrpcContext(self.context, self.method_io)
+        except Exception as ex:
+            return self._abort('pre_request_error;Error while adding context to parameters',
+                               grpc.StatusCode.FAILED_PRECONDITION, ex)
+
+    def prepare(self):
+        if not self.method_io.is_input_stream():
+            self._p2d()
+        self._unpack()
+        self._add_ctx()
+
+    def _pack(self):
+        self.response_dc = None
+        try:
+            self.response_dc = casting.pack_dataclass_response(self.data_cls, self.raw_response)
+        except Exception as ex:
+            return self._abort('post_request_error;Error while packing raw response to dataclass',
+                               grpc.StatusCode.CANCELLED, ex)
+
+    def _d2p(self):
+        self.response_proto = None
+        try:
+            self.response_proto = casting.dataclass_to_proto(self.response_dc)
+        except Exception as ex:
+            return self._abort('post_request_error;Error while casting dataclass to proto',
+                               grpc.StatusCode.CANCELLED, ex)
+
+    def call(self) -> Union[GeneratedProtocolMessageType,
+                            Iterable[GeneratedProtocolMessageType]]:
+        # Prepare the call
+        self.prepare()
+
+        try:
+            if self.method_io.is_output_stream():
+                self.raw_response_iterable = self.impl_method(**self.unpacked_args)
+
+            else:
+                self.raw_response = self.impl_method(**self.unpacked_args)
+
+        except errors.ServiceApiException as ex:
+            return self._abort_internal(ex)
+
+        except Exception as ex:
+            return self._abort('Unexpected exception in implementation method',
+                               grpc.StatusCode.UNKNOWN, ex)
+
+        if not self.method_io.is_output_stream():
+            # Pack up results for unary results
+            self._pack()
+            self._d2p()
+            return self.response_proto
+
+        else:
+            return self.iterable_response_proto
+
+    @property
+    def wrapped_iterable_raw_response(self) -> Iterable[Any]:
+        try:
+            for res in self.raw_response_iterable:
+                yield res
+        except errors.ServiceApiException as ex:
+            return self._abort_internal(ex)
+        except Exception as ex:
+            return self._abort('Unexpected exception in implementation method',
+                               grpc.StatusCode.UNKNOWN, ex)
+
+    @property
+    def iterable_response_proto(self) -> Iterable[GeneratedProtocolMessageType]:
+        for res in self.wrapped_iterable_raw_response:
+            self.raw_response = res
+            self._pack()
+            self._d2p()
+            yield self.response_proto
+
+            self.raw_response = None
+            self.response_dc = None
+            self.response_proto = None