diff --git a/.gitignore b/.gitignore index 61d2a647..829efc43 100644 --- a/.gitignore +++ b/.gitignore @@ -10,6 +10,10 @@ __pycache__/ !/test/generated/**/__init__.py /test/generated_concrete/**/*.py !/test/generated_concrete/**/__init__.py +/test/generated_async_only/**/*.py +!/test/generated_async_only/**/__init__.py +/test/generated_sync_only/**/*.py +!/test/generated_sync_only/**/__init__.py .pytest_cache /build/ /dist/ diff --git a/CHANGELOG.md b/CHANGELOG.md index aecc078d..7eb5e8e6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,6 +7,7 @@ - Protobuf <6.32 still had the edition enums and field options, so it *should* still work. But is untested - Add support for editions (up to 2024) - Add `generate_concrete_servicer_stubs` option to generate concrete instead of abstract servicer stubs +- Add `sync_only`/`async_only` options to generate only sync or async version of GRPC stubs - Switch to types-grpcio instead of no longer maintained grpc-stubs - Add `_HasFieldArgType` and `_ClearFieldArgType` aliases to allow for typing field manipulation functions - Add `_WhichOneofArgType_` and `_WhichOneofReturnType_` type aliases diff --git a/README.md b/README.md index 220a3736..dc794ad8 100644 --- a/README.md +++ b/README.md @@ -348,6 +348,21 @@ By default mypy-protobuf will output servicer stubs with abstract methods. To ou protoc --python_out=output/location --mypy_grpc_out=generate_concrete_servicer_stubs:output/location ``` +### `sync_only/async_only` + +By default, generated GRPC stubs are compatible with both sync and async variants. If you only +want sync or async GRPC stubs, use this option: + +``` +protoc --python_out=output/location --mypy_grpc_out=sync_only:output/location +``` + +or + +``` +protoc --python_out=output/location --mypy_grpc_out=async_only:output/location +``` + ### Output suppression To suppress output, you can run diff --git a/mypy_protobuf/main.py b/mypy_protobuf/main.py index 81fa9164..1a061563 100644 --- a/mypy_protobuf/main.py +++ b/mypy_protobuf/main.py @@ -3,6 +3,7 @@ from __future__ import annotations import ast +import enum import sys from collections import defaultdict from contextlib import contextmanager @@ -114,9 +115,9 @@ def _add_enums( prefix: str, _fd: d.FileDescriptorProto, ) -> None: - for enum in enums: - self.message_to_fd[prefix + enum.name] = _fd - self.message_to_fd[prefix + enum.name + ".ValueType"] = _fd + for enum_proto in enums: + self.message_to_fd[prefix + enum_proto.name] = _fd + self.message_to_fd[prefix + enum_proto.name + ".ValueType"] = _fd def _add_messages( messages: "RepeatedCompositeFieldContainer[d.DescriptorProto]", @@ -136,6 +137,34 @@ def _add_messages( _add_enums(fd.enum_type, start_prefix, fd) +class GRPCType(enum.Enum): + SYNC = "SYNC" + ASYNC = "ASYNC" + BOTH = "BOTH" + + @classmethod + def from_parameter(cls, parameter: str) -> GRPCType: + has_sync = "only_sync" in parameter + has_async = "only_async" in parameter + + if has_sync and has_async: + raise ValueError("Cannot specify both only_sync and only_async") + elif has_sync: + return GRPCType.SYNC + elif has_async: + return GRPCType.ASYNC + else: + return GRPCType.BOTH + + @property + def supports_sync(self) -> bool: + return self in (GRPCType.SYNC, GRPCType.BOTH) + + @property + def supports_async(self) -> bool: + return self in (GRPCType.ASYNC, GRPCType.BOTH) + + class PkgWriter(object): """Writes a single pyi file""" @@ -148,6 +177,7 @@ def __init__( use_default_deprecation_warnings: bool, generate_concrete_servicer_stubs: bool, grpc: bool, + grpc_type: GRPCType = GRPCType.BOTH, ) -> None: self.fd = fd self.descriptors = descriptors @@ -156,6 +186,7 @@ def __init__( self.use_default_depreaction_warnings = use_default_deprecation_warnings self.generate_concrete_servicer_stubs = generate_concrete_servicer_stubs self.grpc = grpc + self.grpc_type = grpc_type self.lines: List[str] = [] self.indent = "" @@ -380,12 +411,12 @@ def write_enums( scl_prefix: SourceCodeLocation, ) -> None: wl = self._write_line - for i, enum in enumerate(enums): - class_name = enum.name if enum.name not in PYTHON_RESERVED else "_r_" + enum.name + for i, enum_proto in enumerate(enums): + class_name = enum_proto.name if enum_proto.name not in PYTHON_RESERVED else "_r_" + enum_proto.name value_type_fq = prefix + class_name + ".ValueType" - enum_helper_class = "_" + enum.name + enum_helper_class = "_" + enum_proto.name value_type_helper_fq = prefix + enum_helper_class + ".ValueType" - etw_helper_class = "_" + enum.name + "EnumTypeWrapper" + etw_helper_class = "_" + enum_proto.name + "EnumTypeWrapper" scl = scl_prefix + [i] wl(f"class {enum_helper_class}:") @@ -409,13 +440,13 @@ def write_enums( ed = self._import("google.protobuf.descriptor", "EnumDescriptor") wl(f"DESCRIPTOR: {ed}") self.write_enum_values( - [(i, v) for i, v in enumerate(enum.value) if v.name not in PROTO_ENUM_RESERVED], + [(i, v) for i, v in enumerate(enum_proto.value) if v.name not in PROTO_ENUM_RESERVED], value_type_helper_fq, scl + [d.EnumDescriptorProto.VALUE_FIELD_NUMBER], ) wl("") - if enum.options.deprecated: + if enum_proto.options.deprecated: self._write_deprecation_warning( scl + [d.EnumDescriptorProto.OPTIONS_FIELD_NUMBER] + [d.EnumOptions.DEPRECATED_FIELD_NUMBER], "This enum has been marked as deprecated using proto enum options.", @@ -431,7 +462,7 @@ def write_enums( wl("") self.write_enum_values( - enumerate(enum.value), + enumerate(enum_proto.value), value_type_fq, scl + [d.EnumDescriptorProto.VALUE_FIELD_NUMBER], ) @@ -762,8 +793,13 @@ def _input_type(self, method: d.MethodDescriptorProto) -> str: def _servicer_input_type(self, method: d.MethodDescriptorProto) -> str: result = self._import_message(method.input_type) if method.client_streaming: - # See write_grpc_async_hacks(). - result = f"_MaybeAsyncIterator[{result}]" + # See write_grpc_iterator_type(). + if self.grpc_type == GRPCType.SYNC: + result = f'{self._import("collections.abc", "Iterator")}[{result}]' + elif self.grpc_type == GRPCType.ASYNC: + result = f'{self._import("collections.abc", "AsyncIterator")}[{result}]' + else: + result = f"_MaybeAsyncIterator[{result}]" return result def _output_type(self, method: d.MethodDescriptorProto) -> str: @@ -775,33 +811,64 @@ def _servicer_output_type(self, method: d.MethodDescriptorProto) -> str: if method.server_streaming: # Union[Iterator[Resp], AsyncIterator[Resp]] is subtyped by Iterator[Resp] and AsyncIterator[Resp]. # So both can be used in the covariant function return position. - iterator = f"{self._import('collections.abc', 'Iterator')}[{result}]" - aiterator = f"{self._import('collections.abc', 'AsyncIterator')}[{result}]" - result = f"{self._import('typing', 'Union')}[{iterator}, {aiterator}]" + sync = f"{self._import('collections.abc', 'Iterator')}[{result}]" + a_sync = f"{self._import('collections.abc', 'AsyncIterator')}[{result}]" + result = f"{self._import('typing', 'Union')}[{sync}, {a_sync}]" else: # Union[Resp, Awaitable[Resp]] is subtyped by Resp and Awaitable[Resp]. # So both can be used in the covariant function return position. # Awaitable[Resp] is equivalent to async def. - awaitable = f"{self._import('collections.abc', 'Awaitable')}[{result}]" - result = f"{self._import('typing', 'Union')}[{result}, {awaitable}]" - return result + sync = result + a_sync = f"{self._import('collections.abc', 'Awaitable')}[{result}]" + result = f"{self._import('typing', 'Union')}[{sync}, {a_sync}]" + + if self.grpc_type == GRPCType.SYNC: + return sync + elif self.grpc_type == GRPCType.ASYNC: + return a_sync + else: + return result - def write_grpc_async_hacks(self) -> None: + def write_grpc_iterator_type(self) -> None: wl = self._write_line - # _MaybeAsyncIterator[Req] is supertyped by Iterator[Req] and AsyncIterator[Req]. - # So both can be used in the contravariant function parameter position. - wl('_T = {}("_T")', self._import("typing", "TypeVar")) - wl("") - wl( - "class _MaybeAsyncIterator({}[_T], {}[_T], metaclass={}): ...", - self._import("collections.abc", "AsyncIterator"), - self._import("collections.abc", "Iterator"), - self._import("abc", "ABCMeta"), - ) + + if self.grpc_type == GRPCType.SYNC: + self._import("collections.abc", "Iterator") + elif self.grpc_type == GRPCType.ASYNC: + self._import("collections.abc", "AsyncIterator") + else: + # _MaybeAsyncIterator[Req] is supertyped by Iterator[Req] and AsyncIterator[Req]. + # So both can be used in the contravariant function parameter position. + wl('_T = {}("_T")', self._import("typing", "TypeVar")) + wl("") + wl( + "class _MaybeAsyncIterator({}[_T], {}[_T], metaclass={}): ...", + self._import("collections.abc", "AsyncIterator"), + self._import("collections.abc", "Iterator"), + self._import("abc", "ABCMeta"), + ) wl("") - # _ServicerContext is supertyped by grpc.ServicerContext and grpc.aio.ServicerContext - # So both can be used in the contravariant function parameter position. + def get_servicer_context_type(self, input_: str, output: str) -> str: + """Get the type to use for the context parameter in servicer methods.""" + if self.grpc_type == GRPCType.ASYNC: + return self._import("grpc.aio", f"ServicerContext[{input_}, {output}]") + elif self.grpc_type == GRPCType.SYNC: + return self._import("grpc", "ServicerContext") + else: + # BOTH mode uses _ServicerContext union class + return "_ServicerContext" + + def write_grpc_servicer_context(self) -> None: + """Write _ServicerContext class only for BOTH mode (union type needed).""" + wl = self._write_line + + if self.grpc_type != GRPCType.BOTH: + return + + # BOTH mode: _ServicerContext is a union class that's supertyped by both + # grpc.ServicerContext and grpc.aio.ServicerContext, so both can be used + # in the contravariant function parameter position. wl( "class _ServicerContext({}, {}): # type: ignore[misc, type-arg]", self._import("grpc", "ServicerContext"), @@ -842,6 +909,8 @@ def write_grpc_methods(self, service: d.ServiceDescriptorProto, scl_prefix: Sour wl("") for i, method in methods: scl = scl_prefix + [d.ServiceDescriptorProto.METHOD_FIELD_NUMBER, i] + input_type = self._servicer_input_type(method) + output_type = self._servicer_output_type(method) if self.generate_concrete_servicer_stubs is False: wl("@{}", self._import("abc", "abstractmethod")) @@ -849,12 +918,11 @@ def write_grpc_methods(self, service: d.ServiceDescriptorProto, scl_prefix: Sour with self._indent(): wl("self,") input_name = "request_iterator" if method.client_streaming else "request" - input_type = self._servicer_input_type(method) wl(f"{input_name}: {input_type},") - wl("context: _ServicerContext,") + wl("context: {},", self.get_servicer_context_type(input_type, output_type)) wl( ") -> {}:{}", - self._servicer_output_type(method), + output_type, " ..." if not self._has_comments(scl) else "", ) if self._has_comments(scl): @@ -863,6 +931,19 @@ def write_grpc_methods(self, service: d.ServiceDescriptorProto, scl_prefix: Sour wl("...") wl("") + def make_server_type(self) -> str: + server = self._import("grpc", "Server") + aserver = self._import("grpc.aio", "Server") + + if self.grpc_type == GRPCType.BOTH: + return f"{self._import('typing', 'Union')}[{server}, {aserver}]" + elif self.grpc_type == GRPCType.ASYNC: + return aserver + elif self.grpc_type == GRPCType.SYNC: + return server + else: + raise RuntimeError(f"Impossible, {self.grpc_type=}") + def write_grpc_services( self, services: Iterable[d.ServiceDescriptorProto], @@ -882,50 +963,69 @@ def write_grpc_services( async_class_alias = f"{service.name}AsyncStub" # The stub client - if service.options.deprecated: - self._write_deprecation_warning( - scl + [d.ServiceDescriptorProto.OPTIONS_FIELD_NUMBER] + [d.ServiceOptions.DEPRECATED_FIELD_NUMBER], - "This stub has been marked as deprecated using proto service options.", - ) - wl( - "class {}:", - class_name, - ) - with self._indent(): - if self._write_comments(scl): - wl("") - # Write sync overload - wl("@{}", self._import("typing", "overload")) + if self.grpc_type.supports_sync: + if service.options.deprecated: + self._write_deprecation_warning( + scl + [d.ServiceDescriptorProto.OPTIONS_FIELD_NUMBER] + [d.ServiceOptions.DEPRECATED_FIELD_NUMBER], + "This stub has been marked as deprecated using proto service options.", + ) wl( - "def __new__(cls, channel: {}) -> {}: ...", - self._import("grpc", "Channel"), + "class {}:", class_name, ) + with self._indent(): + if self._write_comments(scl): + wl("") + + if self.grpc_type == GRPCType.BOTH: + # Write sync overload + wl("@{}", self._import("typing", "overload")) + wl( + "def __new__(cls, channel: {}) -> {}: ...", + self._import("grpc", "Channel"), + class_name, + ) + + # Write async overload + wl("@{}", self._import("typing", "overload")) + wl( + "def __new__(cls, channel: {}) -> {}: ...", + self._import("grpc.aio", "Channel"), + async_class_alias, + ) + else: + # SYNC only - simple __init__ + wl("def __init__(self, channel: {}) -> None: ...", self._import("grpc", "Channel")) - # Write async overload - wl("@{}", self._import("typing", "overload")) - wl( - "def __new__(cls, channel: {}) -> {}: ...", - self._import("grpc.aio", "Channel"), - async_class_alias, - ) - self.write_grpc_stub_methods(service, scl, is_async=False) - wl("") + self.write_grpc_stub_methods(service, scl, is_async=False) + wl("") # Write AsyncStub - if service.options.deprecated: - self._write_deprecation_warning( - scl + [d.ServiceDescriptorProto.OPTIONS_FIELD_NUMBER] + [d.ServiceOptions.DEPRECATED_FIELD_NUMBER], - "This stub has been marked as deprecated using proto service options.", - ) - wl("@{}", self._import("typing", "type_check_only")) - wl("class {}({}):", async_class_alias, class_name) - with self._indent(): - if self._write_comments(scl): - wl("") - wl("def __init__(self, channel: {}) -> None: ...", self._import("grpc.aio", "Channel")) - self.write_grpc_stub_methods(service, scl, is_async=True, ignore_assignment_errors=True) - wl("") + if self.grpc_type.supports_async: + if service.options.deprecated: + self._write_deprecation_warning( + scl + [d.ServiceDescriptorProto.OPTIONS_FIELD_NUMBER] + [d.ServiceOptions.DEPRECATED_FIELD_NUMBER], + "This stub has been marked as deprecated using proto service options.", + ) + + if self.grpc_type == GRPCType.BOTH: + # BOTH mode: AsyncStub inherits from Stub + wl("@{}", self._import("typing", "type_check_only")) + wl("class {}({}):", async_class_alias, class_name) + with self._indent(): + if self._write_comments(scl): + wl("") + wl("def __init__(self, channel: {}) -> None: ...", self._import("grpc.aio", "Channel")) + self.write_grpc_stub_methods(service, scl, is_async=True, ignore_assignment_errors=True) + else: + # ASYNC only - use Stub name (not AsyncStub) since there's only one type + wl("class {}:", class_name) + with self._indent(): + if self._write_comments(scl): + wl("") + wl("def __init__(self, channel: {}) -> None: ...", self._import("grpc.aio", "Channel")) + self.write_grpc_stub_methods(service, scl, is_async=True) + wl("") # The service definition interface if service.options.deprecated: @@ -948,18 +1048,17 @@ def write_grpc_services( if self._write_comments(scl): wl("") self.write_grpc_methods(service, scl) - server = self._import("grpc", "Server") - aserver = self._import("grpc.aio", "Server") if service.options.deprecated: self._write_deprecation_warning( scl + [d.ServiceDescriptorProto.OPTIONS_FIELD_NUMBER] + [d.ServiceOptions.DEPRECATED_FIELD_NUMBER], "This servicer has been marked as deprecated using proto service options.", ) + wl( "def add_{}Servicer_to_server(servicer: {}Servicer, server: {}) -> None: ...", service.name, service.name, - f"{self._import('typing', 'Union')}[{server}, {aserver}]", + self.make_server_type(), ) wl("") @@ -1150,6 +1249,7 @@ def generate_mypy_grpc_stubs( relax_strict_optional_primitives: bool, use_default_deprecation_warnings: bool, generate_concrete_servicer_stubs: bool, + grpc_type: GRPCType, ) -> None: for name, fd in descriptors.to_generate.items(): pkg_writer = PkgWriter( @@ -1160,8 +1260,10 @@ def generate_mypy_grpc_stubs( use_default_deprecation_warnings, generate_concrete_servicer_stubs, grpc=True, + grpc_type=grpc_type, ) - pkg_writer.write_grpc_async_hacks() + pkg_writer.write_grpc_iterator_type() + pkg_writer.write_grpc_servicer_context() pkg_writer.write_grpc_services(fd.service, [d.FileDescriptorProto.SERVICE_FIELD_NUMBER]) assert name == fd.name @@ -1230,6 +1332,7 @@ def grpc() -> None: "relax_strict_optional_primitives" in request.parameter, "use_default_deprecation_warnings" in request.parameter, "generate_concrete_servicer_stubs" in request.parameter, + GRPCType.from_parameter(request.parameter), ) diff --git a/pyproject.toml b/pyproject.toml index ea90959f..a15fcfac 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -13,7 +13,7 @@ line-length = 10000 [tool.isort] profile = "black" skip_gitignore = true -extend_skip_glob = ["*_pb2.py"] +extend_skip_glob = ["*_pb2.py", "*_pb2_grpc.py"] [tool.mypy] strict = true @@ -32,12 +32,16 @@ include = [ exclude = [ "**/*_pb2.py", "**/*_pb2_grpc.py", - "test/test_concrete.py" + "test/test_concrete.py", ] executionEnvironments = [ # Due to how upb is typed, we need to disable incompatible variable override checks { root = "test/generated", extraPaths = ["./"], reportIncompatibleVariableOverride = "none" }, { root = "test/generated_concrete", extraPaths = ["./"], reportIncompatibleVariableOverride = "none" }, + { root = "test/generated_sync_only", extraPaths = ["./"], reportIncompatibleVariableOverride = "none" }, + { root = "test/generated_async_only", extraPaths = ["./"], reportIncompatibleVariableOverride = "none" }, { root = "mypy_protobuf/extensions_pb2.pyi", reportIncompatibleVariableOverride = "none" }, + { root = "test/async_only", extraPaths = ["test/generated_async_only"] }, + { root = "test/sync_only", extraPaths = ["test/generated_sync_only"] }, ] diff --git a/run_test.sh b/run_test.sh index cf27f8ed..190aa587 100755 --- a/run_test.sh +++ b/run_test.sh @@ -108,8 +108,10 @@ MYPY_PROTOBUF_VENV=venv_$PY_VER_MYPY_PROTOBUF # CI Check to make sure generated files are committed SHA_BEFORE=$(find test/generated -name "*.pyi" -print0 | xargs -0 sha1sum) - # Clean out generated/ directory - except for __init__.py + # Clean out generated/ directories - except for __init__.py find test/generated -type f -not -name "__init__.py" -delete + find test/generated_sync_only -type f -not -name "__init__.py" -delete + find test/generated_async_only -type f -not -name "__init__.py" -delete # Compile protoc -> python find proto -name "*.proto" -print0 | xargs -0 "$PROTOC" "${PROTOC_ARGS[@]}" --python_out=test/generated @@ -135,6 +137,13 @@ MYPY_PROTOBUF_VENV=venv_$PY_VER_MYPY_PROTOBUF find proto -name "*.proto" -print0 | xargs -0 "$PROTOC" "${PROTOC_ARGS[@]}" --mypy_out=generate_concrete_servicer_stubs:test/generated_concrete find proto/testproto/grpc -name "*.proto" -print0 | xargs -0 "$PROTOC" "${PROTOC_ARGS[@]}" --mypy_grpc_out=generate_concrete_servicer_stubs:test/generated_concrete + # Generate with sync_only stubs for testing + mkdir -p test/generated_sync_only + find proto/testproto -name "*.proto" -print0 | xargs -0 "$PROTOC" "${PROTOC_ARGS[@]}" --mypy_grpc_out=only_sync:test/generated_sync_only --mypy_out=test/generated_sync_only --python_out=test/generated_sync_only + + # Generate with async_only stubs for testing + mkdir -p test/generated_async_only + find proto/testproto -name "*.proto" -print0 | xargs -0 "$PROTOC" "${PROTOC_ARGS[@]}" --mypy_grpc_out=only_async:test/generated_async_only --mypy_out=test/generated_async_only --python_out=test/generated_async_only if [[ -n $VALIDATE ]] && ! diff <(echo "$SHA_BEFORE") <(find test/generated -name "*.pyi" -print0 | xargs -0 sha1sum); then echo -e "${RED}Some .pyi files did not match. Please commit those files${NC}" @@ -153,6 +162,8 @@ for PY_VER in $PY_VER_UNIT_TESTS; do ( source "$UNIT_TESTS_VENV"/bin/activate find proto/testproto/grpc -name "*.proto" -print0 | xargs -0 python -m grpc_tools.protoc "${PROTOC_ARGS[@]}" --grpc_python_out=test/generated + find proto/testproto/grpc -name "*.proto" -print0 | xargs -0 python -m grpc_tools.protoc "${PROTOC_ARGS[@]}" --grpc_python_out=test/generated_sync_only + find proto/testproto/grpc -name "*.proto" -print0 | xargs -0 python -m grpc_tools.protoc "${PROTOC_ARGS[@]}" --grpc_python_out=test/generated_async_only ) # Run mypy on unit tests / generated output @@ -162,6 +173,14 @@ for PY_VER in $PY_VER_UNIT_TESTS; do CONCRETE_MODULES=( -m test.test_concrete ) MYPYPATH=$MYPYPATH:test/generated_concrete mypy ${CUSTOM_TYPESHED_DIR_ARG:+"$CUSTOM_TYPESHED_DIR_ARG"} --report-deprecated-as-note --no-incremental --python-executable="$UNIT_TESTS_VENV"/bin/python --python-version="$PY_VER_MYPY_TARGET" "${CONCRETE_MODULES[@]}" + # Run sync_only mypy + SYNC_ONLY_MODULES=( -m test.sync_only.test_sync_only ) + MYPYPATH=$MYPYPATH:test/generated_sync_only mypy ${CUSTOM_TYPESHED_DIR_ARG:+"$CUSTOM_TYPESHED_DIR_ARG"} --report-deprecated-as-note --python-executable="$UNIT_TESTS_VENV"/bin/python --python-version="$PY_VER_MYPY_TARGET" "${SYNC_ONLY_MODULES[@]}" + + # Run async_only mypy + ASYNC_ONLY_MODULES=( -m test.async_only.test_async_only ) + MYPYPATH=$MYPYPATH:test/generated_async_only mypy ${CUSTOM_TYPESHED_DIR_ARG:+"$CUSTOM_TYPESHED_DIR_ARG"} --report-deprecated-as-note --python-executable="$UNIT_TESTS_VENV"/bin/python --python-version="$PY_VER_MYPY_TARGET" "${ASYNC_ONLY_MODULES[@]}" + export MYPYPATH=$MYPYPATH:test/generated # Run mypy @@ -210,7 +229,7 @@ for PY_VER in $PY_VER_UNIT_TESTS; do ( # Run unit tests. source "$UNIT_TESTS_VENV"/bin/activate - PYTHONPATH=test/generated py.test --ignore=test/generated -v + PYTHONPATH=test/generated py.test --ignore=test/generated --ignore=test/generated_sync_only --ignore=test/generated_async_only -v ) done diff --git a/test/async_only/test_async_only.py b/test/async_only/test_async_only.py new file mode 100644 index 00000000..d5ab78ec --- /dev/null +++ b/test/async_only/test_async_only.py @@ -0,0 +1,86 @@ +""" +Type-checking and runtime test for async_only GRPC stubs. + +This module validates that stubs generated with the only_async flag have the correct types: +- Stub class (not AsyncStub) that only accepts grpc.aio.Channel +- Servicer methods use AsyncIterator for client streaming (not _MaybeAsyncIterator) +- add_XXXServicer_to_server accepts grpc.aio.Server +""" + +import grpc.aio +import pytest +import typing_extensions as typing +from testproto.grpc import dummy_pb2, dummy_pb2_grpc + +ADDRESS = "localhost:22225" + + +class Servicer(dummy_pb2_grpc.DummyServiceServicer): + async def UnaryUnary( + self, + request: dummy_pb2.DummyRequest, + context: grpc.aio.ServicerContext[dummy_pb2.DummyRequest, typing.Awaitable[dummy_pb2.DummyReply]], + ) -> dummy_pb2.DummyReply: + return dummy_pb2.DummyReply(value=request.value[::-1]) + + async def UnaryStream( + self, + request: dummy_pb2.DummyRequest, + context: grpc.aio.ServicerContext[dummy_pb2.DummyRequest, typing.AsyncIterator[dummy_pb2.DummyReply]], + ) -> typing.AsyncIterator[dummy_pb2.DummyReply]: + for char in request.value: + yield dummy_pb2.DummyReply(value=char) + + async def StreamUnary( + self, + request_iterator: typing.AsyncIterator[dummy_pb2.DummyRequest], + context: grpc.aio.ServicerContext[typing.AsyncIterator[dummy_pb2.DummyRequest], typing.Awaitable[dummy_pb2.DummyReply]], + ) -> dummy_pb2.DummyReply: + values = [data.value async for data in request_iterator] + return dummy_pb2.DummyReply(value="".join(values)) + + async def StreamStream( + self, + request_iterator: typing.AsyncIterator[dummy_pb2.DummyRequest], + context: grpc.aio.ServicerContext[typing.AsyncIterator[dummy_pb2.DummyRequest], typing.AsyncIterator[dummy_pb2.DummyReply]], + ) -> typing.AsyncIterator[dummy_pb2.DummyReply]: + async for data in request_iterator: + yield dummy_pb2.DummyReply(value=data.value.upper()) + + +def make_server() -> grpc.aio.Server: + server = grpc.aio.server() + servicer = Servicer() + server.add_insecure_port(ADDRESS) + dummy_pb2_grpc.add_DummyServiceServicer_to_server(servicer, server) + return server + + +@pytest.mark.asyncio +async def test_async_only_grpc() -> None: + server = make_server() + await server.start() + async with grpc.aio.insecure_channel(ADDRESS) as channel: + client = dummy_pb2_grpc.DummyServiceStub(channel) + request = dummy_pb2.DummyRequest(value="cprg") + result1 = await client.UnaryUnary(request) + result2 = client.UnaryStream(dummy_pb2.DummyRequest(value=result1.value)) + result2_list = [r async for r in result2] + assert len(result2_list) == 4 + result3 = client.StreamStream(dummy_pb2.DummyRequest(value=part.value) for part in result2_list) + result3_list = [r async for r in result3] + assert len(result3_list) == 4 + result4 = await client.StreamUnary(dummy_pb2.DummyRequest(value=part.value) for part in result3_list) + assert result4.value == "GRPC" + + await server.stop(None) + + class TestAttribute: + stub: "dummy_pb2_grpc.DummyServiceStub" + + def __init__(self) -> None: + self.stub = dummy_pb2_grpc.DummyServiceStub(grpc.aio.insecure_channel(ADDRESS)) + + async def test(self) -> None: + val = await self.stub.UnaryUnary(dummy_pb2.DummyRequest(value="test")) + typing.assert_type(val, dummy_pb2.DummyReply) diff --git a/test/generated_async_only/testproto/Capitalized/Capitalized_pb2.pyi b/test/generated_async_only/testproto/Capitalized/Capitalized_pb2.pyi new file mode 100644 index 00000000..0bae1c93 --- /dev/null +++ b/test/generated_async_only/testproto/Capitalized/Capitalized_pb2.pyi @@ -0,0 +1,71 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import builtins +import google.protobuf.descriptor +import google.protobuf.message +import sys +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +@typing.final +class lower(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + A_FIELD_NUMBER: builtins.int + a: builtins.int + def __init__( + self, + *, + a: builtins.int = ..., + ) -> None: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["a", b"a"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___lower: typing_extensions.TypeAlias = lower + +@typing.final +class Upper(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + LOWER_FIELD_NUMBER: builtins.int + @property + def Lower(self) -> Global___lower: ... + def __init__( + self, + *, + Lower: Global___lower | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["Lower", b"Lower"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["Lower", b"Lower"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___Upper: typing_extensions.TypeAlias = Upper + +@typing.final +class lower2(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + UPPER_FIELD_NUMBER: builtins.int + @property + def upper(self) -> Global___Upper: ... + def __init__( + self, + *, + upper: Global___Upper | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["upper", b"upper"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["upper", b"upper"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___lower2: typing_extensions.TypeAlias = lower2 diff --git a/test/generated_async_only/testproto/Capitalized/Capitalized_pb2_grpc.pyi b/test/generated_async_only/testproto/Capitalized/Capitalized_pb2_grpc.pyi new file mode 100644 index 00000000..26b99930 --- /dev/null +++ b/test/generated_async_only/testproto/Capitalized/Capitalized_pb2_grpc.pyi @@ -0,0 +1,10 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import collections.abc + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str diff --git a/test/generated_async_only/testproto/Capitalized/__init__.py b/test/generated_async_only/testproto/Capitalized/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/test/generated_async_only/testproto/__init__.py b/test/generated_async_only/testproto/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/test/generated_async_only/testproto/comment_special_chars_pb2.pyi b/test/generated_async_only/testproto/comment_special_chars_pb2.pyi new file mode 100644 index 00000000..a0f6baf3 --- /dev/null +++ b/test/generated_async_only/testproto/comment_special_chars_pb2.pyi @@ -0,0 +1,83 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import builtins +import google.protobuf.descriptor +import google.protobuf.message +import sys +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +@typing.final +class Test(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + A_FIELD_NUMBER: builtins.int + B_FIELD_NUMBER: builtins.int + C_FIELD_NUMBER: builtins.int + D_FIELD_NUMBER: builtins.int + E_FIELD_NUMBER: builtins.int + F_FIELD_NUMBER: builtins.int + G_FIELD_NUMBER: builtins.int + H_FIELD_NUMBER: builtins.int + I_FIELD_NUMBER: builtins.int + J_FIELD_NUMBER: builtins.int + K_FIELD_NUMBER: builtins.int + a: builtins.str + """Ending with " """ + b: builtins.str + """Ending with "" """ + c: builtins.str + """Ending with \"\"\" """ + d: builtins.str + """Ending with \\ """ + e: builtins.str + """Containing bad escape: \\x""" + f: builtins.str + """Containing \"\"\"" quadruple""" + g: builtins.str + """Containing \"\"\""" quintuple""" + h: builtins.str + """Containing \"\"\"\"\"\" sextuple""" + i: builtins.str + """\"\"\" Multiple \"\"\" triples \"\"\" """ + j: builtins.str + """"quotes" can be a problem in comments. + \"\"\"Triple quotes\"\"\" just as well + """ + k: builtins.str + """\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\" + " " + " Super Duper comments with surrounding edges! " + " " + " Pay attention to me!!!! " + " " + \"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\" + """ + def __init__( + self, + *, + a: builtins.str = ..., + b: builtins.str = ..., + c: builtins.str = ..., + d: builtins.str = ..., + e: builtins.str = ..., + f: builtins.str = ..., + g: builtins.str = ..., + h: builtins.str = ..., + i: builtins.str = ..., + j: builtins.str = ..., + k: builtins.str = ..., + ) -> None: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["a", b"a", "b", b"b", "c", b"c", "d", b"d", "e", b"e", "f", b"f", "g", b"g", "h", b"h", "i", b"i", "j", b"j", "k", b"k"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___Test: typing_extensions.TypeAlias = Test diff --git a/test/generated_async_only/testproto/comment_special_chars_pb2_grpc.pyi b/test/generated_async_only/testproto/comment_special_chars_pb2_grpc.pyi new file mode 100644 index 00000000..26b99930 --- /dev/null +++ b/test/generated_async_only/testproto/comment_special_chars_pb2_grpc.pyi @@ -0,0 +1,10 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import collections.abc + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str diff --git a/test/generated_async_only/testproto/dot/__init__.py b/test/generated_async_only/testproto/dot/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/test/generated_async_only/testproto/dot/com/__init__.py b/test/generated_async_only/testproto/dot/com/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/test/generated_async_only/testproto/dot/com/test_pb2.pyi b/test/generated_async_only/testproto/dot/com/test_pb2.pyi new file mode 100644 index 00000000..a6d2ab11 --- /dev/null +++ b/test/generated_async_only/testproto/dot/com/test_pb2.pyi @@ -0,0 +1,33 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import builtins +import google.protobuf.descriptor +import google.protobuf.message +import sys +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +@typing.final +class TestMessage(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + FOO_FIELD_NUMBER: builtins.int + foo: builtins.str + def __init__( + self, + *, + foo: builtins.str = ..., + ) -> None: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["foo", b"foo"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___TestMessage: typing_extensions.TypeAlias = TestMessage diff --git a/test/generated_async_only/testproto/dot/com/test_pb2_grpc.pyi b/test/generated_async_only/testproto/dot/com/test_pb2_grpc.pyi new file mode 100644 index 00000000..26b99930 --- /dev/null +++ b/test/generated_async_only/testproto/dot/com/test_pb2_grpc.pyi @@ -0,0 +1,10 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import collections.abc + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str diff --git a/test/generated_async_only/testproto/edition2024_pb2.pyi b/test/generated_async_only/testproto/edition2024_pb2.pyi new file mode 100644 index 00000000..02e9c3fb --- /dev/null +++ b/test/generated_async_only/testproto/edition2024_pb2.pyi @@ -0,0 +1,72 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +Edition version of proto2 file""" + +import builtins +import google.protobuf.descriptor +import google.protobuf.message +import sys +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +@typing.final +class Editions2024SubMessage(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + THING_FIELD_NUMBER: builtins.int + thing: builtins.str + def __init__( + self, + *, + thing: builtins.str | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["thing", b"thing"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["thing", b"thing"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___Editions2024SubMessage: typing_extensions.TypeAlias = Editions2024SubMessage + +@typing.final +class Editions2024Test(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + LEGACY_FIELD_NUMBER: builtins.int + EXPLICIT_SINGULAR_FIELD_NUMBER: builtins.int + MESSAGE_FIELD_FIELD_NUMBER: builtins.int + IMPLICIT_SINGULAR_FIELD_NUMBER: builtins.int + DEFAULT_SINGULAR_FIELD_NUMBER: builtins.int + legacy: builtins.str + """Expect to be always set""" + explicit_singular: builtins.str + """Expect HasField generated""" + implicit_singular: builtins.str + """Expect implicit field presence, no HasField generated""" + default_singular: builtins.str + """Not set, should default to EXPLICIT""" + @property + def message_field(self) -> Global___Editions2024SubMessage: + """Expect HasField generated?""" + + def __init__( + self, + *, + legacy: builtins.str | None = ..., + explicit_singular: builtins.str | None = ..., + message_field: Global___Editions2024SubMessage | None = ..., + implicit_singular: builtins.str = ..., + default_singular: builtins.str | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["default_singular", b"default_singular", "explicit_singular", b"explicit_singular", "legacy", b"legacy", "message_field", b"message_field"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["default_singular", b"default_singular", "explicit_singular", b"explicit_singular", "implicit_singular", b"implicit_singular", "legacy", b"legacy", "message_field", b"message_field"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___Editions2024Test: typing_extensions.TypeAlias = Editions2024Test diff --git a/test/generated_async_only/testproto/edition2024_pb2_grpc.pyi b/test/generated_async_only/testproto/edition2024_pb2_grpc.pyi new file mode 100644 index 00000000..af6f0d3a --- /dev/null +++ b/test/generated_async_only/testproto/edition2024_pb2_grpc.pyi @@ -0,0 +1,10 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +Edition version of proto2 file""" + +import collections.abc + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str diff --git a/test/generated_async_only/testproto/grpc/__init__.py b/test/generated_async_only/testproto/grpc/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/test/generated_async_only/testproto/grpc/dummy_pb2.pyi b/test/generated_async_only/testproto/grpc/dummy_pb2.pyi new file mode 100644 index 00000000..94987554 --- /dev/null +++ b/test/generated_async_only/testproto/grpc/dummy_pb2.pyi @@ -0,0 +1,2051 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +https://github.com/vmagamedov/grpclib/blob/master/tests/dummy.proto""" + +import builtins +import google.protobuf.descriptor +import google.protobuf.message +import sys +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +if sys.version_info >= (3, 13): + from warnings import deprecated +else: + from typing_extensions import deprecated + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +@typing.final +class DummyRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + VALUE_FIELD_NUMBER: builtins.int + value: builtins.str + def __init__( + self, + *, + value: builtins.str = ..., + ) -> None: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["value", b"value"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___DummyRequest: typing_extensions.TypeAlias = DummyRequest + +@typing.final +class DummyReply(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + VALUE_FIELD_NUMBER: builtins.int + value: builtins.str + def __init__( + self, + *, + value: builtins.str = ..., + ) -> None: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["value", b"value"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___DummyReply: typing_extensions.TypeAlias = DummyReply + +@deprecated("""This message has been marked as deprecated using proto message options.""") +@typing.final +class DeprecatedRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + OLD_FIELD_FIELD_NUMBER: builtins.int + old_field: builtins.str + def __init__( + self, + *, + old_field: builtins.str = ..., + ) -> None: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["old_field", b"old_field"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___DeprecatedRequest: typing_extensions.TypeAlias = DeprecatedRequest + +@typing.final +class ManyRequest1(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest1: typing_extensions.TypeAlias = ManyRequest1 + +@typing.final +class ManyResponse1(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse1: typing_extensions.TypeAlias = ManyResponse1 + +@typing.final +class ManyRequest2(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest2: typing_extensions.TypeAlias = ManyRequest2 + +@typing.final +class ManyResponse2(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse2: typing_extensions.TypeAlias = ManyResponse2 + +@typing.final +class ManyRequest3(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest3: typing_extensions.TypeAlias = ManyRequest3 + +@typing.final +class ManyResponse3(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse3: typing_extensions.TypeAlias = ManyResponse3 + +@typing.final +class ManyRequest4(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest4: typing_extensions.TypeAlias = ManyRequest4 + +@typing.final +class ManyResponse4(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse4: typing_extensions.TypeAlias = ManyResponse4 + +@typing.final +class ManyRequest5(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest5: typing_extensions.TypeAlias = ManyRequest5 + +@typing.final +class ManyResponse5(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse5: typing_extensions.TypeAlias = ManyResponse5 + +@typing.final +class ManyRequest6(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest6: typing_extensions.TypeAlias = ManyRequest6 + +@typing.final +class ManyResponse6(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse6: typing_extensions.TypeAlias = ManyResponse6 + +@typing.final +class ManyRequest7(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest7: typing_extensions.TypeAlias = ManyRequest7 + +@typing.final +class ManyResponse7(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse7: typing_extensions.TypeAlias = ManyResponse7 + +@typing.final +class ManyRequest8(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest8: typing_extensions.TypeAlias = ManyRequest8 + +@typing.final +class ManyResponse8(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse8: typing_extensions.TypeAlias = ManyResponse8 + +@typing.final +class ManyRequest9(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest9: typing_extensions.TypeAlias = ManyRequest9 + +@typing.final +class ManyResponse9(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse9: typing_extensions.TypeAlias = ManyResponse9 + +@typing.final +class ManyRequest10(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest10: typing_extensions.TypeAlias = ManyRequest10 + +@typing.final +class ManyResponse10(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse10: typing_extensions.TypeAlias = ManyResponse10 + +@typing.final +class ManyRequest11(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest11: typing_extensions.TypeAlias = ManyRequest11 + +@typing.final +class ManyResponse11(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse11: typing_extensions.TypeAlias = ManyResponse11 + +@typing.final +class ManyRequest12(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest12: typing_extensions.TypeAlias = ManyRequest12 + +@typing.final +class ManyResponse12(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse12: typing_extensions.TypeAlias = ManyResponse12 + +@typing.final +class ManyRequest13(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest13: typing_extensions.TypeAlias = ManyRequest13 + +@typing.final +class ManyResponse13(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse13: typing_extensions.TypeAlias = ManyResponse13 + +@typing.final +class ManyRequest14(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest14: typing_extensions.TypeAlias = ManyRequest14 + +@typing.final +class ManyResponse14(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse14: typing_extensions.TypeAlias = ManyResponse14 + +@typing.final +class ManyRequest15(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest15: typing_extensions.TypeAlias = ManyRequest15 + +@typing.final +class ManyResponse15(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse15: typing_extensions.TypeAlias = ManyResponse15 + +@typing.final +class ManyRequest16(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest16: typing_extensions.TypeAlias = ManyRequest16 + +@typing.final +class ManyResponse16(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse16: typing_extensions.TypeAlias = ManyResponse16 + +@typing.final +class ManyRequest17(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest17: typing_extensions.TypeAlias = ManyRequest17 + +@typing.final +class ManyResponse17(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse17: typing_extensions.TypeAlias = ManyResponse17 + +@typing.final +class ManyRequest18(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest18: typing_extensions.TypeAlias = ManyRequest18 + +@typing.final +class ManyResponse18(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse18: typing_extensions.TypeAlias = ManyResponse18 + +@typing.final +class ManyRequest19(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest19: typing_extensions.TypeAlias = ManyRequest19 + +@typing.final +class ManyResponse19(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse19: typing_extensions.TypeAlias = ManyResponse19 + +@typing.final +class ManyRequest20(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest20: typing_extensions.TypeAlias = ManyRequest20 + +@typing.final +class ManyResponse20(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse20: typing_extensions.TypeAlias = ManyResponse20 + +@typing.final +class ManyRequest21(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest21: typing_extensions.TypeAlias = ManyRequest21 + +@typing.final +class ManyResponse21(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse21: typing_extensions.TypeAlias = ManyResponse21 + +@typing.final +class ManyRequest22(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest22: typing_extensions.TypeAlias = ManyRequest22 + +@typing.final +class ManyResponse22(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse22: typing_extensions.TypeAlias = ManyResponse22 + +@typing.final +class ManyRequest23(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest23: typing_extensions.TypeAlias = ManyRequest23 + +@typing.final +class ManyResponse23(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse23: typing_extensions.TypeAlias = ManyResponse23 + +@typing.final +class ManyRequest24(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest24: typing_extensions.TypeAlias = ManyRequest24 + +@typing.final +class ManyResponse24(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse24: typing_extensions.TypeAlias = ManyResponse24 + +@typing.final +class ManyRequest25(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest25: typing_extensions.TypeAlias = ManyRequest25 + +@typing.final +class ManyResponse25(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse25: typing_extensions.TypeAlias = ManyResponse25 + +@typing.final +class ManyRequest26(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest26: typing_extensions.TypeAlias = ManyRequest26 + +@typing.final +class ManyResponse26(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse26: typing_extensions.TypeAlias = ManyResponse26 + +@typing.final +class ManyRequest27(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest27: typing_extensions.TypeAlias = ManyRequest27 + +@typing.final +class ManyResponse27(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse27: typing_extensions.TypeAlias = ManyResponse27 + +@typing.final +class ManyRequest28(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest28: typing_extensions.TypeAlias = ManyRequest28 + +@typing.final +class ManyResponse28(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse28: typing_extensions.TypeAlias = ManyResponse28 + +@typing.final +class ManyRequest29(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest29: typing_extensions.TypeAlias = ManyRequest29 + +@typing.final +class ManyResponse29(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse29: typing_extensions.TypeAlias = ManyResponse29 + +@typing.final +class ManyRequest30(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest30: typing_extensions.TypeAlias = ManyRequest30 + +@typing.final +class ManyResponse30(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse30: typing_extensions.TypeAlias = ManyResponse30 + +@typing.final +class ManyRequest31(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest31: typing_extensions.TypeAlias = ManyRequest31 + +@typing.final +class ManyResponse31(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse31: typing_extensions.TypeAlias = ManyResponse31 + +@typing.final +class ManyRequest32(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest32: typing_extensions.TypeAlias = ManyRequest32 + +@typing.final +class ManyResponse32(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse32: typing_extensions.TypeAlias = ManyResponse32 + +@typing.final +class ManyRequest33(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest33: typing_extensions.TypeAlias = ManyRequest33 + +@typing.final +class ManyResponse33(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse33: typing_extensions.TypeAlias = ManyResponse33 + +@typing.final +class ManyRequest34(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest34: typing_extensions.TypeAlias = ManyRequest34 + +@typing.final +class ManyResponse34(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse34: typing_extensions.TypeAlias = ManyResponse34 + +@typing.final +class ManyRequest35(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest35: typing_extensions.TypeAlias = ManyRequest35 + +@typing.final +class ManyResponse35(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse35: typing_extensions.TypeAlias = ManyResponse35 + +@typing.final +class ManyRequest36(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest36: typing_extensions.TypeAlias = ManyRequest36 + +@typing.final +class ManyResponse36(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse36: typing_extensions.TypeAlias = ManyResponse36 + +@typing.final +class ManyRequest37(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest37: typing_extensions.TypeAlias = ManyRequest37 + +@typing.final +class ManyResponse37(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse37: typing_extensions.TypeAlias = ManyResponse37 + +@typing.final +class ManyRequest38(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest38: typing_extensions.TypeAlias = ManyRequest38 + +@typing.final +class ManyResponse38(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse38: typing_extensions.TypeAlias = ManyResponse38 + +@typing.final +class ManyRequest39(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest39: typing_extensions.TypeAlias = ManyRequest39 + +@typing.final +class ManyResponse39(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse39: typing_extensions.TypeAlias = ManyResponse39 + +@typing.final +class ManyRequest40(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest40: typing_extensions.TypeAlias = ManyRequest40 + +@typing.final +class ManyResponse40(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse40: typing_extensions.TypeAlias = ManyResponse40 + +@typing.final +class ManyRequest41(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest41: typing_extensions.TypeAlias = ManyRequest41 + +@typing.final +class ManyResponse41(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse41: typing_extensions.TypeAlias = ManyResponse41 + +@typing.final +class ManyRequest42(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest42: typing_extensions.TypeAlias = ManyRequest42 + +@typing.final +class ManyResponse42(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse42: typing_extensions.TypeAlias = ManyResponse42 + +@typing.final +class ManyRequest43(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest43: typing_extensions.TypeAlias = ManyRequest43 + +@typing.final +class ManyResponse43(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse43: typing_extensions.TypeAlias = ManyResponse43 + +@typing.final +class ManyRequest44(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest44: typing_extensions.TypeAlias = ManyRequest44 + +@typing.final +class ManyResponse44(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse44: typing_extensions.TypeAlias = ManyResponse44 + +@typing.final +class ManyRequest45(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest45: typing_extensions.TypeAlias = ManyRequest45 + +@typing.final +class ManyResponse45(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse45: typing_extensions.TypeAlias = ManyResponse45 + +@typing.final +class ManyRequest46(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest46: typing_extensions.TypeAlias = ManyRequest46 + +@typing.final +class ManyResponse46(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse46: typing_extensions.TypeAlias = ManyResponse46 + +@typing.final +class ManyRequest47(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest47: typing_extensions.TypeAlias = ManyRequest47 + +@typing.final +class ManyResponse47(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse47: typing_extensions.TypeAlias = ManyResponse47 + +@typing.final +class ManyRequest48(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest48: typing_extensions.TypeAlias = ManyRequest48 + +@typing.final +class ManyResponse48(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse48: typing_extensions.TypeAlias = ManyResponse48 + +@typing.final +class ManyRequest49(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest49: typing_extensions.TypeAlias = ManyRequest49 + +@typing.final +class ManyResponse49(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse49: typing_extensions.TypeAlias = ManyResponse49 + +@typing.final +class ManyRequest50(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest50: typing_extensions.TypeAlias = ManyRequest50 + +@typing.final +class ManyResponse50(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse50: typing_extensions.TypeAlias = ManyResponse50 + +@typing.final +class ManyRequest51(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest51: typing_extensions.TypeAlias = ManyRequest51 + +@typing.final +class ManyResponse51(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse51: typing_extensions.TypeAlias = ManyResponse51 + +@typing.final +class ManyRequest52(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest52: typing_extensions.TypeAlias = ManyRequest52 + +@typing.final +class ManyResponse52(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse52: typing_extensions.TypeAlias = ManyResponse52 + +@typing.final +class ManyRequest53(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest53: typing_extensions.TypeAlias = ManyRequest53 + +@typing.final +class ManyResponse53(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse53: typing_extensions.TypeAlias = ManyResponse53 + +@typing.final +class ManyRequest54(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest54: typing_extensions.TypeAlias = ManyRequest54 + +@typing.final +class ManyResponse54(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse54: typing_extensions.TypeAlias = ManyResponse54 + +@typing.final +class ManyRequest55(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest55: typing_extensions.TypeAlias = ManyRequest55 + +@typing.final +class ManyResponse55(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse55: typing_extensions.TypeAlias = ManyResponse55 + +@typing.final +class ManyRequest56(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest56: typing_extensions.TypeAlias = ManyRequest56 + +@typing.final +class ManyResponse56(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse56: typing_extensions.TypeAlias = ManyResponse56 + +@typing.final +class ManyRequest57(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest57: typing_extensions.TypeAlias = ManyRequest57 + +@typing.final +class ManyResponse57(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse57: typing_extensions.TypeAlias = ManyResponse57 + +@typing.final +class ManyRequest58(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest58: typing_extensions.TypeAlias = ManyRequest58 + +@typing.final +class ManyResponse58(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse58: typing_extensions.TypeAlias = ManyResponse58 + +@typing.final +class ManyRequest59(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest59: typing_extensions.TypeAlias = ManyRequest59 + +@typing.final +class ManyResponse59(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse59: typing_extensions.TypeAlias = ManyResponse59 + +@typing.final +class ManyRequest60(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest60: typing_extensions.TypeAlias = ManyRequest60 + +@typing.final +class ManyResponse60(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse60: typing_extensions.TypeAlias = ManyResponse60 + +@typing.final +class ManyRequest61(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest61: typing_extensions.TypeAlias = ManyRequest61 + +@typing.final +class ManyResponse61(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse61: typing_extensions.TypeAlias = ManyResponse61 + +@typing.final +class ManyRequest62(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest62: typing_extensions.TypeAlias = ManyRequest62 + +@typing.final +class ManyResponse62(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse62: typing_extensions.TypeAlias = ManyResponse62 + +@typing.final +class ManyRequest63(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest63: typing_extensions.TypeAlias = ManyRequest63 + +@typing.final +class ManyResponse63(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse63: typing_extensions.TypeAlias = ManyResponse63 + +@typing.final +class ManyRequest64(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest64: typing_extensions.TypeAlias = ManyRequest64 + +@typing.final +class ManyResponse64(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse64: typing_extensions.TypeAlias = ManyResponse64 + +@typing.final +class ManyRequest65(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest65: typing_extensions.TypeAlias = ManyRequest65 + +@typing.final +class ManyResponse65(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse65: typing_extensions.TypeAlias = ManyResponse65 + +@typing.final +class ManyRequest66(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest66: typing_extensions.TypeAlias = ManyRequest66 + +@typing.final +class ManyResponse66(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse66: typing_extensions.TypeAlias = ManyResponse66 + +@typing.final +class ManyRequest67(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest67: typing_extensions.TypeAlias = ManyRequest67 + +@typing.final +class ManyResponse67(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse67: typing_extensions.TypeAlias = ManyResponse67 + +@typing.final +class ManyRequest68(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest68: typing_extensions.TypeAlias = ManyRequest68 + +@typing.final +class ManyResponse68(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse68: typing_extensions.TypeAlias = ManyResponse68 + +@typing.final +class ManyRequest69(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest69: typing_extensions.TypeAlias = ManyRequest69 + +@typing.final +class ManyResponse69(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse69: typing_extensions.TypeAlias = ManyResponse69 + +@typing.final +class ManyRequest70(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest70: typing_extensions.TypeAlias = ManyRequest70 + +@typing.final +class ManyResponse70(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse70: typing_extensions.TypeAlias = ManyResponse70 + +@typing.final +class ManyRequest71(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest71: typing_extensions.TypeAlias = ManyRequest71 + +@typing.final +class ManyResponse71(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse71: typing_extensions.TypeAlias = ManyResponse71 + +@typing.final +class ManyRequest72(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest72: typing_extensions.TypeAlias = ManyRequest72 + +@typing.final +class ManyResponse72(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse72: typing_extensions.TypeAlias = ManyResponse72 + +@typing.final +class ManyRequest73(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest73: typing_extensions.TypeAlias = ManyRequest73 + +@typing.final +class ManyResponse73(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse73: typing_extensions.TypeAlias = ManyResponse73 + +@typing.final +class ManyRequest74(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest74: typing_extensions.TypeAlias = ManyRequest74 + +@typing.final +class ManyResponse74(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse74: typing_extensions.TypeAlias = ManyResponse74 + +@typing.final +class ManyRequest75(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest75: typing_extensions.TypeAlias = ManyRequest75 + +@typing.final +class ManyResponse75(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse75: typing_extensions.TypeAlias = ManyResponse75 + +@typing.final +class ManyRequest76(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest76: typing_extensions.TypeAlias = ManyRequest76 + +@typing.final +class ManyResponse76(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse76: typing_extensions.TypeAlias = ManyResponse76 + +@typing.final +class ManyRequest77(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest77: typing_extensions.TypeAlias = ManyRequest77 + +@typing.final +class ManyResponse77(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse77: typing_extensions.TypeAlias = ManyResponse77 + +@typing.final +class ManyRequest78(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest78: typing_extensions.TypeAlias = ManyRequest78 + +@typing.final +class ManyResponse78(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse78: typing_extensions.TypeAlias = ManyResponse78 + +@typing.final +class ManyRequest79(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest79: typing_extensions.TypeAlias = ManyRequest79 + +@typing.final +class ManyResponse79(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse79: typing_extensions.TypeAlias = ManyResponse79 + +@typing.final +class ManyRequest80(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest80: typing_extensions.TypeAlias = ManyRequest80 + +@typing.final +class ManyResponse80(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse80: typing_extensions.TypeAlias = ManyResponse80 + +@typing.final +class ManyRequest81(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest81: typing_extensions.TypeAlias = ManyRequest81 + +@typing.final +class ManyResponse81(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse81: typing_extensions.TypeAlias = ManyResponse81 + +@typing.final +class ManyRequest82(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest82: typing_extensions.TypeAlias = ManyRequest82 + +@typing.final +class ManyResponse82(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse82: typing_extensions.TypeAlias = ManyResponse82 + +@typing.final +class ManyRequest83(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest83: typing_extensions.TypeAlias = ManyRequest83 + +@typing.final +class ManyResponse83(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse83: typing_extensions.TypeAlias = ManyResponse83 + +@typing.final +class ManyRequest84(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest84: typing_extensions.TypeAlias = ManyRequest84 + +@typing.final +class ManyResponse84(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse84: typing_extensions.TypeAlias = ManyResponse84 + +@typing.final +class ManyRequest85(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest85: typing_extensions.TypeAlias = ManyRequest85 + +@typing.final +class ManyResponse85(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse85: typing_extensions.TypeAlias = ManyResponse85 + +@typing.final +class ManyRequest86(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest86: typing_extensions.TypeAlias = ManyRequest86 + +@typing.final +class ManyResponse86(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse86: typing_extensions.TypeAlias = ManyResponse86 + +@typing.final +class ManyRequest87(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest87: typing_extensions.TypeAlias = ManyRequest87 + +@typing.final +class ManyResponse87(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse87: typing_extensions.TypeAlias = ManyResponse87 + +@typing.final +class ManyRequest88(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest88: typing_extensions.TypeAlias = ManyRequest88 + +@typing.final +class ManyResponse88(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse88: typing_extensions.TypeAlias = ManyResponse88 + +@typing.final +class ManyRequest89(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest89: typing_extensions.TypeAlias = ManyRequest89 + +@typing.final +class ManyResponse89(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse89: typing_extensions.TypeAlias = ManyResponse89 + +@typing.final +class ManyRequest90(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest90: typing_extensions.TypeAlias = ManyRequest90 + +@typing.final +class ManyResponse90(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse90: typing_extensions.TypeAlias = ManyResponse90 + +@typing.final +class ManyRequest91(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest91: typing_extensions.TypeAlias = ManyRequest91 + +@typing.final +class ManyResponse91(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse91: typing_extensions.TypeAlias = ManyResponse91 + +@typing.final +class ManyRequest92(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest92: typing_extensions.TypeAlias = ManyRequest92 + +@typing.final +class ManyResponse92(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse92: typing_extensions.TypeAlias = ManyResponse92 + +@typing.final +class ManyRequest93(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest93: typing_extensions.TypeAlias = ManyRequest93 + +@typing.final +class ManyResponse93(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse93: typing_extensions.TypeAlias = ManyResponse93 + +@typing.final +class ManyRequest94(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest94: typing_extensions.TypeAlias = ManyRequest94 + +@typing.final +class ManyResponse94(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse94: typing_extensions.TypeAlias = ManyResponse94 + +@typing.final +class ManyRequest95(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest95: typing_extensions.TypeAlias = ManyRequest95 + +@typing.final +class ManyResponse95(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse95: typing_extensions.TypeAlias = ManyResponse95 + +@typing.final +class ManyRequest96(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest96: typing_extensions.TypeAlias = ManyRequest96 + +@typing.final +class ManyResponse96(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse96: typing_extensions.TypeAlias = ManyResponse96 + +@typing.final +class ManyRequest97(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest97: typing_extensions.TypeAlias = ManyRequest97 + +@typing.final +class ManyResponse97(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse97: typing_extensions.TypeAlias = ManyResponse97 + +@typing.final +class ManyRequest98(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest98: typing_extensions.TypeAlias = ManyRequest98 + +@typing.final +class ManyResponse98(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse98: typing_extensions.TypeAlias = ManyResponse98 + +@typing.final +class ManyRequest99(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest99: typing_extensions.TypeAlias = ManyRequest99 + +@typing.final +class ManyResponse99(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse99: typing_extensions.TypeAlias = ManyResponse99 diff --git a/test/generated_async_only/testproto/grpc/dummy_pb2_grpc.pyi b/test/generated_async_only/testproto/grpc/dummy_pb2_grpc.pyi new file mode 100644 index 00000000..009b200c --- /dev/null +++ b/test/generated_async_only/testproto/grpc/dummy_pb2_grpc.pyi @@ -0,0 +1,910 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +https://github.com/vmagamedov/grpclib/blob/master/tests/dummy.proto""" + +import abc +import collections.abc +import grpc +import grpc.aio +import sys +import testproto.grpc.dummy_pb2 +import typing + +if sys.version_info >= (3, 13): + from warnings import deprecated +else: + from typing_extensions import deprecated + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str + +class DummyServiceStub: + """DummyService""" + + def __init__(self, channel: grpc.aio.Channel) -> None: ... + UnaryUnary: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.DummyRequest, testproto.grpc.dummy_pb2.DummyReply] + """UnaryUnary""" + UnaryStream: grpc.aio.UnaryStreamMultiCallable[testproto.grpc.dummy_pb2.DummyRequest, testproto.grpc.dummy_pb2.DummyReply] + """UnaryStream""" + StreamUnary: grpc.aio.StreamUnaryMultiCallable[testproto.grpc.dummy_pb2.DummyRequest, testproto.grpc.dummy_pb2.DummyReply] + """StreamUnary""" + StreamStream: grpc.aio.StreamStreamMultiCallable[testproto.grpc.dummy_pb2.DummyRequest, testproto.grpc.dummy_pb2.DummyReply] + """StreamStream""" + +class DummyServiceServicer(metaclass=abc.ABCMeta): + """DummyService""" + + @abc.abstractmethod + def UnaryUnary( + self, + request: testproto.grpc.dummy_pb2.DummyRequest, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.DummyRequest, collections.abc.Awaitable[testproto.grpc.dummy_pb2.DummyReply]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.DummyReply]: + """UnaryUnary""" + + @abc.abstractmethod + def UnaryStream( + self, + request: testproto.grpc.dummy_pb2.DummyRequest, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.DummyRequest, collections.abc.AsyncIterator[testproto.grpc.dummy_pb2.DummyReply]], + ) -> collections.abc.AsyncIterator[testproto.grpc.dummy_pb2.DummyReply]: + """UnaryStream""" + + @abc.abstractmethod + def StreamUnary( + self, + request_iterator: collections.abc.AsyncIterator[testproto.grpc.dummy_pb2.DummyRequest], + context: grpc.aio.ServicerContext[collections.abc.AsyncIterator[testproto.grpc.dummy_pb2.DummyRequest], collections.abc.Awaitable[testproto.grpc.dummy_pb2.DummyReply]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.DummyReply]: + """StreamUnary""" + + @abc.abstractmethod + def StreamStream( + self, + request_iterator: collections.abc.AsyncIterator[testproto.grpc.dummy_pb2.DummyRequest], + context: grpc.aio.ServicerContext[collections.abc.AsyncIterator[testproto.grpc.dummy_pb2.DummyRequest], collections.abc.AsyncIterator[testproto.grpc.dummy_pb2.DummyReply]], + ) -> collections.abc.AsyncIterator[testproto.grpc.dummy_pb2.DummyReply]: + """StreamStream""" + +def add_DummyServiceServicer_to_server(servicer: DummyServiceServicer, server: grpc.aio.Server) -> None: ... + +@deprecated("""This service is deprecated""") +class DeprecatedServiceStub: + """Marking the service as deprecated""" + + def __init__(self, channel: grpc.aio.Channel) -> None: ... + DeprecatedMethod: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.DeprecatedRequest, testproto.grpc.dummy_pb2.DummyReply] + """DeprecatedMethod""" + DeprecatedMethodNotDeprecatedRequest: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.DummyRequest, testproto.grpc.dummy_pb2.DummyReply] + """DeprecatedMethodNotDeprecatedRequest""" + +@deprecated("""This service is deprecated""") +class DeprecatedServiceServicer(metaclass=abc.ABCMeta): + """Marking the service as deprecated""" + + @abc.abstractmethod + def DeprecatedMethod( + self, + request: testproto.grpc.dummy_pb2.DeprecatedRequest, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.DeprecatedRequest, collections.abc.Awaitable[testproto.grpc.dummy_pb2.DummyReply]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.DummyReply]: + """DeprecatedMethod""" + + @abc.abstractmethod + def DeprecatedMethodNotDeprecatedRequest( + self, + request: testproto.grpc.dummy_pb2.DummyRequest, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.DummyRequest, collections.abc.Awaitable[testproto.grpc.dummy_pb2.DummyReply]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.DummyReply]: + """DeprecatedMethodNotDeprecatedRequest""" + +@deprecated("""This service is deprecated""") +def add_DeprecatedServiceServicer_to_server(servicer: DeprecatedServiceServicer, server: grpc.aio.Server) -> None: ... + +class ManyRPCsServiceStub: + def __init__(self, channel: grpc.aio.Channel) -> None: ... + Method1: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest1, testproto.grpc.dummy_pb2.ManyResponse1] + Method2: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest2, testproto.grpc.dummy_pb2.ManyResponse2] + Method3: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest3, testproto.grpc.dummy_pb2.ManyResponse3] + Method4: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest4, testproto.grpc.dummy_pb2.ManyResponse4] + Method5: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest5, testproto.grpc.dummy_pb2.ManyResponse5] + Method6: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest6, testproto.grpc.dummy_pb2.ManyResponse6] + Method7: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest7, testproto.grpc.dummy_pb2.ManyResponse7] + Method8: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest8, testproto.grpc.dummy_pb2.ManyResponse8] + Method9: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest9, testproto.grpc.dummy_pb2.ManyResponse9] + Method10: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest10, testproto.grpc.dummy_pb2.ManyResponse10] + Method11: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest11, testproto.grpc.dummy_pb2.ManyResponse11] + Method12: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest12, testproto.grpc.dummy_pb2.ManyResponse12] + Method13: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest13, testproto.grpc.dummy_pb2.ManyResponse13] + Method14: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest14, testproto.grpc.dummy_pb2.ManyResponse14] + Method15: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest15, testproto.grpc.dummy_pb2.ManyResponse15] + Method16: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest16, testproto.grpc.dummy_pb2.ManyResponse16] + Method17: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest17, testproto.grpc.dummy_pb2.ManyResponse17] + Method18: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest18, testproto.grpc.dummy_pb2.ManyResponse18] + Method19: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest19, testproto.grpc.dummy_pb2.ManyResponse19] + Method20: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest20, testproto.grpc.dummy_pb2.ManyResponse20] + Method21: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest21, testproto.grpc.dummy_pb2.ManyResponse21] + Method22: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest22, testproto.grpc.dummy_pb2.ManyResponse22] + Method23: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest23, testproto.grpc.dummy_pb2.ManyResponse23] + Method24: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest24, testproto.grpc.dummy_pb2.ManyResponse24] + Method25: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest25, testproto.grpc.dummy_pb2.ManyResponse25] + Method26: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest26, testproto.grpc.dummy_pb2.ManyResponse26] + Method27: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest27, testproto.grpc.dummy_pb2.ManyResponse27] + Method28: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest28, testproto.grpc.dummy_pb2.ManyResponse28] + Method29: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest29, testproto.grpc.dummy_pb2.ManyResponse29] + Method30: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest30, testproto.grpc.dummy_pb2.ManyResponse30] + Method31: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest31, testproto.grpc.dummy_pb2.ManyResponse31] + Method32: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest32, testproto.grpc.dummy_pb2.ManyResponse32] + Method33: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest33, testproto.grpc.dummy_pb2.ManyResponse33] + Method34: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest34, testproto.grpc.dummy_pb2.ManyResponse34] + Method35: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest35, testproto.grpc.dummy_pb2.ManyResponse35] + Method36: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest36, testproto.grpc.dummy_pb2.ManyResponse36] + Method37: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest37, testproto.grpc.dummy_pb2.ManyResponse37] + Method38: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest38, testproto.grpc.dummy_pb2.ManyResponse38] + Method39: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest39, testproto.grpc.dummy_pb2.ManyResponse39] + Method40: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest40, testproto.grpc.dummy_pb2.ManyResponse40] + Method41: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest41, testproto.grpc.dummy_pb2.ManyResponse41] + Method42: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest42, testproto.grpc.dummy_pb2.ManyResponse42] + Method43: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest43, testproto.grpc.dummy_pb2.ManyResponse43] + Method44: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest44, testproto.grpc.dummy_pb2.ManyResponse44] + Method45: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest45, testproto.grpc.dummy_pb2.ManyResponse45] + Method46: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest46, testproto.grpc.dummy_pb2.ManyResponse46] + Method47: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest47, testproto.grpc.dummy_pb2.ManyResponse47] + Method48: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest48, testproto.grpc.dummy_pb2.ManyResponse48] + Method49: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest49, testproto.grpc.dummy_pb2.ManyResponse49] + Method50: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest50, testproto.grpc.dummy_pb2.ManyResponse50] + Method51: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest51, testproto.grpc.dummy_pb2.ManyResponse51] + Method52: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest52, testproto.grpc.dummy_pb2.ManyResponse52] + Method53: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest53, testproto.grpc.dummy_pb2.ManyResponse53] + Method54: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest54, testproto.grpc.dummy_pb2.ManyResponse54] + Method55: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest55, testproto.grpc.dummy_pb2.ManyResponse55] + Method56: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest56, testproto.grpc.dummy_pb2.ManyResponse56] + Method57: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest57, testproto.grpc.dummy_pb2.ManyResponse57] + Method58: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest58, testproto.grpc.dummy_pb2.ManyResponse58] + Method59: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest59, testproto.grpc.dummy_pb2.ManyResponse59] + Method60: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest60, testproto.grpc.dummy_pb2.ManyResponse60] + Method61: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest61, testproto.grpc.dummy_pb2.ManyResponse61] + Method62: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest62, testproto.grpc.dummy_pb2.ManyResponse62] + Method63: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest63, testproto.grpc.dummy_pb2.ManyResponse63] + Method64: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest64, testproto.grpc.dummy_pb2.ManyResponse64] + Method65: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest65, testproto.grpc.dummy_pb2.ManyResponse65] + Method66: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest66, testproto.grpc.dummy_pb2.ManyResponse66] + Method67: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest67, testproto.grpc.dummy_pb2.ManyResponse67] + Method68: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest68, testproto.grpc.dummy_pb2.ManyResponse68] + Method69: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest69, testproto.grpc.dummy_pb2.ManyResponse69] + Method70: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest70, testproto.grpc.dummy_pb2.ManyResponse70] + Method71: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest71, testproto.grpc.dummy_pb2.ManyResponse71] + Method72: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest72, testproto.grpc.dummy_pb2.ManyResponse72] + Method73: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest73, testproto.grpc.dummy_pb2.ManyResponse73] + Method74: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest74, testproto.grpc.dummy_pb2.ManyResponse74] + Method75: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest75, testproto.grpc.dummy_pb2.ManyResponse75] + Method76: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest76, testproto.grpc.dummy_pb2.ManyResponse76] + Method77: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest77, testproto.grpc.dummy_pb2.ManyResponse77] + Method78: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest78, testproto.grpc.dummy_pb2.ManyResponse78] + Method79: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest79, testproto.grpc.dummy_pb2.ManyResponse79] + Method80: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest80, testproto.grpc.dummy_pb2.ManyResponse80] + Method81: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest81, testproto.grpc.dummy_pb2.ManyResponse81] + Method82: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest82, testproto.grpc.dummy_pb2.ManyResponse82] + Method83: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest83, testproto.grpc.dummy_pb2.ManyResponse83] + Method84: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest84, testproto.grpc.dummy_pb2.ManyResponse84] + Method85: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest85, testproto.grpc.dummy_pb2.ManyResponse85] + Method86: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest86, testproto.grpc.dummy_pb2.ManyResponse86] + Method87: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest87, testproto.grpc.dummy_pb2.ManyResponse87] + Method88: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest88, testproto.grpc.dummy_pb2.ManyResponse88] + Method89: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest89, testproto.grpc.dummy_pb2.ManyResponse89] + Method90: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest90, testproto.grpc.dummy_pb2.ManyResponse90] + Method91: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest91, testproto.grpc.dummy_pb2.ManyResponse91] + Method92: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest92, testproto.grpc.dummy_pb2.ManyResponse92] + Method93: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest93, testproto.grpc.dummy_pb2.ManyResponse93] + Method94: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest94, testproto.grpc.dummy_pb2.ManyResponse94] + Method95: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest95, testproto.grpc.dummy_pb2.ManyResponse95] + Method96: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest96, testproto.grpc.dummy_pb2.ManyResponse96] + Method97: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest97, testproto.grpc.dummy_pb2.ManyResponse97] + Method98: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest98, testproto.grpc.dummy_pb2.ManyResponse98] + Method99: grpc.aio.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest99, testproto.grpc.dummy_pb2.ManyResponse99] + +class ManyRPCsServiceServicer(metaclass=abc.ABCMeta): + @abc.abstractmethod + def Method1( + self, + request: testproto.grpc.dummy_pb2.ManyRequest1, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest1, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse1]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse1]: ... + + @abc.abstractmethod + def Method2( + self, + request: testproto.grpc.dummy_pb2.ManyRequest2, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest2, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse2]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse2]: ... + + @abc.abstractmethod + def Method3( + self, + request: testproto.grpc.dummy_pb2.ManyRequest3, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest3, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse3]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse3]: ... + + @abc.abstractmethod + def Method4( + self, + request: testproto.grpc.dummy_pb2.ManyRequest4, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest4, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse4]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse4]: ... + + @abc.abstractmethod + def Method5( + self, + request: testproto.grpc.dummy_pb2.ManyRequest5, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest5, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse5]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse5]: ... + + @abc.abstractmethod + def Method6( + self, + request: testproto.grpc.dummy_pb2.ManyRequest6, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest6, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse6]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse6]: ... + + @abc.abstractmethod + def Method7( + self, + request: testproto.grpc.dummy_pb2.ManyRequest7, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest7, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse7]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse7]: ... + + @abc.abstractmethod + def Method8( + self, + request: testproto.grpc.dummy_pb2.ManyRequest8, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest8, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse8]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse8]: ... + + @abc.abstractmethod + def Method9( + self, + request: testproto.grpc.dummy_pb2.ManyRequest9, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest9, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse9]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse9]: ... + + @abc.abstractmethod + def Method10( + self, + request: testproto.grpc.dummy_pb2.ManyRequest10, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest10, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse10]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse10]: ... + + @abc.abstractmethod + def Method11( + self, + request: testproto.grpc.dummy_pb2.ManyRequest11, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest11, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse11]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse11]: ... + + @abc.abstractmethod + def Method12( + self, + request: testproto.grpc.dummy_pb2.ManyRequest12, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest12, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse12]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse12]: ... + + @abc.abstractmethod + def Method13( + self, + request: testproto.grpc.dummy_pb2.ManyRequest13, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest13, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse13]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse13]: ... + + @abc.abstractmethod + def Method14( + self, + request: testproto.grpc.dummy_pb2.ManyRequest14, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest14, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse14]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse14]: ... + + @abc.abstractmethod + def Method15( + self, + request: testproto.grpc.dummy_pb2.ManyRequest15, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest15, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse15]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse15]: ... + + @abc.abstractmethod + def Method16( + self, + request: testproto.grpc.dummy_pb2.ManyRequest16, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest16, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse16]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse16]: ... + + @abc.abstractmethod + def Method17( + self, + request: testproto.grpc.dummy_pb2.ManyRequest17, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest17, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse17]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse17]: ... + + @abc.abstractmethod + def Method18( + self, + request: testproto.grpc.dummy_pb2.ManyRequest18, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest18, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse18]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse18]: ... + + @abc.abstractmethod + def Method19( + self, + request: testproto.grpc.dummy_pb2.ManyRequest19, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest19, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse19]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse19]: ... + + @abc.abstractmethod + def Method20( + self, + request: testproto.grpc.dummy_pb2.ManyRequest20, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest20, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse20]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse20]: ... + + @abc.abstractmethod + def Method21( + self, + request: testproto.grpc.dummy_pb2.ManyRequest21, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest21, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse21]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse21]: ... + + @abc.abstractmethod + def Method22( + self, + request: testproto.grpc.dummy_pb2.ManyRequest22, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest22, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse22]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse22]: ... + + @abc.abstractmethod + def Method23( + self, + request: testproto.grpc.dummy_pb2.ManyRequest23, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest23, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse23]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse23]: ... + + @abc.abstractmethod + def Method24( + self, + request: testproto.grpc.dummy_pb2.ManyRequest24, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest24, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse24]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse24]: ... + + @abc.abstractmethod + def Method25( + self, + request: testproto.grpc.dummy_pb2.ManyRequest25, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest25, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse25]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse25]: ... + + @abc.abstractmethod + def Method26( + self, + request: testproto.grpc.dummy_pb2.ManyRequest26, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest26, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse26]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse26]: ... + + @abc.abstractmethod + def Method27( + self, + request: testproto.grpc.dummy_pb2.ManyRequest27, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest27, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse27]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse27]: ... + + @abc.abstractmethod + def Method28( + self, + request: testproto.grpc.dummy_pb2.ManyRequest28, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest28, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse28]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse28]: ... + + @abc.abstractmethod + def Method29( + self, + request: testproto.grpc.dummy_pb2.ManyRequest29, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest29, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse29]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse29]: ... + + @abc.abstractmethod + def Method30( + self, + request: testproto.grpc.dummy_pb2.ManyRequest30, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest30, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse30]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse30]: ... + + @abc.abstractmethod + def Method31( + self, + request: testproto.grpc.dummy_pb2.ManyRequest31, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest31, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse31]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse31]: ... + + @abc.abstractmethod + def Method32( + self, + request: testproto.grpc.dummy_pb2.ManyRequest32, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest32, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse32]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse32]: ... + + @abc.abstractmethod + def Method33( + self, + request: testproto.grpc.dummy_pb2.ManyRequest33, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest33, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse33]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse33]: ... + + @abc.abstractmethod + def Method34( + self, + request: testproto.grpc.dummy_pb2.ManyRequest34, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest34, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse34]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse34]: ... + + @abc.abstractmethod + def Method35( + self, + request: testproto.grpc.dummy_pb2.ManyRequest35, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest35, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse35]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse35]: ... + + @abc.abstractmethod + def Method36( + self, + request: testproto.grpc.dummy_pb2.ManyRequest36, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest36, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse36]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse36]: ... + + @abc.abstractmethod + def Method37( + self, + request: testproto.grpc.dummy_pb2.ManyRequest37, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest37, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse37]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse37]: ... + + @abc.abstractmethod + def Method38( + self, + request: testproto.grpc.dummy_pb2.ManyRequest38, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest38, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse38]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse38]: ... + + @abc.abstractmethod + def Method39( + self, + request: testproto.grpc.dummy_pb2.ManyRequest39, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest39, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse39]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse39]: ... + + @abc.abstractmethod + def Method40( + self, + request: testproto.grpc.dummy_pb2.ManyRequest40, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest40, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse40]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse40]: ... + + @abc.abstractmethod + def Method41( + self, + request: testproto.grpc.dummy_pb2.ManyRequest41, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest41, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse41]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse41]: ... + + @abc.abstractmethod + def Method42( + self, + request: testproto.grpc.dummy_pb2.ManyRequest42, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest42, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse42]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse42]: ... + + @abc.abstractmethod + def Method43( + self, + request: testproto.grpc.dummy_pb2.ManyRequest43, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest43, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse43]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse43]: ... + + @abc.abstractmethod + def Method44( + self, + request: testproto.grpc.dummy_pb2.ManyRequest44, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest44, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse44]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse44]: ... + + @abc.abstractmethod + def Method45( + self, + request: testproto.grpc.dummy_pb2.ManyRequest45, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest45, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse45]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse45]: ... + + @abc.abstractmethod + def Method46( + self, + request: testproto.grpc.dummy_pb2.ManyRequest46, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest46, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse46]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse46]: ... + + @abc.abstractmethod + def Method47( + self, + request: testproto.grpc.dummy_pb2.ManyRequest47, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest47, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse47]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse47]: ... + + @abc.abstractmethod + def Method48( + self, + request: testproto.grpc.dummy_pb2.ManyRequest48, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest48, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse48]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse48]: ... + + @abc.abstractmethod + def Method49( + self, + request: testproto.grpc.dummy_pb2.ManyRequest49, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest49, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse49]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse49]: ... + + @abc.abstractmethod + def Method50( + self, + request: testproto.grpc.dummy_pb2.ManyRequest50, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest50, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse50]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse50]: ... + + @abc.abstractmethod + def Method51( + self, + request: testproto.grpc.dummy_pb2.ManyRequest51, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest51, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse51]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse51]: ... + + @abc.abstractmethod + def Method52( + self, + request: testproto.grpc.dummy_pb2.ManyRequest52, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest52, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse52]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse52]: ... + + @abc.abstractmethod + def Method53( + self, + request: testproto.grpc.dummy_pb2.ManyRequest53, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest53, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse53]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse53]: ... + + @abc.abstractmethod + def Method54( + self, + request: testproto.grpc.dummy_pb2.ManyRequest54, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest54, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse54]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse54]: ... + + @abc.abstractmethod + def Method55( + self, + request: testproto.grpc.dummy_pb2.ManyRequest55, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest55, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse55]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse55]: ... + + @abc.abstractmethod + def Method56( + self, + request: testproto.grpc.dummy_pb2.ManyRequest56, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest56, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse56]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse56]: ... + + @abc.abstractmethod + def Method57( + self, + request: testproto.grpc.dummy_pb2.ManyRequest57, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest57, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse57]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse57]: ... + + @abc.abstractmethod + def Method58( + self, + request: testproto.grpc.dummy_pb2.ManyRequest58, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest58, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse58]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse58]: ... + + @abc.abstractmethod + def Method59( + self, + request: testproto.grpc.dummy_pb2.ManyRequest59, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest59, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse59]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse59]: ... + + @abc.abstractmethod + def Method60( + self, + request: testproto.grpc.dummy_pb2.ManyRequest60, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest60, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse60]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse60]: ... + + @abc.abstractmethod + def Method61( + self, + request: testproto.grpc.dummy_pb2.ManyRequest61, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest61, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse61]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse61]: ... + + @abc.abstractmethod + def Method62( + self, + request: testproto.grpc.dummy_pb2.ManyRequest62, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest62, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse62]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse62]: ... + + @abc.abstractmethod + def Method63( + self, + request: testproto.grpc.dummy_pb2.ManyRequest63, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest63, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse63]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse63]: ... + + @abc.abstractmethod + def Method64( + self, + request: testproto.grpc.dummy_pb2.ManyRequest64, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest64, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse64]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse64]: ... + + @abc.abstractmethod + def Method65( + self, + request: testproto.grpc.dummy_pb2.ManyRequest65, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest65, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse65]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse65]: ... + + @abc.abstractmethod + def Method66( + self, + request: testproto.grpc.dummy_pb2.ManyRequest66, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest66, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse66]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse66]: ... + + @abc.abstractmethod + def Method67( + self, + request: testproto.grpc.dummy_pb2.ManyRequest67, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest67, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse67]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse67]: ... + + @abc.abstractmethod + def Method68( + self, + request: testproto.grpc.dummy_pb2.ManyRequest68, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest68, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse68]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse68]: ... + + @abc.abstractmethod + def Method69( + self, + request: testproto.grpc.dummy_pb2.ManyRequest69, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest69, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse69]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse69]: ... + + @abc.abstractmethod + def Method70( + self, + request: testproto.grpc.dummy_pb2.ManyRequest70, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest70, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse70]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse70]: ... + + @abc.abstractmethod + def Method71( + self, + request: testproto.grpc.dummy_pb2.ManyRequest71, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest71, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse71]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse71]: ... + + @abc.abstractmethod + def Method72( + self, + request: testproto.grpc.dummy_pb2.ManyRequest72, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest72, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse72]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse72]: ... + + @abc.abstractmethod + def Method73( + self, + request: testproto.grpc.dummy_pb2.ManyRequest73, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest73, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse73]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse73]: ... + + @abc.abstractmethod + def Method74( + self, + request: testproto.grpc.dummy_pb2.ManyRequest74, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest74, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse74]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse74]: ... + + @abc.abstractmethod + def Method75( + self, + request: testproto.grpc.dummy_pb2.ManyRequest75, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest75, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse75]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse75]: ... + + @abc.abstractmethod + def Method76( + self, + request: testproto.grpc.dummy_pb2.ManyRequest76, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest76, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse76]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse76]: ... + + @abc.abstractmethod + def Method77( + self, + request: testproto.grpc.dummy_pb2.ManyRequest77, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest77, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse77]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse77]: ... + + @abc.abstractmethod + def Method78( + self, + request: testproto.grpc.dummy_pb2.ManyRequest78, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest78, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse78]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse78]: ... + + @abc.abstractmethod + def Method79( + self, + request: testproto.grpc.dummy_pb2.ManyRequest79, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest79, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse79]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse79]: ... + + @abc.abstractmethod + def Method80( + self, + request: testproto.grpc.dummy_pb2.ManyRequest80, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest80, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse80]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse80]: ... + + @abc.abstractmethod + def Method81( + self, + request: testproto.grpc.dummy_pb2.ManyRequest81, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest81, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse81]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse81]: ... + + @abc.abstractmethod + def Method82( + self, + request: testproto.grpc.dummy_pb2.ManyRequest82, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest82, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse82]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse82]: ... + + @abc.abstractmethod + def Method83( + self, + request: testproto.grpc.dummy_pb2.ManyRequest83, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest83, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse83]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse83]: ... + + @abc.abstractmethod + def Method84( + self, + request: testproto.grpc.dummy_pb2.ManyRequest84, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest84, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse84]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse84]: ... + + @abc.abstractmethod + def Method85( + self, + request: testproto.grpc.dummy_pb2.ManyRequest85, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest85, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse85]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse85]: ... + + @abc.abstractmethod + def Method86( + self, + request: testproto.grpc.dummy_pb2.ManyRequest86, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest86, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse86]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse86]: ... + + @abc.abstractmethod + def Method87( + self, + request: testproto.grpc.dummy_pb2.ManyRequest87, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest87, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse87]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse87]: ... + + @abc.abstractmethod + def Method88( + self, + request: testproto.grpc.dummy_pb2.ManyRequest88, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest88, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse88]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse88]: ... + + @abc.abstractmethod + def Method89( + self, + request: testproto.grpc.dummy_pb2.ManyRequest89, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest89, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse89]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse89]: ... + + @abc.abstractmethod + def Method90( + self, + request: testproto.grpc.dummy_pb2.ManyRequest90, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest90, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse90]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse90]: ... + + @abc.abstractmethod + def Method91( + self, + request: testproto.grpc.dummy_pb2.ManyRequest91, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest91, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse91]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse91]: ... + + @abc.abstractmethod + def Method92( + self, + request: testproto.grpc.dummy_pb2.ManyRequest92, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest92, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse92]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse92]: ... + + @abc.abstractmethod + def Method93( + self, + request: testproto.grpc.dummy_pb2.ManyRequest93, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest93, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse93]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse93]: ... + + @abc.abstractmethod + def Method94( + self, + request: testproto.grpc.dummy_pb2.ManyRequest94, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest94, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse94]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse94]: ... + + @abc.abstractmethod + def Method95( + self, + request: testproto.grpc.dummy_pb2.ManyRequest95, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest95, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse95]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse95]: ... + + @abc.abstractmethod + def Method96( + self, + request: testproto.grpc.dummy_pb2.ManyRequest96, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest96, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse96]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse96]: ... + + @abc.abstractmethod + def Method97( + self, + request: testproto.grpc.dummy_pb2.ManyRequest97, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest97, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse97]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse97]: ... + + @abc.abstractmethod + def Method98( + self, + request: testproto.grpc.dummy_pb2.ManyRequest98, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest98, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse98]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse98]: ... + + @abc.abstractmethod + def Method99( + self, + request: testproto.grpc.dummy_pb2.ManyRequest99, + context: grpc.aio.ServicerContext[testproto.grpc.dummy_pb2.ManyRequest99, collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse99]], + ) -> collections.abc.Awaitable[testproto.grpc.dummy_pb2.ManyResponse99]: ... + +def add_ManyRPCsServiceServicer_to_server(servicer: ManyRPCsServiceServicer, server: grpc.aio.Server) -> None: ... + +class EmptyServiceStub: + def __init__(self, channel: grpc.aio.Channel) -> None: ... + +class EmptyServiceServicer(metaclass=abc.ABCMeta): + ... + +def add_EmptyServiceServicer_to_server(servicer: EmptyServiceServicer, server: grpc.aio.Server) -> None: ... diff --git a/test/generated_async_only/testproto/grpc/import_pb2.pyi b/test/generated_async_only/testproto/grpc/import_pb2.pyi new file mode 100644 index 00000000..dd854e28 --- /dev/null +++ b/test/generated_async_only/testproto/grpc/import_pb2.pyi @@ -0,0 +1,8 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import google.protobuf.descriptor + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor diff --git a/test/generated_async_only/testproto/grpc/import_pb2_grpc.pyi b/test/generated_async_only/testproto/grpc/import_pb2_grpc.pyi new file mode 100644 index 00000000..555ad7e6 --- /dev/null +++ b/test/generated_async_only/testproto/grpc/import_pb2_grpc.pyi @@ -0,0 +1,54 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import abc +import collections.abc +import google.protobuf.empty_pb2 +import grpc +import grpc.aio +import testproto.test_pb2 +import typing + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str + +class SimpleServiceStub: + """SimpleService""" + + def __init__(self, channel: grpc.aio.Channel) -> None: ... + UnaryUnary: grpc.aio.UnaryUnaryMultiCallable[google.protobuf.empty_pb2.Empty, testproto.test_pb2.Simple1] + """UnaryUnary""" + UnaryStream: grpc.aio.UnaryUnaryMultiCallable[testproto.test_pb2.Simple1, google.protobuf.empty_pb2.Empty] + """UnaryStream""" + NoComment: grpc.aio.UnaryUnaryMultiCallable[testproto.test_pb2.Simple1, google.protobuf.empty_pb2.Empty] + +class SimpleServiceServicer(metaclass=abc.ABCMeta): + """SimpleService""" + + @abc.abstractmethod + def UnaryUnary( + self, + request: google.protobuf.empty_pb2.Empty, + context: grpc.aio.ServicerContext[google.protobuf.empty_pb2.Empty, collections.abc.Awaitable[testproto.test_pb2.Simple1]], + ) -> collections.abc.Awaitable[testproto.test_pb2.Simple1]: + """UnaryUnary""" + + @abc.abstractmethod + def UnaryStream( + self, + request: testproto.test_pb2.Simple1, + context: grpc.aio.ServicerContext[testproto.test_pb2.Simple1, collections.abc.Awaitable[google.protobuf.empty_pb2.Empty]], + ) -> collections.abc.Awaitable[google.protobuf.empty_pb2.Empty]: + """UnaryStream""" + + @abc.abstractmethod + def NoComment( + self, + request: testproto.test_pb2.Simple1, + context: grpc.aio.ServicerContext[testproto.test_pb2.Simple1, collections.abc.Awaitable[google.protobuf.empty_pb2.Empty]], + ) -> collections.abc.Awaitable[google.protobuf.empty_pb2.Empty]: ... + +def add_SimpleServiceServicer_to_server(servicer: SimpleServiceServicer, server: grpc.aio.Server) -> None: ... diff --git a/test/generated_async_only/testproto/inner/__init__.py b/test/generated_async_only/testproto/inner/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/test/generated_async_only/testproto/inner/inner_pb2.pyi b/test/generated_async_only/testproto/inner/inner_pb2.pyi new file mode 100644 index 00000000..8a029c4e --- /dev/null +++ b/test/generated_async_only/testproto/inner/inner_pb2.pyi @@ -0,0 +1,34 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import builtins +import google.protobuf.descriptor +import google.protobuf.message +import sys +import testproto.test3_pb2 +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +@typing.final +class Inner(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + A_FIELD_NUMBER: builtins.int + a: testproto.test3_pb2.OuterEnum.ValueType + def __init__( + self, + *, + a: testproto.test3_pb2.OuterEnum.ValueType = ..., + ) -> None: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["a", b"a"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___Inner: typing_extensions.TypeAlias = Inner diff --git a/test/generated_async_only/testproto/inner/inner_pb2_grpc.pyi b/test/generated_async_only/testproto/inner/inner_pb2_grpc.pyi new file mode 100644 index 00000000..26b99930 --- /dev/null +++ b/test/generated_async_only/testproto/inner/inner_pb2_grpc.pyi @@ -0,0 +1,10 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import collections.abc + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str diff --git a/test/generated_async_only/testproto/nested/__init__.py b/test/generated_async_only/testproto/nested/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/test/generated_async_only/testproto/nested/nested_pb2.pyi b/test/generated_async_only/testproto/nested/nested_pb2.pyi new file mode 100644 index 00000000..ca263aee --- /dev/null +++ b/test/generated_async_only/testproto/nested/nested_pb2.pyi @@ -0,0 +1,98 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import builtins +import google.protobuf.descriptor +import google.protobuf.internal.enum_type_wrapper +import google.protobuf.message +import sys +import testproto.test3_pb2 +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +@typing.final +class Nested(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + A_FIELD_NUMBER: builtins.int + a: testproto.test3_pb2.OuterEnum.ValueType + def __init__( + self, + *, + a: testproto.test3_pb2.OuterEnum.ValueType = ..., + ) -> None: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["a", b"a"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___Nested: typing_extensions.TypeAlias = Nested + +@typing.final +class AnotherNested(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + class _NestedEnum: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + + class _NestedEnumEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[AnotherNested._NestedEnum.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + INVALID: AnotherNested._NestedEnum.ValueType # 0 + ONE: AnotherNested._NestedEnum.ValueType # 1 + TWO: AnotherNested._NestedEnum.ValueType # 2 + + class NestedEnum(_NestedEnum, metaclass=_NestedEnumEnumTypeWrapper): ... + INVALID: AnotherNested.NestedEnum.ValueType # 0 + ONE: AnotherNested.NestedEnum.ValueType # 1 + TWO: AnotherNested.NestedEnum.ValueType # 2 + + @typing.final + class NestedMessage(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + class _NestedEnum2: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + + class _NestedEnum2EnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[AnotherNested.NestedMessage._NestedEnum2.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + UNDEFINED: AnotherNested.NestedMessage._NestedEnum2.ValueType # 0 + NESTED_ENUM1: AnotherNested.NestedMessage._NestedEnum2.ValueType # 1 + NESTED_ENUM2: AnotherNested.NestedMessage._NestedEnum2.ValueType # 2 + + class NestedEnum2(_NestedEnum2, metaclass=_NestedEnum2EnumTypeWrapper): ... + UNDEFINED: AnotherNested.NestedMessage.NestedEnum2.ValueType # 0 + NESTED_ENUM1: AnotherNested.NestedMessage.NestedEnum2.ValueType # 1 + NESTED_ENUM2: AnotherNested.NestedMessage.NestedEnum2.ValueType # 2 + + S_FIELD_NUMBER: builtins.int + B_FIELD_NUMBER: builtins.int + NE_FIELD_NUMBER: builtins.int + NE2_FIELD_NUMBER: builtins.int + s: builtins.str + b: builtins.bool + ne: Global___AnotherNested.NestedEnum.ValueType + ne2: Global___AnotherNested.NestedMessage.NestedEnum2.ValueType + def __init__( + self, + *, + s: builtins.str = ..., + b: builtins.bool = ..., + ne: Global___AnotherNested.NestedEnum.ValueType = ..., + ne2: Global___AnotherNested.NestedMessage.NestedEnum2.ValueType = ..., + ) -> None: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["b", b"b", "ne", b"ne", "ne2", b"ne2", "s", b"s"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + + def __init__( + self, + ) -> None: ... + +Global___AnotherNested: typing_extensions.TypeAlias = AnotherNested diff --git a/test/generated_async_only/testproto/nested/nested_pb2_grpc.pyi b/test/generated_async_only/testproto/nested/nested_pb2_grpc.pyi new file mode 100644 index 00000000..26b99930 --- /dev/null +++ b/test/generated_async_only/testproto/nested/nested_pb2_grpc.pyi @@ -0,0 +1,10 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import collections.abc + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str diff --git a/test/generated_async_only/testproto/nopackage_pb2.pyi b/test/generated_async_only/testproto/nopackage_pb2.pyi new file mode 100644 index 00000000..f4455c17 --- /dev/null +++ b/test/generated_async_only/testproto/nopackage_pb2.pyi @@ -0,0 +1,54 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import builtins +import collections.abc +import google.protobuf.descriptor +import google.protobuf.internal.containers +import google.protobuf.message +import sys +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +@typing.final +class NoPackage(google.protobuf.message.Message): + """Intentionally don't set a package - just to make sure we can handle it.""" + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___NoPackage: typing_extensions.TypeAlias = NoPackage + +@typing.final +class NoPackage2(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + NP_FIELD_NUMBER: builtins.int + NP_REP_FIELD_NUMBER: builtins.int + @property + def np(self) -> Global___NoPackage: ... + @property + def np_rep(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[Global___NoPackage]: ... + def __init__( + self, + *, + np: Global___NoPackage | None = ..., + np_rep: collections.abc.Iterable[Global___NoPackage] | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["np", b"np"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["np", b"np", "np_rep", b"np_rep"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___NoPackage2: typing_extensions.TypeAlias = NoPackage2 diff --git a/test/generated_async_only/testproto/nopackage_pb2_grpc.pyi b/test/generated_async_only/testproto/nopackage_pb2_grpc.pyi new file mode 100644 index 00000000..26b99930 --- /dev/null +++ b/test/generated_async_only/testproto/nopackage_pb2_grpc.pyi @@ -0,0 +1,10 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import collections.abc + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str diff --git a/test/generated_async_only/testproto/readme_enum_pb2.pyi b/test/generated_async_only/testproto/readme_enum_pb2.pyi new file mode 100644 index 00000000..be8369c4 --- /dev/null +++ b/test/generated_async_only/testproto/readme_enum_pb2.pyi @@ -0,0 +1,32 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import builtins +import google.protobuf.descriptor +import google.protobuf.internal.enum_type_wrapper +import sys +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +class _MyEnum: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _MyEnumEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_MyEnum.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + HELLO: _MyEnum.ValueType # 0 + WORLD: _MyEnum.ValueType # 1 + +class MyEnum(_MyEnum, metaclass=_MyEnumEnumTypeWrapper): ... + +HELLO: MyEnum.ValueType # 0 +WORLD: MyEnum.ValueType # 1 +Global___MyEnum: typing_extensions.TypeAlias = MyEnum diff --git a/test/generated_async_only/testproto/readme_enum_pb2_grpc.pyi b/test/generated_async_only/testproto/readme_enum_pb2_grpc.pyi new file mode 100644 index 00000000..26b99930 --- /dev/null +++ b/test/generated_async_only/testproto/readme_enum_pb2_grpc.pyi @@ -0,0 +1,10 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import collections.abc + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str diff --git a/test/generated_async_only/testproto/reexport_pb2.pyi b/test/generated_async_only/testproto/reexport_pb2.pyi new file mode 100644 index 00000000..9702c2bd --- /dev/null +++ b/test/generated_async_only/testproto/reexport_pb2.pyi @@ -0,0 +1,19 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import google.protobuf.descriptor +from google.protobuf.empty_pb2 import ( + Empty as Empty, +) +from testproto.test3_pb2 import ( + BAR3 as BAR3, + FOO3 as FOO3, + OuterEnum as OuterEnum, + OuterMessage3 as OuterMessage3, + SimpleProto3 as SimpleProto3, + UNKNOWN as UNKNOWN, +) + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor diff --git a/test/generated_async_only/testproto/reexport_pb2_grpc.pyi b/test/generated_async_only/testproto/reexport_pb2_grpc.pyi new file mode 100644 index 00000000..9c28bd7a --- /dev/null +++ b/test/generated_async_only/testproto/reexport_pb2_grpc.pyi @@ -0,0 +1,21 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import collections.abc +from google.protobuf.empty_pb2 import ( + Empty as Empty, +) +from testproto.test3_pb2 import ( + BAR3 as BAR3, + FOO3 as FOO3, + OuterEnum as OuterEnum, + OuterMessage3 as OuterMessage3, + SimpleProto3 as SimpleProto3, + UNKNOWN as UNKNOWN, +) + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str diff --git a/test/generated_async_only/testproto/test3_pb2.pyi b/test/generated_async_only/testproto/test3_pb2.pyi new file mode 100644 index 00000000..ca2421ab --- /dev/null +++ b/test/generated_async_only/testproto/test3_pb2.pyi @@ -0,0 +1,222 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +package test3""" + +import builtins +import collections.abc +import google.protobuf.descriptor +import google.protobuf.internal.containers +import google.protobuf.internal.enum_type_wrapper +import google.protobuf.message +import sys +import test.test_generated_mypy +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +class _OuterEnum: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _OuterEnumEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_OuterEnum.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + UNKNOWN: _OuterEnum.ValueType # 0 + FOO3: _OuterEnum.ValueType # 1 + BAR3: _OuterEnum.ValueType # 2 + +class OuterEnum(_OuterEnum, metaclass=_OuterEnumEnumTypeWrapper): ... + +UNKNOWN: OuterEnum.ValueType # 0 +FOO3: OuterEnum.ValueType # 1 +BAR3: OuterEnum.ValueType # 2 +Global___OuterEnum: typing_extensions.TypeAlias = OuterEnum + +@typing.final +class OuterMessage3(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + A_STRING_FIELD_NUMBER: builtins.int + a_string: builtins.str + def __init__( + self, + *, + a_string: builtins.str = ..., + ) -> None: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["a_string", b"a_string"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___OuterMessage3: typing_extensions.TypeAlias = OuterMessage3 + +@typing.final +class SimpleProto3(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + class _InnerEnum: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + + class _InnerEnumEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[SimpleProto3._InnerEnum.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + INNER1: SimpleProto3._InnerEnum.ValueType # 0 + INNER2: SimpleProto3._InnerEnum.ValueType # 1 + + class InnerEnum(_InnerEnum, metaclass=_InnerEnumEnumTypeWrapper): ... + INNER1: SimpleProto3.InnerEnum.ValueType # 0 + INNER2: SimpleProto3.InnerEnum.ValueType # 1 + + @typing.final + class MapScalarEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.int + value: builtins.str + def __init__( + self, + *, + key: builtins.int = ..., + value: builtins.str = ..., + ) -> None: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["key", b"key", "value", b"value"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + + @typing.final + class MapMessageEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.int + @property + def value(self) -> Global___OuterMessage3: ... + def __init__( + self, + *, + key: builtins.int = ..., + value: Global___OuterMessage3 | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["value", b"value"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["key", b"key", "value", b"value"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + + @typing.final + class EmailByUidEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.int + value: builtins.str + def __init__( + self, + *, + key: builtins.int = ..., + value: builtins.str = ..., + ) -> None: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["key", b"key", "value", b"value"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + + A_STRING_FIELD_NUMBER: builtins.int + A_REPEATED_STRING_FIELD_NUMBER: builtins.int + A_OUTER_ENUM_FIELD_NUMBER: builtins.int + OUTER_MESSAGE_FIELD_NUMBER: builtins.int + INNER_ENUM_FIELD_NUMBER: builtins.int + A_ONEOF_1_FIELD_NUMBER: builtins.int + A_ONEOF_2_FIELD_NUMBER: builtins.int + OUTER_MESSAGE_IN_ONEOF_FIELD_NUMBER: builtins.int + OUTER_ENUM_IN_ONEOF_FIELD_NUMBER: builtins.int + INNER_ENUM_IN_ONEOF_FIELD_NUMBER: builtins.int + B_ONEOF_1_FIELD_NUMBER: builtins.int + B_ONEOF_2_FIELD_NUMBER: builtins.int + BOOL_FIELD_NUMBER: builtins.int + OUTERENUM_FIELD_NUMBER: builtins.int + OUTERMESSAGE3_FIELD_NUMBER: builtins.int + MAP_SCALAR_FIELD_NUMBER: builtins.int + MAP_MESSAGE_FIELD_NUMBER: builtins.int + AN_OPTIONAL_STRING_FIELD_NUMBER: builtins.int + USER_ID_FIELD_NUMBER: builtins.int + EMAIL_FIELD_NUMBER: builtins.int + EMAIL_BY_UID_FIELD_NUMBER: builtins.int + a_string: builtins.str + a_outer_enum: Global___OuterEnum.ValueType + inner_enum: Global___SimpleProto3.InnerEnum.ValueType + a_oneof_1: builtins.str + a_oneof_2: builtins.str + outer_enum_in_oneof: Global___OuterEnum.ValueType + inner_enum_in_oneof: Global___SimpleProto3.InnerEnum.ValueType + b_oneof_1: builtins.str + b_oneof_2: builtins.str + OuterEnum: Global___OuterEnum.ValueType + """Test having fieldname match messagename""" + an_optional_string: builtins.str + user_id: test.test_generated_mypy.UserId + email: test.test_generated_mypy.Email + @property + def a_repeated_string(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]: ... + @property + def outer_message(self) -> Global___OuterMessage3: ... + @property + def outer_message_in_oneof(self) -> Global___OuterMessage3: ... + @property + def bool(self) -> Global___OuterMessage3: ... + @property + def OuterMessage3(self) -> Global___OuterMessage3: ... + @property + def map_scalar(self) -> google.protobuf.internal.containers.ScalarMap[builtins.int, builtins.str]: + """Test generation of map""" + + @property + def map_message(self) -> google.protobuf.internal.containers.MessageMap[builtins.int, Global___OuterMessage3]: ... + @property + def email_by_uid(self) -> google.protobuf.internal.containers.ScalarMap[test.test_generated_mypy.UserId, test.test_generated_mypy.Email]: ... + def __init__( + self, + *, + a_string: builtins.str = ..., + a_repeated_string: collections.abc.Iterable[builtins.str] | None = ..., + a_outer_enum: Global___OuterEnum.ValueType = ..., + outer_message: Global___OuterMessage3 | None = ..., + inner_enum: Global___SimpleProto3.InnerEnum.ValueType = ..., + a_oneof_1: builtins.str = ..., + a_oneof_2: builtins.str = ..., + outer_message_in_oneof: Global___OuterMessage3 | None = ..., + outer_enum_in_oneof: Global___OuterEnum.ValueType = ..., + inner_enum_in_oneof: Global___SimpleProto3.InnerEnum.ValueType = ..., + b_oneof_1: builtins.str = ..., + b_oneof_2: builtins.str = ..., + bool: Global___OuterMessage3 | None = ..., + OuterEnum: Global___OuterEnum.ValueType = ..., + OuterMessage3: Global___OuterMessage3 | None = ..., + map_scalar: collections.abc.Mapping[builtins.int, builtins.str] | None = ..., + map_message: collections.abc.Mapping[builtins.int, Global___OuterMessage3] | None = ..., + an_optional_string: builtins.str | None = ..., + user_id: test.test_generated_mypy.UserId = ..., + email: test.test_generated_mypy.Email = ..., + email_by_uid: collections.abc.Mapping[test.test_generated_mypy.UserId, test.test_generated_mypy.Email] | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["OuterMessage3", b"OuterMessage3", "_an_optional_string", b"_an_optional_string", "a_oneof", b"a_oneof", "a_oneof_1", b"a_oneof_1", "a_oneof_2", b"a_oneof_2", "an_optional_string", b"an_optional_string", "b_oneof", b"b_oneof", "b_oneof_1", b"b_oneof_1", "b_oneof_2", b"b_oneof_2", "bool", b"bool", "inner_enum_in_oneof", b"inner_enum_in_oneof", "outer_enum_in_oneof", b"outer_enum_in_oneof", "outer_message", b"outer_message", "outer_message_in_oneof", b"outer_message_in_oneof"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["OuterEnum", b"OuterEnum", "OuterMessage3", b"OuterMessage3", "_an_optional_string", b"_an_optional_string", "a_oneof", b"a_oneof", "a_oneof_1", b"a_oneof_1", "a_oneof_2", b"a_oneof_2", "a_outer_enum", b"a_outer_enum", "a_repeated_string", b"a_repeated_string", "a_string", b"a_string", "an_optional_string", b"an_optional_string", "b_oneof", b"b_oneof", "b_oneof_1", b"b_oneof_1", "b_oneof_2", b"b_oneof_2", "bool", b"bool", "email", b"email", "email_by_uid", b"email_by_uid", "inner_enum", b"inner_enum", "inner_enum_in_oneof", b"inner_enum_in_oneof", "map_message", b"map_message", "map_scalar", b"map_scalar", "outer_enum_in_oneof", b"outer_enum_in_oneof", "outer_message", b"outer_message", "outer_message_in_oneof", b"outer_message_in_oneof", "user_id", b"user_id"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + _WhichOneofReturnType__an_optional_string: typing_extensions.TypeAlias = typing.Literal["an_optional_string"] + _WhichOneofArgType__an_optional_string: typing_extensions.TypeAlias = typing.Literal["_an_optional_string", b"_an_optional_string"] + _WhichOneofReturnType_a_oneof: typing_extensions.TypeAlias = typing.Literal["a_oneof_1", "a_oneof_2", "outer_message_in_oneof", "outer_enum_in_oneof", "inner_enum_in_oneof"] + _WhichOneofArgType_a_oneof: typing_extensions.TypeAlias = typing.Literal["a_oneof", b"a_oneof"] + _WhichOneofReturnType_b_oneof: typing_extensions.TypeAlias = typing.Literal["b_oneof_1", "b_oneof_2"] + _WhichOneofArgType_b_oneof: typing_extensions.TypeAlias = typing.Literal["b_oneof", b"b_oneof"] + @typing.overload + def WhichOneof(self, oneof_group: _WhichOneofArgType__an_optional_string) -> _WhichOneofReturnType__an_optional_string | None: ... + @typing.overload + def WhichOneof(self, oneof_group: _WhichOneofArgType_a_oneof) -> _WhichOneofReturnType_a_oneof | None: ... + @typing.overload + def WhichOneof(self, oneof_group: _WhichOneofArgType_b_oneof) -> _WhichOneofReturnType_b_oneof | None: ... + +Global___SimpleProto3: typing_extensions.TypeAlias = SimpleProto3 diff --git a/test/generated_async_only/testproto/test3_pb2_grpc.pyi b/test/generated_async_only/testproto/test3_pb2_grpc.pyi new file mode 100644 index 00000000..18b6fcb4 --- /dev/null +++ b/test/generated_async_only/testproto/test3_pb2_grpc.pyi @@ -0,0 +1,10 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +package test3""" + +import collections.abc + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str diff --git a/test/generated_async_only/testproto/test_extensions2_pb2.pyi b/test/generated_async_only/testproto/test_extensions2_pb2.pyi new file mode 100644 index 00000000..f36b2068 --- /dev/null +++ b/test/generated_async_only/testproto/test_extensions2_pb2.pyi @@ -0,0 +1,39 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import builtins +import google.protobuf.descriptor +import google.protobuf.internal.extension_dict +import google.protobuf.message +import sys +import testproto.test_pb2 +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +@typing.final +class SeparateFileExtension(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + FLAG_FIELD_NUMBER: builtins.int + flag: builtins.bool + EXT_FIELD_NUMBER: builtins.int + ext: google.protobuf.internal.extension_dict._ExtensionFieldDescriptor[testproto.test_pb2.Simple2, Global___SeparateFileExtension] + def __init__( + self, + *, + flag: builtins.bool | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["flag", b"flag"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["flag", b"flag"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___SeparateFileExtension: typing_extensions.TypeAlias = SeparateFileExtension diff --git a/test/generated_async_only/testproto/test_extensions2_pb2_grpc.pyi b/test/generated_async_only/testproto/test_extensions2_pb2_grpc.pyi new file mode 100644 index 00000000..26b99930 --- /dev/null +++ b/test/generated_async_only/testproto/test_extensions2_pb2_grpc.pyi @@ -0,0 +1,10 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import collections.abc + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str diff --git a/test/generated_async_only/testproto/test_extensions3_pb2.pyi b/test/generated_async_only/testproto/test_extensions3_pb2.pyi new file mode 100644 index 00000000..f2292855 --- /dev/null +++ b/test/generated_async_only/testproto/test_extensions3_pb2.pyi @@ -0,0 +1,46 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import builtins +import google.protobuf.descriptor +import google.protobuf.descriptor_pb2 +import google.protobuf.internal.containers +import google.protobuf.internal.extension_dict +import google.protobuf.message +import sys +import testproto.test3_pb2 +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +@typing.final +class MessageOptionsTestMsg(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___MessageOptionsTestMsg: typing_extensions.TypeAlias = MessageOptionsTestMsg + +TEST_FIELD_EXTENSION_FIELD_NUMBER: builtins.int +SCALAR_OPTION_FIELD_NUMBER: builtins.int +REPEATED_SCALAR_OPTION_FIELD_NUMBER: builtins.int +ENUM_OPTION_FIELD_NUMBER: builtins.int +REPEATED_ENUM_OPTION_FIELD_NUMBER: builtins.int +MSG_OPTION_FIELD_NUMBER: builtins.int +REPEATED_MSG_OPTION_FIELD_NUMBER: builtins.int +test_field_extension: google.protobuf.internal.extension_dict._ExtensionFieldDescriptor[google.protobuf.descriptor_pb2.FieldOptions, builtins.str] +scalar_option: google.protobuf.internal.extension_dict._ExtensionFieldDescriptor[google.protobuf.descriptor_pb2.MessageOptions, builtins.str] +repeated_scalar_option: google.protobuf.internal.extension_dict._ExtensionFieldDescriptor[google.protobuf.descriptor_pb2.MessageOptions, google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]] +enum_option: google.protobuf.internal.extension_dict._ExtensionFieldDescriptor[google.protobuf.descriptor_pb2.MessageOptions, testproto.test3_pb2.OuterEnum.ValueType] +repeated_enum_option: google.protobuf.internal.extension_dict._ExtensionFieldDescriptor[google.protobuf.descriptor_pb2.MessageOptions, google.protobuf.internal.containers.RepeatedScalarFieldContainer[testproto.test3_pb2.OuterEnum.ValueType]] +msg_option: google.protobuf.internal.extension_dict._ExtensionFieldDescriptor[google.protobuf.descriptor_pb2.MessageOptions, testproto.test3_pb2.OuterMessage3] +repeated_msg_option: google.protobuf.internal.extension_dict._ExtensionFieldDescriptor[google.protobuf.descriptor_pb2.MessageOptions, google.protobuf.internal.containers.RepeatedCompositeFieldContainer[testproto.test3_pb2.OuterMessage3]] diff --git a/test/generated_async_only/testproto/test_extensions3_pb2_grpc.pyi b/test/generated_async_only/testproto/test_extensions3_pb2_grpc.pyi new file mode 100644 index 00000000..26b99930 --- /dev/null +++ b/test/generated_async_only/testproto/test_extensions3_pb2_grpc.pyi @@ -0,0 +1,10 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import collections.abc + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str diff --git a/test/generated_async_only/testproto/test_no_generic_services_pb2.pyi b/test/generated_async_only/testproto/test_no_generic_services_pb2.pyi new file mode 100644 index 00000000..04cf9c56 --- /dev/null +++ b/test/generated_async_only/testproto/test_no_generic_services_pb2.pyi @@ -0,0 +1,35 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import builtins +import google.protobuf.descriptor +import google.protobuf.message +import sys +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +@typing.final +class Simple3(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + A_STRING_FIELD_NUMBER: builtins.int + a_string: builtins.str + def __init__( + self, + *, + a_string: builtins.str | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["a_string", b"a_string"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["a_string", b"a_string"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___Simple3: typing_extensions.TypeAlias = Simple3 diff --git a/test/generated_async_only/testproto/test_no_generic_services_pb2_grpc.pyi b/test/generated_async_only/testproto/test_no_generic_services_pb2_grpc.pyi new file mode 100644 index 00000000..99a6ca66 --- /dev/null +++ b/test/generated_async_only/testproto/test_no_generic_services_pb2_grpc.pyi @@ -0,0 +1,29 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import abc +import collections.abc +import grpc +import grpc.aio +import testproto.test_no_generic_services_pb2 +import typing + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str + +class ATestService2Stub: + def __init__(self, channel: grpc.aio.Channel) -> None: ... + Echo: grpc.aio.UnaryUnaryMultiCallable[testproto.test_no_generic_services_pb2.Simple3, testproto.test_no_generic_services_pb2.Simple3] + +class ATestService2Servicer(metaclass=abc.ABCMeta): + @abc.abstractmethod + def Echo( + self, + request: testproto.test_no_generic_services_pb2.Simple3, + context: grpc.aio.ServicerContext[testproto.test_no_generic_services_pb2.Simple3, collections.abc.Awaitable[testproto.test_no_generic_services_pb2.Simple3]], + ) -> collections.abc.Awaitable[testproto.test_no_generic_services_pb2.Simple3]: ... + +def add_ATestService2Servicer_to_server(servicer: ATestService2Servicer, server: grpc.aio.Server) -> None: ... diff --git a/test/generated_async_only/testproto/test_pb2.pyi b/test/generated_async_only/testproto/test_pb2.pyi new file mode 100644 index 00000000..94e646db --- /dev/null +++ b/test/generated_async_only/testproto/test_pb2.pyi @@ -0,0 +1,465 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +Proto 2 test file.""" + +import builtins +import collections.abc +import google.protobuf.descriptor +import google.protobuf.internal.containers +import google.protobuf.internal.enum_type_wrapper +import google.protobuf.internal.extension_dict +import google.protobuf.message +import sys +import test.test_generated_mypy +import testproto.inner.inner_pb2 +import testproto.nested.nested_pb2 +import testproto.nopackage_pb2 +import testproto.test3_pb2 +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +if sys.version_info >= (3, 13): + from warnings import deprecated +else: + from typing_extensions import deprecated + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +class _OuterEnum: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _OuterEnumEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_OuterEnum.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + FOO: _OuterEnum.ValueType # 1 + """FOO""" + BAR: _OuterEnum.ValueType # 2 + """BAR""" + +class OuterEnum(_OuterEnum, metaclass=_OuterEnumEnumTypeWrapper): + """Outer Enum""" + +FOO: OuterEnum.ValueType # 1 +"""FOO""" +BAR: OuterEnum.ValueType # 2 +"""BAR""" +Global___OuterEnum: typing_extensions.TypeAlias = OuterEnum + +class _NamingConflicts: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _NamingConflictsEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_NamingConflicts.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + +class NamingConflicts(_NamingConflicts, metaclass=_NamingConflictsEnumTypeWrapper): + """Naming conflicts!""" + +Name: NamingConflicts.ValueType # 1 +Value: NamingConflicts.ValueType # 2 +keys: NamingConflicts.ValueType # 3 +values: NamingConflicts.ValueType # 4 +items: NamingConflicts.ValueType # 5 +"""See https://github.com/protocolbuffers/protobuf/issues/8803 +proto itself generates broken code when DESCRIPTOR is there +DESCRIPTOR = 8; +""" +Global___NamingConflicts: typing_extensions.TypeAlias = NamingConflicts + +class _DeprecatedEnum: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _DeprecatedEnumEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_DeprecatedEnum.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + DEPRECATED_ONE: _DeprecatedEnum.ValueType # 1 + DEPRECATED_TWO: _DeprecatedEnum.ValueType # 2 + +@deprecated("""This enum is deprecated\n2 lines of comments\n"Quotes in comments"\nand 'single quotes'\nTrailing comment""") +class DeprecatedEnum(_DeprecatedEnum, metaclass=_DeprecatedEnumEnumTypeWrapper): ... + +DEPRECATED_ONE: DeprecatedEnum.ValueType # 1 +DEPRECATED_TWO: DeprecatedEnum.ValueType # 2 +Global___DeprecatedEnum: typing_extensions.TypeAlias = DeprecatedEnum + +@typing.final +class Simple1(google.protobuf.message.Message): + """Message with one of everything""" + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + class _InnerEnum: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + + class _InnerEnumEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[Simple1._InnerEnum.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + INNER1: Simple1._InnerEnum.ValueType # 1 + """INNER1""" + INNER2: Simple1._InnerEnum.ValueType # 2 + """INNER2""" + + class InnerEnum(_InnerEnum, metaclass=_InnerEnumEnumTypeWrapper): + """Inner Enum""" + + INNER1: Simple1.InnerEnum.ValueType # 1 + """INNER1""" + INNER2: Simple1.InnerEnum.ValueType # 2 + """INNER2""" + + @typing.final + class InnerMessage(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + + @typing.final + class EmailByUidEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.int + value: builtins.str + def __init__( + self, + *, + key: builtins.int | None = ..., + value: builtins.str | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["key", b"key", "value", b"value"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["key", b"key", "value", b"value"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + + A_STRING_FIELD_NUMBER: builtins.int + A_REPEATED_STRING_FIELD_NUMBER: builtins.int + A_BOOLEAN_FIELD_NUMBER: builtins.int + A_UINT32_FIELD_NUMBER: builtins.int + A_ENUM_FIELD_NUMBER: builtins.int + A_EXTERNAL_ENUM_FIELD_NUMBER: builtins.int + A_INNER_FIELD_NUMBER: builtins.int + A_NESTED_FIELD_NUMBER: builtins.int + INNER_ENUM_FIELD_NUMBER: builtins.int + REP_INNER_ENUM_FIELD_NUMBER: builtins.int + INNER_MESSAGE_FIELD_NUMBER: builtins.int + REP_INNER_MESSAGE_FIELD_NUMBER: builtins.int + NO_PACKAGE_FIELD_NUMBER: builtins.int + NESTED_ENUM_FIELD_NUMBER: builtins.int + NESTED_MESSAGE_FIELD_NUMBER: builtins.int + A_ONEOF_1_FIELD_NUMBER: builtins.int + A_ONEOF_2_FIELD_NUMBER: builtins.int + OUTER_MESSAGE_IN_ONEOF_FIELD_NUMBER: builtins.int + OUTER_ENUM_IN_ONEOF_FIELD_NUMBER: builtins.int + INNER_ENUM_IN_ONEOF_FIELD_NUMBER: builtins.int + USER_ID_FIELD_NUMBER: builtins.int + EMAIL_FIELD_NUMBER: builtins.int + EMAIL_BY_UID_FIELD_NUMBER: builtins.int + a_string: builtins.str + a_boolean: builtins.bool + a_uint32: builtins.int + a_enum: Global___OuterEnum.ValueType + a_external_enum: testproto.test3_pb2.OuterEnum.ValueType + inner_enum: Global___Simple1.InnerEnum.ValueType + nested_enum: testproto.nested.nested_pb2.AnotherNested.NestedEnum.ValueType + a_oneof_1: builtins.str + a_oneof_2: builtins.str + outer_enum_in_oneof: Global___OuterEnum.ValueType + inner_enum_in_oneof: Global___Simple1.InnerEnum.ValueType + user_id: test.test_generated_mypy.UserId + email: test.test_generated_mypy.Email + @property + def a_repeated_string(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]: ... + @property + def a_inner(self) -> testproto.inner.inner_pb2.Inner: ... + @property + def a_nested(self) -> testproto.nested.nested_pb2.Nested: ... + @property + def rep_inner_enum(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[Global___Simple1.InnerEnum.ValueType]: ... + @property + def inner_message(self) -> Global___Simple1.InnerMessage: ... + @property + def rep_inner_message(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[Global___Simple1.InnerMessage]: ... + @property + def no_package(self) -> testproto.nopackage_pb2.NoPackage: ... + @property + def nested_message(self) -> testproto.nested.nested_pb2.AnotherNested.NestedMessage: ... + @property + def outer_message_in_oneof(self) -> Global___Simple2: ... + @property + def email_by_uid(self) -> google.protobuf.internal.containers.ScalarMap[test.test_generated_mypy.UserId, test.test_generated_mypy.Email]: ... + def __init__( + self, + *, + a_string: builtins.str | None = ..., + a_repeated_string: collections.abc.Iterable[builtins.str] | None = ..., + a_boolean: builtins.bool | None = ..., + a_uint32: builtins.int | None = ..., + a_enum: Global___OuterEnum.ValueType | None = ..., + a_external_enum: testproto.test3_pb2.OuterEnum.ValueType | None = ..., + a_inner: testproto.inner.inner_pb2.Inner | None = ..., + a_nested: testproto.nested.nested_pb2.Nested | None = ..., + inner_enum: Global___Simple1.InnerEnum.ValueType | None = ..., + rep_inner_enum: collections.abc.Iterable[Global___Simple1.InnerEnum.ValueType] | None = ..., + inner_message: Global___Simple1.InnerMessage | None = ..., + rep_inner_message: collections.abc.Iterable[Global___Simple1.InnerMessage] | None = ..., + no_package: testproto.nopackage_pb2.NoPackage | None = ..., + nested_enum: testproto.nested.nested_pb2.AnotherNested.NestedEnum.ValueType | None = ..., + nested_message: testproto.nested.nested_pb2.AnotherNested.NestedMessage | None = ..., + a_oneof_1: builtins.str | None = ..., + a_oneof_2: builtins.str | None = ..., + outer_message_in_oneof: Global___Simple2 | None = ..., + outer_enum_in_oneof: Global___OuterEnum.ValueType | None = ..., + inner_enum_in_oneof: Global___Simple1.InnerEnum.ValueType | None = ..., + user_id: test.test_generated_mypy.UserId | None = ..., + email: test.test_generated_mypy.Email | None = ..., + email_by_uid: collections.abc.Mapping[test.test_generated_mypy.UserId, test.test_generated_mypy.Email] | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["a_boolean", b"a_boolean", "a_enum", b"a_enum", "a_external_enum", b"a_external_enum", "a_inner", b"a_inner", "a_nested", b"a_nested", "a_oneof", b"a_oneof", "a_oneof_1", b"a_oneof_1", "a_oneof_2", b"a_oneof_2", "a_string", b"a_string", "a_uint32", b"a_uint32", "email", b"email", "inner_enum", b"inner_enum", "inner_enum_in_oneof", b"inner_enum_in_oneof", "inner_message", b"inner_message", "nested_enum", b"nested_enum", "nested_message", b"nested_message", "no_package", b"no_package", "outer_enum_in_oneof", b"outer_enum_in_oneof", "outer_message_in_oneof", b"outer_message_in_oneof", "user_id", b"user_id"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["a_boolean", b"a_boolean", "a_enum", b"a_enum", "a_external_enum", b"a_external_enum", "a_inner", b"a_inner", "a_nested", b"a_nested", "a_oneof", b"a_oneof", "a_oneof_1", b"a_oneof_1", "a_oneof_2", b"a_oneof_2", "a_repeated_string", b"a_repeated_string", "a_string", b"a_string", "a_uint32", b"a_uint32", "email", b"email", "email_by_uid", b"email_by_uid", "inner_enum", b"inner_enum", "inner_enum_in_oneof", b"inner_enum_in_oneof", "inner_message", b"inner_message", "nested_enum", b"nested_enum", "nested_message", b"nested_message", "no_package", b"no_package", "outer_enum_in_oneof", b"outer_enum_in_oneof", "outer_message_in_oneof", b"outer_message_in_oneof", "rep_inner_enum", b"rep_inner_enum", "rep_inner_message", b"rep_inner_message", "user_id", b"user_id"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + _WhichOneofReturnType_a_oneof: typing_extensions.TypeAlias = typing.Literal["a_oneof_1", "a_oneof_2", "outer_message_in_oneof", "outer_enum_in_oneof", "inner_enum_in_oneof"] + _WhichOneofArgType_a_oneof: typing_extensions.TypeAlias = typing.Literal["a_oneof", b"a_oneof"] + def WhichOneof(self, oneof_group: _WhichOneofArgType_a_oneof) -> _WhichOneofReturnType_a_oneof | None: ... + +Global___Simple1: typing_extensions.TypeAlias = Simple1 + +@typing.final +class Simple2(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + A_STRING_FIELD_NUMBER: builtins.int + a_string: builtins.str + def __init__( + self, + *, + a_string: builtins.str | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["a_string", b"a_string"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["a_string", b"a_string"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___Simple2: typing_extensions.TypeAlias = Simple2 + +@typing.final +class Extensions1(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + EXT1_STRING_FIELD_NUMBER: builtins.int + ext1_string: builtins.str + EXT_FIELD_NUMBER: builtins.int + ext: google.protobuf.internal.extension_dict._ExtensionFieldDescriptor[Global___Simple1, Global___Extensions1] + """ext""" + def __init__( + self, + *, + ext1_string: builtins.str | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["ext1_string", b"ext1_string"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["ext1_string", b"ext1_string"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___Extensions1: typing_extensions.TypeAlias = Extensions1 + +@typing.final +class Extensions2(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + FLAG_FIELD_NUMBER: builtins.int + flag: builtins.bool + FOO_FIELD_NUMBER: builtins.int + foo: google.protobuf.internal.extension_dict._ExtensionFieldDescriptor[Global___Simple1, Global___Extensions2] + """foo""" + def __init__( + self, + *, + flag: builtins.bool | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["flag", b"flag"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["flag", b"flag"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___Extensions2: typing_extensions.TypeAlias = Extensions2 + +@typing.final +class _r_None(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + VALID_FIELD_NUMBER: builtins.int + valid: builtins.int + def __init__( + self, + *, + valid: builtins.int | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["valid", b"valid"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["valid", b"valid"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global____r_None: typing_extensions.TypeAlias = _r_None + +@typing.final +class PythonReservedKeywords(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + class _finally: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + + class _finallyEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[PythonReservedKeywords._finally.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + valid_in_finally: PythonReservedKeywords._finally.ValueType # 2 + + class _r_finally(_finally, metaclass=_finallyEnumTypeWrapper): ... + valid_in_finally: PythonReservedKeywords._r_finally.ValueType # 2 + + @typing.final + class _r_lambda(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CONTINUE_FIELD_NUMBER: builtins.int + VALID_FIELD_NUMBER: builtins.int + valid: builtins.int + def __init__( + self, + *, + valid: builtins.int | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["continue", b"continue", "valid", b"valid"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["continue", b"continue", "valid", b"valid"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + + FROM_FIELD_NUMBER: builtins.int + IN_FIELD_NUMBER: builtins.int + IS_FIELD_NUMBER: builtins.int + FOR_FIELD_NUMBER: builtins.int + TRY_FIELD_NUMBER: builtins.int + DEF_FIELD_NUMBER: builtins.int + NONLOCAL_FIELD_NUMBER: builtins.int + WHILE_FIELD_NUMBER: builtins.int + AND_FIELD_NUMBER: builtins.int + DEL_FIELD_NUMBER: builtins.int + GLOBAL_FIELD_NUMBER: builtins.int + NOT_FIELD_NUMBER: builtins.int + WITH_FIELD_NUMBER: builtins.int + AS_FIELD_NUMBER: builtins.int + ELIF_FIELD_NUMBER: builtins.int + IF_FIELD_NUMBER: builtins.int + OR_FIELD_NUMBER: builtins.int + YIELD_FIELD_NUMBER: builtins.int + ASSERT_FIELD_NUMBER: builtins.int + ELSE_FIELD_NUMBER: builtins.int + IMPORT_FIELD_NUMBER: builtins.int + PASS_FIELD_NUMBER: builtins.int + BREAK_FIELD_NUMBER: builtins.int + EXCEPT_FIELD_NUMBER: builtins.int + RAISE_FIELD_NUMBER: builtins.int + FALSE_FIELD_NUMBER: builtins.int + TRUE_FIELD_NUMBER: builtins.int + CLASS_FIELD_NUMBER: builtins.int + NONE_FIELD_NUMBER: builtins.int + VALID_FIELD_NUMBER: builtins.int + valid: Global___PythonReservedKeywords._r_finally.ValueType + @property + def none(self) -> Global____r_None: + """Test unreserved identifiers w/ reserved message names""" + + def __init__( + self, + *, + none: Global____r_None | None = ..., + valid: Global___PythonReservedKeywords._r_finally.ValueType | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["False", b"False", "True", b"True", "and", b"and", "as", b"as", "assert", b"assert", "break", b"break", "class", b"class", "def", b"def", "del", b"del", "elif", b"elif", "else", b"else", "except", b"except", "for", b"for", "from", b"from", "global", b"global", "if", b"if", "import", b"import", "in", b"in", "is", b"is", "none", b"none", "nonlocal", b"nonlocal", "not", b"not", "or", b"or", "pass", b"pass", "raise", b"raise", "try", b"try", "valid", b"valid", "while", b"while", "with", b"with", "yield", b"yield"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["False", b"False", "True", b"True", "and", b"and", "as", b"as", "assert", b"assert", "break", b"break", "class", b"class", "def", b"def", "del", b"del", "elif", b"elif", "else", b"else", "except", b"except", "for", b"for", "from", b"from", "global", b"global", "if", b"if", "import", b"import", "in", b"in", "is", b"is", "none", b"none", "nonlocal", b"nonlocal", "not", b"not", "or", b"or", "pass", b"pass", "raise", b"raise", "try", b"try", "valid", b"valid", "while", b"while", "with", b"with", "yield", b"yield"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___PythonReservedKeywords: typing_extensions.TypeAlias = PythonReservedKeywords + +@typing.final +class PythonReservedKeywordsSmall(google.protobuf.message.Message): + """Do one with just one arg - to make sure it's syntactically correct""" + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + FROM_FIELD_NUMBER: builtins.int + def __init__( + self, + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["from", b"from"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["from", b"from"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___PythonReservedKeywordsSmall: typing_extensions.TypeAlias = PythonReservedKeywordsSmall + +@typing.final +class SelfField(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + SELF_FIELD_NUMBER: builtins.int + self: builtins.int + """Field self -> must generate an __init__ method w/ different name""" + def __init__( + self_, # pyright: ignore[reportSelfClsParameterName] + *, + self: builtins.int | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["self", b"self"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["self", b"self"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___SelfField: typing_extensions.TypeAlias = SelfField + +@deprecated("""This message is deprecated""") +@typing.final +class DeprecatedMessage(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + A_STRING_FIELD_NUMBER: builtins.int + a_string: builtins.str + def __init__( + self, + *, + a_string: builtins.str | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["a_string", b"a_string"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["a_string", b"a_string"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___DeprecatedMessage: typing_extensions.TypeAlias = DeprecatedMessage + +@deprecated("""This message has been marked as deprecated using proto message options.""") +@typing.final +class DeprecatedMessageBadComment(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + A_STRING_FIELD_NUMBER: builtins.int + a_string: builtins.str + def __init__( + self, + *, + a_string: builtins.str | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["a_string", b"a_string"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["a_string", b"a_string"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___DeprecatedMessageBadComment: typing_extensions.TypeAlias = DeprecatedMessageBadComment diff --git a/test/generated_async_only/testproto/test_pb2_grpc.pyi b/test/generated_async_only/testproto/test_pb2_grpc.pyi new file mode 100644 index 00000000..4ebe0505 --- /dev/null +++ b/test/generated_async_only/testproto/test_pb2_grpc.pyi @@ -0,0 +1,45 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +Proto 2 test file.""" + +import abc +import collections.abc +import grpc +import grpc.aio +import testproto.test_pb2 +import typing + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str + +class PythonReservedKeywordsServiceStub: + """Method name is reserved""" + + def __init__(self, channel: grpc.aio.Channel) -> None: ... + valid_method_name1: grpc.aio.UnaryUnaryMultiCallable[testproto.test_pb2.Simple1, testproto.test_pb2._r_None] + """valid_method_name1""" + valid_method_name2: grpc.aio.UnaryUnaryMultiCallable[testproto.test_pb2.Simple1, testproto.test_pb2.PythonReservedKeywords._r_lambda] + """valid_method_name2""" + +class PythonReservedKeywordsServiceServicer(metaclass=abc.ABCMeta): + """Method name is reserved""" + + @abc.abstractmethod + def valid_method_name1( + self, + request: testproto.test_pb2.Simple1, + context: grpc.aio.ServicerContext[testproto.test_pb2.Simple1, collections.abc.Awaitable[testproto.test_pb2._r_None]], + ) -> collections.abc.Awaitable[testproto.test_pb2._r_None]: + """valid_method_name1""" + + @abc.abstractmethod + def valid_method_name2( + self, + request: testproto.test_pb2.Simple1, + context: grpc.aio.ServicerContext[testproto.test_pb2.Simple1, collections.abc.Awaitable[testproto.test_pb2.PythonReservedKeywords._r_lambda]], + ) -> collections.abc.Awaitable[testproto.test_pb2.PythonReservedKeywords._r_lambda]: + """valid_method_name2""" + +def add_PythonReservedKeywordsServiceServicer_to_server(servicer: PythonReservedKeywordsServiceServicer, server: grpc.aio.Server) -> None: ... diff --git a/test/generated_sync_only/testproto/Capitalized/Capitalized_pb2.pyi b/test/generated_sync_only/testproto/Capitalized/Capitalized_pb2.pyi new file mode 100644 index 00000000..0bae1c93 --- /dev/null +++ b/test/generated_sync_only/testproto/Capitalized/Capitalized_pb2.pyi @@ -0,0 +1,71 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import builtins +import google.protobuf.descriptor +import google.protobuf.message +import sys +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +@typing.final +class lower(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + A_FIELD_NUMBER: builtins.int + a: builtins.int + def __init__( + self, + *, + a: builtins.int = ..., + ) -> None: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["a", b"a"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___lower: typing_extensions.TypeAlias = lower + +@typing.final +class Upper(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + LOWER_FIELD_NUMBER: builtins.int + @property + def Lower(self) -> Global___lower: ... + def __init__( + self, + *, + Lower: Global___lower | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["Lower", b"Lower"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["Lower", b"Lower"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___Upper: typing_extensions.TypeAlias = Upper + +@typing.final +class lower2(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + UPPER_FIELD_NUMBER: builtins.int + @property + def upper(self) -> Global___Upper: ... + def __init__( + self, + *, + upper: Global___Upper | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["upper", b"upper"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["upper", b"upper"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___lower2: typing_extensions.TypeAlias = lower2 diff --git a/test/generated_sync_only/testproto/Capitalized/Capitalized_pb2_grpc.pyi b/test/generated_sync_only/testproto/Capitalized/Capitalized_pb2_grpc.pyi new file mode 100644 index 00000000..26b99930 --- /dev/null +++ b/test/generated_sync_only/testproto/Capitalized/Capitalized_pb2_grpc.pyi @@ -0,0 +1,10 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import collections.abc + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str diff --git a/test/generated_sync_only/testproto/Capitalized/__init__.py b/test/generated_sync_only/testproto/Capitalized/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/test/generated_sync_only/testproto/__init__.py b/test/generated_sync_only/testproto/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/test/generated_sync_only/testproto/comment_special_chars_pb2.pyi b/test/generated_sync_only/testproto/comment_special_chars_pb2.pyi new file mode 100644 index 00000000..a0f6baf3 --- /dev/null +++ b/test/generated_sync_only/testproto/comment_special_chars_pb2.pyi @@ -0,0 +1,83 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import builtins +import google.protobuf.descriptor +import google.protobuf.message +import sys +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +@typing.final +class Test(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + A_FIELD_NUMBER: builtins.int + B_FIELD_NUMBER: builtins.int + C_FIELD_NUMBER: builtins.int + D_FIELD_NUMBER: builtins.int + E_FIELD_NUMBER: builtins.int + F_FIELD_NUMBER: builtins.int + G_FIELD_NUMBER: builtins.int + H_FIELD_NUMBER: builtins.int + I_FIELD_NUMBER: builtins.int + J_FIELD_NUMBER: builtins.int + K_FIELD_NUMBER: builtins.int + a: builtins.str + """Ending with " """ + b: builtins.str + """Ending with "" """ + c: builtins.str + """Ending with \"\"\" """ + d: builtins.str + """Ending with \\ """ + e: builtins.str + """Containing bad escape: \\x""" + f: builtins.str + """Containing \"\"\"" quadruple""" + g: builtins.str + """Containing \"\"\""" quintuple""" + h: builtins.str + """Containing \"\"\"\"\"\" sextuple""" + i: builtins.str + """\"\"\" Multiple \"\"\" triples \"\"\" """ + j: builtins.str + """"quotes" can be a problem in comments. + \"\"\"Triple quotes\"\"\" just as well + """ + k: builtins.str + """\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\" + " " + " Super Duper comments with surrounding edges! " + " " + " Pay attention to me!!!! " + " " + \"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\" + """ + def __init__( + self, + *, + a: builtins.str = ..., + b: builtins.str = ..., + c: builtins.str = ..., + d: builtins.str = ..., + e: builtins.str = ..., + f: builtins.str = ..., + g: builtins.str = ..., + h: builtins.str = ..., + i: builtins.str = ..., + j: builtins.str = ..., + k: builtins.str = ..., + ) -> None: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["a", b"a", "b", b"b", "c", b"c", "d", b"d", "e", b"e", "f", b"f", "g", b"g", "h", b"h", "i", b"i", "j", b"j", "k", b"k"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___Test: typing_extensions.TypeAlias = Test diff --git a/test/generated_sync_only/testproto/comment_special_chars_pb2_grpc.pyi b/test/generated_sync_only/testproto/comment_special_chars_pb2_grpc.pyi new file mode 100644 index 00000000..26b99930 --- /dev/null +++ b/test/generated_sync_only/testproto/comment_special_chars_pb2_grpc.pyi @@ -0,0 +1,10 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import collections.abc + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str diff --git a/test/generated_sync_only/testproto/dot/__init__.py b/test/generated_sync_only/testproto/dot/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/test/generated_sync_only/testproto/dot/com/__init__.py b/test/generated_sync_only/testproto/dot/com/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/test/generated_sync_only/testproto/dot/com/test_pb2.pyi b/test/generated_sync_only/testproto/dot/com/test_pb2.pyi new file mode 100644 index 00000000..a6d2ab11 --- /dev/null +++ b/test/generated_sync_only/testproto/dot/com/test_pb2.pyi @@ -0,0 +1,33 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import builtins +import google.protobuf.descriptor +import google.protobuf.message +import sys +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +@typing.final +class TestMessage(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + FOO_FIELD_NUMBER: builtins.int + foo: builtins.str + def __init__( + self, + *, + foo: builtins.str = ..., + ) -> None: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["foo", b"foo"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___TestMessage: typing_extensions.TypeAlias = TestMessage diff --git a/test/generated_sync_only/testproto/dot/com/test_pb2_grpc.pyi b/test/generated_sync_only/testproto/dot/com/test_pb2_grpc.pyi new file mode 100644 index 00000000..26b99930 --- /dev/null +++ b/test/generated_sync_only/testproto/dot/com/test_pb2_grpc.pyi @@ -0,0 +1,10 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import collections.abc + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str diff --git a/test/generated_sync_only/testproto/edition2024_pb2.pyi b/test/generated_sync_only/testproto/edition2024_pb2.pyi new file mode 100644 index 00000000..02e9c3fb --- /dev/null +++ b/test/generated_sync_only/testproto/edition2024_pb2.pyi @@ -0,0 +1,72 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +Edition version of proto2 file""" + +import builtins +import google.protobuf.descriptor +import google.protobuf.message +import sys +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +@typing.final +class Editions2024SubMessage(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + THING_FIELD_NUMBER: builtins.int + thing: builtins.str + def __init__( + self, + *, + thing: builtins.str | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["thing", b"thing"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["thing", b"thing"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___Editions2024SubMessage: typing_extensions.TypeAlias = Editions2024SubMessage + +@typing.final +class Editions2024Test(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + LEGACY_FIELD_NUMBER: builtins.int + EXPLICIT_SINGULAR_FIELD_NUMBER: builtins.int + MESSAGE_FIELD_FIELD_NUMBER: builtins.int + IMPLICIT_SINGULAR_FIELD_NUMBER: builtins.int + DEFAULT_SINGULAR_FIELD_NUMBER: builtins.int + legacy: builtins.str + """Expect to be always set""" + explicit_singular: builtins.str + """Expect HasField generated""" + implicit_singular: builtins.str + """Expect implicit field presence, no HasField generated""" + default_singular: builtins.str + """Not set, should default to EXPLICIT""" + @property + def message_field(self) -> Global___Editions2024SubMessage: + """Expect HasField generated?""" + + def __init__( + self, + *, + legacy: builtins.str | None = ..., + explicit_singular: builtins.str | None = ..., + message_field: Global___Editions2024SubMessage | None = ..., + implicit_singular: builtins.str = ..., + default_singular: builtins.str | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["default_singular", b"default_singular", "explicit_singular", b"explicit_singular", "legacy", b"legacy", "message_field", b"message_field"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["default_singular", b"default_singular", "explicit_singular", b"explicit_singular", "implicit_singular", b"implicit_singular", "legacy", b"legacy", "message_field", b"message_field"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___Editions2024Test: typing_extensions.TypeAlias = Editions2024Test diff --git a/test/generated_sync_only/testproto/edition2024_pb2_grpc.pyi b/test/generated_sync_only/testproto/edition2024_pb2_grpc.pyi new file mode 100644 index 00000000..af6f0d3a --- /dev/null +++ b/test/generated_sync_only/testproto/edition2024_pb2_grpc.pyi @@ -0,0 +1,10 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +Edition version of proto2 file""" + +import collections.abc + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str diff --git a/test/generated_sync_only/testproto/grpc/__init__.py b/test/generated_sync_only/testproto/grpc/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/test/generated_sync_only/testproto/grpc/dummy_pb2.pyi b/test/generated_sync_only/testproto/grpc/dummy_pb2.pyi new file mode 100644 index 00000000..94987554 --- /dev/null +++ b/test/generated_sync_only/testproto/grpc/dummy_pb2.pyi @@ -0,0 +1,2051 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +https://github.com/vmagamedov/grpclib/blob/master/tests/dummy.proto""" + +import builtins +import google.protobuf.descriptor +import google.protobuf.message +import sys +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +if sys.version_info >= (3, 13): + from warnings import deprecated +else: + from typing_extensions import deprecated + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +@typing.final +class DummyRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + VALUE_FIELD_NUMBER: builtins.int + value: builtins.str + def __init__( + self, + *, + value: builtins.str = ..., + ) -> None: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["value", b"value"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___DummyRequest: typing_extensions.TypeAlias = DummyRequest + +@typing.final +class DummyReply(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + VALUE_FIELD_NUMBER: builtins.int + value: builtins.str + def __init__( + self, + *, + value: builtins.str = ..., + ) -> None: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["value", b"value"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___DummyReply: typing_extensions.TypeAlias = DummyReply + +@deprecated("""This message has been marked as deprecated using proto message options.""") +@typing.final +class DeprecatedRequest(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + OLD_FIELD_FIELD_NUMBER: builtins.int + old_field: builtins.str + def __init__( + self, + *, + old_field: builtins.str = ..., + ) -> None: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["old_field", b"old_field"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___DeprecatedRequest: typing_extensions.TypeAlias = DeprecatedRequest + +@typing.final +class ManyRequest1(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest1: typing_extensions.TypeAlias = ManyRequest1 + +@typing.final +class ManyResponse1(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse1: typing_extensions.TypeAlias = ManyResponse1 + +@typing.final +class ManyRequest2(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest2: typing_extensions.TypeAlias = ManyRequest2 + +@typing.final +class ManyResponse2(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse2: typing_extensions.TypeAlias = ManyResponse2 + +@typing.final +class ManyRequest3(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest3: typing_extensions.TypeAlias = ManyRequest3 + +@typing.final +class ManyResponse3(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse3: typing_extensions.TypeAlias = ManyResponse3 + +@typing.final +class ManyRequest4(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest4: typing_extensions.TypeAlias = ManyRequest4 + +@typing.final +class ManyResponse4(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse4: typing_extensions.TypeAlias = ManyResponse4 + +@typing.final +class ManyRequest5(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest5: typing_extensions.TypeAlias = ManyRequest5 + +@typing.final +class ManyResponse5(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse5: typing_extensions.TypeAlias = ManyResponse5 + +@typing.final +class ManyRequest6(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest6: typing_extensions.TypeAlias = ManyRequest6 + +@typing.final +class ManyResponse6(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse6: typing_extensions.TypeAlias = ManyResponse6 + +@typing.final +class ManyRequest7(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest7: typing_extensions.TypeAlias = ManyRequest7 + +@typing.final +class ManyResponse7(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse7: typing_extensions.TypeAlias = ManyResponse7 + +@typing.final +class ManyRequest8(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest8: typing_extensions.TypeAlias = ManyRequest8 + +@typing.final +class ManyResponse8(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse8: typing_extensions.TypeAlias = ManyResponse8 + +@typing.final +class ManyRequest9(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest9: typing_extensions.TypeAlias = ManyRequest9 + +@typing.final +class ManyResponse9(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse9: typing_extensions.TypeAlias = ManyResponse9 + +@typing.final +class ManyRequest10(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest10: typing_extensions.TypeAlias = ManyRequest10 + +@typing.final +class ManyResponse10(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse10: typing_extensions.TypeAlias = ManyResponse10 + +@typing.final +class ManyRequest11(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest11: typing_extensions.TypeAlias = ManyRequest11 + +@typing.final +class ManyResponse11(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse11: typing_extensions.TypeAlias = ManyResponse11 + +@typing.final +class ManyRequest12(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest12: typing_extensions.TypeAlias = ManyRequest12 + +@typing.final +class ManyResponse12(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse12: typing_extensions.TypeAlias = ManyResponse12 + +@typing.final +class ManyRequest13(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest13: typing_extensions.TypeAlias = ManyRequest13 + +@typing.final +class ManyResponse13(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse13: typing_extensions.TypeAlias = ManyResponse13 + +@typing.final +class ManyRequest14(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest14: typing_extensions.TypeAlias = ManyRequest14 + +@typing.final +class ManyResponse14(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse14: typing_extensions.TypeAlias = ManyResponse14 + +@typing.final +class ManyRequest15(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest15: typing_extensions.TypeAlias = ManyRequest15 + +@typing.final +class ManyResponse15(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse15: typing_extensions.TypeAlias = ManyResponse15 + +@typing.final +class ManyRequest16(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest16: typing_extensions.TypeAlias = ManyRequest16 + +@typing.final +class ManyResponse16(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse16: typing_extensions.TypeAlias = ManyResponse16 + +@typing.final +class ManyRequest17(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest17: typing_extensions.TypeAlias = ManyRequest17 + +@typing.final +class ManyResponse17(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse17: typing_extensions.TypeAlias = ManyResponse17 + +@typing.final +class ManyRequest18(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest18: typing_extensions.TypeAlias = ManyRequest18 + +@typing.final +class ManyResponse18(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse18: typing_extensions.TypeAlias = ManyResponse18 + +@typing.final +class ManyRequest19(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest19: typing_extensions.TypeAlias = ManyRequest19 + +@typing.final +class ManyResponse19(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse19: typing_extensions.TypeAlias = ManyResponse19 + +@typing.final +class ManyRequest20(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest20: typing_extensions.TypeAlias = ManyRequest20 + +@typing.final +class ManyResponse20(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse20: typing_extensions.TypeAlias = ManyResponse20 + +@typing.final +class ManyRequest21(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest21: typing_extensions.TypeAlias = ManyRequest21 + +@typing.final +class ManyResponse21(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse21: typing_extensions.TypeAlias = ManyResponse21 + +@typing.final +class ManyRequest22(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest22: typing_extensions.TypeAlias = ManyRequest22 + +@typing.final +class ManyResponse22(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse22: typing_extensions.TypeAlias = ManyResponse22 + +@typing.final +class ManyRequest23(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest23: typing_extensions.TypeAlias = ManyRequest23 + +@typing.final +class ManyResponse23(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse23: typing_extensions.TypeAlias = ManyResponse23 + +@typing.final +class ManyRequest24(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest24: typing_extensions.TypeAlias = ManyRequest24 + +@typing.final +class ManyResponse24(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse24: typing_extensions.TypeAlias = ManyResponse24 + +@typing.final +class ManyRequest25(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest25: typing_extensions.TypeAlias = ManyRequest25 + +@typing.final +class ManyResponse25(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse25: typing_extensions.TypeAlias = ManyResponse25 + +@typing.final +class ManyRequest26(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest26: typing_extensions.TypeAlias = ManyRequest26 + +@typing.final +class ManyResponse26(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse26: typing_extensions.TypeAlias = ManyResponse26 + +@typing.final +class ManyRequest27(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest27: typing_extensions.TypeAlias = ManyRequest27 + +@typing.final +class ManyResponse27(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse27: typing_extensions.TypeAlias = ManyResponse27 + +@typing.final +class ManyRequest28(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest28: typing_extensions.TypeAlias = ManyRequest28 + +@typing.final +class ManyResponse28(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse28: typing_extensions.TypeAlias = ManyResponse28 + +@typing.final +class ManyRequest29(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest29: typing_extensions.TypeAlias = ManyRequest29 + +@typing.final +class ManyResponse29(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse29: typing_extensions.TypeAlias = ManyResponse29 + +@typing.final +class ManyRequest30(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest30: typing_extensions.TypeAlias = ManyRequest30 + +@typing.final +class ManyResponse30(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse30: typing_extensions.TypeAlias = ManyResponse30 + +@typing.final +class ManyRequest31(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest31: typing_extensions.TypeAlias = ManyRequest31 + +@typing.final +class ManyResponse31(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse31: typing_extensions.TypeAlias = ManyResponse31 + +@typing.final +class ManyRequest32(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest32: typing_extensions.TypeAlias = ManyRequest32 + +@typing.final +class ManyResponse32(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse32: typing_extensions.TypeAlias = ManyResponse32 + +@typing.final +class ManyRequest33(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest33: typing_extensions.TypeAlias = ManyRequest33 + +@typing.final +class ManyResponse33(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse33: typing_extensions.TypeAlias = ManyResponse33 + +@typing.final +class ManyRequest34(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest34: typing_extensions.TypeAlias = ManyRequest34 + +@typing.final +class ManyResponse34(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse34: typing_extensions.TypeAlias = ManyResponse34 + +@typing.final +class ManyRequest35(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest35: typing_extensions.TypeAlias = ManyRequest35 + +@typing.final +class ManyResponse35(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse35: typing_extensions.TypeAlias = ManyResponse35 + +@typing.final +class ManyRequest36(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest36: typing_extensions.TypeAlias = ManyRequest36 + +@typing.final +class ManyResponse36(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse36: typing_extensions.TypeAlias = ManyResponse36 + +@typing.final +class ManyRequest37(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest37: typing_extensions.TypeAlias = ManyRequest37 + +@typing.final +class ManyResponse37(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse37: typing_extensions.TypeAlias = ManyResponse37 + +@typing.final +class ManyRequest38(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest38: typing_extensions.TypeAlias = ManyRequest38 + +@typing.final +class ManyResponse38(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse38: typing_extensions.TypeAlias = ManyResponse38 + +@typing.final +class ManyRequest39(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest39: typing_extensions.TypeAlias = ManyRequest39 + +@typing.final +class ManyResponse39(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse39: typing_extensions.TypeAlias = ManyResponse39 + +@typing.final +class ManyRequest40(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest40: typing_extensions.TypeAlias = ManyRequest40 + +@typing.final +class ManyResponse40(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse40: typing_extensions.TypeAlias = ManyResponse40 + +@typing.final +class ManyRequest41(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest41: typing_extensions.TypeAlias = ManyRequest41 + +@typing.final +class ManyResponse41(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse41: typing_extensions.TypeAlias = ManyResponse41 + +@typing.final +class ManyRequest42(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest42: typing_extensions.TypeAlias = ManyRequest42 + +@typing.final +class ManyResponse42(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse42: typing_extensions.TypeAlias = ManyResponse42 + +@typing.final +class ManyRequest43(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest43: typing_extensions.TypeAlias = ManyRequest43 + +@typing.final +class ManyResponse43(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse43: typing_extensions.TypeAlias = ManyResponse43 + +@typing.final +class ManyRequest44(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest44: typing_extensions.TypeAlias = ManyRequest44 + +@typing.final +class ManyResponse44(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse44: typing_extensions.TypeAlias = ManyResponse44 + +@typing.final +class ManyRequest45(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest45: typing_extensions.TypeAlias = ManyRequest45 + +@typing.final +class ManyResponse45(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse45: typing_extensions.TypeAlias = ManyResponse45 + +@typing.final +class ManyRequest46(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest46: typing_extensions.TypeAlias = ManyRequest46 + +@typing.final +class ManyResponse46(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse46: typing_extensions.TypeAlias = ManyResponse46 + +@typing.final +class ManyRequest47(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest47: typing_extensions.TypeAlias = ManyRequest47 + +@typing.final +class ManyResponse47(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse47: typing_extensions.TypeAlias = ManyResponse47 + +@typing.final +class ManyRequest48(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest48: typing_extensions.TypeAlias = ManyRequest48 + +@typing.final +class ManyResponse48(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse48: typing_extensions.TypeAlias = ManyResponse48 + +@typing.final +class ManyRequest49(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest49: typing_extensions.TypeAlias = ManyRequest49 + +@typing.final +class ManyResponse49(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse49: typing_extensions.TypeAlias = ManyResponse49 + +@typing.final +class ManyRequest50(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest50: typing_extensions.TypeAlias = ManyRequest50 + +@typing.final +class ManyResponse50(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse50: typing_extensions.TypeAlias = ManyResponse50 + +@typing.final +class ManyRequest51(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest51: typing_extensions.TypeAlias = ManyRequest51 + +@typing.final +class ManyResponse51(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse51: typing_extensions.TypeAlias = ManyResponse51 + +@typing.final +class ManyRequest52(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest52: typing_extensions.TypeAlias = ManyRequest52 + +@typing.final +class ManyResponse52(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse52: typing_extensions.TypeAlias = ManyResponse52 + +@typing.final +class ManyRequest53(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest53: typing_extensions.TypeAlias = ManyRequest53 + +@typing.final +class ManyResponse53(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse53: typing_extensions.TypeAlias = ManyResponse53 + +@typing.final +class ManyRequest54(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest54: typing_extensions.TypeAlias = ManyRequest54 + +@typing.final +class ManyResponse54(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse54: typing_extensions.TypeAlias = ManyResponse54 + +@typing.final +class ManyRequest55(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest55: typing_extensions.TypeAlias = ManyRequest55 + +@typing.final +class ManyResponse55(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse55: typing_extensions.TypeAlias = ManyResponse55 + +@typing.final +class ManyRequest56(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest56: typing_extensions.TypeAlias = ManyRequest56 + +@typing.final +class ManyResponse56(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse56: typing_extensions.TypeAlias = ManyResponse56 + +@typing.final +class ManyRequest57(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest57: typing_extensions.TypeAlias = ManyRequest57 + +@typing.final +class ManyResponse57(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse57: typing_extensions.TypeAlias = ManyResponse57 + +@typing.final +class ManyRequest58(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest58: typing_extensions.TypeAlias = ManyRequest58 + +@typing.final +class ManyResponse58(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse58: typing_extensions.TypeAlias = ManyResponse58 + +@typing.final +class ManyRequest59(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest59: typing_extensions.TypeAlias = ManyRequest59 + +@typing.final +class ManyResponse59(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse59: typing_extensions.TypeAlias = ManyResponse59 + +@typing.final +class ManyRequest60(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest60: typing_extensions.TypeAlias = ManyRequest60 + +@typing.final +class ManyResponse60(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse60: typing_extensions.TypeAlias = ManyResponse60 + +@typing.final +class ManyRequest61(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest61: typing_extensions.TypeAlias = ManyRequest61 + +@typing.final +class ManyResponse61(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse61: typing_extensions.TypeAlias = ManyResponse61 + +@typing.final +class ManyRequest62(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest62: typing_extensions.TypeAlias = ManyRequest62 + +@typing.final +class ManyResponse62(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse62: typing_extensions.TypeAlias = ManyResponse62 + +@typing.final +class ManyRequest63(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest63: typing_extensions.TypeAlias = ManyRequest63 + +@typing.final +class ManyResponse63(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse63: typing_extensions.TypeAlias = ManyResponse63 + +@typing.final +class ManyRequest64(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest64: typing_extensions.TypeAlias = ManyRequest64 + +@typing.final +class ManyResponse64(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse64: typing_extensions.TypeAlias = ManyResponse64 + +@typing.final +class ManyRequest65(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest65: typing_extensions.TypeAlias = ManyRequest65 + +@typing.final +class ManyResponse65(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse65: typing_extensions.TypeAlias = ManyResponse65 + +@typing.final +class ManyRequest66(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest66: typing_extensions.TypeAlias = ManyRequest66 + +@typing.final +class ManyResponse66(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse66: typing_extensions.TypeAlias = ManyResponse66 + +@typing.final +class ManyRequest67(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest67: typing_extensions.TypeAlias = ManyRequest67 + +@typing.final +class ManyResponse67(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse67: typing_extensions.TypeAlias = ManyResponse67 + +@typing.final +class ManyRequest68(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest68: typing_extensions.TypeAlias = ManyRequest68 + +@typing.final +class ManyResponse68(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse68: typing_extensions.TypeAlias = ManyResponse68 + +@typing.final +class ManyRequest69(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest69: typing_extensions.TypeAlias = ManyRequest69 + +@typing.final +class ManyResponse69(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse69: typing_extensions.TypeAlias = ManyResponse69 + +@typing.final +class ManyRequest70(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest70: typing_extensions.TypeAlias = ManyRequest70 + +@typing.final +class ManyResponse70(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse70: typing_extensions.TypeAlias = ManyResponse70 + +@typing.final +class ManyRequest71(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest71: typing_extensions.TypeAlias = ManyRequest71 + +@typing.final +class ManyResponse71(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse71: typing_extensions.TypeAlias = ManyResponse71 + +@typing.final +class ManyRequest72(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest72: typing_extensions.TypeAlias = ManyRequest72 + +@typing.final +class ManyResponse72(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse72: typing_extensions.TypeAlias = ManyResponse72 + +@typing.final +class ManyRequest73(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest73: typing_extensions.TypeAlias = ManyRequest73 + +@typing.final +class ManyResponse73(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse73: typing_extensions.TypeAlias = ManyResponse73 + +@typing.final +class ManyRequest74(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest74: typing_extensions.TypeAlias = ManyRequest74 + +@typing.final +class ManyResponse74(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse74: typing_extensions.TypeAlias = ManyResponse74 + +@typing.final +class ManyRequest75(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest75: typing_extensions.TypeAlias = ManyRequest75 + +@typing.final +class ManyResponse75(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse75: typing_extensions.TypeAlias = ManyResponse75 + +@typing.final +class ManyRequest76(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest76: typing_extensions.TypeAlias = ManyRequest76 + +@typing.final +class ManyResponse76(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse76: typing_extensions.TypeAlias = ManyResponse76 + +@typing.final +class ManyRequest77(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest77: typing_extensions.TypeAlias = ManyRequest77 + +@typing.final +class ManyResponse77(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse77: typing_extensions.TypeAlias = ManyResponse77 + +@typing.final +class ManyRequest78(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest78: typing_extensions.TypeAlias = ManyRequest78 + +@typing.final +class ManyResponse78(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse78: typing_extensions.TypeAlias = ManyResponse78 + +@typing.final +class ManyRequest79(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest79: typing_extensions.TypeAlias = ManyRequest79 + +@typing.final +class ManyResponse79(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse79: typing_extensions.TypeAlias = ManyResponse79 + +@typing.final +class ManyRequest80(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest80: typing_extensions.TypeAlias = ManyRequest80 + +@typing.final +class ManyResponse80(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse80: typing_extensions.TypeAlias = ManyResponse80 + +@typing.final +class ManyRequest81(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest81: typing_extensions.TypeAlias = ManyRequest81 + +@typing.final +class ManyResponse81(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse81: typing_extensions.TypeAlias = ManyResponse81 + +@typing.final +class ManyRequest82(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest82: typing_extensions.TypeAlias = ManyRequest82 + +@typing.final +class ManyResponse82(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse82: typing_extensions.TypeAlias = ManyResponse82 + +@typing.final +class ManyRequest83(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest83: typing_extensions.TypeAlias = ManyRequest83 + +@typing.final +class ManyResponse83(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse83: typing_extensions.TypeAlias = ManyResponse83 + +@typing.final +class ManyRequest84(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest84: typing_extensions.TypeAlias = ManyRequest84 + +@typing.final +class ManyResponse84(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse84: typing_extensions.TypeAlias = ManyResponse84 + +@typing.final +class ManyRequest85(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest85: typing_extensions.TypeAlias = ManyRequest85 + +@typing.final +class ManyResponse85(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse85: typing_extensions.TypeAlias = ManyResponse85 + +@typing.final +class ManyRequest86(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest86: typing_extensions.TypeAlias = ManyRequest86 + +@typing.final +class ManyResponse86(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse86: typing_extensions.TypeAlias = ManyResponse86 + +@typing.final +class ManyRequest87(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest87: typing_extensions.TypeAlias = ManyRequest87 + +@typing.final +class ManyResponse87(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse87: typing_extensions.TypeAlias = ManyResponse87 + +@typing.final +class ManyRequest88(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest88: typing_extensions.TypeAlias = ManyRequest88 + +@typing.final +class ManyResponse88(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse88: typing_extensions.TypeAlias = ManyResponse88 + +@typing.final +class ManyRequest89(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest89: typing_extensions.TypeAlias = ManyRequest89 + +@typing.final +class ManyResponse89(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse89: typing_extensions.TypeAlias = ManyResponse89 + +@typing.final +class ManyRequest90(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest90: typing_extensions.TypeAlias = ManyRequest90 + +@typing.final +class ManyResponse90(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse90: typing_extensions.TypeAlias = ManyResponse90 + +@typing.final +class ManyRequest91(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest91: typing_extensions.TypeAlias = ManyRequest91 + +@typing.final +class ManyResponse91(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse91: typing_extensions.TypeAlias = ManyResponse91 + +@typing.final +class ManyRequest92(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest92: typing_extensions.TypeAlias = ManyRequest92 + +@typing.final +class ManyResponse92(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse92: typing_extensions.TypeAlias = ManyResponse92 + +@typing.final +class ManyRequest93(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest93: typing_extensions.TypeAlias = ManyRequest93 + +@typing.final +class ManyResponse93(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse93: typing_extensions.TypeAlias = ManyResponse93 + +@typing.final +class ManyRequest94(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest94: typing_extensions.TypeAlias = ManyRequest94 + +@typing.final +class ManyResponse94(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse94: typing_extensions.TypeAlias = ManyResponse94 + +@typing.final +class ManyRequest95(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest95: typing_extensions.TypeAlias = ManyRequest95 + +@typing.final +class ManyResponse95(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse95: typing_extensions.TypeAlias = ManyResponse95 + +@typing.final +class ManyRequest96(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest96: typing_extensions.TypeAlias = ManyRequest96 + +@typing.final +class ManyResponse96(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse96: typing_extensions.TypeAlias = ManyResponse96 + +@typing.final +class ManyRequest97(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest97: typing_extensions.TypeAlias = ManyRequest97 + +@typing.final +class ManyResponse97(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse97: typing_extensions.TypeAlias = ManyResponse97 + +@typing.final +class ManyRequest98(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest98: typing_extensions.TypeAlias = ManyRequest98 + +@typing.final +class ManyResponse98(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse98: typing_extensions.TypeAlias = ManyResponse98 + +@typing.final +class ManyRequest99(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyRequest99: typing_extensions.TypeAlias = ManyRequest99 + +@typing.final +class ManyResponse99(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___ManyResponse99: typing_extensions.TypeAlias = ManyResponse99 diff --git a/test/generated_sync_only/testproto/grpc/dummy_pb2_grpc.pyi b/test/generated_sync_only/testproto/grpc/dummy_pb2_grpc.pyi new file mode 100644 index 00000000..f389dbb2 --- /dev/null +++ b/test/generated_sync_only/testproto/grpc/dummy_pb2_grpc.pyi @@ -0,0 +1,909 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +https://github.com/vmagamedov/grpclib/blob/master/tests/dummy.proto""" + +import abc +import collections.abc +import grpc +import sys +import testproto.grpc.dummy_pb2 +import typing + +if sys.version_info >= (3, 13): + from warnings import deprecated +else: + from typing_extensions import deprecated + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str + +class DummyServiceStub: + """DummyService""" + + def __init__(self, channel: grpc.Channel) -> None: ... + UnaryUnary: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.DummyRequest, testproto.grpc.dummy_pb2.DummyReply] + """UnaryUnary""" + UnaryStream: grpc.UnaryStreamMultiCallable[testproto.grpc.dummy_pb2.DummyRequest, testproto.grpc.dummy_pb2.DummyReply] + """UnaryStream""" + StreamUnary: grpc.StreamUnaryMultiCallable[testproto.grpc.dummy_pb2.DummyRequest, testproto.grpc.dummy_pb2.DummyReply] + """StreamUnary""" + StreamStream: grpc.StreamStreamMultiCallable[testproto.grpc.dummy_pb2.DummyRequest, testproto.grpc.dummy_pb2.DummyReply] + """StreamStream""" + +class DummyServiceServicer(metaclass=abc.ABCMeta): + """DummyService""" + + @abc.abstractmethod + def UnaryUnary( + self, + request: testproto.grpc.dummy_pb2.DummyRequest, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.DummyReply: + """UnaryUnary""" + + @abc.abstractmethod + def UnaryStream( + self, + request: testproto.grpc.dummy_pb2.DummyRequest, + context: grpc.ServicerContext, + ) -> collections.abc.Iterator[testproto.grpc.dummy_pb2.DummyReply]: + """UnaryStream""" + + @abc.abstractmethod + def StreamUnary( + self, + request_iterator: collections.abc.Iterator[testproto.grpc.dummy_pb2.DummyRequest], + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.DummyReply: + """StreamUnary""" + + @abc.abstractmethod + def StreamStream( + self, + request_iterator: collections.abc.Iterator[testproto.grpc.dummy_pb2.DummyRequest], + context: grpc.ServicerContext, + ) -> collections.abc.Iterator[testproto.grpc.dummy_pb2.DummyReply]: + """StreamStream""" + +def add_DummyServiceServicer_to_server(servicer: DummyServiceServicer, server: grpc.Server) -> None: ... + +@deprecated("""This service is deprecated""") +class DeprecatedServiceStub: + """Marking the service as deprecated""" + + def __init__(self, channel: grpc.Channel) -> None: ... + DeprecatedMethod: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.DeprecatedRequest, testproto.grpc.dummy_pb2.DummyReply] + """DeprecatedMethod""" + DeprecatedMethodNotDeprecatedRequest: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.DummyRequest, testproto.grpc.dummy_pb2.DummyReply] + """DeprecatedMethodNotDeprecatedRequest""" + +@deprecated("""This service is deprecated""") +class DeprecatedServiceServicer(metaclass=abc.ABCMeta): + """Marking the service as deprecated""" + + @abc.abstractmethod + def DeprecatedMethod( + self, + request: testproto.grpc.dummy_pb2.DeprecatedRequest, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.DummyReply: + """DeprecatedMethod""" + + @abc.abstractmethod + def DeprecatedMethodNotDeprecatedRequest( + self, + request: testproto.grpc.dummy_pb2.DummyRequest, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.DummyReply: + """DeprecatedMethodNotDeprecatedRequest""" + +@deprecated("""This service is deprecated""") +def add_DeprecatedServiceServicer_to_server(servicer: DeprecatedServiceServicer, server: grpc.Server) -> None: ... + +class ManyRPCsServiceStub: + def __init__(self, channel: grpc.Channel) -> None: ... + Method1: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest1, testproto.grpc.dummy_pb2.ManyResponse1] + Method2: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest2, testproto.grpc.dummy_pb2.ManyResponse2] + Method3: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest3, testproto.grpc.dummy_pb2.ManyResponse3] + Method4: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest4, testproto.grpc.dummy_pb2.ManyResponse4] + Method5: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest5, testproto.grpc.dummy_pb2.ManyResponse5] + Method6: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest6, testproto.grpc.dummy_pb2.ManyResponse6] + Method7: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest7, testproto.grpc.dummy_pb2.ManyResponse7] + Method8: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest8, testproto.grpc.dummy_pb2.ManyResponse8] + Method9: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest9, testproto.grpc.dummy_pb2.ManyResponse9] + Method10: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest10, testproto.grpc.dummy_pb2.ManyResponse10] + Method11: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest11, testproto.grpc.dummy_pb2.ManyResponse11] + Method12: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest12, testproto.grpc.dummy_pb2.ManyResponse12] + Method13: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest13, testproto.grpc.dummy_pb2.ManyResponse13] + Method14: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest14, testproto.grpc.dummy_pb2.ManyResponse14] + Method15: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest15, testproto.grpc.dummy_pb2.ManyResponse15] + Method16: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest16, testproto.grpc.dummy_pb2.ManyResponse16] + Method17: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest17, testproto.grpc.dummy_pb2.ManyResponse17] + Method18: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest18, testproto.grpc.dummy_pb2.ManyResponse18] + Method19: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest19, testproto.grpc.dummy_pb2.ManyResponse19] + Method20: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest20, testproto.grpc.dummy_pb2.ManyResponse20] + Method21: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest21, testproto.grpc.dummy_pb2.ManyResponse21] + Method22: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest22, testproto.grpc.dummy_pb2.ManyResponse22] + Method23: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest23, testproto.grpc.dummy_pb2.ManyResponse23] + Method24: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest24, testproto.grpc.dummy_pb2.ManyResponse24] + Method25: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest25, testproto.grpc.dummy_pb2.ManyResponse25] + Method26: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest26, testproto.grpc.dummy_pb2.ManyResponse26] + Method27: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest27, testproto.grpc.dummy_pb2.ManyResponse27] + Method28: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest28, testproto.grpc.dummy_pb2.ManyResponse28] + Method29: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest29, testproto.grpc.dummy_pb2.ManyResponse29] + Method30: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest30, testproto.grpc.dummy_pb2.ManyResponse30] + Method31: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest31, testproto.grpc.dummy_pb2.ManyResponse31] + Method32: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest32, testproto.grpc.dummy_pb2.ManyResponse32] + Method33: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest33, testproto.grpc.dummy_pb2.ManyResponse33] + Method34: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest34, testproto.grpc.dummy_pb2.ManyResponse34] + Method35: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest35, testproto.grpc.dummy_pb2.ManyResponse35] + Method36: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest36, testproto.grpc.dummy_pb2.ManyResponse36] + Method37: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest37, testproto.grpc.dummy_pb2.ManyResponse37] + Method38: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest38, testproto.grpc.dummy_pb2.ManyResponse38] + Method39: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest39, testproto.grpc.dummy_pb2.ManyResponse39] + Method40: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest40, testproto.grpc.dummy_pb2.ManyResponse40] + Method41: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest41, testproto.grpc.dummy_pb2.ManyResponse41] + Method42: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest42, testproto.grpc.dummy_pb2.ManyResponse42] + Method43: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest43, testproto.grpc.dummy_pb2.ManyResponse43] + Method44: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest44, testproto.grpc.dummy_pb2.ManyResponse44] + Method45: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest45, testproto.grpc.dummy_pb2.ManyResponse45] + Method46: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest46, testproto.grpc.dummy_pb2.ManyResponse46] + Method47: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest47, testproto.grpc.dummy_pb2.ManyResponse47] + Method48: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest48, testproto.grpc.dummy_pb2.ManyResponse48] + Method49: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest49, testproto.grpc.dummy_pb2.ManyResponse49] + Method50: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest50, testproto.grpc.dummy_pb2.ManyResponse50] + Method51: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest51, testproto.grpc.dummy_pb2.ManyResponse51] + Method52: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest52, testproto.grpc.dummy_pb2.ManyResponse52] + Method53: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest53, testproto.grpc.dummy_pb2.ManyResponse53] + Method54: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest54, testproto.grpc.dummy_pb2.ManyResponse54] + Method55: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest55, testproto.grpc.dummy_pb2.ManyResponse55] + Method56: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest56, testproto.grpc.dummy_pb2.ManyResponse56] + Method57: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest57, testproto.grpc.dummy_pb2.ManyResponse57] + Method58: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest58, testproto.grpc.dummy_pb2.ManyResponse58] + Method59: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest59, testproto.grpc.dummy_pb2.ManyResponse59] + Method60: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest60, testproto.grpc.dummy_pb2.ManyResponse60] + Method61: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest61, testproto.grpc.dummy_pb2.ManyResponse61] + Method62: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest62, testproto.grpc.dummy_pb2.ManyResponse62] + Method63: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest63, testproto.grpc.dummy_pb2.ManyResponse63] + Method64: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest64, testproto.grpc.dummy_pb2.ManyResponse64] + Method65: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest65, testproto.grpc.dummy_pb2.ManyResponse65] + Method66: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest66, testproto.grpc.dummy_pb2.ManyResponse66] + Method67: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest67, testproto.grpc.dummy_pb2.ManyResponse67] + Method68: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest68, testproto.grpc.dummy_pb2.ManyResponse68] + Method69: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest69, testproto.grpc.dummy_pb2.ManyResponse69] + Method70: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest70, testproto.grpc.dummy_pb2.ManyResponse70] + Method71: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest71, testproto.grpc.dummy_pb2.ManyResponse71] + Method72: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest72, testproto.grpc.dummy_pb2.ManyResponse72] + Method73: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest73, testproto.grpc.dummy_pb2.ManyResponse73] + Method74: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest74, testproto.grpc.dummy_pb2.ManyResponse74] + Method75: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest75, testproto.grpc.dummy_pb2.ManyResponse75] + Method76: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest76, testproto.grpc.dummy_pb2.ManyResponse76] + Method77: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest77, testproto.grpc.dummy_pb2.ManyResponse77] + Method78: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest78, testproto.grpc.dummy_pb2.ManyResponse78] + Method79: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest79, testproto.grpc.dummy_pb2.ManyResponse79] + Method80: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest80, testproto.grpc.dummy_pb2.ManyResponse80] + Method81: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest81, testproto.grpc.dummy_pb2.ManyResponse81] + Method82: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest82, testproto.grpc.dummy_pb2.ManyResponse82] + Method83: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest83, testproto.grpc.dummy_pb2.ManyResponse83] + Method84: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest84, testproto.grpc.dummy_pb2.ManyResponse84] + Method85: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest85, testproto.grpc.dummy_pb2.ManyResponse85] + Method86: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest86, testproto.grpc.dummy_pb2.ManyResponse86] + Method87: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest87, testproto.grpc.dummy_pb2.ManyResponse87] + Method88: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest88, testproto.grpc.dummy_pb2.ManyResponse88] + Method89: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest89, testproto.grpc.dummy_pb2.ManyResponse89] + Method90: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest90, testproto.grpc.dummy_pb2.ManyResponse90] + Method91: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest91, testproto.grpc.dummy_pb2.ManyResponse91] + Method92: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest92, testproto.grpc.dummy_pb2.ManyResponse92] + Method93: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest93, testproto.grpc.dummy_pb2.ManyResponse93] + Method94: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest94, testproto.grpc.dummy_pb2.ManyResponse94] + Method95: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest95, testproto.grpc.dummy_pb2.ManyResponse95] + Method96: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest96, testproto.grpc.dummy_pb2.ManyResponse96] + Method97: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest97, testproto.grpc.dummy_pb2.ManyResponse97] + Method98: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest98, testproto.grpc.dummy_pb2.ManyResponse98] + Method99: grpc.UnaryUnaryMultiCallable[testproto.grpc.dummy_pb2.ManyRequest99, testproto.grpc.dummy_pb2.ManyResponse99] + +class ManyRPCsServiceServicer(metaclass=abc.ABCMeta): + @abc.abstractmethod + def Method1( + self, + request: testproto.grpc.dummy_pb2.ManyRequest1, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse1: ... + + @abc.abstractmethod + def Method2( + self, + request: testproto.grpc.dummy_pb2.ManyRequest2, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse2: ... + + @abc.abstractmethod + def Method3( + self, + request: testproto.grpc.dummy_pb2.ManyRequest3, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse3: ... + + @abc.abstractmethod + def Method4( + self, + request: testproto.grpc.dummy_pb2.ManyRequest4, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse4: ... + + @abc.abstractmethod + def Method5( + self, + request: testproto.grpc.dummy_pb2.ManyRequest5, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse5: ... + + @abc.abstractmethod + def Method6( + self, + request: testproto.grpc.dummy_pb2.ManyRequest6, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse6: ... + + @abc.abstractmethod + def Method7( + self, + request: testproto.grpc.dummy_pb2.ManyRequest7, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse7: ... + + @abc.abstractmethod + def Method8( + self, + request: testproto.grpc.dummy_pb2.ManyRequest8, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse8: ... + + @abc.abstractmethod + def Method9( + self, + request: testproto.grpc.dummy_pb2.ManyRequest9, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse9: ... + + @abc.abstractmethod + def Method10( + self, + request: testproto.grpc.dummy_pb2.ManyRequest10, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse10: ... + + @abc.abstractmethod + def Method11( + self, + request: testproto.grpc.dummy_pb2.ManyRequest11, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse11: ... + + @abc.abstractmethod + def Method12( + self, + request: testproto.grpc.dummy_pb2.ManyRequest12, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse12: ... + + @abc.abstractmethod + def Method13( + self, + request: testproto.grpc.dummy_pb2.ManyRequest13, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse13: ... + + @abc.abstractmethod + def Method14( + self, + request: testproto.grpc.dummy_pb2.ManyRequest14, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse14: ... + + @abc.abstractmethod + def Method15( + self, + request: testproto.grpc.dummy_pb2.ManyRequest15, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse15: ... + + @abc.abstractmethod + def Method16( + self, + request: testproto.grpc.dummy_pb2.ManyRequest16, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse16: ... + + @abc.abstractmethod + def Method17( + self, + request: testproto.grpc.dummy_pb2.ManyRequest17, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse17: ... + + @abc.abstractmethod + def Method18( + self, + request: testproto.grpc.dummy_pb2.ManyRequest18, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse18: ... + + @abc.abstractmethod + def Method19( + self, + request: testproto.grpc.dummy_pb2.ManyRequest19, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse19: ... + + @abc.abstractmethod + def Method20( + self, + request: testproto.grpc.dummy_pb2.ManyRequest20, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse20: ... + + @abc.abstractmethod + def Method21( + self, + request: testproto.grpc.dummy_pb2.ManyRequest21, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse21: ... + + @abc.abstractmethod + def Method22( + self, + request: testproto.grpc.dummy_pb2.ManyRequest22, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse22: ... + + @abc.abstractmethod + def Method23( + self, + request: testproto.grpc.dummy_pb2.ManyRequest23, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse23: ... + + @abc.abstractmethod + def Method24( + self, + request: testproto.grpc.dummy_pb2.ManyRequest24, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse24: ... + + @abc.abstractmethod + def Method25( + self, + request: testproto.grpc.dummy_pb2.ManyRequest25, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse25: ... + + @abc.abstractmethod + def Method26( + self, + request: testproto.grpc.dummy_pb2.ManyRequest26, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse26: ... + + @abc.abstractmethod + def Method27( + self, + request: testproto.grpc.dummy_pb2.ManyRequest27, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse27: ... + + @abc.abstractmethod + def Method28( + self, + request: testproto.grpc.dummy_pb2.ManyRequest28, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse28: ... + + @abc.abstractmethod + def Method29( + self, + request: testproto.grpc.dummy_pb2.ManyRequest29, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse29: ... + + @abc.abstractmethod + def Method30( + self, + request: testproto.grpc.dummy_pb2.ManyRequest30, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse30: ... + + @abc.abstractmethod + def Method31( + self, + request: testproto.grpc.dummy_pb2.ManyRequest31, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse31: ... + + @abc.abstractmethod + def Method32( + self, + request: testproto.grpc.dummy_pb2.ManyRequest32, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse32: ... + + @abc.abstractmethod + def Method33( + self, + request: testproto.grpc.dummy_pb2.ManyRequest33, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse33: ... + + @abc.abstractmethod + def Method34( + self, + request: testproto.grpc.dummy_pb2.ManyRequest34, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse34: ... + + @abc.abstractmethod + def Method35( + self, + request: testproto.grpc.dummy_pb2.ManyRequest35, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse35: ... + + @abc.abstractmethod + def Method36( + self, + request: testproto.grpc.dummy_pb2.ManyRequest36, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse36: ... + + @abc.abstractmethod + def Method37( + self, + request: testproto.grpc.dummy_pb2.ManyRequest37, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse37: ... + + @abc.abstractmethod + def Method38( + self, + request: testproto.grpc.dummy_pb2.ManyRequest38, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse38: ... + + @abc.abstractmethod + def Method39( + self, + request: testproto.grpc.dummy_pb2.ManyRequest39, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse39: ... + + @abc.abstractmethod + def Method40( + self, + request: testproto.grpc.dummy_pb2.ManyRequest40, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse40: ... + + @abc.abstractmethod + def Method41( + self, + request: testproto.grpc.dummy_pb2.ManyRequest41, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse41: ... + + @abc.abstractmethod + def Method42( + self, + request: testproto.grpc.dummy_pb2.ManyRequest42, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse42: ... + + @abc.abstractmethod + def Method43( + self, + request: testproto.grpc.dummy_pb2.ManyRequest43, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse43: ... + + @abc.abstractmethod + def Method44( + self, + request: testproto.grpc.dummy_pb2.ManyRequest44, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse44: ... + + @abc.abstractmethod + def Method45( + self, + request: testproto.grpc.dummy_pb2.ManyRequest45, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse45: ... + + @abc.abstractmethod + def Method46( + self, + request: testproto.grpc.dummy_pb2.ManyRequest46, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse46: ... + + @abc.abstractmethod + def Method47( + self, + request: testproto.grpc.dummy_pb2.ManyRequest47, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse47: ... + + @abc.abstractmethod + def Method48( + self, + request: testproto.grpc.dummy_pb2.ManyRequest48, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse48: ... + + @abc.abstractmethod + def Method49( + self, + request: testproto.grpc.dummy_pb2.ManyRequest49, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse49: ... + + @abc.abstractmethod + def Method50( + self, + request: testproto.grpc.dummy_pb2.ManyRequest50, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse50: ... + + @abc.abstractmethod + def Method51( + self, + request: testproto.grpc.dummy_pb2.ManyRequest51, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse51: ... + + @abc.abstractmethod + def Method52( + self, + request: testproto.grpc.dummy_pb2.ManyRequest52, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse52: ... + + @abc.abstractmethod + def Method53( + self, + request: testproto.grpc.dummy_pb2.ManyRequest53, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse53: ... + + @abc.abstractmethod + def Method54( + self, + request: testproto.grpc.dummy_pb2.ManyRequest54, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse54: ... + + @abc.abstractmethod + def Method55( + self, + request: testproto.grpc.dummy_pb2.ManyRequest55, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse55: ... + + @abc.abstractmethod + def Method56( + self, + request: testproto.grpc.dummy_pb2.ManyRequest56, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse56: ... + + @abc.abstractmethod + def Method57( + self, + request: testproto.grpc.dummy_pb2.ManyRequest57, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse57: ... + + @abc.abstractmethod + def Method58( + self, + request: testproto.grpc.dummy_pb2.ManyRequest58, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse58: ... + + @abc.abstractmethod + def Method59( + self, + request: testproto.grpc.dummy_pb2.ManyRequest59, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse59: ... + + @abc.abstractmethod + def Method60( + self, + request: testproto.grpc.dummy_pb2.ManyRequest60, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse60: ... + + @abc.abstractmethod + def Method61( + self, + request: testproto.grpc.dummy_pb2.ManyRequest61, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse61: ... + + @abc.abstractmethod + def Method62( + self, + request: testproto.grpc.dummy_pb2.ManyRequest62, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse62: ... + + @abc.abstractmethod + def Method63( + self, + request: testproto.grpc.dummy_pb2.ManyRequest63, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse63: ... + + @abc.abstractmethod + def Method64( + self, + request: testproto.grpc.dummy_pb2.ManyRequest64, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse64: ... + + @abc.abstractmethod + def Method65( + self, + request: testproto.grpc.dummy_pb2.ManyRequest65, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse65: ... + + @abc.abstractmethod + def Method66( + self, + request: testproto.grpc.dummy_pb2.ManyRequest66, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse66: ... + + @abc.abstractmethod + def Method67( + self, + request: testproto.grpc.dummy_pb2.ManyRequest67, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse67: ... + + @abc.abstractmethod + def Method68( + self, + request: testproto.grpc.dummy_pb2.ManyRequest68, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse68: ... + + @abc.abstractmethod + def Method69( + self, + request: testproto.grpc.dummy_pb2.ManyRequest69, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse69: ... + + @abc.abstractmethod + def Method70( + self, + request: testproto.grpc.dummy_pb2.ManyRequest70, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse70: ... + + @abc.abstractmethod + def Method71( + self, + request: testproto.grpc.dummy_pb2.ManyRequest71, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse71: ... + + @abc.abstractmethod + def Method72( + self, + request: testproto.grpc.dummy_pb2.ManyRequest72, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse72: ... + + @abc.abstractmethod + def Method73( + self, + request: testproto.grpc.dummy_pb2.ManyRequest73, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse73: ... + + @abc.abstractmethod + def Method74( + self, + request: testproto.grpc.dummy_pb2.ManyRequest74, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse74: ... + + @abc.abstractmethod + def Method75( + self, + request: testproto.grpc.dummy_pb2.ManyRequest75, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse75: ... + + @abc.abstractmethod + def Method76( + self, + request: testproto.grpc.dummy_pb2.ManyRequest76, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse76: ... + + @abc.abstractmethod + def Method77( + self, + request: testproto.grpc.dummy_pb2.ManyRequest77, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse77: ... + + @abc.abstractmethod + def Method78( + self, + request: testproto.grpc.dummy_pb2.ManyRequest78, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse78: ... + + @abc.abstractmethod + def Method79( + self, + request: testproto.grpc.dummy_pb2.ManyRequest79, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse79: ... + + @abc.abstractmethod + def Method80( + self, + request: testproto.grpc.dummy_pb2.ManyRequest80, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse80: ... + + @abc.abstractmethod + def Method81( + self, + request: testproto.grpc.dummy_pb2.ManyRequest81, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse81: ... + + @abc.abstractmethod + def Method82( + self, + request: testproto.grpc.dummy_pb2.ManyRequest82, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse82: ... + + @abc.abstractmethod + def Method83( + self, + request: testproto.grpc.dummy_pb2.ManyRequest83, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse83: ... + + @abc.abstractmethod + def Method84( + self, + request: testproto.grpc.dummy_pb2.ManyRequest84, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse84: ... + + @abc.abstractmethod + def Method85( + self, + request: testproto.grpc.dummy_pb2.ManyRequest85, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse85: ... + + @abc.abstractmethod + def Method86( + self, + request: testproto.grpc.dummy_pb2.ManyRequest86, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse86: ... + + @abc.abstractmethod + def Method87( + self, + request: testproto.grpc.dummy_pb2.ManyRequest87, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse87: ... + + @abc.abstractmethod + def Method88( + self, + request: testproto.grpc.dummy_pb2.ManyRequest88, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse88: ... + + @abc.abstractmethod + def Method89( + self, + request: testproto.grpc.dummy_pb2.ManyRequest89, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse89: ... + + @abc.abstractmethod + def Method90( + self, + request: testproto.grpc.dummy_pb2.ManyRequest90, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse90: ... + + @abc.abstractmethod + def Method91( + self, + request: testproto.grpc.dummy_pb2.ManyRequest91, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse91: ... + + @abc.abstractmethod + def Method92( + self, + request: testproto.grpc.dummy_pb2.ManyRequest92, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse92: ... + + @abc.abstractmethod + def Method93( + self, + request: testproto.grpc.dummy_pb2.ManyRequest93, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse93: ... + + @abc.abstractmethod + def Method94( + self, + request: testproto.grpc.dummy_pb2.ManyRequest94, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse94: ... + + @abc.abstractmethod + def Method95( + self, + request: testproto.grpc.dummy_pb2.ManyRequest95, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse95: ... + + @abc.abstractmethod + def Method96( + self, + request: testproto.grpc.dummy_pb2.ManyRequest96, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse96: ... + + @abc.abstractmethod + def Method97( + self, + request: testproto.grpc.dummy_pb2.ManyRequest97, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse97: ... + + @abc.abstractmethod + def Method98( + self, + request: testproto.grpc.dummy_pb2.ManyRequest98, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse98: ... + + @abc.abstractmethod + def Method99( + self, + request: testproto.grpc.dummy_pb2.ManyRequest99, + context: grpc.ServicerContext, + ) -> testproto.grpc.dummy_pb2.ManyResponse99: ... + +def add_ManyRPCsServiceServicer_to_server(servicer: ManyRPCsServiceServicer, server: grpc.Server) -> None: ... + +class EmptyServiceStub: + def __init__(self, channel: grpc.Channel) -> None: ... + +class EmptyServiceServicer(metaclass=abc.ABCMeta): + ... + +def add_EmptyServiceServicer_to_server(servicer: EmptyServiceServicer, server: grpc.Server) -> None: ... diff --git a/test/generated_sync_only/testproto/grpc/import_pb2.pyi b/test/generated_sync_only/testproto/grpc/import_pb2.pyi new file mode 100644 index 00000000..dd854e28 --- /dev/null +++ b/test/generated_sync_only/testproto/grpc/import_pb2.pyi @@ -0,0 +1,8 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import google.protobuf.descriptor + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor diff --git a/test/generated_sync_only/testproto/grpc/import_pb2_grpc.pyi b/test/generated_sync_only/testproto/grpc/import_pb2_grpc.pyi new file mode 100644 index 00000000..4525deb7 --- /dev/null +++ b/test/generated_sync_only/testproto/grpc/import_pb2_grpc.pyi @@ -0,0 +1,53 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import abc +import collections.abc +import google.protobuf.empty_pb2 +import grpc +import testproto.test_pb2 +import typing + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str + +class SimpleServiceStub: + """SimpleService""" + + def __init__(self, channel: grpc.Channel) -> None: ... + UnaryUnary: grpc.UnaryUnaryMultiCallable[google.protobuf.empty_pb2.Empty, testproto.test_pb2.Simple1] + """UnaryUnary""" + UnaryStream: grpc.UnaryUnaryMultiCallable[testproto.test_pb2.Simple1, google.protobuf.empty_pb2.Empty] + """UnaryStream""" + NoComment: grpc.UnaryUnaryMultiCallable[testproto.test_pb2.Simple1, google.protobuf.empty_pb2.Empty] + +class SimpleServiceServicer(metaclass=abc.ABCMeta): + """SimpleService""" + + @abc.abstractmethod + def UnaryUnary( + self, + request: google.protobuf.empty_pb2.Empty, + context: grpc.ServicerContext, + ) -> testproto.test_pb2.Simple1: + """UnaryUnary""" + + @abc.abstractmethod + def UnaryStream( + self, + request: testproto.test_pb2.Simple1, + context: grpc.ServicerContext, + ) -> google.protobuf.empty_pb2.Empty: + """UnaryStream""" + + @abc.abstractmethod + def NoComment( + self, + request: testproto.test_pb2.Simple1, + context: grpc.ServicerContext, + ) -> google.protobuf.empty_pb2.Empty: ... + +def add_SimpleServiceServicer_to_server(servicer: SimpleServiceServicer, server: grpc.Server) -> None: ... diff --git a/test/generated_sync_only/testproto/inner/__init__.py b/test/generated_sync_only/testproto/inner/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/test/generated_sync_only/testproto/inner/inner_pb2.pyi b/test/generated_sync_only/testproto/inner/inner_pb2.pyi new file mode 100644 index 00000000..8a029c4e --- /dev/null +++ b/test/generated_sync_only/testproto/inner/inner_pb2.pyi @@ -0,0 +1,34 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import builtins +import google.protobuf.descriptor +import google.protobuf.message +import sys +import testproto.test3_pb2 +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +@typing.final +class Inner(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + A_FIELD_NUMBER: builtins.int + a: testproto.test3_pb2.OuterEnum.ValueType + def __init__( + self, + *, + a: testproto.test3_pb2.OuterEnum.ValueType = ..., + ) -> None: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["a", b"a"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___Inner: typing_extensions.TypeAlias = Inner diff --git a/test/generated_sync_only/testproto/inner/inner_pb2_grpc.pyi b/test/generated_sync_only/testproto/inner/inner_pb2_grpc.pyi new file mode 100644 index 00000000..26b99930 --- /dev/null +++ b/test/generated_sync_only/testproto/inner/inner_pb2_grpc.pyi @@ -0,0 +1,10 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import collections.abc + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str diff --git a/test/generated_sync_only/testproto/nested/__init__.py b/test/generated_sync_only/testproto/nested/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/test/generated_sync_only/testproto/nested/nested_pb2.pyi b/test/generated_sync_only/testproto/nested/nested_pb2.pyi new file mode 100644 index 00000000..ca263aee --- /dev/null +++ b/test/generated_sync_only/testproto/nested/nested_pb2.pyi @@ -0,0 +1,98 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import builtins +import google.protobuf.descriptor +import google.protobuf.internal.enum_type_wrapper +import google.protobuf.message +import sys +import testproto.test3_pb2 +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +@typing.final +class Nested(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + A_FIELD_NUMBER: builtins.int + a: testproto.test3_pb2.OuterEnum.ValueType + def __init__( + self, + *, + a: testproto.test3_pb2.OuterEnum.ValueType = ..., + ) -> None: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["a", b"a"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___Nested: typing_extensions.TypeAlias = Nested + +@typing.final +class AnotherNested(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + class _NestedEnum: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + + class _NestedEnumEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[AnotherNested._NestedEnum.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + INVALID: AnotherNested._NestedEnum.ValueType # 0 + ONE: AnotherNested._NestedEnum.ValueType # 1 + TWO: AnotherNested._NestedEnum.ValueType # 2 + + class NestedEnum(_NestedEnum, metaclass=_NestedEnumEnumTypeWrapper): ... + INVALID: AnotherNested.NestedEnum.ValueType # 0 + ONE: AnotherNested.NestedEnum.ValueType # 1 + TWO: AnotherNested.NestedEnum.ValueType # 2 + + @typing.final + class NestedMessage(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + class _NestedEnum2: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + + class _NestedEnum2EnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[AnotherNested.NestedMessage._NestedEnum2.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + UNDEFINED: AnotherNested.NestedMessage._NestedEnum2.ValueType # 0 + NESTED_ENUM1: AnotherNested.NestedMessage._NestedEnum2.ValueType # 1 + NESTED_ENUM2: AnotherNested.NestedMessage._NestedEnum2.ValueType # 2 + + class NestedEnum2(_NestedEnum2, metaclass=_NestedEnum2EnumTypeWrapper): ... + UNDEFINED: AnotherNested.NestedMessage.NestedEnum2.ValueType # 0 + NESTED_ENUM1: AnotherNested.NestedMessage.NestedEnum2.ValueType # 1 + NESTED_ENUM2: AnotherNested.NestedMessage.NestedEnum2.ValueType # 2 + + S_FIELD_NUMBER: builtins.int + B_FIELD_NUMBER: builtins.int + NE_FIELD_NUMBER: builtins.int + NE2_FIELD_NUMBER: builtins.int + s: builtins.str + b: builtins.bool + ne: Global___AnotherNested.NestedEnum.ValueType + ne2: Global___AnotherNested.NestedMessage.NestedEnum2.ValueType + def __init__( + self, + *, + s: builtins.str = ..., + b: builtins.bool = ..., + ne: Global___AnotherNested.NestedEnum.ValueType = ..., + ne2: Global___AnotherNested.NestedMessage.NestedEnum2.ValueType = ..., + ) -> None: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["b", b"b", "ne", b"ne", "ne2", b"ne2", "s", b"s"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + + def __init__( + self, + ) -> None: ... + +Global___AnotherNested: typing_extensions.TypeAlias = AnotherNested diff --git a/test/generated_sync_only/testproto/nested/nested_pb2_grpc.pyi b/test/generated_sync_only/testproto/nested/nested_pb2_grpc.pyi new file mode 100644 index 00000000..26b99930 --- /dev/null +++ b/test/generated_sync_only/testproto/nested/nested_pb2_grpc.pyi @@ -0,0 +1,10 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import collections.abc + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str diff --git a/test/generated_sync_only/testproto/nopackage_pb2.pyi b/test/generated_sync_only/testproto/nopackage_pb2.pyi new file mode 100644 index 00000000..f4455c17 --- /dev/null +++ b/test/generated_sync_only/testproto/nopackage_pb2.pyi @@ -0,0 +1,54 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import builtins +import collections.abc +import google.protobuf.descriptor +import google.protobuf.internal.containers +import google.protobuf.message +import sys +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +@typing.final +class NoPackage(google.protobuf.message.Message): + """Intentionally don't set a package - just to make sure we can handle it.""" + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___NoPackage: typing_extensions.TypeAlias = NoPackage + +@typing.final +class NoPackage2(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + NP_FIELD_NUMBER: builtins.int + NP_REP_FIELD_NUMBER: builtins.int + @property + def np(self) -> Global___NoPackage: ... + @property + def np_rep(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[Global___NoPackage]: ... + def __init__( + self, + *, + np: Global___NoPackage | None = ..., + np_rep: collections.abc.Iterable[Global___NoPackage] | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["np", b"np"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["np", b"np", "np_rep", b"np_rep"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___NoPackage2: typing_extensions.TypeAlias = NoPackage2 diff --git a/test/generated_sync_only/testproto/nopackage_pb2_grpc.pyi b/test/generated_sync_only/testproto/nopackage_pb2_grpc.pyi new file mode 100644 index 00000000..26b99930 --- /dev/null +++ b/test/generated_sync_only/testproto/nopackage_pb2_grpc.pyi @@ -0,0 +1,10 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import collections.abc + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str diff --git a/test/generated_sync_only/testproto/readme_enum_pb2.pyi b/test/generated_sync_only/testproto/readme_enum_pb2.pyi new file mode 100644 index 00000000..be8369c4 --- /dev/null +++ b/test/generated_sync_only/testproto/readme_enum_pb2.pyi @@ -0,0 +1,32 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import builtins +import google.protobuf.descriptor +import google.protobuf.internal.enum_type_wrapper +import sys +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +class _MyEnum: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _MyEnumEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_MyEnum.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + HELLO: _MyEnum.ValueType # 0 + WORLD: _MyEnum.ValueType # 1 + +class MyEnum(_MyEnum, metaclass=_MyEnumEnumTypeWrapper): ... + +HELLO: MyEnum.ValueType # 0 +WORLD: MyEnum.ValueType # 1 +Global___MyEnum: typing_extensions.TypeAlias = MyEnum diff --git a/test/generated_sync_only/testproto/readme_enum_pb2_grpc.pyi b/test/generated_sync_only/testproto/readme_enum_pb2_grpc.pyi new file mode 100644 index 00000000..26b99930 --- /dev/null +++ b/test/generated_sync_only/testproto/readme_enum_pb2_grpc.pyi @@ -0,0 +1,10 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import collections.abc + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str diff --git a/test/generated_sync_only/testproto/reexport_pb2.pyi b/test/generated_sync_only/testproto/reexport_pb2.pyi new file mode 100644 index 00000000..9702c2bd --- /dev/null +++ b/test/generated_sync_only/testproto/reexport_pb2.pyi @@ -0,0 +1,19 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import google.protobuf.descriptor +from google.protobuf.empty_pb2 import ( + Empty as Empty, +) +from testproto.test3_pb2 import ( + BAR3 as BAR3, + FOO3 as FOO3, + OuterEnum as OuterEnum, + OuterMessage3 as OuterMessage3, + SimpleProto3 as SimpleProto3, + UNKNOWN as UNKNOWN, +) + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor diff --git a/test/generated_sync_only/testproto/reexport_pb2_grpc.pyi b/test/generated_sync_only/testproto/reexport_pb2_grpc.pyi new file mode 100644 index 00000000..9c28bd7a --- /dev/null +++ b/test/generated_sync_only/testproto/reexport_pb2_grpc.pyi @@ -0,0 +1,21 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import collections.abc +from google.protobuf.empty_pb2 import ( + Empty as Empty, +) +from testproto.test3_pb2 import ( + BAR3 as BAR3, + FOO3 as FOO3, + OuterEnum as OuterEnum, + OuterMessage3 as OuterMessage3, + SimpleProto3 as SimpleProto3, + UNKNOWN as UNKNOWN, +) + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str diff --git a/test/generated_sync_only/testproto/test3_pb2.pyi b/test/generated_sync_only/testproto/test3_pb2.pyi new file mode 100644 index 00000000..ca2421ab --- /dev/null +++ b/test/generated_sync_only/testproto/test3_pb2.pyi @@ -0,0 +1,222 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +package test3""" + +import builtins +import collections.abc +import google.protobuf.descriptor +import google.protobuf.internal.containers +import google.protobuf.internal.enum_type_wrapper +import google.protobuf.message +import sys +import test.test_generated_mypy +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +class _OuterEnum: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _OuterEnumEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_OuterEnum.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + UNKNOWN: _OuterEnum.ValueType # 0 + FOO3: _OuterEnum.ValueType # 1 + BAR3: _OuterEnum.ValueType # 2 + +class OuterEnum(_OuterEnum, metaclass=_OuterEnumEnumTypeWrapper): ... + +UNKNOWN: OuterEnum.ValueType # 0 +FOO3: OuterEnum.ValueType # 1 +BAR3: OuterEnum.ValueType # 2 +Global___OuterEnum: typing_extensions.TypeAlias = OuterEnum + +@typing.final +class OuterMessage3(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + A_STRING_FIELD_NUMBER: builtins.int + a_string: builtins.str + def __init__( + self, + *, + a_string: builtins.str = ..., + ) -> None: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["a_string", b"a_string"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___OuterMessage3: typing_extensions.TypeAlias = OuterMessage3 + +@typing.final +class SimpleProto3(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + class _InnerEnum: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + + class _InnerEnumEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[SimpleProto3._InnerEnum.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + INNER1: SimpleProto3._InnerEnum.ValueType # 0 + INNER2: SimpleProto3._InnerEnum.ValueType # 1 + + class InnerEnum(_InnerEnum, metaclass=_InnerEnumEnumTypeWrapper): ... + INNER1: SimpleProto3.InnerEnum.ValueType # 0 + INNER2: SimpleProto3.InnerEnum.ValueType # 1 + + @typing.final + class MapScalarEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.int + value: builtins.str + def __init__( + self, + *, + key: builtins.int = ..., + value: builtins.str = ..., + ) -> None: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["key", b"key", "value", b"value"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + + @typing.final + class MapMessageEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.int + @property + def value(self) -> Global___OuterMessage3: ... + def __init__( + self, + *, + key: builtins.int = ..., + value: Global___OuterMessage3 | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["value", b"value"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["key", b"key", "value", b"value"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + + @typing.final + class EmailByUidEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.int + value: builtins.str + def __init__( + self, + *, + key: builtins.int = ..., + value: builtins.str = ..., + ) -> None: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["key", b"key", "value", b"value"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + + A_STRING_FIELD_NUMBER: builtins.int + A_REPEATED_STRING_FIELD_NUMBER: builtins.int + A_OUTER_ENUM_FIELD_NUMBER: builtins.int + OUTER_MESSAGE_FIELD_NUMBER: builtins.int + INNER_ENUM_FIELD_NUMBER: builtins.int + A_ONEOF_1_FIELD_NUMBER: builtins.int + A_ONEOF_2_FIELD_NUMBER: builtins.int + OUTER_MESSAGE_IN_ONEOF_FIELD_NUMBER: builtins.int + OUTER_ENUM_IN_ONEOF_FIELD_NUMBER: builtins.int + INNER_ENUM_IN_ONEOF_FIELD_NUMBER: builtins.int + B_ONEOF_1_FIELD_NUMBER: builtins.int + B_ONEOF_2_FIELD_NUMBER: builtins.int + BOOL_FIELD_NUMBER: builtins.int + OUTERENUM_FIELD_NUMBER: builtins.int + OUTERMESSAGE3_FIELD_NUMBER: builtins.int + MAP_SCALAR_FIELD_NUMBER: builtins.int + MAP_MESSAGE_FIELD_NUMBER: builtins.int + AN_OPTIONAL_STRING_FIELD_NUMBER: builtins.int + USER_ID_FIELD_NUMBER: builtins.int + EMAIL_FIELD_NUMBER: builtins.int + EMAIL_BY_UID_FIELD_NUMBER: builtins.int + a_string: builtins.str + a_outer_enum: Global___OuterEnum.ValueType + inner_enum: Global___SimpleProto3.InnerEnum.ValueType + a_oneof_1: builtins.str + a_oneof_2: builtins.str + outer_enum_in_oneof: Global___OuterEnum.ValueType + inner_enum_in_oneof: Global___SimpleProto3.InnerEnum.ValueType + b_oneof_1: builtins.str + b_oneof_2: builtins.str + OuterEnum: Global___OuterEnum.ValueType + """Test having fieldname match messagename""" + an_optional_string: builtins.str + user_id: test.test_generated_mypy.UserId + email: test.test_generated_mypy.Email + @property + def a_repeated_string(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]: ... + @property + def outer_message(self) -> Global___OuterMessage3: ... + @property + def outer_message_in_oneof(self) -> Global___OuterMessage3: ... + @property + def bool(self) -> Global___OuterMessage3: ... + @property + def OuterMessage3(self) -> Global___OuterMessage3: ... + @property + def map_scalar(self) -> google.protobuf.internal.containers.ScalarMap[builtins.int, builtins.str]: + """Test generation of map""" + + @property + def map_message(self) -> google.protobuf.internal.containers.MessageMap[builtins.int, Global___OuterMessage3]: ... + @property + def email_by_uid(self) -> google.protobuf.internal.containers.ScalarMap[test.test_generated_mypy.UserId, test.test_generated_mypy.Email]: ... + def __init__( + self, + *, + a_string: builtins.str = ..., + a_repeated_string: collections.abc.Iterable[builtins.str] | None = ..., + a_outer_enum: Global___OuterEnum.ValueType = ..., + outer_message: Global___OuterMessage3 | None = ..., + inner_enum: Global___SimpleProto3.InnerEnum.ValueType = ..., + a_oneof_1: builtins.str = ..., + a_oneof_2: builtins.str = ..., + outer_message_in_oneof: Global___OuterMessage3 | None = ..., + outer_enum_in_oneof: Global___OuterEnum.ValueType = ..., + inner_enum_in_oneof: Global___SimpleProto3.InnerEnum.ValueType = ..., + b_oneof_1: builtins.str = ..., + b_oneof_2: builtins.str = ..., + bool: Global___OuterMessage3 | None = ..., + OuterEnum: Global___OuterEnum.ValueType = ..., + OuterMessage3: Global___OuterMessage3 | None = ..., + map_scalar: collections.abc.Mapping[builtins.int, builtins.str] | None = ..., + map_message: collections.abc.Mapping[builtins.int, Global___OuterMessage3] | None = ..., + an_optional_string: builtins.str | None = ..., + user_id: test.test_generated_mypy.UserId = ..., + email: test.test_generated_mypy.Email = ..., + email_by_uid: collections.abc.Mapping[test.test_generated_mypy.UserId, test.test_generated_mypy.Email] | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["OuterMessage3", b"OuterMessage3", "_an_optional_string", b"_an_optional_string", "a_oneof", b"a_oneof", "a_oneof_1", b"a_oneof_1", "a_oneof_2", b"a_oneof_2", "an_optional_string", b"an_optional_string", "b_oneof", b"b_oneof", "b_oneof_1", b"b_oneof_1", "b_oneof_2", b"b_oneof_2", "bool", b"bool", "inner_enum_in_oneof", b"inner_enum_in_oneof", "outer_enum_in_oneof", b"outer_enum_in_oneof", "outer_message", b"outer_message", "outer_message_in_oneof", b"outer_message_in_oneof"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["OuterEnum", b"OuterEnum", "OuterMessage3", b"OuterMessage3", "_an_optional_string", b"_an_optional_string", "a_oneof", b"a_oneof", "a_oneof_1", b"a_oneof_1", "a_oneof_2", b"a_oneof_2", "a_outer_enum", b"a_outer_enum", "a_repeated_string", b"a_repeated_string", "a_string", b"a_string", "an_optional_string", b"an_optional_string", "b_oneof", b"b_oneof", "b_oneof_1", b"b_oneof_1", "b_oneof_2", b"b_oneof_2", "bool", b"bool", "email", b"email", "email_by_uid", b"email_by_uid", "inner_enum", b"inner_enum", "inner_enum_in_oneof", b"inner_enum_in_oneof", "map_message", b"map_message", "map_scalar", b"map_scalar", "outer_enum_in_oneof", b"outer_enum_in_oneof", "outer_message", b"outer_message", "outer_message_in_oneof", b"outer_message_in_oneof", "user_id", b"user_id"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + _WhichOneofReturnType__an_optional_string: typing_extensions.TypeAlias = typing.Literal["an_optional_string"] + _WhichOneofArgType__an_optional_string: typing_extensions.TypeAlias = typing.Literal["_an_optional_string", b"_an_optional_string"] + _WhichOneofReturnType_a_oneof: typing_extensions.TypeAlias = typing.Literal["a_oneof_1", "a_oneof_2", "outer_message_in_oneof", "outer_enum_in_oneof", "inner_enum_in_oneof"] + _WhichOneofArgType_a_oneof: typing_extensions.TypeAlias = typing.Literal["a_oneof", b"a_oneof"] + _WhichOneofReturnType_b_oneof: typing_extensions.TypeAlias = typing.Literal["b_oneof_1", "b_oneof_2"] + _WhichOneofArgType_b_oneof: typing_extensions.TypeAlias = typing.Literal["b_oneof", b"b_oneof"] + @typing.overload + def WhichOneof(self, oneof_group: _WhichOneofArgType__an_optional_string) -> _WhichOneofReturnType__an_optional_string | None: ... + @typing.overload + def WhichOneof(self, oneof_group: _WhichOneofArgType_a_oneof) -> _WhichOneofReturnType_a_oneof | None: ... + @typing.overload + def WhichOneof(self, oneof_group: _WhichOneofArgType_b_oneof) -> _WhichOneofReturnType_b_oneof | None: ... + +Global___SimpleProto3: typing_extensions.TypeAlias = SimpleProto3 diff --git a/test/generated_sync_only/testproto/test3_pb2_grpc.pyi b/test/generated_sync_only/testproto/test3_pb2_grpc.pyi new file mode 100644 index 00000000..18b6fcb4 --- /dev/null +++ b/test/generated_sync_only/testproto/test3_pb2_grpc.pyi @@ -0,0 +1,10 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +package test3""" + +import collections.abc + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str diff --git a/test/generated_sync_only/testproto/test_extensions2_pb2.pyi b/test/generated_sync_only/testproto/test_extensions2_pb2.pyi new file mode 100644 index 00000000..f36b2068 --- /dev/null +++ b/test/generated_sync_only/testproto/test_extensions2_pb2.pyi @@ -0,0 +1,39 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import builtins +import google.protobuf.descriptor +import google.protobuf.internal.extension_dict +import google.protobuf.message +import sys +import testproto.test_pb2 +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +@typing.final +class SeparateFileExtension(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + FLAG_FIELD_NUMBER: builtins.int + flag: builtins.bool + EXT_FIELD_NUMBER: builtins.int + ext: google.protobuf.internal.extension_dict._ExtensionFieldDescriptor[testproto.test_pb2.Simple2, Global___SeparateFileExtension] + def __init__( + self, + *, + flag: builtins.bool | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["flag", b"flag"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["flag", b"flag"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___SeparateFileExtension: typing_extensions.TypeAlias = SeparateFileExtension diff --git a/test/generated_sync_only/testproto/test_extensions2_pb2_grpc.pyi b/test/generated_sync_only/testproto/test_extensions2_pb2_grpc.pyi new file mode 100644 index 00000000..26b99930 --- /dev/null +++ b/test/generated_sync_only/testproto/test_extensions2_pb2_grpc.pyi @@ -0,0 +1,10 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import collections.abc + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str diff --git a/test/generated_sync_only/testproto/test_extensions3_pb2.pyi b/test/generated_sync_only/testproto/test_extensions3_pb2.pyi new file mode 100644 index 00000000..f2292855 --- /dev/null +++ b/test/generated_sync_only/testproto/test_extensions3_pb2.pyi @@ -0,0 +1,46 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import builtins +import google.protobuf.descriptor +import google.protobuf.descriptor_pb2 +import google.protobuf.internal.containers +import google.protobuf.internal.extension_dict +import google.protobuf.message +import sys +import testproto.test3_pb2 +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +@typing.final +class MessageOptionsTestMsg(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + +Global___MessageOptionsTestMsg: typing_extensions.TypeAlias = MessageOptionsTestMsg + +TEST_FIELD_EXTENSION_FIELD_NUMBER: builtins.int +SCALAR_OPTION_FIELD_NUMBER: builtins.int +REPEATED_SCALAR_OPTION_FIELD_NUMBER: builtins.int +ENUM_OPTION_FIELD_NUMBER: builtins.int +REPEATED_ENUM_OPTION_FIELD_NUMBER: builtins.int +MSG_OPTION_FIELD_NUMBER: builtins.int +REPEATED_MSG_OPTION_FIELD_NUMBER: builtins.int +test_field_extension: google.protobuf.internal.extension_dict._ExtensionFieldDescriptor[google.protobuf.descriptor_pb2.FieldOptions, builtins.str] +scalar_option: google.protobuf.internal.extension_dict._ExtensionFieldDescriptor[google.protobuf.descriptor_pb2.MessageOptions, builtins.str] +repeated_scalar_option: google.protobuf.internal.extension_dict._ExtensionFieldDescriptor[google.protobuf.descriptor_pb2.MessageOptions, google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]] +enum_option: google.protobuf.internal.extension_dict._ExtensionFieldDescriptor[google.protobuf.descriptor_pb2.MessageOptions, testproto.test3_pb2.OuterEnum.ValueType] +repeated_enum_option: google.protobuf.internal.extension_dict._ExtensionFieldDescriptor[google.protobuf.descriptor_pb2.MessageOptions, google.protobuf.internal.containers.RepeatedScalarFieldContainer[testproto.test3_pb2.OuterEnum.ValueType]] +msg_option: google.protobuf.internal.extension_dict._ExtensionFieldDescriptor[google.protobuf.descriptor_pb2.MessageOptions, testproto.test3_pb2.OuterMessage3] +repeated_msg_option: google.protobuf.internal.extension_dict._ExtensionFieldDescriptor[google.protobuf.descriptor_pb2.MessageOptions, google.protobuf.internal.containers.RepeatedCompositeFieldContainer[testproto.test3_pb2.OuterMessage3]] diff --git a/test/generated_sync_only/testproto/test_extensions3_pb2_grpc.pyi b/test/generated_sync_only/testproto/test_extensions3_pb2_grpc.pyi new file mode 100644 index 00000000..26b99930 --- /dev/null +++ b/test/generated_sync_only/testproto/test_extensions3_pb2_grpc.pyi @@ -0,0 +1,10 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import collections.abc + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str diff --git a/test/generated_sync_only/testproto/test_no_generic_services_pb2.pyi b/test/generated_sync_only/testproto/test_no_generic_services_pb2.pyi new file mode 100644 index 00000000..04cf9c56 --- /dev/null +++ b/test/generated_sync_only/testproto/test_no_generic_services_pb2.pyi @@ -0,0 +1,35 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import builtins +import google.protobuf.descriptor +import google.protobuf.message +import sys +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +@typing.final +class Simple3(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + A_STRING_FIELD_NUMBER: builtins.int + a_string: builtins.str + def __init__( + self, + *, + a_string: builtins.str | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["a_string", b"a_string"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["a_string", b"a_string"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___Simple3: typing_extensions.TypeAlias = Simple3 diff --git a/test/generated_sync_only/testproto/test_no_generic_services_pb2_grpc.pyi b/test/generated_sync_only/testproto/test_no_generic_services_pb2_grpc.pyi new file mode 100644 index 00000000..eb15b37f --- /dev/null +++ b/test/generated_sync_only/testproto/test_no_generic_services_pb2_grpc.pyi @@ -0,0 +1,28 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +""" + +import abc +import collections.abc +import grpc +import testproto.test_no_generic_services_pb2 +import typing + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str + +class ATestService2Stub: + def __init__(self, channel: grpc.Channel) -> None: ... + Echo: grpc.UnaryUnaryMultiCallable[testproto.test_no_generic_services_pb2.Simple3, testproto.test_no_generic_services_pb2.Simple3] + +class ATestService2Servicer(metaclass=abc.ABCMeta): + @abc.abstractmethod + def Echo( + self, + request: testproto.test_no_generic_services_pb2.Simple3, + context: grpc.ServicerContext, + ) -> testproto.test_no_generic_services_pb2.Simple3: ... + +def add_ATestService2Servicer_to_server(servicer: ATestService2Servicer, server: grpc.Server) -> None: ... diff --git a/test/generated_sync_only/testproto/test_pb2.pyi b/test/generated_sync_only/testproto/test_pb2.pyi new file mode 100644 index 00000000..94e646db --- /dev/null +++ b/test/generated_sync_only/testproto/test_pb2.pyi @@ -0,0 +1,465 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +Proto 2 test file.""" + +import builtins +import collections.abc +import google.protobuf.descriptor +import google.protobuf.internal.containers +import google.protobuf.internal.enum_type_wrapper +import google.protobuf.internal.extension_dict +import google.protobuf.message +import sys +import test.test_generated_mypy +import testproto.inner.inner_pb2 +import testproto.nested.nested_pb2 +import testproto.nopackage_pb2 +import testproto.test3_pb2 +import typing + +if sys.version_info >= (3, 10): + import typing as typing_extensions +else: + import typing_extensions + +if sys.version_info >= (3, 13): + from warnings import deprecated +else: + from typing_extensions import deprecated + +DESCRIPTOR: google.protobuf.descriptor.FileDescriptor + +class _OuterEnum: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _OuterEnumEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_OuterEnum.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + FOO: _OuterEnum.ValueType # 1 + """FOO""" + BAR: _OuterEnum.ValueType # 2 + """BAR""" + +class OuterEnum(_OuterEnum, metaclass=_OuterEnumEnumTypeWrapper): + """Outer Enum""" + +FOO: OuterEnum.ValueType # 1 +"""FOO""" +BAR: OuterEnum.ValueType # 2 +"""BAR""" +Global___OuterEnum: typing_extensions.TypeAlias = OuterEnum + +class _NamingConflicts: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _NamingConflictsEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_NamingConflicts.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + +class NamingConflicts(_NamingConflicts, metaclass=_NamingConflictsEnumTypeWrapper): + """Naming conflicts!""" + +Name: NamingConflicts.ValueType # 1 +Value: NamingConflicts.ValueType # 2 +keys: NamingConflicts.ValueType # 3 +values: NamingConflicts.ValueType # 4 +items: NamingConflicts.ValueType # 5 +"""See https://github.com/protocolbuffers/protobuf/issues/8803 +proto itself generates broken code when DESCRIPTOR is there +DESCRIPTOR = 8; +""" +Global___NamingConflicts: typing_extensions.TypeAlias = NamingConflicts + +class _DeprecatedEnum: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + +class _DeprecatedEnumEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_DeprecatedEnum.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + DEPRECATED_ONE: _DeprecatedEnum.ValueType # 1 + DEPRECATED_TWO: _DeprecatedEnum.ValueType # 2 + +@deprecated("""This enum is deprecated\n2 lines of comments\n"Quotes in comments"\nand 'single quotes'\nTrailing comment""") +class DeprecatedEnum(_DeprecatedEnum, metaclass=_DeprecatedEnumEnumTypeWrapper): ... + +DEPRECATED_ONE: DeprecatedEnum.ValueType # 1 +DEPRECATED_TWO: DeprecatedEnum.ValueType # 2 +Global___DeprecatedEnum: typing_extensions.TypeAlias = DeprecatedEnum + +@typing.final +class Simple1(google.protobuf.message.Message): + """Message with one of everything""" + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + class _InnerEnum: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + + class _InnerEnumEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[Simple1._InnerEnum.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + INNER1: Simple1._InnerEnum.ValueType # 1 + """INNER1""" + INNER2: Simple1._InnerEnum.ValueType # 2 + """INNER2""" + + class InnerEnum(_InnerEnum, metaclass=_InnerEnumEnumTypeWrapper): + """Inner Enum""" + + INNER1: Simple1.InnerEnum.ValueType # 1 + """INNER1""" + INNER2: Simple1.InnerEnum.ValueType # 2 + """INNER2""" + + @typing.final + class InnerMessage(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + def __init__( + self, + ) -> None: ... + + @typing.final + class EmailByUidEntry(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + KEY_FIELD_NUMBER: builtins.int + VALUE_FIELD_NUMBER: builtins.int + key: builtins.int + value: builtins.str + def __init__( + self, + *, + key: builtins.int | None = ..., + value: builtins.str | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["key", b"key", "value", b"value"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["key", b"key", "value", b"value"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + + A_STRING_FIELD_NUMBER: builtins.int + A_REPEATED_STRING_FIELD_NUMBER: builtins.int + A_BOOLEAN_FIELD_NUMBER: builtins.int + A_UINT32_FIELD_NUMBER: builtins.int + A_ENUM_FIELD_NUMBER: builtins.int + A_EXTERNAL_ENUM_FIELD_NUMBER: builtins.int + A_INNER_FIELD_NUMBER: builtins.int + A_NESTED_FIELD_NUMBER: builtins.int + INNER_ENUM_FIELD_NUMBER: builtins.int + REP_INNER_ENUM_FIELD_NUMBER: builtins.int + INNER_MESSAGE_FIELD_NUMBER: builtins.int + REP_INNER_MESSAGE_FIELD_NUMBER: builtins.int + NO_PACKAGE_FIELD_NUMBER: builtins.int + NESTED_ENUM_FIELD_NUMBER: builtins.int + NESTED_MESSAGE_FIELD_NUMBER: builtins.int + A_ONEOF_1_FIELD_NUMBER: builtins.int + A_ONEOF_2_FIELD_NUMBER: builtins.int + OUTER_MESSAGE_IN_ONEOF_FIELD_NUMBER: builtins.int + OUTER_ENUM_IN_ONEOF_FIELD_NUMBER: builtins.int + INNER_ENUM_IN_ONEOF_FIELD_NUMBER: builtins.int + USER_ID_FIELD_NUMBER: builtins.int + EMAIL_FIELD_NUMBER: builtins.int + EMAIL_BY_UID_FIELD_NUMBER: builtins.int + a_string: builtins.str + a_boolean: builtins.bool + a_uint32: builtins.int + a_enum: Global___OuterEnum.ValueType + a_external_enum: testproto.test3_pb2.OuterEnum.ValueType + inner_enum: Global___Simple1.InnerEnum.ValueType + nested_enum: testproto.nested.nested_pb2.AnotherNested.NestedEnum.ValueType + a_oneof_1: builtins.str + a_oneof_2: builtins.str + outer_enum_in_oneof: Global___OuterEnum.ValueType + inner_enum_in_oneof: Global___Simple1.InnerEnum.ValueType + user_id: test.test_generated_mypy.UserId + email: test.test_generated_mypy.Email + @property + def a_repeated_string(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]: ... + @property + def a_inner(self) -> testproto.inner.inner_pb2.Inner: ... + @property + def a_nested(self) -> testproto.nested.nested_pb2.Nested: ... + @property + def rep_inner_enum(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[Global___Simple1.InnerEnum.ValueType]: ... + @property + def inner_message(self) -> Global___Simple1.InnerMessage: ... + @property + def rep_inner_message(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[Global___Simple1.InnerMessage]: ... + @property + def no_package(self) -> testproto.nopackage_pb2.NoPackage: ... + @property + def nested_message(self) -> testproto.nested.nested_pb2.AnotherNested.NestedMessage: ... + @property + def outer_message_in_oneof(self) -> Global___Simple2: ... + @property + def email_by_uid(self) -> google.protobuf.internal.containers.ScalarMap[test.test_generated_mypy.UserId, test.test_generated_mypy.Email]: ... + def __init__( + self, + *, + a_string: builtins.str | None = ..., + a_repeated_string: collections.abc.Iterable[builtins.str] | None = ..., + a_boolean: builtins.bool | None = ..., + a_uint32: builtins.int | None = ..., + a_enum: Global___OuterEnum.ValueType | None = ..., + a_external_enum: testproto.test3_pb2.OuterEnum.ValueType | None = ..., + a_inner: testproto.inner.inner_pb2.Inner | None = ..., + a_nested: testproto.nested.nested_pb2.Nested | None = ..., + inner_enum: Global___Simple1.InnerEnum.ValueType | None = ..., + rep_inner_enum: collections.abc.Iterable[Global___Simple1.InnerEnum.ValueType] | None = ..., + inner_message: Global___Simple1.InnerMessage | None = ..., + rep_inner_message: collections.abc.Iterable[Global___Simple1.InnerMessage] | None = ..., + no_package: testproto.nopackage_pb2.NoPackage | None = ..., + nested_enum: testproto.nested.nested_pb2.AnotherNested.NestedEnum.ValueType | None = ..., + nested_message: testproto.nested.nested_pb2.AnotherNested.NestedMessage | None = ..., + a_oneof_1: builtins.str | None = ..., + a_oneof_2: builtins.str | None = ..., + outer_message_in_oneof: Global___Simple2 | None = ..., + outer_enum_in_oneof: Global___OuterEnum.ValueType | None = ..., + inner_enum_in_oneof: Global___Simple1.InnerEnum.ValueType | None = ..., + user_id: test.test_generated_mypy.UserId | None = ..., + email: test.test_generated_mypy.Email | None = ..., + email_by_uid: collections.abc.Mapping[test.test_generated_mypy.UserId, test.test_generated_mypy.Email] | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["a_boolean", b"a_boolean", "a_enum", b"a_enum", "a_external_enum", b"a_external_enum", "a_inner", b"a_inner", "a_nested", b"a_nested", "a_oneof", b"a_oneof", "a_oneof_1", b"a_oneof_1", "a_oneof_2", b"a_oneof_2", "a_string", b"a_string", "a_uint32", b"a_uint32", "email", b"email", "inner_enum", b"inner_enum", "inner_enum_in_oneof", b"inner_enum_in_oneof", "inner_message", b"inner_message", "nested_enum", b"nested_enum", "nested_message", b"nested_message", "no_package", b"no_package", "outer_enum_in_oneof", b"outer_enum_in_oneof", "outer_message_in_oneof", b"outer_message_in_oneof", "user_id", b"user_id"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["a_boolean", b"a_boolean", "a_enum", b"a_enum", "a_external_enum", b"a_external_enum", "a_inner", b"a_inner", "a_nested", b"a_nested", "a_oneof", b"a_oneof", "a_oneof_1", b"a_oneof_1", "a_oneof_2", b"a_oneof_2", "a_repeated_string", b"a_repeated_string", "a_string", b"a_string", "a_uint32", b"a_uint32", "email", b"email", "email_by_uid", b"email_by_uid", "inner_enum", b"inner_enum", "inner_enum_in_oneof", b"inner_enum_in_oneof", "inner_message", b"inner_message", "nested_enum", b"nested_enum", "nested_message", b"nested_message", "no_package", b"no_package", "outer_enum_in_oneof", b"outer_enum_in_oneof", "outer_message_in_oneof", b"outer_message_in_oneof", "rep_inner_enum", b"rep_inner_enum", "rep_inner_message", b"rep_inner_message", "user_id", b"user_id"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + _WhichOneofReturnType_a_oneof: typing_extensions.TypeAlias = typing.Literal["a_oneof_1", "a_oneof_2", "outer_message_in_oneof", "outer_enum_in_oneof", "inner_enum_in_oneof"] + _WhichOneofArgType_a_oneof: typing_extensions.TypeAlias = typing.Literal["a_oneof", b"a_oneof"] + def WhichOneof(self, oneof_group: _WhichOneofArgType_a_oneof) -> _WhichOneofReturnType_a_oneof | None: ... + +Global___Simple1: typing_extensions.TypeAlias = Simple1 + +@typing.final +class Simple2(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + A_STRING_FIELD_NUMBER: builtins.int + a_string: builtins.str + def __init__( + self, + *, + a_string: builtins.str | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["a_string", b"a_string"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["a_string", b"a_string"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___Simple2: typing_extensions.TypeAlias = Simple2 + +@typing.final +class Extensions1(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + EXT1_STRING_FIELD_NUMBER: builtins.int + ext1_string: builtins.str + EXT_FIELD_NUMBER: builtins.int + ext: google.protobuf.internal.extension_dict._ExtensionFieldDescriptor[Global___Simple1, Global___Extensions1] + """ext""" + def __init__( + self, + *, + ext1_string: builtins.str | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["ext1_string", b"ext1_string"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["ext1_string", b"ext1_string"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___Extensions1: typing_extensions.TypeAlias = Extensions1 + +@typing.final +class Extensions2(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + FLAG_FIELD_NUMBER: builtins.int + flag: builtins.bool + FOO_FIELD_NUMBER: builtins.int + foo: google.protobuf.internal.extension_dict._ExtensionFieldDescriptor[Global___Simple1, Global___Extensions2] + """foo""" + def __init__( + self, + *, + flag: builtins.bool | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["flag", b"flag"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["flag", b"flag"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___Extensions2: typing_extensions.TypeAlias = Extensions2 + +@typing.final +class _r_None(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + VALID_FIELD_NUMBER: builtins.int + valid: builtins.int + def __init__( + self, + *, + valid: builtins.int | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["valid", b"valid"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["valid", b"valid"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global____r_None: typing_extensions.TypeAlias = _r_None + +@typing.final +class PythonReservedKeywords(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + class _finally: + ValueType = typing.NewType("ValueType", builtins.int) + V: typing_extensions.TypeAlias = ValueType + + class _finallyEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[PythonReservedKeywords._finally.ValueType], builtins.type): + DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor + valid_in_finally: PythonReservedKeywords._finally.ValueType # 2 + + class _r_finally(_finally, metaclass=_finallyEnumTypeWrapper): ... + valid_in_finally: PythonReservedKeywords._r_finally.ValueType # 2 + + @typing.final + class _r_lambda(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + CONTINUE_FIELD_NUMBER: builtins.int + VALID_FIELD_NUMBER: builtins.int + valid: builtins.int + def __init__( + self, + *, + valid: builtins.int | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["continue", b"continue", "valid", b"valid"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["continue", b"continue", "valid", b"valid"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + + FROM_FIELD_NUMBER: builtins.int + IN_FIELD_NUMBER: builtins.int + IS_FIELD_NUMBER: builtins.int + FOR_FIELD_NUMBER: builtins.int + TRY_FIELD_NUMBER: builtins.int + DEF_FIELD_NUMBER: builtins.int + NONLOCAL_FIELD_NUMBER: builtins.int + WHILE_FIELD_NUMBER: builtins.int + AND_FIELD_NUMBER: builtins.int + DEL_FIELD_NUMBER: builtins.int + GLOBAL_FIELD_NUMBER: builtins.int + NOT_FIELD_NUMBER: builtins.int + WITH_FIELD_NUMBER: builtins.int + AS_FIELD_NUMBER: builtins.int + ELIF_FIELD_NUMBER: builtins.int + IF_FIELD_NUMBER: builtins.int + OR_FIELD_NUMBER: builtins.int + YIELD_FIELD_NUMBER: builtins.int + ASSERT_FIELD_NUMBER: builtins.int + ELSE_FIELD_NUMBER: builtins.int + IMPORT_FIELD_NUMBER: builtins.int + PASS_FIELD_NUMBER: builtins.int + BREAK_FIELD_NUMBER: builtins.int + EXCEPT_FIELD_NUMBER: builtins.int + RAISE_FIELD_NUMBER: builtins.int + FALSE_FIELD_NUMBER: builtins.int + TRUE_FIELD_NUMBER: builtins.int + CLASS_FIELD_NUMBER: builtins.int + NONE_FIELD_NUMBER: builtins.int + VALID_FIELD_NUMBER: builtins.int + valid: Global___PythonReservedKeywords._r_finally.ValueType + @property + def none(self) -> Global____r_None: + """Test unreserved identifiers w/ reserved message names""" + + def __init__( + self, + *, + none: Global____r_None | None = ..., + valid: Global___PythonReservedKeywords._r_finally.ValueType | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["False", b"False", "True", b"True", "and", b"and", "as", b"as", "assert", b"assert", "break", b"break", "class", b"class", "def", b"def", "del", b"del", "elif", b"elif", "else", b"else", "except", b"except", "for", b"for", "from", b"from", "global", b"global", "if", b"if", "import", b"import", "in", b"in", "is", b"is", "none", b"none", "nonlocal", b"nonlocal", "not", b"not", "or", b"or", "pass", b"pass", "raise", b"raise", "try", b"try", "valid", b"valid", "while", b"while", "with", b"with", "yield", b"yield"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["False", b"False", "True", b"True", "and", b"and", "as", b"as", "assert", b"assert", "break", b"break", "class", b"class", "def", b"def", "del", b"del", "elif", b"elif", "else", b"else", "except", b"except", "for", b"for", "from", b"from", "global", b"global", "if", b"if", "import", b"import", "in", b"in", "is", b"is", "none", b"none", "nonlocal", b"nonlocal", "not", b"not", "or", b"or", "pass", b"pass", "raise", b"raise", "try", b"try", "valid", b"valid", "while", b"while", "with", b"with", "yield", b"yield"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___PythonReservedKeywords: typing_extensions.TypeAlias = PythonReservedKeywords + +@typing.final +class PythonReservedKeywordsSmall(google.protobuf.message.Message): + """Do one with just one arg - to make sure it's syntactically correct""" + + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + FROM_FIELD_NUMBER: builtins.int + def __init__( + self, + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["from", b"from"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["from", b"from"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___PythonReservedKeywordsSmall: typing_extensions.TypeAlias = PythonReservedKeywordsSmall + +@typing.final +class SelfField(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + SELF_FIELD_NUMBER: builtins.int + self: builtins.int + """Field self -> must generate an __init__ method w/ different name""" + def __init__( + self_, # pyright: ignore[reportSelfClsParameterName] + *, + self: builtins.int | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["self", b"self"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["self", b"self"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___SelfField: typing_extensions.TypeAlias = SelfField + +@deprecated("""This message is deprecated""") +@typing.final +class DeprecatedMessage(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + A_STRING_FIELD_NUMBER: builtins.int + a_string: builtins.str + def __init__( + self, + *, + a_string: builtins.str | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["a_string", b"a_string"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["a_string", b"a_string"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___DeprecatedMessage: typing_extensions.TypeAlias = DeprecatedMessage + +@deprecated("""This message has been marked as deprecated using proto message options.""") +@typing.final +class DeprecatedMessageBadComment(google.protobuf.message.Message): + DESCRIPTOR: google.protobuf.descriptor.Descriptor + + A_STRING_FIELD_NUMBER: builtins.int + a_string: builtins.str + def __init__( + self, + *, + a_string: builtins.str | None = ..., + ) -> None: ... + _HasFieldArgType: typing_extensions.TypeAlias = typing.Literal["a_string", b"a_string"] + def HasField(self, field_name: _HasFieldArgType) -> builtins.bool: ... + _ClearFieldArgType: typing_extensions.TypeAlias = typing.Literal["a_string", b"a_string"] + def ClearField(self, field_name: _ClearFieldArgType) -> None: ... + +Global___DeprecatedMessageBadComment: typing_extensions.TypeAlias = DeprecatedMessageBadComment diff --git a/test/generated_sync_only/testproto/test_pb2_grpc.pyi b/test/generated_sync_only/testproto/test_pb2_grpc.pyi new file mode 100644 index 00000000..71b14ba3 --- /dev/null +++ b/test/generated_sync_only/testproto/test_pb2_grpc.pyi @@ -0,0 +1,44 @@ +""" +@generated by mypy-protobuf. Do not edit manually! +isort:skip_file +Proto 2 test file.""" + +import abc +import collections.abc +import grpc +import testproto.test_pb2 +import typing + + +GRPC_GENERATED_VERSION: str +GRPC_VERSION: str + +class PythonReservedKeywordsServiceStub: + """Method name is reserved""" + + def __init__(self, channel: grpc.Channel) -> None: ... + valid_method_name1: grpc.UnaryUnaryMultiCallable[testproto.test_pb2.Simple1, testproto.test_pb2._r_None] + """valid_method_name1""" + valid_method_name2: grpc.UnaryUnaryMultiCallable[testproto.test_pb2.Simple1, testproto.test_pb2.PythonReservedKeywords._r_lambda] + """valid_method_name2""" + +class PythonReservedKeywordsServiceServicer(metaclass=abc.ABCMeta): + """Method name is reserved""" + + @abc.abstractmethod + def valid_method_name1( + self, + request: testproto.test_pb2.Simple1, + context: grpc.ServicerContext, + ) -> testproto.test_pb2._r_None: + """valid_method_name1""" + + @abc.abstractmethod + def valid_method_name2( + self, + request: testproto.test_pb2.Simple1, + context: grpc.ServicerContext, + ) -> testproto.test_pb2.PythonReservedKeywords._r_lambda: + """valid_method_name2""" + +def add_PythonReservedKeywordsServiceServicer_to_server(servicer: PythonReservedKeywordsServiceServicer, server: grpc.Server) -> None: ... diff --git a/test/sync_only/test_sync_only.py b/test/sync_only/test_sync_only.py new file mode 100644 index 00000000..229bf475 --- /dev/null +++ b/test/sync_only/test_sync_only.py @@ -0,0 +1,94 @@ +""" +Type-checking and runtime test for sync_only GRPC stubs. + +This module validates that stubs generated with the only_sync flag have the correct types: +- Regular (non-generic) Stub class that only accepts grpc.Channel +- Servicer methods use Iterator for client streaming (not _MaybeAsyncIterator) +- add_XXXServicer_to_server accepts grpc.Server +""" + +from concurrent import futures + +import grpc +import typing_extensions as typing +from testproto.grpc import dummy_pb2, dummy_pb2_grpc + +ADDRESS = "localhost:22224" + + +class Servicer(dummy_pb2_grpc.DummyServiceServicer): + def UnaryUnary( + self, + request: dummy_pb2.DummyRequest, + context: grpc.ServicerContext, + ) -> dummy_pb2.DummyReply: + return dummy_pb2.DummyReply(value=request.value[::-1]) + + def UnaryStream( + self, + request: dummy_pb2.DummyRequest, + context: grpc.ServicerContext, + ) -> typing.Iterator[dummy_pb2.DummyReply]: + for char in request.value: + yield dummy_pb2.DummyReply(value=char) + + def StreamUnary( + self, + request_iterator: typing.Iterator[dummy_pb2.DummyRequest], + context: grpc.ServicerContext, + ) -> dummy_pb2.DummyReply: + return dummy_pb2.DummyReply(value="".join(data.value for data in request_iterator)) + + def StreamStream( + self, + request_iterator: typing.Iterator[dummy_pb2.DummyRequest], + context: grpc.ServicerContext, + ) -> typing.Iterator[dummy_pb2.DummyReply]: + for data in request_iterator: + yield dummy_pb2.DummyReply(value=data.value.upper()) + + +def make_server() -> grpc.Server: + server = grpc.server(futures.ThreadPoolExecutor()) + servicer = Servicer() + server.add_insecure_port(ADDRESS) + dummy_pb2_grpc.add_DummyServiceServicer_to_server(servicer, server) + return server + + +def test_sync_only_grpc() -> None: + server = make_server() + server.start() + channel = grpc.insecure_channel(ADDRESS) + client = dummy_pb2_grpc.DummyServiceStub(channel) + request = dummy_pb2.DummyRequest(value="cprg") + result1 = client.UnaryUnary(request) + result2 = client.UnaryStream(dummy_pb2.DummyRequest(value=result1.value)) + result2_list = list(result2) + assert len(result2_list) == 4 + result3 = client.StreamStream(dummy_pb2.DummyRequest(value=part.value) for part in result2_list) + result3_list = list(result3) + assert len(result3_list) == 4 + result4 = client.StreamUnary(dummy_pb2.DummyRequest(value=part.value) for part in result3_list) + assert result4.value == "GRPC" + + # test future() in MultiCallable + future_test: grpc._CallFuture[dummy_pb2.DummyReply] = client.UnaryUnary.future(request) + result5 = future_test.result() + assert result5.value == "grpc" + + # test params on __call__ in MultiCallable + result6: dummy_pb2.DummyReply = client.UnaryUnary(request, timeout=4, metadata=(("test", "metadata"), ("cheems", "many"))) + assert result6.value == "grpc" + + server.stop(None) + + class TestAttribute: + stub: dummy_pb2_grpc.DummyServiceStub + + def __init__(self) -> None: + self.stub = dummy_pb2_grpc.DummyServiceStub(grpc.insecure_channel(ADDRESS)) + + def test(self) -> None: + val = self.stub.UnaryUnary(dummy_pb2.DummyRequest(value="test")) + typing.assert_type(val, dummy_pb2.DummyReply) diff --git a/uv.lock b/uv.lock new file mode 100644 index 00000000..a5bc5147 --- /dev/null +++ b/uv.lock @@ -0,0 +1,3 @@ +version = 1 +revision = 3 +requires-python = ">=3.14"