diff --git a/third_party/2/google/protobuf/any_pb2.pyi b/third_party/2/google/protobuf/any_pb2.pyi new file mode 100644 index 000000000..4aa013f57 --- /dev/null +++ b/third_party/2/google/protobuf/any_pb2.pyi @@ -0,0 +1,20 @@ +from google.protobuf.message import ( + Message, +) +from typing import ( + Optional, + Text, +) + + +class Any(Message): + type_url = ... # type: Text + value = ... # type: str + + def __init__(self, + type_url: Optional[Text] = ..., + value: Optional[str] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> Any: ... diff --git a/third_party/2/google/protobuf/any_test_pb2.pyi b/third_party/2/google/protobuf/any_test_pb2.pyi new file mode 100644 index 000000000..2e1053db4 --- /dev/null +++ b/third_party/2/google/protobuf/any_test_pb2.pyi @@ -0,0 +1,32 @@ +from google.protobuf.any_pb2 import ( + Any, +) +from google.protobuf.internal.containers import ( + RepeatedCompositeFieldContainer, +) +from google.protobuf.message import ( + Message, +) +from typing import ( + Iterable, + Optional, +) + + +class TestAny(Message): + int32_value = ... # type: int + + @property + def any_value(self) -> Any: ... + + @property + def repeated_any_value(self) -> RepeatedCompositeFieldContainer[Any]: ... + + def __init__(self, + int32_value: Optional[int] = ..., + any_value: Optional[Any] = ..., + repeated_any_value: Optional[Iterable[Any]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAny: ... diff --git a/third_party/2/google/protobuf/api_pb2.pyi b/third_party/2/google/protobuf/api_pb2.pyi new file mode 100644 index 000000000..9ca6842c8 --- /dev/null +++ b/third_party/2/google/protobuf/api_pb2.pyi @@ -0,0 +1,87 @@ +from google.protobuf.internal.containers import ( + RepeatedCompositeFieldContainer, +) +from google.protobuf.message import ( + Message, +) +from google.protobuf.source_context_pb2 import ( + SourceContext, +) +from google.protobuf.type_pb2 import ( + Option, + Syntax, +) +from typing import ( + Iterable, + Optional, + Text, +) + + +class Api(Message): + name = ... # type: Text + version = ... # type: Text + syntax = ... # type: Syntax + + @property + def methods(self) -> RepeatedCompositeFieldContainer[Method]: ... + + @property + def options(self) -> RepeatedCompositeFieldContainer[Option]: ... + + @property + def source_context(self) -> SourceContext: ... + + @property + def mixins(self) -> RepeatedCompositeFieldContainer[Mixin]: ... + + def __init__(self, + name: Optional[Text] = ..., + methods: Optional[Iterable[Method]] = ..., + options: Optional[Iterable[Option]] = ..., + version: Optional[Text] = ..., + source_context: Optional[SourceContext] = ..., + mixins: Optional[Iterable[Mixin]] = ..., + syntax: Optional[Syntax] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> Api: ... + + +class Method(Message): + name = ... # type: Text + request_type_url = ... # type: Text + request_streaming = ... # type: bool + response_type_url = ... # type: Text + response_streaming = ... # type: bool + syntax = ... # type: Syntax + + @property + def options(self) -> RepeatedCompositeFieldContainer[Option]: ... + + def __init__(self, + name: Optional[Text] = ..., + request_type_url: Optional[Text] = ..., + request_streaming: Optional[bool] = ..., + response_type_url: Optional[Text] = ..., + response_streaming: Optional[bool] = ..., + options: Optional[Iterable[Option]] = ..., + syntax: Optional[Syntax] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> Method: ... + + +class Mixin(Message): + name = ... # type: Text + root = ... # type: Text + + def __init__(self, + name: Optional[Text] = ..., + root: Optional[Text] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> Mixin: ... diff --git a/third_party/2/google/protobuf/compiler/plugin_pb2.pyi b/third_party/2/google/protobuf/compiler/plugin_pb2.pyi new file mode 100644 index 000000000..813ffc89e --- /dev/null +++ b/third_party/2/google/protobuf/compiler/plugin_pb2.pyi @@ -0,0 +1,82 @@ +from google.protobuf.descriptor_pb2 import ( + FileDescriptorProto, +) +from google.protobuf.internal.containers import ( + RepeatedCompositeFieldContainer, + RepeatedScalarFieldContainer, +) +from google.protobuf.message import ( + Message, +) +from typing import ( + Iterable, + Optional, + Text, +) + + +class Version(Message): + major = ... # type: int + minor = ... # type: int + patch = ... # type: int + suffix = ... # type: Text + + def __init__(self, + major: Optional[int] = ..., + minor: Optional[int] = ..., + patch: Optional[int] = ..., + suffix: Optional[Text] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> Version: ... + + +class CodeGeneratorRequest(Message): + file_to_generate = ... # type: RepeatedScalarFieldContainer[Text] + parameter = ... # type: Text + + @property + def proto_file(self) -> RepeatedCompositeFieldContainer[FileDescriptorProto]: ... + + @property + def compiler_version(self) -> Version: ... + + def __init__(self, + file_to_generate: Optional[Iterable[Text]] = ..., + parameter: Optional[Text] = ..., + proto_file: Optional[Iterable[FileDescriptorProto]] = ..., + compiler_version: Optional[Version] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> CodeGeneratorRequest: ... + + +class CodeGeneratorResponse(Message): + + class File(Message): + name = ... # type: Text + insertion_point = ... # type: Text + content = ... # type: Text + + def __init__(self, + name: Optional[Text] = ..., + insertion_point: Optional[Text] = ..., + content: Optional[Text] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> CodeGeneratorResponse.File: ... + error = ... # type: Text + + @property + def file(self) -> RepeatedCompositeFieldContainer[CodeGeneratorResponse.File]: ... + + def __init__(self, + error: Optional[Text] = ..., + file: Optional[Iterable[CodeGeneratorResponse.File]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> CodeGeneratorResponse: ... diff --git a/third_party/2/google/protobuf/descriptor_pb2.pyi b/third_party/2/google/protobuf/descriptor_pb2.pyi index 4ac2e4c15..60247dd3d 100644 --- a/third_party/2/google/protobuf/descriptor_pb2.pyi +++ b/third_party/2/google/protobuf/descriptor_pb2.pyi @@ -1,2 +1,732 @@ -class FileOptions(object): ... -class FieldOptions(object): ... +from google.protobuf.internal.containers import ( + RepeatedCompositeFieldContainer, + RepeatedScalarFieldContainer, +) +from google.protobuf.message import ( + Message, +) +from typing import ( + Iterable, + List, + Optional, + Text, + Tuple, + cast, +) + + +class FileDescriptorSet(Message): + + @property + def file(self) -> RepeatedCompositeFieldContainer[FileDescriptorProto]: ... + + def __init__(self, + file: Optional[Iterable[FileDescriptorProto]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> FileDescriptorSet: ... + + +class FileDescriptorProto(Message): + name = ... # type: Text + package = ... # type: Text + dependency = ... # type: RepeatedScalarFieldContainer[Text] + public_dependency = ... # type: RepeatedScalarFieldContainer[int] + weak_dependency = ... # type: RepeatedScalarFieldContainer[int] + syntax = ... # type: Text + + @property + def message_type( + self) -> RepeatedCompositeFieldContainer[DescriptorProto]: ... + + @property + def enum_type( + self) -> RepeatedCompositeFieldContainer[EnumDescriptorProto]: ... + + @property + def service( + self) -> RepeatedCompositeFieldContainer[ServiceDescriptorProto]: ... + + @property + def extension( + self) -> RepeatedCompositeFieldContainer[FieldDescriptorProto]: ... + + @property + def options(self) -> FileOptions: ... + + @property + def source_code_info(self) -> SourceCodeInfo: ... + + def __init__(self, + name: Optional[Text] = ..., + package: Optional[Text] = ..., + dependency: Optional[Iterable[Text]] = ..., + public_dependency: Optional[Iterable[int]] = ..., + weak_dependency: Optional[Iterable[int]] = ..., + message_type: Optional[Iterable[DescriptorProto]] = ..., + enum_type: Optional[Iterable[EnumDescriptorProto]] = ..., + service: Optional[Iterable[ServiceDescriptorProto]] = ..., + extension: Optional[Iterable[FieldDescriptorProto]] = ..., + options: Optional[FileOptions] = ..., + source_code_info: Optional[SourceCodeInfo] = ..., + syntax: Optional[Text] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> FileDescriptorProto: ... + + +class DescriptorProto(Message): + + class ExtensionRange(Message): + start = ... # type: int + end = ... # type: int + + @property + def options(self) -> ExtensionRangeOptions: ... + + def __init__(self, + start: Optional[int] = ..., + end: Optional[int] = ..., + options: Optional[ExtensionRangeOptions] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> DescriptorProto.ExtensionRange: ... + + class ReservedRange(Message): + start = ... # type: int + end = ... # type: int + + def __init__(self, + start: Optional[int] = ..., + end: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> DescriptorProto.ReservedRange: ... + name = ... # type: Text + reserved_name = ... # type: RepeatedScalarFieldContainer[Text] + + @property + def field( + self) -> RepeatedCompositeFieldContainer[FieldDescriptorProto]: ... + + @property + def extension( + self) -> RepeatedCompositeFieldContainer[FieldDescriptorProto]: ... + + @property + def nested_type( + self) -> RepeatedCompositeFieldContainer[DescriptorProto]: ... + + @property + def enum_type( + self) -> RepeatedCompositeFieldContainer[EnumDescriptorProto]: ... + + @property + def extension_range( + self) -> RepeatedCompositeFieldContainer[DescriptorProto.ExtensionRange]: ... + + @property + def oneof_decl( + self) -> RepeatedCompositeFieldContainer[OneofDescriptorProto]: ... + + @property + def options(self) -> MessageOptions: ... + + @property + def reserved_range( + self) -> RepeatedCompositeFieldContainer[DescriptorProto.ReservedRange]: ... + + def __init__(self, + name: Optional[Text] = ..., + field: Optional[Iterable[FieldDescriptorProto]] = ..., + extension: Optional[Iterable[FieldDescriptorProto]] = ..., + nested_type: Optional[Iterable[DescriptorProto]] = ..., + enum_type: Optional[Iterable[EnumDescriptorProto]] = ..., + extension_range: Optional[Iterable[DescriptorProto.ExtensionRange]] = ..., + oneof_decl: Optional[Iterable[OneofDescriptorProto]] = ..., + options: Optional[MessageOptions] = ..., + reserved_range: Optional[Iterable[DescriptorProto.ReservedRange]] = ..., + reserved_name: Optional[Iterable[Text]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> DescriptorProto: ... + + +class ExtensionRangeOptions(Message): + + @property + def uninterpreted_option( + self) -> RepeatedCompositeFieldContainer[UninterpretedOption]: ... + + def __init__(self, + uninterpreted_option: Optional[Iterable[UninterpretedOption]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> ExtensionRangeOptions: ... + + +class FieldDescriptorProto(Message): + + class Type(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> FieldDescriptorProto.Type: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[FieldDescriptorProto.Type]: ... + + @classmethod + def items(cls) -> List[Tuple[str, FieldDescriptorProto.Type]]: ... + TYPE_DOUBLE: Type + TYPE_FLOAT: Type + TYPE_INT64: Type + TYPE_UINT64: Type + TYPE_INT32: Type + TYPE_FIXED64: Type + TYPE_FIXED32: Type + TYPE_BOOL: Type + TYPE_STRING: Type + TYPE_GROUP: Type + TYPE_MESSAGE: Type + TYPE_BYTES: Type + TYPE_UINT32: Type + TYPE_ENUM: Type + TYPE_SFIXED32: Type + TYPE_SFIXED64: Type + TYPE_SINT32: Type + TYPE_SINT64: Type + + class Label(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> FieldDescriptorProto.Label: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[FieldDescriptorProto.Label]: ... + + @classmethod + def items(cls) -> List[Tuple[str, FieldDescriptorProto.Label]]: ... + LABEL_OPTIONAL: Label + LABEL_REQUIRED: Label + LABEL_REPEATED: Label + name = ... # type: Text + number = ... # type: int + label = ... # type: FieldDescriptorProto.Label + type = ... # type: FieldDescriptorProto.Type + type_name = ... # type: Text + extendee = ... # type: Text + default_value = ... # type: Text + oneof_index = ... # type: int + json_name = ... # type: Text + + @property + def options(self) -> FieldOptions: ... + + def __init__(self, + name: Optional[Text] = ..., + number: Optional[int] = ..., + label: Optional[FieldDescriptorProto.Label] = ..., + type: Optional[FieldDescriptorProto.Type] = ..., + type_name: Optional[Text] = ..., + extendee: Optional[Text] = ..., + default_value: Optional[Text] = ..., + oneof_index: Optional[int] = ..., + json_name: Optional[Text] = ..., + options: Optional[FieldOptions] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> FieldDescriptorProto: ... + + +class OneofDescriptorProto(Message): + name = ... # type: Text + + @property + def options(self) -> OneofOptions: ... + + def __init__(self, + name: Optional[Text] = ..., + options: Optional[OneofOptions] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> OneofDescriptorProto: ... + + +class EnumDescriptorProto(Message): + + class EnumReservedRange(Message): + start = ... # type: int + end = ... # type: int + + def __init__(self, + start: Optional[int] = ..., + end: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> EnumDescriptorProto.EnumReservedRange: ... + name = ... # type: Text + reserved_name = ... # type: RepeatedScalarFieldContainer[Text] + + @property + def value( + self) -> RepeatedCompositeFieldContainer[EnumValueDescriptorProto]: ... + + @property + def options(self) -> EnumOptions: ... + + @property + def reserved_range( + self) -> RepeatedCompositeFieldContainer[EnumDescriptorProto.EnumReservedRange]: ... + + def __init__(self, + name: Optional[Text] = ..., + value: Optional[Iterable[EnumValueDescriptorProto]] = ..., + options: Optional[EnumOptions] = ..., + reserved_range: Optional[Iterable[EnumDescriptorProto.EnumReservedRange]] = ..., + reserved_name: Optional[Iterable[Text]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> EnumDescriptorProto: ... + + +class EnumValueDescriptorProto(Message): + name = ... # type: Text + number = ... # type: int + + @property + def options(self) -> EnumValueOptions: ... + + def __init__(self, + name: Optional[Text] = ..., + number: Optional[int] = ..., + options: Optional[EnumValueOptions] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> EnumValueDescriptorProto: ... + + +class ServiceDescriptorProto(Message): + name = ... # type: Text + + @property + def method( + self) -> RepeatedCompositeFieldContainer[MethodDescriptorProto]: ... + + @property + def options(self) -> ServiceOptions: ... + + def __init__(self, + name: Optional[Text] = ..., + method: Optional[Iterable[MethodDescriptorProto]] = ..., + options: Optional[ServiceOptions] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> ServiceDescriptorProto: ... + + +class MethodDescriptorProto(Message): + name = ... # type: Text + input_type = ... # type: Text + output_type = ... # type: Text + client_streaming = ... # type: bool + server_streaming = ... # type: bool + + @property + def options(self) -> MethodOptions: ... + + def __init__(self, + name: Optional[Text] = ..., + input_type: Optional[Text] = ..., + output_type: Optional[Text] = ..., + options: Optional[MethodOptions] = ..., + client_streaming: Optional[bool] = ..., + server_streaming: Optional[bool] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> MethodDescriptorProto: ... + + +class FileOptions(Message): + + class OptimizeMode(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> FileOptions.OptimizeMode: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[FileOptions.OptimizeMode]: ... + + @classmethod + def items(cls) -> List[Tuple[str, FileOptions.OptimizeMode]]: ... + SPEED: OptimizeMode + CODE_SIZE: OptimizeMode + LITE_RUNTIME: OptimizeMode + java_package = ... # type: Text + java_outer_classname = ... # type: Text + java_multiple_files = ... # type: bool + java_generate_equals_and_hash = ... # type: bool + java_string_check_utf8 = ... # type: bool + optimize_for = ... # type: FileOptions.OptimizeMode + go_package = ... # type: Text + cc_generic_services = ... # type: bool + java_generic_services = ... # type: bool + py_generic_services = ... # type: bool + php_generic_services = ... # type: bool + deprecated = ... # type: bool + cc_enable_arenas = ... # type: bool + objc_class_prefix = ... # type: Text + csharp_namespace = ... # type: Text + swift_prefix = ... # type: Text + php_class_prefix = ... # type: Text + php_namespace = ... # type: Text + + @property + def uninterpreted_option( + self) -> RepeatedCompositeFieldContainer[UninterpretedOption]: ... + + def __init__(self, + java_package: Optional[Text] = ..., + java_outer_classname: Optional[Text] = ..., + java_multiple_files: Optional[bool] = ..., + java_generate_equals_and_hash: Optional[bool] = ..., + java_string_check_utf8: Optional[bool] = ..., + optimize_for: Optional[FileOptions.OptimizeMode] = ..., + go_package: Optional[Text] = ..., + cc_generic_services: Optional[bool] = ..., + java_generic_services: Optional[bool] = ..., + py_generic_services: Optional[bool] = ..., + php_generic_services: Optional[bool] = ..., + deprecated: Optional[bool] = ..., + cc_enable_arenas: Optional[bool] = ..., + objc_class_prefix: Optional[Text] = ..., + csharp_namespace: Optional[Text] = ..., + swift_prefix: Optional[Text] = ..., + php_class_prefix: Optional[Text] = ..., + php_namespace: Optional[Text] = ..., + uninterpreted_option: Optional[Iterable[UninterpretedOption]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> FileOptions: ... + + +class MessageOptions(Message): + message_set_wire_format = ... # type: bool + no_standard_descriptor_accessor = ... # type: bool + deprecated = ... # type: bool + map_entry = ... # type: bool + + @property + def uninterpreted_option( + self) -> RepeatedCompositeFieldContainer[UninterpretedOption]: ... + + def __init__(self, + message_set_wire_format: Optional[bool] = ..., + no_standard_descriptor_accessor: Optional[bool] = ..., + deprecated: Optional[bool] = ..., + map_entry: Optional[bool] = ..., + uninterpreted_option: Optional[Iterable[UninterpretedOption]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> MessageOptions: ... + + +class FieldOptions(Message): + + class CType(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> FieldOptions.CType: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[FieldOptions.CType]: ... + + @classmethod + def items(cls) -> List[Tuple[str, FieldOptions.CType]]: ... + STRING: CType + CORD: CType + STRING_PIECE: CType + + class JSType(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> FieldOptions.JSType: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[FieldOptions.JSType]: ... + + @classmethod + def items(cls) -> List[Tuple[str, FieldOptions.JSType]]: ... + JS_NORMAL: JSType + JS_STRING: JSType + JS_NUMBER: JSType + ctype = ... # type: FieldOptions.CType + packed = ... # type: bool + jstype = ... # type: FieldOptions.JSType + lazy = ... # type: bool + deprecated = ... # type: bool + weak = ... # type: bool + + @property + def uninterpreted_option( + self) -> RepeatedCompositeFieldContainer[UninterpretedOption]: ... + + def __init__(self, + ctype: Optional[FieldOptions.CType] = ..., + packed: Optional[bool] = ..., + jstype: Optional[FieldOptions.JSType] = ..., + lazy: Optional[bool] = ..., + deprecated: Optional[bool] = ..., + weak: Optional[bool] = ..., + uninterpreted_option: Optional[Iterable[UninterpretedOption]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> FieldOptions: ... + + +class OneofOptions(Message): + + @property + def uninterpreted_option( + self) -> RepeatedCompositeFieldContainer[UninterpretedOption]: ... + + def __init__(self, + uninterpreted_option: Optional[Iterable[UninterpretedOption]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> OneofOptions: ... + + +class EnumOptions(Message): + allow_alias = ... # type: bool + deprecated = ... # type: bool + + @property + def uninterpreted_option( + self) -> RepeatedCompositeFieldContainer[UninterpretedOption]: ... + + def __init__(self, + allow_alias: Optional[bool] = ..., + deprecated: Optional[bool] = ..., + uninterpreted_option: Optional[Iterable[UninterpretedOption]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> EnumOptions: ... + + +class EnumValueOptions(Message): + deprecated = ... # type: bool + + @property + def uninterpreted_option( + self) -> RepeatedCompositeFieldContainer[UninterpretedOption]: ... + + def __init__(self, + deprecated: Optional[bool] = ..., + uninterpreted_option: Optional[Iterable[UninterpretedOption]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> EnumValueOptions: ... + + +class ServiceOptions(Message): + deprecated = ... # type: bool + + @property + def uninterpreted_option( + self) -> RepeatedCompositeFieldContainer[UninterpretedOption]: ... + + def __init__(self, + deprecated: Optional[bool] = ..., + uninterpreted_option: Optional[Iterable[UninterpretedOption]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> ServiceOptions: ... + + +class MethodOptions(Message): + + class IdempotencyLevel(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> MethodOptions.IdempotencyLevel: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[MethodOptions.IdempotencyLevel]: ... + + @classmethod + def items(cls) -> List[Tuple[str, MethodOptions.IdempotencyLevel]]: ... + IDEMPOTENCY_UNKNOWN: IdempotencyLevel + NO_SIDE_EFFECTS: IdempotencyLevel + IDEMPOTENT: IdempotencyLevel + deprecated = ... # type: bool + idempotency_level = ... # type: MethodOptions.IdempotencyLevel + + @property + def uninterpreted_option( + self) -> RepeatedCompositeFieldContainer[UninterpretedOption]: ... + + def __init__(self, + deprecated: Optional[bool] = ..., + idempotency_level: Optional[MethodOptions.IdempotencyLevel] = ..., + uninterpreted_option: Optional[Iterable[UninterpretedOption]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> MethodOptions: ... + + +class UninterpretedOption(Message): + + class NamePart(Message): + name_part = ... # type: Text + is_extension = ... # type: bool + + def __init__(self, + name_part: Text, + is_extension: bool, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> UninterpretedOption.NamePart: ... + identifier_value = ... # type: Text + positive_int_value = ... # type: int + negative_int_value = ... # type: int + double_value = ... # type: float + string_value = ... # type: str + aggregate_value = ... # type: Text + + @property + def name( + self) -> RepeatedCompositeFieldContainer[UninterpretedOption.NamePart]: ... + + def __init__(self, + name: Optional[Iterable[UninterpretedOption.NamePart]] = ..., + identifier_value: Optional[Text] = ..., + positive_int_value: Optional[int] = ..., + negative_int_value: Optional[int] = ..., + double_value: Optional[float] = ..., + string_value: Optional[str] = ..., + aggregate_value: Optional[Text] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> UninterpretedOption: ... + + +class SourceCodeInfo(Message): + + class Location(Message): + path = ... # type: RepeatedScalarFieldContainer[int] + span = ... # type: RepeatedScalarFieldContainer[int] + leading_comments = ... # type: Text + trailing_comments = ... # type: Text + leading_detached_comments = ... # type: RepeatedScalarFieldContainer[Text] + + def __init__(self, + path: Optional[Iterable[int]] = ..., + span: Optional[Iterable[int]] = ..., + leading_comments: Optional[Text] = ..., + trailing_comments: Optional[Text] = ..., + leading_detached_comments: Optional[Iterable[Text]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> SourceCodeInfo.Location: ... + + @property + def location( + self) -> RepeatedCompositeFieldContainer[SourceCodeInfo.Location]: ... + + def __init__(self, + location: Optional[Iterable[SourceCodeInfo.Location]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> SourceCodeInfo: ... + + +class GeneratedCodeInfo(Message): + + class Annotation(Message): + path = ... # type: RepeatedScalarFieldContainer[int] + source_file = ... # type: Text + begin = ... # type: int + end = ... # type: int + + def __init__(self, + path: Optional[Iterable[int]] = ..., + source_file: Optional[Text] = ..., + begin: Optional[int] = ..., + end: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> GeneratedCodeInfo.Annotation: ... + + @property + def annotation( + self) -> RepeatedCompositeFieldContainer[GeneratedCodeInfo.Annotation]: ... + + def __init__(self, + annotation: Optional[Iterable[GeneratedCodeInfo.Annotation]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> GeneratedCodeInfo: ... diff --git a/third_party/2/google/protobuf/duration_pb2.pyi b/third_party/2/google/protobuf/duration_pb2.pyi new file mode 100644 index 000000000..eb7b8876c --- /dev/null +++ b/third_party/2/google/protobuf/duration_pb2.pyi @@ -0,0 +1,19 @@ +from google.protobuf.message import ( + Message, +) +from typing import ( + Optional, +) + + +class Duration(Message): + seconds = ... # type: int + nanos = ... # type: int + + def __init__(self, + seconds: Optional[int] = ..., + nanos: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> Duration: ... diff --git a/third_party/2/google/protobuf/empty_pb2.pyi b/third_party/2/google/protobuf/empty_pb2.pyi new file mode 100644 index 000000000..6541b5eca --- /dev/null +++ b/third_party/2/google/protobuf/empty_pb2.pyi @@ -0,0 +1,12 @@ +from google.protobuf.message import ( + Message, +) + + +class Empty(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> Empty: ... diff --git a/third_party/2/google/protobuf/field_mask_pb2.pyi b/third_party/2/google/protobuf/field_mask_pb2.pyi new file mode 100644 index 000000000..1bae0ba7f --- /dev/null +++ b/third_party/2/google/protobuf/field_mask_pb2.pyi @@ -0,0 +1,22 @@ +from google.protobuf.internal.containers import ( + RepeatedScalarFieldContainer, +) +from google.protobuf.message import ( + Message, +) +from typing import ( + Iterable, + Optional, + Text, +) + + +class FieldMask(Message): + paths = ... # type: RepeatedScalarFieldContainer[Text] + + def __init__(self, + paths: Optional[Iterable[Text]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> FieldMask: ... diff --git a/third_party/2/google/protobuf/map_proto2_unittest_pb2.pyi b/third_party/2/google/protobuf/map_proto2_unittest_pb2.pyi new file mode 100644 index 000000000..9534b3043 --- /dev/null +++ b/third_party/2/google/protobuf/map_proto2_unittest_pb2.pyi @@ -0,0 +1,428 @@ +from google.protobuf.message import ( + Message, +) +from google.protobuf.unittest_import_pb2 import ( + ImportEnumForMap, +) +from typing import ( + List, + Mapping, + MutableMapping, + Optional, + Text, + Tuple, + cast, +) + + +class Proto2MapEnum(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> Proto2MapEnum: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[Proto2MapEnum]: ... + + @classmethod + def items(cls) -> List[Tuple[str, Proto2MapEnum]]: ... +PROTO2_MAP_ENUM_FOO: Proto2MapEnum +PROTO2_MAP_ENUM_BAR: Proto2MapEnum +PROTO2_MAP_ENUM_BAZ: Proto2MapEnum + + +class Proto2MapEnumPlusExtra(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> Proto2MapEnumPlusExtra: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[Proto2MapEnumPlusExtra]: ... + + @classmethod + def items(cls) -> List[Tuple[str, Proto2MapEnumPlusExtra]]: ... +E_PROTO2_MAP_ENUM_FOO: Proto2MapEnumPlusExtra +E_PROTO2_MAP_ENUM_BAR: Proto2MapEnumPlusExtra +E_PROTO2_MAP_ENUM_BAZ: Proto2MapEnumPlusExtra +E_PROTO2_MAP_ENUM_EXTRA: Proto2MapEnumPlusExtra + + +class TestEnumMap(Message): + + class KnownMapFieldEntry(Message): + key = ... # type: int + value = ... # type: Proto2MapEnum + + def __init__(self, + key: Optional[int] = ..., + value: Optional[Proto2MapEnum] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestEnumMap.KnownMapFieldEntry: ... + + class UnknownMapFieldEntry(Message): + key = ... # type: int + value = ... # type: Proto2MapEnum + + def __init__(self, + key: Optional[int] = ..., + value: Optional[Proto2MapEnum] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestEnumMap.UnknownMapFieldEntry: ... + + @property + def known_map_field(self) -> MutableMapping[int, Proto2MapEnum]: ... + + @property + def unknown_map_field(self) -> MutableMapping[int, Proto2MapEnum]: ... + + def __init__(self, + known_map_field: Optional[Mapping[int, Proto2MapEnum]]=..., + unknown_map_field: Optional[Mapping[int, Proto2MapEnum]]=..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestEnumMap: ... + + +class TestEnumMapPlusExtra(Message): + + class KnownMapFieldEntry(Message): + key = ... # type: int + value = ... # type: Proto2MapEnumPlusExtra + + def __init__(self, + key: Optional[int] = ..., + value: Optional[Proto2MapEnumPlusExtra] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestEnumMapPlusExtra.KnownMapFieldEntry: ... + + class UnknownMapFieldEntry(Message): + key = ... # type: int + value = ... # type: Proto2MapEnumPlusExtra + + def __init__(self, + key: Optional[int] = ..., + value: Optional[Proto2MapEnumPlusExtra] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestEnumMapPlusExtra.UnknownMapFieldEntry: ... + + @property + def known_map_field(self) -> MutableMapping[int, Proto2MapEnumPlusExtra]: ... + + @property + def unknown_map_field(self) -> MutableMapping[int, Proto2MapEnumPlusExtra]: ... + + def __init__(self, + known_map_field: Optional[Mapping[int, Proto2MapEnumPlusExtra]]=..., + unknown_map_field: Optional[Mapping[int, Proto2MapEnumPlusExtra]]=..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestEnumMapPlusExtra: ... + + +class TestImportEnumMap(Message): + + class ImportEnumAmpEntry(Message): + key = ... # type: int + value = ... # type: ImportEnumForMap + + def __init__(self, + key: Optional[int] = ..., + value: Optional[ImportEnumForMap] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestImportEnumMap.ImportEnumAmpEntry: ... + + @property + def import_enum_amp(self) -> MutableMapping[int, ImportEnumForMap]: ... + + def __init__(self, + import_enum_amp: Optional[Mapping[int, ImportEnumForMap]]=..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestImportEnumMap: ... + + +class TestIntIntMap(Message): + + class MEntry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestIntIntMap.MEntry: ... + + @property + def m(self) -> MutableMapping[int, int]: ... + + def __init__(self, + m: Optional[Mapping[int, int]]=..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestIntIntMap: ... + + +class TestMaps(Message): + + class MInt32Entry(Message): + key = ... # type: int + + @property + def value(self) -> TestIntIntMap: ... + + def __init__(self, + key: Optional[int] = ..., + value: Optional[TestIntIntMap] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMaps.MInt32Entry: ... + + class MInt64Entry(Message): + key = ... # type: int + + @property + def value(self) -> TestIntIntMap: ... + + def __init__(self, + key: Optional[int] = ..., + value: Optional[TestIntIntMap] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMaps.MInt64Entry: ... + + class MUint32Entry(Message): + key = ... # type: int + + @property + def value(self) -> TestIntIntMap: ... + + def __init__(self, + key: Optional[int] = ..., + value: Optional[TestIntIntMap] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMaps.MUint32Entry: ... + + class MUint64Entry(Message): + key = ... # type: int + + @property + def value(self) -> TestIntIntMap: ... + + def __init__(self, + key: Optional[int] = ..., + value: Optional[TestIntIntMap] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMaps.MUint64Entry: ... + + class MSint32Entry(Message): + key = ... # type: int + + @property + def value(self) -> TestIntIntMap: ... + + def __init__(self, + key: Optional[int] = ..., + value: Optional[TestIntIntMap] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMaps.MSint32Entry: ... + + class MSint64Entry(Message): + key = ... # type: int + + @property + def value(self) -> TestIntIntMap: ... + + def __init__(self, + key: Optional[int] = ..., + value: Optional[TestIntIntMap] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMaps.MSint64Entry: ... + + class MFixed32Entry(Message): + key = ... # type: int + + @property + def value(self) -> TestIntIntMap: ... + + def __init__(self, + key: Optional[int] = ..., + value: Optional[TestIntIntMap] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMaps.MFixed32Entry: ... + + class MFixed64Entry(Message): + key = ... # type: int + + @property + def value(self) -> TestIntIntMap: ... + + def __init__(self, + key: Optional[int] = ..., + value: Optional[TestIntIntMap] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMaps.MFixed64Entry: ... + + class MSfixed32Entry(Message): + key = ... # type: int + + @property + def value(self) -> TestIntIntMap: ... + + def __init__(self, + key: Optional[int] = ..., + value: Optional[TestIntIntMap] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMaps.MSfixed32Entry: ... + + class MSfixed64Entry(Message): + key = ... # type: int + + @property + def value(self) -> TestIntIntMap: ... + + def __init__(self, + key: Optional[int] = ..., + value: Optional[TestIntIntMap] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMaps.MSfixed64Entry: ... + + class MBoolEntry(Message): + key = ... # type: bool + + @property + def value(self) -> TestIntIntMap: ... + + def __init__(self, + key: Optional[bool] = ..., + value: Optional[TestIntIntMap] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMaps.MBoolEntry: ... + + class MStringEntry(Message): + key = ... # type: Text + + @property + def value(self) -> TestIntIntMap: ... + + def __init__(self, + key: Optional[Text] = ..., + value: Optional[TestIntIntMap] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMaps.MStringEntry: ... + + @property + def m_int32(self) -> MutableMapping[int, TestIntIntMap]: ... + + @property + def m_int64(self) -> MutableMapping[int, TestIntIntMap]: ... + + @property + def m_uint32(self) -> MutableMapping[int, TestIntIntMap]: ... + + @property + def m_uint64(self) -> MutableMapping[int, TestIntIntMap]: ... + + @property + def m_sint32(self) -> MutableMapping[int, TestIntIntMap]: ... + + @property + def m_sint64(self) -> MutableMapping[int, TestIntIntMap]: ... + + @property + def m_fixed32(self) -> MutableMapping[int, TestIntIntMap]: ... + + @property + def m_fixed64(self) -> MutableMapping[int, TestIntIntMap]: ... + + @property + def m_sfixed32(self) -> MutableMapping[int, TestIntIntMap]: ... + + @property + def m_sfixed64(self) -> MutableMapping[int, TestIntIntMap]: ... + + @property + def m_bool(self) -> MutableMapping[bool, TestIntIntMap]: ... + + @property + def m_string(self) -> MutableMapping[Text, TestIntIntMap]: ... + + def __init__(self, + m_int32: Optional[Mapping[int, TestIntIntMap]]=..., + m_int64: Optional[Mapping[int, TestIntIntMap]]=..., + m_uint32: Optional[Mapping[int, TestIntIntMap]]=..., + m_uint64: Optional[Mapping[int, TestIntIntMap]]=..., + m_sint32: Optional[Mapping[int, TestIntIntMap]]=..., + m_sint64: Optional[Mapping[int, TestIntIntMap]]=..., + m_fixed32: Optional[Mapping[int, TestIntIntMap]]=..., + m_fixed64: Optional[Mapping[int, TestIntIntMap]]=..., + m_sfixed32: Optional[Mapping[int, TestIntIntMap]]=..., + m_sfixed64: Optional[Mapping[int, TestIntIntMap]]=..., + m_bool: Optional[Mapping[bool, TestIntIntMap]]=..., + m_string: Optional[Mapping[Text, TestIntIntMap]]=..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMaps: ... + + +class TestSubmessageMaps(Message): + + @property + def m(self) -> TestMaps: ... + + def __init__(self, + m: Optional[TestMaps] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestSubmessageMaps: ... diff --git a/third_party/2/google/protobuf/map_unittest_pb2.pyi b/third_party/2/google/protobuf/map_unittest_pb2.pyi new file mode 100644 index 000000000..2d146d593 --- /dev/null +++ b/third_party/2/google/protobuf/map_unittest_pb2.pyi @@ -0,0 +1,882 @@ +from google.protobuf.message import ( + Message, +) +from google.protobuf.unittest_no_arena_pb2 import ( + ForeignMessage, +) +from google.protobuf.unittest_pb2 import ( + ForeignMessage as ForeignMessage1, + TestAllTypes, + TestRequired, +) +from typing import ( + List, + Mapping, + MutableMapping, + Optional, + Text, + Tuple, + cast, +) + + +class MapEnum(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> MapEnum: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[MapEnum]: ... + + @classmethod + def items(cls) -> List[Tuple[str, MapEnum]]: ... + + +MAP_ENUM_FOO: MapEnum +MAP_ENUM_BAR: MapEnum +MAP_ENUM_BAZ: MapEnum + + +class TestMap(Message): + + class MapInt32Int32Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMap.MapInt32Int32Entry: ... + + class MapInt64Int64Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMap.MapInt64Int64Entry: ... + + class MapUint32Uint32Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMap.MapUint32Uint32Entry: ... + + class MapUint64Uint64Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMap.MapUint64Uint64Entry: ... + + class MapSint32Sint32Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMap.MapSint32Sint32Entry: ... + + class MapSint64Sint64Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMap.MapSint64Sint64Entry: ... + + class MapFixed32Fixed32Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMap.MapFixed32Fixed32Entry: ... + + class MapFixed64Fixed64Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMap.MapFixed64Fixed64Entry: ... + + class MapSfixed32Sfixed32Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMap.MapSfixed32Sfixed32Entry: ... + + class MapSfixed64Sfixed64Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMap.MapSfixed64Sfixed64Entry: ... + + class MapInt32FloatEntry(Message): + key = ... # type: int + value = ... # type: float + + def __init__(self, + key: Optional[int] = ..., + value: Optional[float] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMap.MapInt32FloatEntry: ... + + class MapInt32DoubleEntry(Message): + key = ... # type: int + value = ... # type: float + + def __init__(self, + key: Optional[int] = ..., + value: Optional[float] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMap.MapInt32DoubleEntry: ... + + class MapBoolBoolEntry(Message): + key = ... # type: bool + value = ... # type: bool + + def __init__(self, + key: Optional[bool] = ..., + value: Optional[bool] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMap.MapBoolBoolEntry: ... + + class MapStringStringEntry(Message): + key = ... # type: Text + value = ... # type: Text + + def __init__(self, + key: Optional[Text] = ..., + value: Optional[Text] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMap.MapStringStringEntry: ... + + class MapInt32BytesEntry(Message): + key = ... # type: int + value = ... # type: str + + def __init__(self, + key: Optional[int] = ..., + value: Optional[str] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMap.MapInt32BytesEntry: ... + + class MapInt32EnumEntry(Message): + key = ... # type: int + value = ... # type: MapEnum + + def __init__(self, + key: Optional[int] = ..., + value: Optional[MapEnum] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMap.MapInt32EnumEntry: ... + + class MapInt32ForeignMessageEntry(Message): + key = ... # type: int + + @property + def value(self) -> ForeignMessage1: ... + + def __init__(self, + key: Optional[int] = ..., + value: Optional[ForeignMessage1] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMap.MapInt32ForeignMessageEntry: ... + + class MapStringForeignMessageEntry(Message): + key = ... # type: Text + + @property + def value(self) -> ForeignMessage1: ... + + def __init__(self, + key: Optional[Text] = ..., + value: Optional[ForeignMessage1] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestMap.MapStringForeignMessageEntry: ... + + class MapInt32AllTypesEntry(Message): + key = ... # type: int + + @property + def value(self) -> TestAllTypes: ... + + def __init__(self, + key: Optional[int] = ..., + value: Optional[TestAllTypes] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMap.MapInt32AllTypesEntry: ... + + @property + def map_int32_int32(self) -> MutableMapping[int, int]: ... + + @property + def map_int64_int64(self) -> MutableMapping[int, int]: ... + + @property + def map_uint32_uint32(self) -> MutableMapping[int, int]: ... + + @property + def map_uint64_uint64(self) -> MutableMapping[int, int]: ... + + @property + def map_sint32_sint32(self) -> MutableMapping[int, int]: ... + + @property + def map_sint64_sint64(self) -> MutableMapping[int, int]: ... + + @property + def map_fixed32_fixed32(self) -> MutableMapping[int, int]: ... + + @property + def map_fixed64_fixed64(self) -> MutableMapping[int, int]: ... + + @property + def map_sfixed32_sfixed32(self) -> MutableMapping[int, int]: ... + + @property + def map_sfixed64_sfixed64(self) -> MutableMapping[int, int]: ... + + @property + def map_int32_float(self) -> MutableMapping[int, float]: ... + + @property + def map_int32_double(self) -> MutableMapping[int, float]: ... + + @property + def map_bool_bool(self) -> MutableMapping[bool, bool]: ... + + @property + def map_string_string(self) -> MutableMapping[Text, Text]: ... + + @property + def map_int32_bytes(self) -> MutableMapping[int, str]: ... + + @property + def map_int32_enum(self) -> MutableMapping[int, MapEnum]: ... + + @property + def map_int32_foreign_message( + self) -> MutableMapping[int, ForeignMessage1]: ... + + @property + def map_string_foreign_message( + self) -> MutableMapping[Text, ForeignMessage1]: ... + + @property + def map_int32_all_types(self) -> MutableMapping[int, TestAllTypes]: ... + + def __init__(self, + map_int32_int32: Optional[Mapping[int, int]]=..., + map_int64_int64: Optional[Mapping[int, int]]=..., + map_uint32_uint32: Optional[Mapping[int, int]]=..., + map_uint64_uint64: Optional[Mapping[int, int]]=..., + map_sint32_sint32: Optional[Mapping[int, int]]=..., + map_sint64_sint64: Optional[Mapping[int, int]]=..., + map_fixed32_fixed32: Optional[Mapping[int, int]]=..., + map_fixed64_fixed64: Optional[Mapping[int, int]]=..., + map_sfixed32_sfixed32: Optional[Mapping[int, int]]=..., + map_sfixed64_sfixed64: Optional[Mapping[int, int]]=..., + map_int32_float: Optional[Mapping[int, float]]=..., + map_int32_double: Optional[Mapping[int, float]]=..., + map_bool_bool: Optional[Mapping[bool, bool]]=..., + map_string_string: Optional[Mapping[Text, Text]]=..., + map_int32_bytes: Optional[Mapping[int, str]]=..., + map_int32_enum: Optional[Mapping[int, MapEnum]]=..., + map_int32_foreign_message: Optional[Mapping[int, ForeignMessage1]]=..., + map_string_foreign_message: Optional[Mapping[Text, ForeignMessage1]]=..., + map_int32_all_types: Optional[Mapping[int, TestAllTypes]]=..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMap: ... + + +class TestMapSubmessage(Message): + + @property + def test_map(self) -> TestMap: ... + + def __init__(self, + test_map: Optional[TestMap] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMapSubmessage: ... + + +class TestMessageMap(Message): + + class MapInt32MessageEntry(Message): + key = ... # type: int + + @property + def value(self) -> TestAllTypes: ... + + def __init__(self, + key: Optional[int] = ..., + value: Optional[TestAllTypes] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMessageMap.MapInt32MessageEntry: ... + + @property + def map_int32_message(self) -> MutableMapping[int, TestAllTypes]: ... + + def __init__(self, + map_int32_message: Optional[Mapping[int, TestAllTypes]]=..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMessageMap: ... + + +class TestSameTypeMap(Message): + + class Map1Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestSameTypeMap.Map1Entry: ... + + class Map2Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestSameTypeMap.Map2Entry: ... + + @property + def map1(self) -> MutableMapping[int, int]: ... + + @property + def map2(self) -> MutableMapping[int, int]: ... + + def __init__(self, + map1: Optional[Mapping[int, int]]=..., + map2: Optional[Mapping[int, int]]=..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestSameTypeMap: ... + + +class TestRequiredMessageMap(Message): + + class MapFieldEntry(Message): + key = ... # type: int + + @property + def value(self) -> TestRequired: ... + + def __init__(self, + key: Optional[int] = ..., + value: Optional[TestRequired] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestRequiredMessageMap.MapFieldEntry: ... + + @property + def map_field(self) -> MutableMapping[int, TestRequired]: ... + + def __init__(self, + map_field: Optional[Mapping[int, TestRequired]]=..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestRequiredMessageMap: ... + + +class TestArenaMap(Message): + + class MapInt32Int32Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestArenaMap.MapInt32Int32Entry: ... + + class MapInt64Int64Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestArenaMap.MapInt64Int64Entry: ... + + class MapUint32Uint32Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestArenaMap.MapUint32Uint32Entry: ... + + class MapUint64Uint64Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestArenaMap.MapUint64Uint64Entry: ... + + class MapSint32Sint32Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestArenaMap.MapSint32Sint32Entry: ... + + class MapSint64Sint64Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestArenaMap.MapSint64Sint64Entry: ... + + class MapFixed32Fixed32Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestArenaMap.MapFixed32Fixed32Entry: ... + + class MapFixed64Fixed64Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestArenaMap.MapFixed64Fixed64Entry: ... + + class MapSfixed32Sfixed32Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestArenaMap.MapSfixed32Sfixed32Entry: ... + + class MapSfixed64Sfixed64Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestArenaMap.MapSfixed64Sfixed64Entry: ... + + class MapInt32FloatEntry(Message): + key = ... # type: int + value = ... # type: float + + def __init__(self, + key: Optional[int] = ..., + value: Optional[float] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestArenaMap.MapInt32FloatEntry: ... + + class MapInt32DoubleEntry(Message): + key = ... # type: int + value = ... # type: float + + def __init__(self, + key: Optional[int] = ..., + value: Optional[float] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestArenaMap.MapInt32DoubleEntry: ... + + class MapBoolBoolEntry(Message): + key = ... # type: bool + value = ... # type: bool + + def __init__(self, + key: Optional[bool] = ..., + value: Optional[bool] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestArenaMap.MapBoolBoolEntry: ... + + class MapStringStringEntry(Message): + key = ... # type: Text + value = ... # type: Text + + def __init__(self, + key: Optional[Text] = ..., + value: Optional[Text] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestArenaMap.MapStringStringEntry: ... + + class MapInt32BytesEntry(Message): + key = ... # type: int + value = ... # type: str + + def __init__(self, + key: Optional[int] = ..., + value: Optional[str] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestArenaMap.MapInt32BytesEntry: ... + + class MapInt32EnumEntry(Message): + key = ... # type: int + value = ... # type: MapEnum + + def __init__(self, + key: Optional[int] = ..., + value: Optional[MapEnum] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestArenaMap.MapInt32EnumEntry: ... + + class MapInt32ForeignMessageEntry(Message): + key = ... # type: int + + @property + def value(self) -> ForeignMessage1: ... + + def __init__(self, + key: Optional[int] = ..., + value: Optional[ForeignMessage1] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestArenaMap.MapInt32ForeignMessageEntry: ... + + class MapInt32ForeignMessageNoArenaEntry(Message): + key = ... # type: int + + @property + def value(self) -> ForeignMessage: ... + + def __init__(self, + key: Optional[int] = ..., + value: Optional[ForeignMessage] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestArenaMap.MapInt32ForeignMessageNoArenaEntry: ... + + @property + def map_int32_int32(self) -> MutableMapping[int, int]: ... + + @property + def map_int64_int64(self) -> MutableMapping[int, int]: ... + + @property + def map_uint32_uint32(self) -> MutableMapping[int, int]: ... + + @property + def map_uint64_uint64(self) -> MutableMapping[int, int]: ... + + @property + def map_sint32_sint32(self) -> MutableMapping[int, int]: ... + + @property + def map_sint64_sint64(self) -> MutableMapping[int, int]: ... + + @property + def map_fixed32_fixed32(self) -> MutableMapping[int, int]: ... + + @property + def map_fixed64_fixed64(self) -> MutableMapping[int, int]: ... + + @property + def map_sfixed32_sfixed32(self) -> MutableMapping[int, int]: ... + + @property + def map_sfixed64_sfixed64(self) -> MutableMapping[int, int]: ... + + @property + def map_int32_float(self) -> MutableMapping[int, float]: ... + + @property + def map_int32_double(self) -> MutableMapping[int, float]: ... + + @property + def map_bool_bool(self) -> MutableMapping[bool, bool]: ... + + @property + def map_string_string(self) -> MutableMapping[Text, Text]: ... + + @property + def map_int32_bytes(self) -> MutableMapping[int, str]: ... + + @property + def map_int32_enum(self) -> MutableMapping[int, MapEnum]: ... + + @property + def map_int32_foreign_message( + self) -> MutableMapping[int, ForeignMessage1]: ... + + @property + def map_int32_foreign_message_no_arena( + self) -> MutableMapping[int, ForeignMessage]: ... + + def __init__(self, + map_int32_int32: Optional[Mapping[int, int]]=..., + map_int64_int64: Optional[Mapping[int, int]]=..., + map_uint32_uint32: Optional[Mapping[int, int]]=..., + map_uint64_uint64: Optional[Mapping[int, int]]=..., + map_sint32_sint32: Optional[Mapping[int, int]]=..., + map_sint64_sint64: Optional[Mapping[int, int]]=..., + map_fixed32_fixed32: Optional[Mapping[int, int]]=..., + map_fixed64_fixed64: Optional[Mapping[int, int]]=..., + map_sfixed32_sfixed32: Optional[Mapping[int, int]]=..., + map_sfixed64_sfixed64: Optional[Mapping[int, int]]=..., + map_int32_float: Optional[Mapping[int, float]]=..., + map_int32_double: Optional[Mapping[int, float]]=..., + map_bool_bool: Optional[Mapping[bool, bool]]=..., + map_string_string: Optional[Mapping[Text, Text]]=..., + map_int32_bytes: Optional[Mapping[int, str]]=..., + map_int32_enum: Optional[Mapping[int, MapEnum]]=..., + map_int32_foreign_message: Optional[Mapping[int, ForeignMessage1]]=..., + map_int32_foreign_message_no_arena: Optional[Mapping[int, ForeignMessage]]=..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestArenaMap: ... + + +class MessageContainingEnumCalledType(Message): + + class Type(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> MessageContainingEnumCalledType.Type: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[MessageContainingEnumCalledType.Type]: ... + + @classmethod + def items(cls) -> List[Tuple[str, + MessageContainingEnumCalledType.Type]]: ... + TYPE_FOO: Type + + class TypeEntry(Message): + key = ... # type: Text + + @property + def value(self) -> MessageContainingEnumCalledType: ... + + def __init__(self, + key: Optional[Text] = ..., + value: Optional[MessageContainingEnumCalledType] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> MessageContainingEnumCalledType.TypeEntry: ... + + @property + def type(self) -> MutableMapping[Text, + MessageContainingEnumCalledType]: ... + + def __init__(self, + type: Optional[Mapping[Text, MessageContainingEnumCalledType]]=..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> MessageContainingEnumCalledType: ... + + +class MessageContainingMapCalledEntry(Message): + + class EntryEntry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> MessageContainingMapCalledEntry.EntryEntry: ... + + @property + def entry(self) -> MutableMapping[int, int]: ... + + def __init__(self, + entry: Optional[Mapping[int, int]]=..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> MessageContainingMapCalledEntry: ... + + +class TestRecursiveMapMessage(Message): + + class AEntry(Message): + key = ... # type: Text + + @property + def value(self) -> TestRecursiveMapMessage: ... + + def __init__(self, + key: Optional[Text] = ..., + value: Optional[TestRecursiveMapMessage] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestRecursiveMapMessage.AEntry: ... + + @property + def a(self) -> MutableMapping[Text, TestRecursiveMapMessage]: ... + + def __init__(self, + a: Optional[Mapping[Text, TestRecursiveMapMessage]]=..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestRecursiveMapMessage: ... diff --git a/third_party/2/google/protobuf/source_context_pb2.pyi b/third_party/2/google/protobuf/source_context_pb2.pyi new file mode 100644 index 000000000..7411fdf2e --- /dev/null +++ b/third_party/2/google/protobuf/source_context_pb2.pyi @@ -0,0 +1,18 @@ +from google.protobuf.message import ( + Message, +) +from typing import ( + Optional, + Text, +) + + +class SourceContext(Message): + file_name = ... # type: Text + + def __init__(self, + file_name: Optional[Text] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> SourceContext: ... diff --git a/third_party/2/google/protobuf/struct_pb2.pyi b/third_party/2/google/protobuf/struct_pb2.pyi new file mode 100644 index 000000000..53fc2dcde --- /dev/null +++ b/third_party/2/google/protobuf/struct_pb2.pyi @@ -0,0 +1,103 @@ +from google.protobuf.internal.containers import ( + RepeatedCompositeFieldContainer, +) +from google.protobuf.message import ( + Message, +) +from typing import ( + Iterable, + List, + Mapping, + MutableMapping, + Optional, + Text, + Tuple, + cast, +) + + +class NullValue(int): + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> NullValue: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[NullValue]: ... + + @classmethod + def items(cls) -> List[Tuple[str, NullValue]]: ... + + +NULL_VALUE: NullValue + + +class Struct(Message): + class FieldsEntry(Message): + key = ... # type: Text + + @property + def value(self) -> Value: ... + + def __init__(self, + key: Optional[Text] = ..., + value: Optional[Value] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> Struct.FieldsEntry: ... + + @property + def fields(self) -> MutableMapping[Text, Value]: ... + + def __init__(self, + fields: Optional[Mapping[Text, Value]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> Struct: ... + + +class _Value(Message): + null_value = ... # type: NullValue + number_value = ... # type: float + string_value = ... # type: Text + bool_value = ... # type: bool + + @property + def struct_value(self) -> Struct: ... + + @property + def list_value(self) -> ListValue: ... + + def __init__(self, + null_value: Optional[NullValue] = ..., + number_value: Optional[float] = ..., + string_value: Optional[Text] = ..., + bool_value: Optional[bool] = ..., + struct_value: Optional[Struct] = ..., + list_value: Optional[ListValue] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> _Value: ... + + +Value = _Value + + +class ListValue(Message): + + @property + def values(self) -> RepeatedCompositeFieldContainer[Value]: ... + + def __init__(self, + values: Optional[Iterable[Value]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> ListValue: ... diff --git a/third_party/2/google/protobuf/test_messages_proto2_pb2.pyi b/third_party/2/google/protobuf/test_messages_proto2_pb2.pyi new file mode 100644 index 000000000..bbf14e132 --- /dev/null +++ b/third_party/2/google/protobuf/test_messages_proto2_pb2.pyi @@ -0,0 +1,627 @@ +from google.protobuf.internal.containers import ( + RepeatedCompositeFieldContainer, + RepeatedScalarFieldContainer, +) +from google.protobuf.message import ( + Message, +) +import builtins +from typing import ( + Iterable, + List, + Mapping, + MutableMapping, + Optional, + Text, + Tuple, + cast, +) + + +class ForeignEnumProto2(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> ForeignEnumProto2: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[ForeignEnumProto2]: ... + + @classmethod + def items(cls) -> List[Tuple[str, ForeignEnumProto2]]: ... + + +FOREIGN_FOO: ForeignEnumProto2 +FOREIGN_BAR: ForeignEnumProto2 +FOREIGN_BAZ: ForeignEnumProto2 + + +class TestAllTypesProto2(Message): + + class NestedEnum(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> TestAllTypesProto2.NestedEnum: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[TestAllTypesProto2.NestedEnum]: ... + + @classmethod + def items(cls) -> List[Tuple[str, TestAllTypesProto2.NestedEnum]]: ... + FOO: NestedEnum + BAR: NestedEnum + BAZ: NestedEnum + NEG: NestedEnum + + class NestedMessage(Message): + a = ... # type: int + + @property + def corecursive(self) -> TestAllTypesProto2: ... + + def __init__(self, + a: Optional[int] = ..., + corecursive: Optional[TestAllTypesProto2] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypesProto2.NestedMessage: ... + + class MapInt32Int32Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestAllTypesProto2.MapInt32Int32Entry: ... + + class MapInt64Int64Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestAllTypesProto2.MapInt64Int64Entry: ... + + class MapUint32Uint32Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestAllTypesProto2.MapUint32Uint32Entry: ... + + class MapUint64Uint64Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestAllTypesProto2.MapUint64Uint64Entry: ... + + class MapSint32Sint32Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestAllTypesProto2.MapSint32Sint32Entry: ... + + class MapSint64Sint64Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestAllTypesProto2.MapSint64Sint64Entry: ... + + class MapFixed32Fixed32Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestAllTypesProto2.MapFixed32Fixed32Entry: ... + + class MapFixed64Fixed64Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestAllTypesProto2.MapFixed64Fixed64Entry: ... + + class MapSfixed32Sfixed32Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestAllTypesProto2.MapSfixed32Sfixed32Entry: ... + + class MapSfixed64Sfixed64Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestAllTypesProto2.MapSfixed64Sfixed64Entry: ... + + class MapInt32FloatEntry(Message): + key = ... # type: int + value = ... # type: float + + def __init__(self, + key: Optional[int] = ..., + value: Optional[float] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestAllTypesProto2.MapInt32FloatEntry: ... + + class MapInt32DoubleEntry(Message): + key = ... # type: int + value = ... # type: float + + def __init__(self, + key: Optional[int] = ..., + value: Optional[float] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestAllTypesProto2.MapInt32DoubleEntry: ... + + class MapBoolBoolEntry(Message): + key = ... # type: bool + value = ... # type: bool + + def __init__(self, + key: Optional[bool] = ..., + value: Optional[bool] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypesProto2.MapBoolBoolEntry: ... + + class MapStringStringEntry(Message): + key = ... # type: Text + value = ... # type: Text + + def __init__(self, + key: Optional[Text] = ..., + value: Optional[Text] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestAllTypesProto2.MapStringStringEntry: ... + + class MapStringBytesEntry(Message): + key = ... # type: Text + value = ... # type: str + + def __init__(self, + key: Optional[Text] = ..., + value: Optional[str] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestAllTypesProto2.MapStringBytesEntry: ... + + class MapStringNestedMessageEntry(Message): + key = ... # type: Text + + @property + def value(self) -> TestAllTypesProto2.NestedMessage: ... + + def __init__(self, + key: Optional[Text] = ..., + value: Optional[TestAllTypesProto2.NestedMessage] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestAllTypesProto2.MapStringNestedMessageEntry: ... + + class MapStringForeignMessageEntry(Message): + key = ... # type: Text + + @property + def value(self) -> ForeignMessageProto2: ... + + def __init__(self, + key: Optional[Text] = ..., + value: Optional[ForeignMessageProto2] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestAllTypesProto2.MapStringForeignMessageEntry: ... + + class MapStringNestedEnumEntry(Message): + key = ... # type: Text + value = ... # type: TestAllTypesProto2.NestedEnum + + def __init__(self, + key: Optional[Text] = ..., + value: Optional[TestAllTypesProto2.NestedEnum] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestAllTypesProto2.MapStringNestedEnumEntry: ... + + class MapStringForeignEnumEntry(Message): + key = ... # type: Text + value = ... # type: ForeignEnumProto2 + + def __init__(self, + key: Optional[Text] = ..., + value: Optional[ForeignEnumProto2] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestAllTypesProto2.MapStringForeignEnumEntry: ... + + class Data(Message): + group_int32 = ... # type: int + group_uint32 = ... # type: int + + def __init__(self, + group_int32: Optional[int] = ..., + group_uint32: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypesProto2.Data: ... + + class MessageSetCorrect(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestAllTypesProto2.MessageSetCorrect: ... + + class MessageSetCorrectExtension1(Message): + str = ... # type: Text + + def __init__(self, + str: Optional[Text] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: builtins.str) -> TestAllTypesProto2.MessageSetCorrectExtension1: ... + + class MessageSetCorrectExtension2(Message): + i = ... # type: int + + def __init__(self, + i: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestAllTypesProto2.MessageSetCorrectExtension2: ... + optional_int32 = ... # type: int + optional_int64 = ... # type: int + optional_uint32 = ... # type: int + optional_uint64 = ... # type: int + optional_sint32 = ... # type: int + optional_sint64 = ... # type: int + optional_fixed32 = ... # type: int + optional_fixed64 = ... # type: int + optional_sfixed32 = ... # type: int + optional_sfixed64 = ... # type: int + optional_float = ... # type: float + optional_double = ... # type: float + optional_bool = ... # type: bool + optional_string = ... # type: Text + optional_bytes = ... # type: str + optional_nested_enum = ... # type: TestAllTypesProto2.NestedEnum + optional_foreign_enum = ... # type: ForeignEnumProto2 + optional_string_piece = ... # type: Text + optional_cord = ... # type: Text + repeated_int32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_int64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_uint32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_uint64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_sint32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_sint64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_fixed32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_fixed64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_sfixed32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_sfixed64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_float = ... # type: RepeatedScalarFieldContainer[float] + repeated_double = ... # type: RepeatedScalarFieldContainer[float] + repeated_bool = ... # type: RepeatedScalarFieldContainer[bool] + repeated_string = ... # type: RepeatedScalarFieldContainer[Text] + repeated_bytes = ... # type: RepeatedScalarFieldContainer[str] + repeated_nested_enum = ... # type: RepeatedScalarFieldContainer[TestAllTypesProto2.NestedEnum] + repeated_foreign_enum = ... # type: RepeatedScalarFieldContainer[ForeignEnumProto2] + repeated_string_piece = ... # type: RepeatedScalarFieldContainer[Text] + repeated_cord = ... # type: RepeatedScalarFieldContainer[Text] + oneof_uint32 = ... # type: int + oneof_string = ... # type: Text + oneof_bytes = ... # type: str + oneof_bool = ... # type: bool + oneof_uint64 = ... # type: int + oneof_float = ... # type: float + oneof_double = ... # type: float + oneof_enum = ... # type: TestAllTypesProto2.NestedEnum + fieldname1 = ... # type: int + field_name2 = ... # type: int + _field_name3 = ... # type: int + field__name4_ = ... # type: int + field0name5 = ... # type: int + field_0_name6 = ... # type: int + fieldName7 = ... # type: int + FieldName8 = ... # type: int + field_Name9 = ... # type: int + Field_Name10 = ... # type: int + FIELD_NAME11 = ... # type: int + FIELD_name12 = ... # type: int + __field_name13 = ... # type: int + __Field_name14 = ... # type: int + field__name15 = ... # type: int + field__Name16 = ... # type: int + field_name17__ = ... # type: int + Field_name18__ = ... # type: int + + @property + def optional_nested_message(self) -> TestAllTypesProto2.NestedMessage: ... + + @property + def optional_foreign_message(self) -> ForeignMessageProto2: ... + + @property + def recursive_message(self) -> TestAllTypesProto2: ... + + @property + def repeated_nested_message( + self) -> RepeatedCompositeFieldContainer[TestAllTypesProto2.NestedMessage]: ... + + @property + def repeated_foreign_message( + self) -> RepeatedCompositeFieldContainer[ForeignMessageProto2]: ... + + @property + def map_int32_int32(self) -> MutableMapping[int, int]: ... + + @property + def map_int64_int64(self) -> MutableMapping[int, int]: ... + + @property + def map_uint32_uint32(self) -> MutableMapping[int, int]: ... + + @property + def map_uint64_uint64(self) -> MutableMapping[int, int]: ... + + @property + def map_sint32_sint32(self) -> MutableMapping[int, int]: ... + + @property + def map_sint64_sint64(self) -> MutableMapping[int, int]: ... + + @property + def map_fixed32_fixed32(self) -> MutableMapping[int, int]: ... + + @property + def map_fixed64_fixed64(self) -> MutableMapping[int, int]: ... + + @property + def map_sfixed32_sfixed32(self) -> MutableMapping[int, int]: ... + + @property + def map_sfixed64_sfixed64(self) -> MutableMapping[int, int]: ... + + @property + def map_int32_float(self) -> MutableMapping[int, float]: ... + + @property + def map_int32_double(self) -> MutableMapping[int, float]: ... + + @property + def map_bool_bool(self) -> MutableMapping[bool, bool]: ... + + @property + def map_string_string(self) -> MutableMapping[Text, Text]: ... + + @property + def map_string_bytes(self) -> MutableMapping[Text, str]: ... + + @property + def map_string_nested_message( + self) -> MutableMapping[Text, TestAllTypesProto2.NestedMessage]: ... + + @property + def map_string_foreign_message( + self) -> MutableMapping[Text, ForeignMessageProto2]: ... + + @property + def map_string_nested_enum( + self) -> MutableMapping[Text, TestAllTypesProto2.NestedEnum]: ... + + @property + def map_string_foreign_enum( + self) -> MutableMapping[Text, ForeignEnumProto2]: ... + + @property + def oneof_nested_message(self) -> TestAllTypesProto2.NestedMessage: ... + + @property + def data(self) -> TestAllTypesProto2.Data: ... + + def __init__(self, + optional_int32: Optional[int] = ..., + optional_int64: Optional[int] = ..., + optional_uint32: Optional[int] = ..., + optional_uint64: Optional[int] = ..., + optional_sint32: Optional[int] = ..., + optional_sint64: Optional[int] = ..., + optional_fixed32: Optional[int] = ..., + optional_fixed64: Optional[int] = ..., + optional_sfixed32: Optional[int] = ..., + optional_sfixed64: Optional[int] = ..., + optional_float: Optional[float] = ..., + optional_double: Optional[float] = ..., + optional_bool: Optional[bool] = ..., + optional_string: Optional[Text] = ..., + optional_bytes: Optional[str] = ..., + optional_nested_message: Optional[TestAllTypesProto2.NestedMessage] = ..., + optional_foreign_message: Optional[ForeignMessageProto2] = ..., + optional_nested_enum: Optional[TestAllTypesProto2.NestedEnum] = ..., + optional_foreign_enum: Optional[ForeignEnumProto2] = ..., + optional_string_piece: Optional[Text] = ..., + optional_cord: Optional[Text] = ..., + recursive_message: Optional[TestAllTypesProto2] = ..., + repeated_int32: Optional[Iterable[int]] = ..., + repeated_int64: Optional[Iterable[int]] = ..., + repeated_uint32: Optional[Iterable[int]] = ..., + repeated_uint64: Optional[Iterable[int]] = ..., + repeated_sint32: Optional[Iterable[int]] = ..., + repeated_sint64: Optional[Iterable[int]] = ..., + repeated_fixed32: Optional[Iterable[int]] = ..., + repeated_fixed64: Optional[Iterable[int]] = ..., + repeated_sfixed32: Optional[Iterable[int]] = ..., + repeated_sfixed64: Optional[Iterable[int]] = ..., + repeated_float: Optional[Iterable[float]] = ..., + repeated_double: Optional[Iterable[float]] = ..., + repeated_bool: Optional[Iterable[bool]] = ..., + repeated_string: Optional[Iterable[Text]] = ..., + repeated_bytes: Optional[Iterable[str]] = ..., + repeated_nested_message: Optional[Iterable[TestAllTypesProto2.NestedMessage]] = ..., + repeated_foreign_message: Optional[Iterable[ForeignMessageProto2]] = ..., + repeated_nested_enum: Optional[Iterable[TestAllTypesProto2.NestedEnum]] = ..., + repeated_foreign_enum: Optional[Iterable[ForeignEnumProto2]] = ..., + repeated_string_piece: Optional[Iterable[Text]] = ..., + repeated_cord: Optional[Iterable[Text]] = ..., + map_int32_int32: Optional[Mapping[int, int]]=..., + map_int64_int64: Optional[Mapping[int, int]]=..., + map_uint32_uint32: Optional[Mapping[int, int]]=..., + map_uint64_uint64: Optional[Mapping[int, int]]=..., + map_sint32_sint32: Optional[Mapping[int, int]]=..., + map_sint64_sint64: Optional[Mapping[int, int]]=..., + map_fixed32_fixed32: Optional[Mapping[int, int]]=..., + map_fixed64_fixed64: Optional[Mapping[int, int]]=..., + map_sfixed32_sfixed32: Optional[Mapping[int, int]]=..., + map_sfixed64_sfixed64: Optional[Mapping[int, int]]=..., + map_int32_float: Optional[Mapping[int, float]]=..., + map_int32_double: Optional[Mapping[int, float]]=..., + map_bool_bool: Optional[Mapping[bool, bool]]=..., + map_string_string: Optional[Mapping[Text, Text]]=..., + map_string_bytes: Optional[Mapping[Text, str]]=..., + map_string_nested_message: Optional[Mapping[Text, TestAllTypesProto2.NestedMessage]]=..., + map_string_foreign_message: Optional[Mapping[Text, ForeignMessageProto2]]=..., + map_string_nested_enum: Optional[Mapping[Text, TestAllTypesProto2.NestedEnum]]=..., + map_string_foreign_enum: Optional[Mapping[Text, ForeignEnumProto2]]=..., + oneof_uint32: Optional[int] = ..., + oneof_nested_message: Optional[TestAllTypesProto2.NestedMessage] = ..., + oneof_string: Optional[Text] = ..., + oneof_bytes: Optional[str] = ..., + oneof_bool: Optional[bool] = ..., + oneof_uint64: Optional[int] = ..., + oneof_float: Optional[float] = ..., + oneof_double: Optional[float] = ..., + oneof_enum: Optional[TestAllTypesProto2.NestedEnum] = ..., + data: Optional[TestAllTypesProto2.Data] = ..., + fieldname1: Optional[int] = ..., + field_name2: Optional[int] = ..., + _field_name3: Optional[int] = ..., + field__name4_: Optional[int] = ..., + field0name5: Optional[int] = ..., + field_0_name6: Optional[int] = ..., + fieldName7: Optional[int] = ..., + FieldName8: Optional[int] = ..., + field_Name9: Optional[int] = ..., + Field_Name10: Optional[int] = ..., + FIELD_NAME11: Optional[int] = ..., + FIELD_name12: Optional[int] = ..., + __field_name13: Optional[int] = ..., + __Field_name14: Optional[int] = ..., + field__name15: Optional[int] = ..., + field__Name16: Optional[int] = ..., + field_name17__: Optional[int] = ..., + Field_name18__: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypesProto2: ... + + +class ForeignMessageProto2(Message): + c = ... # type: int + + def __init__(self, + c: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> ForeignMessageProto2: ... diff --git a/third_party/2/google/protobuf/test_messages_proto3_pb2.pyi b/third_party/2/google/protobuf/test_messages_proto3_pb2.pyi new file mode 100644 index 000000000..932253964 --- /dev/null +++ b/third_party/2/google/protobuf/test_messages_proto3_pb2.pyi @@ -0,0 +1,700 @@ +from google.protobuf.any_pb2 import ( + Any, +) +from google.protobuf.duration_pb2 import ( + Duration, +) +from google.protobuf.field_mask_pb2 import ( + FieldMask, +) +from google.protobuf.internal.containers import ( + RepeatedCompositeFieldContainer, + RepeatedScalarFieldContainer, +) +from google.protobuf.message import ( + Message, +) +from google.protobuf.struct_pb2 import ( + Struct, + Value, +) +from google.protobuf.timestamp_pb2 import ( + Timestamp, +) +from google.protobuf.wrappers_pb2 import ( + BoolValue, + BytesValue, + DoubleValue, + FloatValue, + Int32Value, + Int64Value, + StringValue, + UInt32Value, + UInt64Value, +) +from typing import ( + Iterable, + List, + Mapping, + MutableMapping, + Optional, + Text, + Tuple, + cast, +) + + +class ForeignEnum(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> ForeignEnum: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[ForeignEnum]: ... + + @classmethod + def items(cls) -> List[Tuple[str, ForeignEnum]]: ... +FOREIGN_FOO: ForeignEnum +FOREIGN_BAR: ForeignEnum +FOREIGN_BAZ: ForeignEnum + + +class TestAllTypesProto3(Message): + + class NestedEnum(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> TestAllTypesProto3.NestedEnum: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[TestAllTypesProto3.NestedEnum]: ... + + @classmethod + def items(cls) -> List[Tuple[str, TestAllTypesProto3.NestedEnum]]: ... + FOO: NestedEnum + BAR: NestedEnum + BAZ: NestedEnum + NEG: NestedEnum + + class NestedMessage(Message): + a = ... # type: int + + @property + def corecursive(self) -> TestAllTypesProto3: ... + + def __init__(self, + a: Optional[int] = ..., + corecursive: Optional[TestAllTypesProto3] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypesProto3.NestedMessage: ... + + class MapInt32Int32Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypesProto3.MapInt32Int32Entry: ... + + class MapInt64Int64Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypesProto3.MapInt64Int64Entry: ... + + class MapUint32Uint32Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypesProto3.MapUint32Uint32Entry: ... + + class MapUint64Uint64Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypesProto3.MapUint64Uint64Entry: ... + + class MapSint32Sint32Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypesProto3.MapSint32Sint32Entry: ... + + class MapSint64Sint64Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypesProto3.MapSint64Sint64Entry: ... + + class MapFixed32Fixed32Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypesProto3.MapFixed32Fixed32Entry: ... + + class MapFixed64Fixed64Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypesProto3.MapFixed64Fixed64Entry: ... + + class MapSfixed32Sfixed32Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypesProto3.MapSfixed32Sfixed32Entry: ... + + class MapSfixed64Sfixed64Entry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypesProto3.MapSfixed64Sfixed64Entry: ... + + class MapInt32FloatEntry(Message): + key = ... # type: int + value = ... # type: float + + def __init__(self, + key: Optional[int] = ..., + value: Optional[float] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypesProto3.MapInt32FloatEntry: ... + + class MapInt32DoubleEntry(Message): + key = ... # type: int + value = ... # type: float + + def __init__(self, + key: Optional[int] = ..., + value: Optional[float] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypesProto3.MapInt32DoubleEntry: ... + + class MapBoolBoolEntry(Message): + key = ... # type: bool + value = ... # type: bool + + def __init__(self, + key: Optional[bool] = ..., + value: Optional[bool] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypesProto3.MapBoolBoolEntry: ... + + class MapStringStringEntry(Message): + key = ... # type: Text + value = ... # type: Text + + def __init__(self, + key: Optional[Text] = ..., + value: Optional[Text] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypesProto3.MapStringStringEntry: ... + + class MapStringBytesEntry(Message): + key = ... # type: Text + value = ... # type: str + + def __init__(self, + key: Optional[Text] = ..., + value: Optional[str] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypesProto3.MapStringBytesEntry: ... + + class MapStringNestedMessageEntry(Message): + key = ... # type: Text + + @property + def value(self) -> TestAllTypesProto3.NestedMessage: ... + + def __init__(self, + key: Optional[Text] = ..., + value: Optional[TestAllTypesProto3.NestedMessage] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypesProto3.MapStringNestedMessageEntry: ... + + class MapStringForeignMessageEntry(Message): + key = ... # type: Text + + @property + def value(self) -> ForeignMessage: ... + + def __init__(self, + key: Optional[Text] = ..., + value: Optional[ForeignMessage] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypesProto3.MapStringForeignMessageEntry: ... + + class MapStringNestedEnumEntry(Message): + key = ... # type: Text + value = ... # type: TestAllTypesProto3.NestedEnum + + def __init__(self, + key: Optional[Text] = ..., + value: Optional[TestAllTypesProto3.NestedEnum] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypesProto3.MapStringNestedEnumEntry: ... + + class MapStringForeignEnumEntry(Message): + key = ... # type: Text + value = ... # type: ForeignEnum + + def __init__(self, + key: Optional[Text] = ..., + value: Optional[ForeignEnum] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypesProto3.MapStringForeignEnumEntry: ... + optional_int32 = ... # type: int + optional_int64 = ... # type: int + optional_uint32 = ... # type: int + optional_uint64 = ... # type: int + optional_sint32 = ... # type: int + optional_sint64 = ... # type: int + optional_fixed32 = ... # type: int + optional_fixed64 = ... # type: int + optional_sfixed32 = ... # type: int + optional_sfixed64 = ... # type: int + optional_float = ... # type: float + optional_double = ... # type: float + optional_bool = ... # type: bool + optional_string = ... # type: Text + optional_bytes = ... # type: str + optional_nested_enum = ... # type: TestAllTypesProto3.NestedEnum + optional_foreign_enum = ... # type: ForeignEnum + optional_string_piece = ... # type: Text + optional_cord = ... # type: Text + repeated_int32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_int64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_uint32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_uint64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_sint32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_sint64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_fixed32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_fixed64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_sfixed32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_sfixed64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_float = ... # type: RepeatedScalarFieldContainer[float] + repeated_double = ... # type: RepeatedScalarFieldContainer[float] + repeated_bool = ... # type: RepeatedScalarFieldContainer[bool] + repeated_string = ... # type: RepeatedScalarFieldContainer[Text] + repeated_bytes = ... # type: RepeatedScalarFieldContainer[str] + repeated_nested_enum = ... # type: RepeatedScalarFieldContainer[TestAllTypesProto3.NestedEnum] + repeated_foreign_enum = ... # type: RepeatedScalarFieldContainer[ForeignEnum] + repeated_string_piece = ... # type: RepeatedScalarFieldContainer[Text] + repeated_cord = ... # type: RepeatedScalarFieldContainer[Text] + oneof_uint32 = ... # type: int + oneof_string = ... # type: Text + oneof_bytes = ... # type: str + oneof_bool = ... # type: bool + oneof_uint64 = ... # type: int + oneof_float = ... # type: float + oneof_double = ... # type: float + oneof_enum = ... # type: TestAllTypesProto3.NestedEnum + fieldname1 = ... # type: int + field_name2 = ... # type: int + _field_name3 = ... # type: int + field__name4_ = ... # type: int + field0name5 = ... # type: int + field_0_name6 = ... # type: int + fieldName7 = ... # type: int + FieldName8 = ... # type: int + field_Name9 = ... # type: int + Field_Name10 = ... # type: int + FIELD_NAME11 = ... # type: int + FIELD_name12 = ... # type: int + __field_name13 = ... # type: int + __Field_name14 = ... # type: int + field__name15 = ... # type: int + field__Name16 = ... # type: int + field_name17__ = ... # type: int + Field_name18__ = ... # type: int + + @property + def optional_nested_message(self) -> TestAllTypesProto3.NestedMessage: ... + + @property + def optional_foreign_message(self) -> ForeignMessage: ... + + @property + def recursive_message(self) -> TestAllTypesProto3: ... + + @property + def repeated_nested_message(self) -> RepeatedCompositeFieldContainer[TestAllTypesProto3.NestedMessage]: ... + + @property + def repeated_foreign_message(self) -> RepeatedCompositeFieldContainer[ForeignMessage]: ... + + @property + def map_int32_int32(self) -> MutableMapping[int, int]: ... + + @property + def map_int64_int64(self) -> MutableMapping[int, int]: ... + + @property + def map_uint32_uint32(self) -> MutableMapping[int, int]: ... + + @property + def map_uint64_uint64(self) -> MutableMapping[int, int]: ... + + @property + def map_sint32_sint32(self) -> MutableMapping[int, int]: ... + + @property + def map_sint64_sint64(self) -> MutableMapping[int, int]: ... + + @property + def map_fixed32_fixed32(self) -> MutableMapping[int, int]: ... + + @property + def map_fixed64_fixed64(self) -> MutableMapping[int, int]: ... + + @property + def map_sfixed32_sfixed32(self) -> MutableMapping[int, int]: ... + + @property + def map_sfixed64_sfixed64(self) -> MutableMapping[int, int]: ... + + @property + def map_int32_float(self) -> MutableMapping[int, float]: ... + + @property + def map_int32_double(self) -> MutableMapping[int, float]: ... + + @property + def map_bool_bool(self) -> MutableMapping[bool, bool]: ... + + @property + def map_string_string(self) -> MutableMapping[Text, Text]: ... + + @property + def map_string_bytes(self) -> MutableMapping[Text, str]: ... + + @property + def map_string_nested_message(self) -> MutableMapping[Text, TestAllTypesProto3.NestedMessage]: ... + + @property + def map_string_foreign_message(self) -> MutableMapping[Text, ForeignMessage]: ... + + @property + def map_string_nested_enum(self) -> MutableMapping[Text, TestAllTypesProto3.NestedEnum]: ... + + @property + def map_string_foreign_enum(self) -> MutableMapping[Text, ForeignEnum]: ... + + @property + def oneof_nested_message(self) -> TestAllTypesProto3.NestedMessage: ... + + @property + def optional_bool_wrapper(self) -> BoolValue: ... + + @property + def optional_int32_wrapper(self) -> Int32Value: ... + + @property + def optional_int64_wrapper(self) -> Int64Value: ... + + @property + def optional_uint32_wrapper(self) -> UInt32Value: ... + + @property + def optional_uint64_wrapper(self) -> UInt64Value: ... + + @property + def optional_float_wrapper(self) -> FloatValue: ... + + @property + def optional_double_wrapper(self) -> DoubleValue: ... + + @property + def optional_string_wrapper(self) -> StringValue: ... + + @property + def optional_bytes_wrapper(self) -> BytesValue: ... + + @property + def repeated_bool_wrapper(self) -> RepeatedCompositeFieldContainer[BoolValue]: ... + + @property + def repeated_int32_wrapper(self) -> RepeatedCompositeFieldContainer[Int32Value]: ... + + @property + def repeated_int64_wrapper(self) -> RepeatedCompositeFieldContainer[Int64Value]: ... + + @property + def repeated_uint32_wrapper(self) -> RepeatedCompositeFieldContainer[UInt32Value]: ... + + @property + def repeated_uint64_wrapper(self) -> RepeatedCompositeFieldContainer[UInt64Value]: ... + + @property + def repeated_float_wrapper(self) -> RepeatedCompositeFieldContainer[FloatValue]: ... + + @property + def repeated_double_wrapper(self) -> RepeatedCompositeFieldContainer[DoubleValue]: ... + + @property + def repeated_string_wrapper(self) -> RepeatedCompositeFieldContainer[StringValue]: ... + + @property + def repeated_bytes_wrapper(self) -> RepeatedCompositeFieldContainer[BytesValue]: ... + + @property + def optional_duration(self) -> Duration: ... + + @property + def optional_timestamp(self) -> Timestamp: ... + + @property + def optional_field_mask(self) -> FieldMask: ... + + @property + def optional_struct(self) -> Struct: ... + + @property + def optional_any(self) -> Any: ... + + @property + def optional_value(self) -> Value: ... + + @property + def repeated_duration(self) -> RepeatedCompositeFieldContainer[Duration]: ... + + @property + def repeated_timestamp(self) -> RepeatedCompositeFieldContainer[Timestamp]: ... + + @property + def repeated_fieldmask(self) -> RepeatedCompositeFieldContainer[FieldMask]: ... + + @property + def repeated_struct(self) -> RepeatedCompositeFieldContainer[Struct]: ... + + @property + def repeated_any(self) -> RepeatedCompositeFieldContainer[Any]: ... + + @property + def repeated_value(self) -> RepeatedCompositeFieldContainer[Value]: ... + + def __init__(self, + optional_int32: Optional[int] = ..., + optional_int64: Optional[int] = ..., + optional_uint32: Optional[int] = ..., + optional_uint64: Optional[int] = ..., + optional_sint32: Optional[int] = ..., + optional_sint64: Optional[int] = ..., + optional_fixed32: Optional[int] = ..., + optional_fixed64: Optional[int] = ..., + optional_sfixed32: Optional[int] = ..., + optional_sfixed64: Optional[int] = ..., + optional_float: Optional[float] = ..., + optional_double: Optional[float] = ..., + optional_bool: Optional[bool] = ..., + optional_string: Optional[Text] = ..., + optional_bytes: Optional[str] = ..., + optional_nested_message: Optional[TestAllTypesProto3.NestedMessage] = ..., + optional_foreign_message: Optional[ForeignMessage] = ..., + optional_nested_enum: Optional[TestAllTypesProto3.NestedEnum] = ..., + optional_foreign_enum: Optional[ForeignEnum] = ..., + optional_string_piece: Optional[Text] = ..., + optional_cord: Optional[Text] = ..., + recursive_message: Optional[TestAllTypesProto3] = ..., + repeated_int32: Optional[Iterable[int]] = ..., + repeated_int64: Optional[Iterable[int]] = ..., + repeated_uint32: Optional[Iterable[int]] = ..., + repeated_uint64: Optional[Iterable[int]] = ..., + repeated_sint32: Optional[Iterable[int]] = ..., + repeated_sint64: Optional[Iterable[int]] = ..., + repeated_fixed32: Optional[Iterable[int]] = ..., + repeated_fixed64: Optional[Iterable[int]] = ..., + repeated_sfixed32: Optional[Iterable[int]] = ..., + repeated_sfixed64: Optional[Iterable[int]] = ..., + repeated_float: Optional[Iterable[float]] = ..., + repeated_double: Optional[Iterable[float]] = ..., + repeated_bool: Optional[Iterable[bool]] = ..., + repeated_string: Optional[Iterable[Text]] = ..., + repeated_bytes: Optional[Iterable[str]] = ..., + repeated_nested_message: Optional[Iterable[TestAllTypesProto3.NestedMessage]] = ..., + repeated_foreign_message: Optional[Iterable[ForeignMessage]] = ..., + repeated_nested_enum: Optional[Iterable[TestAllTypesProto3.NestedEnum]] = ..., + repeated_foreign_enum: Optional[Iterable[ForeignEnum]] = ..., + repeated_string_piece: Optional[Iterable[Text]] = ..., + repeated_cord: Optional[Iterable[Text]] = ..., + map_int32_int32: Optional[Mapping[int, int]]=..., + map_int64_int64: Optional[Mapping[int, int]]=..., + map_uint32_uint32: Optional[Mapping[int, int]]=..., + map_uint64_uint64: Optional[Mapping[int, int]]=..., + map_sint32_sint32: Optional[Mapping[int, int]]=..., + map_sint64_sint64: Optional[Mapping[int, int]]=..., + map_fixed32_fixed32: Optional[Mapping[int, int]]=..., + map_fixed64_fixed64: Optional[Mapping[int, int]]=..., + map_sfixed32_sfixed32: Optional[Mapping[int, int]]=..., + map_sfixed64_sfixed64: Optional[Mapping[int, int]]=..., + map_int32_float: Optional[Mapping[int, float]]=..., + map_int32_double: Optional[Mapping[int, float]]=..., + map_bool_bool: Optional[Mapping[bool, bool]]=..., + map_string_string: Optional[Mapping[Text, Text]]=..., + map_string_bytes: Optional[Mapping[Text, str]]=..., + map_string_nested_message: Optional[Mapping[Text, TestAllTypesProto3.NestedMessage]]=..., + map_string_foreign_message: Optional[Mapping[Text, ForeignMessage]]=..., + map_string_nested_enum: Optional[Mapping[Text, TestAllTypesProto3.NestedEnum]]=..., + map_string_foreign_enum: Optional[Mapping[Text, ForeignEnum]]=..., + oneof_uint32: Optional[int] = ..., + oneof_nested_message: Optional[TestAllTypesProto3.NestedMessage] = ..., + oneof_string: Optional[Text] = ..., + oneof_bytes: Optional[str] = ..., + oneof_bool: Optional[bool] = ..., + oneof_uint64: Optional[int] = ..., + oneof_float: Optional[float] = ..., + oneof_double: Optional[float] = ..., + oneof_enum: Optional[TestAllTypesProto3.NestedEnum] = ..., + optional_bool_wrapper: Optional[BoolValue] = ..., + optional_int32_wrapper: Optional[Int32Value] = ..., + optional_int64_wrapper: Optional[Int64Value] = ..., + optional_uint32_wrapper: Optional[UInt32Value] = ..., + optional_uint64_wrapper: Optional[UInt64Value] = ..., + optional_float_wrapper: Optional[FloatValue] = ..., + optional_double_wrapper: Optional[DoubleValue] = ..., + optional_string_wrapper: Optional[StringValue] = ..., + optional_bytes_wrapper: Optional[BytesValue] = ..., + repeated_bool_wrapper: Optional[Iterable[BoolValue]] = ..., + repeated_int32_wrapper: Optional[Iterable[Int32Value]] = ..., + repeated_int64_wrapper: Optional[Iterable[Int64Value]] = ..., + repeated_uint32_wrapper: Optional[Iterable[UInt32Value]] = ..., + repeated_uint64_wrapper: Optional[Iterable[UInt64Value]] = ..., + repeated_float_wrapper: Optional[Iterable[FloatValue]] = ..., + repeated_double_wrapper: Optional[Iterable[DoubleValue]] = ..., + repeated_string_wrapper: Optional[Iterable[StringValue]] = ..., + repeated_bytes_wrapper: Optional[Iterable[BytesValue]] = ..., + optional_duration: Optional[Duration] = ..., + optional_timestamp: Optional[Timestamp] = ..., + optional_field_mask: Optional[FieldMask] = ..., + optional_struct: Optional[Struct] = ..., + optional_any: Optional[Any] = ..., + optional_value: Optional[Value] = ..., + repeated_duration: Optional[Iterable[Duration]] = ..., + repeated_timestamp: Optional[Iterable[Timestamp]] = ..., + repeated_fieldmask: Optional[Iterable[FieldMask]] = ..., + repeated_struct: Optional[Iterable[Struct]] = ..., + repeated_any: Optional[Iterable[Any]] = ..., + repeated_value: Optional[Iterable[Value]] = ..., + fieldname1: Optional[int] = ..., + field_name2: Optional[int] = ..., + _field_name3: Optional[int] = ..., + field__name4_: Optional[int] = ..., + field0name5: Optional[int] = ..., + field_0_name6: Optional[int] = ..., + fieldName7: Optional[int] = ..., + FieldName8: Optional[int] = ..., + field_Name9: Optional[int] = ..., + Field_Name10: Optional[int] = ..., + FIELD_NAME11: Optional[int] = ..., + FIELD_name12: Optional[int] = ..., + __field_name13: Optional[int] = ..., + __Field_name14: Optional[int] = ..., + field__name15: Optional[int] = ..., + field__Name16: Optional[int] = ..., + field_name17__: Optional[int] = ..., + Field_name18__: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypesProto3: ... + + +class ForeignMessage(Message): + c = ... # type: int + + def __init__(self, + c: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> ForeignMessage: ... diff --git a/third_party/2/google/protobuf/timestamp_pb2.pyi b/third_party/2/google/protobuf/timestamp_pb2.pyi new file mode 100644 index 000000000..ffc248fd7 --- /dev/null +++ b/third_party/2/google/protobuf/timestamp_pb2.pyi @@ -0,0 +1,19 @@ +from google.protobuf.message import ( + Message, +) +from typing import ( + Optional, +) + + +class Timestamp(Message): + seconds = ... # type: int + nanos = ... # type: int + + def __init__(self, + seconds: Optional[int] = ..., + nanos: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> Timestamp: ... diff --git a/third_party/2/google/protobuf/type_pb2.pyi b/third_party/2/google/protobuf/type_pb2.pyi new file mode 100644 index 000000000..61c46d7c6 --- /dev/null +++ b/third_party/2/google/protobuf/type_pb2.pyi @@ -0,0 +1,215 @@ +from google.protobuf.any_pb2 import ( + Any, +) +from google.protobuf.internal.containers import ( + RepeatedCompositeFieldContainer, + RepeatedScalarFieldContainer, +) +from google.protobuf.message import ( + Message, +) +from google.protobuf.source_context_pb2 import ( + SourceContext, +) +from typing import ( + Iterable, + List, + Optional, + Text, + Tuple, + cast, +) + + +class Syntax(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> Syntax: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[Syntax]: ... + + @classmethod + def items(cls) -> List[Tuple[str, Syntax]]: ... + + +SYNTAX_PROTO2: Syntax +SYNTAX_PROTO3: Syntax + + +class Type(Message): + name = ... # type: Text + oneofs = ... # type: RepeatedScalarFieldContainer[Text] + syntax = ... # type: Syntax + + @property + def fields(self) -> RepeatedCompositeFieldContainer[Field]: ... + + @property + def options(self) -> RepeatedCompositeFieldContainer[Option]: ... + + @property + def source_context(self) -> SourceContext: ... + + def __init__(self, + name: Optional[Text] = ..., + fields: Optional[Iterable[Field]] = ..., + oneofs: Optional[Iterable[Text]] = ..., + options: Optional[Iterable[Option]] = ..., + source_context: Optional[SourceContext] = ..., + syntax: Optional[Syntax] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> Type: ... + + +class Field(Message): + + class Kind(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> Field.Kind: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[Field.Kind]: ... + + @classmethod + def items(cls) -> List[Tuple[str, Field.Kind]]: ... + TYPE_UNKNOWN: Kind + TYPE_DOUBLE: Kind + TYPE_FLOAT: Kind + TYPE_INT64: Kind + TYPE_UINT64: Kind + TYPE_INT32: Kind + TYPE_FIXED64: Kind + TYPE_FIXED32: Kind + TYPE_BOOL: Kind + TYPE_STRING: Kind + TYPE_GROUP: Kind + TYPE_MESSAGE: Kind + TYPE_BYTES: Kind + TYPE_UINT32: Kind + TYPE_ENUM: Kind + TYPE_SFIXED32: Kind + TYPE_SFIXED64: Kind + TYPE_SINT32: Kind + TYPE_SINT64: Kind + + class Cardinality(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> Field.Cardinality: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[Field.Cardinality]: ... + + @classmethod + def items(cls) -> List[Tuple[str, Field.Cardinality]]: ... + CARDINALITY_UNKNOWN: Cardinality + CARDINALITY_OPTIONAL: Cardinality + CARDINALITY_REQUIRED: Cardinality + CARDINALITY_REPEATED: Cardinality + kind = ... # type: Field.Kind + cardinality = ... # type: Field.Cardinality + number = ... # type: int + name = ... # type: Text + type_url = ... # type: Text + oneof_index = ... # type: int + packed = ... # type: bool + json_name = ... # type: Text + default_value = ... # type: Text + + @property + def options(self) -> RepeatedCompositeFieldContainer[Option]: ... + + def __init__(self, + kind: Optional[Field.Kind] = ..., + cardinality: Optional[Field.Cardinality] = ..., + number: Optional[int] = ..., + name: Optional[Text] = ..., + type_url: Optional[Text] = ..., + oneof_index: Optional[int] = ..., + packed: Optional[bool] = ..., + options: Optional[Iterable[Option]] = ..., + json_name: Optional[Text] = ..., + default_value: Optional[Text] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> Field: ... + + +class Enum(Message): + name = ... # type: Text + syntax = ... # type: Syntax + + @property + def enumvalue(self) -> RepeatedCompositeFieldContainer[EnumValue]: ... + + @property + def options(self) -> RepeatedCompositeFieldContainer[Option]: ... + + @property + def source_context(self) -> SourceContext: ... + + def __init__(self, + name: Optional[Text] = ..., + enumvalue: Optional[Iterable[EnumValue]] = ..., + options: Optional[Iterable[Option]] = ..., + source_context: Optional[SourceContext] = ..., + syntax: Optional[Syntax] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> Enum: ... + + +class EnumValue(Message): + name = ... # type: Text + number = ... # type: int + + @property + def options(self) -> RepeatedCompositeFieldContainer[Option]: ... + + def __init__(self, + name: Optional[Text] = ..., + number: Optional[int] = ..., + options: Optional[Iterable[Option]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> EnumValue: ... + + +class Option(Message): + name = ... # type: Text + + @property + def value(self) -> Any: ... + + def __init__(self, + name: Optional[Text] = ..., + value: Optional[Any] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> Option: ... diff --git a/third_party/2/google/protobuf/unittest_arena_pb2.pyi b/third_party/2/google/protobuf/unittest_arena_pb2.pyi new file mode 100644 index 000000000..9fca5932d --- /dev/null +++ b/third_party/2/google/protobuf/unittest_arena_pb2.pyi @@ -0,0 +1,43 @@ +from google.protobuf.internal.containers import ( + RepeatedCompositeFieldContainer, +) +from google.protobuf.message import ( + Message, +) +from google.protobuf.unittest_no_arena_import_pb2 import ( + ImportNoArenaNestedMessage, +) +from typing import ( + Iterable, + Optional, +) + + +class NestedMessage(Message): + d = ... # type: int + + def __init__(self, + d: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> NestedMessage: ... + + +class ArenaMessage(Message): + + @property + def repeated_nested_message( + self) -> RepeatedCompositeFieldContainer[NestedMessage]: ... + + @property + def repeated_import_no_arena_message( + self) -> RepeatedCompositeFieldContainer[ImportNoArenaNestedMessage]: ... + + def __init__(self, + repeated_nested_message: Optional[Iterable[NestedMessage]] = ..., + repeated_import_no_arena_message: Optional[Iterable[ImportNoArenaNestedMessage]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> ArenaMessage: ... diff --git a/third_party/2/google/protobuf/unittest_custom_options_pb2.pyi b/third_party/2/google/protobuf/unittest_custom_options_pb2.pyi new file mode 100644 index 000000000..2216a902a --- /dev/null +++ b/third_party/2/google/protobuf/unittest_custom_options_pb2.pyi @@ -0,0 +1,472 @@ +from google.protobuf.descriptor_pb2 import ( + FileOptions, +) +from google.protobuf.internal.containers import ( + RepeatedCompositeFieldContainer, + RepeatedScalarFieldContainer, +) +from google.protobuf.message import ( + Message, +) +from typing import ( + Iterable, + List, + Optional, + Text, + Tuple, + cast, +) + + +class MethodOpt1(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> MethodOpt1: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[MethodOpt1]: ... + + @classmethod + def items(cls) -> List[Tuple[str, MethodOpt1]]: ... + + +METHODOPT1_VAL1: MethodOpt1 +METHODOPT1_VAL2: MethodOpt1 + + +class AggregateEnum(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> AggregateEnum: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[AggregateEnum]: ... + + @classmethod + def items(cls) -> List[Tuple[str, AggregateEnum]]: ... + + +VALUE: AggregateEnum + + +class TestMessageWithCustomOptions(Message): + + class AnEnum(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> TestMessageWithCustomOptions.AnEnum: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[TestMessageWithCustomOptions.AnEnum]: ... + + @classmethod + def items(cls) -> List[Tuple[str, + TestMessageWithCustomOptions.AnEnum]]: ... + ANENUM_VAL1: AnEnum + ANENUM_VAL2: AnEnum + field1 = ... # type: Text + oneof_field = ... # type: int + + def __init__(self, + field1: Optional[Text] = ..., + oneof_field: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMessageWithCustomOptions: ... + + +class CustomOptionFooRequest(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> CustomOptionFooRequest: ... + + +class CustomOptionFooResponse(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> CustomOptionFooResponse: ... + + +class CustomOptionFooClientMessage(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> CustomOptionFooClientMessage: ... + + +class CustomOptionFooServerMessage(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> CustomOptionFooServerMessage: ... + + +class DummyMessageContainingEnum(Message): + + class TestEnumType(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> DummyMessageContainingEnum.TestEnumType: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[DummyMessageContainingEnum.TestEnumType]: ... + + @classmethod + def items(cls) -> List[Tuple[str, + DummyMessageContainingEnum.TestEnumType]]: ... + TEST_OPTION_ENUM_TYPE1: TestEnumType + TEST_OPTION_ENUM_TYPE2: TestEnumType + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> DummyMessageContainingEnum: ... + + +class DummyMessageInvalidAsOptionType(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> DummyMessageInvalidAsOptionType: ... + + +class CustomOptionMinIntegerValues(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> CustomOptionMinIntegerValues: ... + + +class CustomOptionMaxIntegerValues(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> CustomOptionMaxIntegerValues: ... + + +class CustomOptionOtherValues(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> CustomOptionOtherValues: ... + + +class SettingRealsFromPositiveInts(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> SettingRealsFromPositiveInts: ... + + +class SettingRealsFromNegativeInts(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> SettingRealsFromNegativeInts: ... + + +class ComplexOptionType1(Message): + foo = ... # type: int + foo2 = ... # type: int + foo3 = ... # type: int + foo4 = ... # type: RepeatedScalarFieldContainer[int] + + def __init__(self, + foo: Optional[int] = ..., + foo2: Optional[int] = ..., + foo3: Optional[int] = ..., + foo4: Optional[Iterable[int]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> ComplexOptionType1: ... + + +class ComplexOptionType2(Message): + + class ComplexOptionType4(Message): + waldo = ... # type: int + + def __init__(self, + waldo: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> ComplexOptionType2.ComplexOptionType4: ... + baz = ... # type: int + + @property + def bar(self) -> ComplexOptionType1: ... + + @property + def fred(self) -> ComplexOptionType2.ComplexOptionType4: ... + + @property + def barney( + self) -> RepeatedCompositeFieldContainer[ComplexOptionType2.ComplexOptionType4]: ... + + def __init__(self, + bar: Optional[ComplexOptionType1] = ..., + baz: Optional[int] = ..., + fred: Optional[ComplexOptionType2.ComplexOptionType4] = ..., + barney: Optional[Iterable[ComplexOptionType2.ComplexOptionType4]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> ComplexOptionType2: ... + + +class ComplexOptionType3(Message): + + class ComplexOptionType5(Message): + plugh = ... # type: int + + def __init__(self, + plugh: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> ComplexOptionType3.ComplexOptionType5: ... + qux = ... # type: int + + @property + def complexoptiontype5(self) -> ComplexOptionType3.ComplexOptionType5: ... + + def __init__(self, + qux: Optional[int] = ..., + complexoptiontype5: Optional[ComplexOptionType3.ComplexOptionType5] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> ComplexOptionType3: ... + + +class ComplexOpt6(Message): + xyzzy = ... # type: int + + def __init__(self, + xyzzy: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> ComplexOpt6: ... + + +class VariousComplexOptions(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> VariousComplexOptions: ... + + +class AggregateMessageSet(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> AggregateMessageSet: ... + + +class AggregateMessageSetElement(Message): + s = ... # type: Text + + def __init__(self, + s: Optional[Text] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> AggregateMessageSetElement: ... + + +class Aggregate(Message): + i = ... # type: int + s = ... # type: Text + + @property + def sub(self) -> Aggregate: ... + + @property + def file(self) -> FileOptions: ... + + @property + def mset(self) -> AggregateMessageSet: ... + + def __init__(self, + i: Optional[int] = ..., + s: Optional[Text] = ..., + sub: Optional[Aggregate] = ..., + file: Optional[FileOptions] = ..., + mset: Optional[AggregateMessageSet] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> Aggregate: ... + + +class AggregateMessage(Message): + fieldname = ... # type: int + + def __init__(self, + fieldname: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> AggregateMessage: ... + + +class NestedOptionType(Message): + + class NestedEnum(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> NestedOptionType.NestedEnum: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[NestedOptionType.NestedEnum]: ... + + @classmethod + def items(cls) -> List[Tuple[str, NestedOptionType.NestedEnum]]: ... + NESTED_ENUM_VALUE: NestedEnum + + class NestedMessage(Message): + nested_field = ... # type: int + + def __init__(self, + nested_field: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> NestedOptionType.NestedMessage: ... + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> NestedOptionType: ... + + +class OldOptionType(Message): + + class TestEnum(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> OldOptionType.TestEnum: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[OldOptionType.TestEnum]: ... + + @classmethod + def items(cls) -> List[Tuple[str, OldOptionType.TestEnum]]: ... + OLD_VALUE: TestEnum + value = ... # type: OldOptionType.TestEnum + + def __init__(self, + value: OldOptionType.TestEnum, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> OldOptionType: ... + + +class NewOptionType(Message): + + class TestEnum(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> NewOptionType.TestEnum: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[NewOptionType.TestEnum]: ... + + @classmethod + def items(cls) -> List[Tuple[str, NewOptionType.TestEnum]]: ... + OLD_VALUE: TestEnum + NEW_VALUE: TestEnum + value = ... # type: NewOptionType.TestEnum + + def __init__(self, + value: NewOptionType.TestEnum, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> NewOptionType: ... + + +class TestMessageWithRequiredEnumOption(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMessageWithRequiredEnumOption: ... diff --git a/third_party/2/google/protobuf/unittest_import_pb2.pyi b/third_party/2/google/protobuf/unittest_import_pb2.pyi new file mode 100644 index 000000000..cdd97d871 --- /dev/null +++ b/third_party/2/google/protobuf/unittest_import_pb2.pyi @@ -0,0 +1,66 @@ +from google.protobuf.message import ( + Message, +) +from typing import ( + List, + Optional, + Tuple, + cast, +) + + +class ImportEnum(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> ImportEnum: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[ImportEnum]: ... + + @classmethod + def items(cls) -> List[Tuple[str, ImportEnum]]: ... + + +IMPORT_FOO: ImportEnum +IMPORT_BAR: ImportEnum +IMPORT_BAZ: ImportEnum + + +class ImportEnumForMap(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> ImportEnumForMap: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[ImportEnumForMap]: ... + + @classmethod + def items(cls) -> List[Tuple[str, ImportEnumForMap]]: ... + + +UNKNOWN: ImportEnumForMap +FOO: ImportEnumForMap +BAR: ImportEnumForMap + + +class ImportMessage(Message): + d = ... # type: int + + def __init__(self, + d: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> ImportMessage: ... diff --git a/third_party/2/google/protobuf/unittest_import_public_pb2.pyi b/third_party/2/google/protobuf/unittest_import_public_pb2.pyi new file mode 100644 index 000000000..30cf48d91 --- /dev/null +++ b/third_party/2/google/protobuf/unittest_import_public_pb2.pyi @@ -0,0 +1,17 @@ +from google.protobuf.message import ( + Message, +) +from typing import ( + Optional, +) + + +class PublicImportMessage(Message): + e = ... # type: int + + def __init__(self, + e: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> PublicImportMessage: ... diff --git a/third_party/2/google/protobuf/unittest_mset_pb2.pyi b/third_party/2/google/protobuf/unittest_mset_pb2.pyi new file mode 100644 index 000000000..a6a3b0eff --- /dev/null +++ b/third_party/2/google/protobuf/unittest_mset_pb2.pyi @@ -0,0 +1,75 @@ +from google.protobuf.internal.containers import ( + RepeatedCompositeFieldContainer, +) +from google.protobuf.message import ( + Message, +) +from google.protobuf.unittest_mset_wire_format_pb2 import ( + TestMessageSet, +) +import builtins +from typing import ( + Iterable, + Optional, + Text, +) + + +class TestMessageSetContainer(Message): + + @property + def message_set(self) -> TestMessageSet: ... + + def __init__(self, + message_set: Optional[TestMessageSet] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMessageSetContainer: ... + + +class TestMessageSetExtension1(Message): + i = ... # type: int + + def __init__(self, + i: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMessageSetExtension1: ... + + +class TestMessageSetExtension2(Message): + str = ... # type: Text + + def __init__(self, + str: Optional[Text] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: builtins.str) -> TestMessageSetExtension2: ... + + +class RawMessageSet(Message): + + class Item(Message): + type_id = ... # type: int + message = ... # type: str + + def __init__(self, + type_id: int, + message: str, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> RawMessageSet.Item: ... + + @property + def item(self) -> RepeatedCompositeFieldContainer[RawMessageSet.Item]: ... + + def __init__(self, + item: Optional[Iterable[RawMessageSet.Item]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> RawMessageSet: ... diff --git a/third_party/2/google/protobuf/unittest_mset_wire_format_pb2.pyi b/third_party/2/google/protobuf/unittest_mset_wire_format_pb2.pyi new file mode 100644 index 000000000..95cfda4a2 --- /dev/null +++ b/third_party/2/google/protobuf/unittest_mset_wire_format_pb2.pyi @@ -0,0 +1,28 @@ +from google.protobuf.message import ( + Message, +) +from typing import ( + Optional, +) + + +class TestMessageSet(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMessageSet: ... + + +class TestMessageSetWireFormatContainer(Message): + + @property + def message_set(self) -> TestMessageSet: ... + + def __init__(self, + message_set: Optional[TestMessageSet] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMessageSetWireFormatContainer: ... diff --git a/third_party/2/google/protobuf/unittest_no_arena_import_pb2.pyi b/third_party/2/google/protobuf/unittest_no_arena_import_pb2.pyi new file mode 100644 index 000000000..8870d98a2 --- /dev/null +++ b/third_party/2/google/protobuf/unittest_no_arena_import_pb2.pyi @@ -0,0 +1,17 @@ +from google.protobuf.message import ( + Message, +) +from typing import ( + Optional, +) + + +class ImportNoArenaNestedMessage(Message): + d = ... # type: int + + def __init__(self, + d: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> ImportNoArenaNestedMessage: ... diff --git a/third_party/2/google/protobuf/unittest_no_arena_pb2.pyi b/third_party/2/google/protobuf/unittest_no_arena_pb2.pyi new file mode 100644 index 000000000..ee03ad0cf --- /dev/null +++ b/third_party/2/google/protobuf/unittest_no_arena_pb2.pyi @@ -0,0 +1,315 @@ +from google.protobuf.internal.containers import ( + RepeatedCompositeFieldContainer, + RepeatedScalarFieldContainer, +) +from google.protobuf.message import ( + Message, +) +from google.protobuf.unittest_arena_pb2 import ( + ArenaMessage, +) +from google.protobuf.unittest_import_pb2 import ( + ImportEnum, + ImportMessage, +) +from google.protobuf.unittest_import_public_pb2 import ( + PublicImportMessage, +) +from typing import ( + Iterable, + List, + Optional, + Text, + Tuple, + cast, +) + + +class ForeignEnum(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> ForeignEnum: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[ForeignEnum]: ... + + @classmethod + def items(cls) -> List[Tuple[str, ForeignEnum]]: ... + + +FOREIGN_FOO: ForeignEnum +FOREIGN_BAR: ForeignEnum +FOREIGN_BAZ: ForeignEnum + + +class TestAllTypes(Message): + + class NestedEnum(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> TestAllTypes.NestedEnum: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[TestAllTypes.NestedEnum]: ... + + @classmethod + def items(cls) -> List[Tuple[str, TestAllTypes.NestedEnum]]: ... + FOO: NestedEnum + BAR: NestedEnum + BAZ: NestedEnum + NEG: NestedEnum + + class NestedMessage(Message): + bb = ... # type: int + + def __init__(self, + bb: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypes.NestedMessage: ... + + class OptionalGroup(Message): + a = ... # type: int + + def __init__(self, + a: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypes.OptionalGroup: ... + + class RepeatedGroup(Message): + a = ... # type: int + + def __init__(self, + a: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypes.RepeatedGroup: ... + optional_int32 = ... # type: int + optional_int64 = ... # type: int + optional_uint32 = ... # type: int + optional_uint64 = ... # type: int + optional_sint32 = ... # type: int + optional_sint64 = ... # type: int + optional_fixed32 = ... # type: int + optional_fixed64 = ... # type: int + optional_sfixed32 = ... # type: int + optional_sfixed64 = ... # type: int + optional_float = ... # type: float + optional_double = ... # type: float + optional_bool = ... # type: bool + optional_string = ... # type: Text + optional_bytes = ... # type: str + optional_nested_enum = ... # type: TestAllTypes.NestedEnum + optional_foreign_enum = ... # type: ForeignEnum + optional_import_enum = ... # type: ImportEnum + optional_string_piece = ... # type: Text + optional_cord = ... # type: Text + repeated_int32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_int64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_uint32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_uint64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_sint32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_sint64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_fixed32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_fixed64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_sfixed32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_sfixed64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_float = ... # type: RepeatedScalarFieldContainer[float] + repeated_double = ... # type: RepeatedScalarFieldContainer[float] + repeated_bool = ... # type: RepeatedScalarFieldContainer[bool] + repeated_string = ... # type: RepeatedScalarFieldContainer[Text] + repeated_bytes = ... # type: RepeatedScalarFieldContainer[str] + repeated_nested_enum = ... # type: RepeatedScalarFieldContainer[TestAllTypes.NestedEnum] + repeated_foreign_enum = ... # type: RepeatedScalarFieldContainer[ForeignEnum] + repeated_import_enum = ... # type: RepeatedScalarFieldContainer[ImportEnum] + repeated_string_piece = ... # type: RepeatedScalarFieldContainer[Text] + repeated_cord = ... # type: RepeatedScalarFieldContainer[Text] + default_int32 = ... # type: int + default_int64 = ... # type: int + default_uint32 = ... # type: int + default_uint64 = ... # type: int + default_sint32 = ... # type: int + default_sint64 = ... # type: int + default_fixed32 = ... # type: int + default_fixed64 = ... # type: int + default_sfixed32 = ... # type: int + default_sfixed64 = ... # type: int + default_float = ... # type: float + default_double = ... # type: float + default_bool = ... # type: bool + default_string = ... # type: Text + default_bytes = ... # type: str + default_nested_enum = ... # type: TestAllTypes.NestedEnum + default_foreign_enum = ... # type: ForeignEnum + default_import_enum = ... # type: ImportEnum + default_string_piece = ... # type: Text + default_cord = ... # type: Text + oneof_uint32 = ... # type: int + oneof_string = ... # type: Text + oneof_bytes = ... # type: str + + @property + def optionalgroup(self) -> TestAllTypes.OptionalGroup: ... + + @property + def optional_nested_message(self) -> TestAllTypes.NestedMessage: ... + + @property + def optional_foreign_message(self) -> ForeignMessage: ... + + @property + def optional_import_message(self) -> ImportMessage: ... + + @property + def optional_public_import_message(self) -> PublicImportMessage: ... + + @property + def optional_message(self) -> TestAllTypes.NestedMessage: ... + + @property + def repeatedgroup( + self) -> RepeatedCompositeFieldContainer[TestAllTypes.RepeatedGroup]: ... + + @property + def repeated_nested_message( + self) -> RepeatedCompositeFieldContainer[TestAllTypes.NestedMessage]: ... + + @property + def repeated_foreign_message( + self) -> RepeatedCompositeFieldContainer[ForeignMessage]: ... + + @property + def repeated_import_message( + self) -> RepeatedCompositeFieldContainer[ImportMessage]: ... + + @property + def repeated_lazy_message( + self) -> RepeatedCompositeFieldContainer[TestAllTypes.NestedMessage]: ... + + @property + def oneof_nested_message(self) -> TestAllTypes.NestedMessage: ... + + @property + def lazy_oneof_nested_message(self) -> TestAllTypes.NestedMessage: ... + + def __init__(self, + optional_int32: Optional[int] = ..., + optional_int64: Optional[int] = ..., + optional_uint32: Optional[int] = ..., + optional_uint64: Optional[int] = ..., + optional_sint32: Optional[int] = ..., + optional_sint64: Optional[int] = ..., + optional_fixed32: Optional[int] = ..., + optional_fixed64: Optional[int] = ..., + optional_sfixed32: Optional[int] = ..., + optional_sfixed64: Optional[int] = ..., + optional_float: Optional[float] = ..., + optional_double: Optional[float] = ..., + optional_bool: Optional[bool] = ..., + optional_string: Optional[Text] = ..., + optional_bytes: Optional[str] = ..., + optionalgroup: Optional[TestAllTypes.OptionalGroup] = ..., + optional_nested_message: Optional[TestAllTypes.NestedMessage] = ..., + optional_foreign_message: Optional[ForeignMessage] = ..., + optional_import_message: Optional[ImportMessage] = ..., + optional_nested_enum: Optional[TestAllTypes.NestedEnum] = ..., + optional_foreign_enum: Optional[ForeignEnum] = ..., + optional_import_enum: Optional[ImportEnum] = ..., + optional_string_piece: Optional[Text] = ..., + optional_cord: Optional[Text] = ..., + optional_public_import_message: Optional[PublicImportMessage] = ..., + optional_message: Optional[TestAllTypes.NestedMessage] = ..., + repeated_int32: Optional[Iterable[int]] = ..., + repeated_int64: Optional[Iterable[int]] = ..., + repeated_uint32: Optional[Iterable[int]] = ..., + repeated_uint64: Optional[Iterable[int]] = ..., + repeated_sint32: Optional[Iterable[int]] = ..., + repeated_sint64: Optional[Iterable[int]] = ..., + repeated_fixed32: Optional[Iterable[int]] = ..., + repeated_fixed64: Optional[Iterable[int]] = ..., + repeated_sfixed32: Optional[Iterable[int]] = ..., + repeated_sfixed64: Optional[Iterable[int]] = ..., + repeated_float: Optional[Iterable[float]] = ..., + repeated_double: Optional[Iterable[float]] = ..., + repeated_bool: Optional[Iterable[bool]] = ..., + repeated_string: Optional[Iterable[Text]] = ..., + repeated_bytes: Optional[Iterable[str]] = ..., + repeatedgroup: Optional[Iterable[TestAllTypes.RepeatedGroup]] = ..., + repeated_nested_message: Optional[Iterable[TestAllTypes.NestedMessage]] = ..., + repeated_foreign_message: Optional[Iterable[ForeignMessage]] = ..., + repeated_import_message: Optional[Iterable[ImportMessage]] = ..., + repeated_nested_enum: Optional[Iterable[TestAllTypes.NestedEnum]] = ..., + repeated_foreign_enum: Optional[Iterable[ForeignEnum]] = ..., + repeated_import_enum: Optional[Iterable[ImportEnum]] = ..., + repeated_string_piece: Optional[Iterable[Text]] = ..., + repeated_cord: Optional[Iterable[Text]] = ..., + repeated_lazy_message: Optional[Iterable[TestAllTypes.NestedMessage]] = ..., + default_int32: Optional[int] = ..., + default_int64: Optional[int] = ..., + default_uint32: Optional[int] = ..., + default_uint64: Optional[int] = ..., + default_sint32: Optional[int] = ..., + default_sint64: Optional[int] = ..., + default_fixed32: Optional[int] = ..., + default_fixed64: Optional[int] = ..., + default_sfixed32: Optional[int] = ..., + default_sfixed64: Optional[int] = ..., + default_float: Optional[float] = ..., + default_double: Optional[float] = ..., + default_bool: Optional[bool] = ..., + default_string: Optional[Text] = ..., + default_bytes: Optional[str] = ..., + default_nested_enum: Optional[TestAllTypes.NestedEnum] = ..., + default_foreign_enum: Optional[ForeignEnum] = ..., + default_import_enum: Optional[ImportEnum] = ..., + default_string_piece: Optional[Text] = ..., + default_cord: Optional[Text] = ..., + oneof_uint32: Optional[int] = ..., + oneof_nested_message: Optional[TestAllTypes.NestedMessage] = ..., + oneof_string: Optional[Text] = ..., + oneof_bytes: Optional[str] = ..., + lazy_oneof_nested_message: Optional[TestAllTypes.NestedMessage] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypes: ... + + +class ForeignMessage(Message): + c = ... # type: int + + def __init__(self, + c: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> ForeignMessage: ... + + +class TestNoArenaMessage(Message): + + @property + def arena_message(self) -> ArenaMessage: ... + + def __init__(self, + arena_message: Optional[ArenaMessage] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestNoArenaMessage: ... diff --git a/third_party/2/google/protobuf/unittest_no_generic_services_pb2.pyi b/third_party/2/google/protobuf/unittest_no_generic_services_pb2.pyi new file mode 100644 index 000000000..0e4fe03c2 --- /dev/null +++ b/third_party/2/google/protobuf/unittest_no_generic_services_pb2.pyi @@ -0,0 +1,40 @@ +from google.protobuf.message import ( + Message, +) +from typing import ( + List, + Optional, + Tuple, + cast, +) + + +class TestEnum(int): + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> TestEnum: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[TestEnum]: ... + + @classmethod + def items(cls) -> List[Tuple[str, TestEnum]]: ... + + +FOO: TestEnum + + +class TestMessage(Message): + a = ... # type: int + + def __init__(self, + a: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMessage: ... diff --git a/third_party/2/google/protobuf/unittest_pb2.pyi b/third_party/2/google/protobuf/unittest_pb2.pyi new file mode 100644 index 000000000..1fbd014fe --- /dev/null +++ b/third_party/2/google/protobuf/unittest_pb2.pyi @@ -0,0 +1,1777 @@ +from google.protobuf.internal.containers import ( + RepeatedCompositeFieldContainer, + RepeatedScalarFieldContainer, +) +from google.protobuf.message import ( + Message, +) +from google.protobuf.unittest_import_pb2 import ( + ImportEnum, + ImportMessage, +) +from google.protobuf.unittest_import_public_pb2 import ( + PublicImportMessage, +) +from typing import ( + Iterable, + List, + Mapping, + MutableMapping, + Optional, + Text, + Tuple, + cast, +) + + +class ForeignEnum(int): + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> ForeignEnum: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[ForeignEnum]: ... + + @classmethod + def items(cls) -> List[Tuple[str, ForeignEnum]]: ... + + +FOREIGN_FOO: ForeignEnum +FOREIGN_BAR: ForeignEnum +FOREIGN_BAZ: ForeignEnum + + +class TestEnumWithDupValue(int): + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> TestEnumWithDupValue: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[TestEnumWithDupValue]: ... + + @classmethod + def items(cls) -> List[Tuple[str, TestEnumWithDupValue]]: ... + + +FOO1: TestEnumWithDupValue +BAR1: TestEnumWithDupValue +BAZ: TestEnumWithDupValue +FOO2: TestEnumWithDupValue +BAR2: TestEnumWithDupValue + + +class TestSparseEnum(int): + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> TestSparseEnum: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[TestSparseEnum]: ... + + @classmethod + def items(cls) -> List[Tuple[str, TestSparseEnum]]: ... + + +SPARSE_A: TestSparseEnum +SPARSE_B: TestSparseEnum +SPARSE_C: TestSparseEnum +SPARSE_D: TestSparseEnum +SPARSE_E: TestSparseEnum +SPARSE_F: TestSparseEnum +SPARSE_G: TestSparseEnum + + +class TestAllTypes(Message): + class NestedEnum(int): + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> TestAllTypes.NestedEnum: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[TestAllTypes.NestedEnum]: ... + + @classmethod + def items(cls) -> List[Tuple[str, TestAllTypes.NestedEnum]]: ... + FOO: NestedEnum + BAR: NestedEnum + BAZ: NestedEnum + NEG: NestedEnum + + class NestedMessage(Message): + bb = ... # type: int + + def __init__(self, + bb: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypes.NestedMessage: ... + + class OptionalGroup(Message): + a = ... # type: int + + def __init__(self, + a: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypes.OptionalGroup: ... + + class RepeatedGroup(Message): + a = ... # type: int + + def __init__(self, + a: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypes.RepeatedGroup: ... + optional_int32 = ... # type: int + optional_int64 = ... # type: int + optional_uint32 = ... # type: int + optional_uint64 = ... # type: int + optional_sint32 = ... # type: int + optional_sint64 = ... # type: int + optional_fixed32 = ... # type: int + optional_fixed64 = ... # type: int + optional_sfixed32 = ... # type: int + optional_sfixed64 = ... # type: int + optional_float = ... # type: float + optional_double = ... # type: float + optional_bool = ... # type: bool + optional_string = ... # type: Text + optional_bytes = ... # type: str + optional_nested_enum = ... # type: TestAllTypes.NestedEnum + optional_foreign_enum = ... # type: ForeignEnum + optional_import_enum = ... # type: ImportEnum + optional_string_piece = ... # type: Text + optional_cord = ... # type: Text + repeated_int32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_int64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_uint32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_uint64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_sint32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_sint64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_fixed32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_fixed64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_sfixed32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_sfixed64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_float = ... # type: RepeatedScalarFieldContainer[float] + repeated_double = ... # type: RepeatedScalarFieldContainer[float] + repeated_bool = ... # type: RepeatedScalarFieldContainer[bool] + repeated_string = ... # type: RepeatedScalarFieldContainer[Text] + repeated_bytes = ... # type: RepeatedScalarFieldContainer[str] + repeated_nested_enum = ... # type: RepeatedScalarFieldContainer[TestAllTypes.NestedEnum] + repeated_foreign_enum = ... # type: RepeatedScalarFieldContainer[ForeignEnum] + repeated_import_enum = ... # type: RepeatedScalarFieldContainer[ImportEnum] + repeated_string_piece = ... # type: RepeatedScalarFieldContainer[Text] + repeated_cord = ... # type: RepeatedScalarFieldContainer[Text] + default_int32 = ... # type: int + default_int64 = ... # type: int + default_uint32 = ... # type: int + default_uint64 = ... # type: int + default_sint32 = ... # type: int + default_sint64 = ... # type: int + default_fixed32 = ... # type: int + default_fixed64 = ... # type: int + default_sfixed32 = ... # type: int + default_sfixed64 = ... # type: int + default_float = ... # type: float + default_double = ... # type: float + default_bool = ... # type: bool + default_string = ... # type: Text + default_bytes = ... # type: str + default_nested_enum = ... # type: TestAllTypes.NestedEnum + default_foreign_enum = ... # type: ForeignEnum + default_import_enum = ... # type: ImportEnum + default_string_piece = ... # type: Text + default_cord = ... # type: Text + oneof_uint32 = ... # type: int + oneof_string = ... # type: Text + oneof_bytes = ... # type: str + + @property + def optionalgroup(self) -> TestAllTypes.OptionalGroup: ... + + @property + def optional_nested_message(self) -> TestAllTypes.NestedMessage: ... + + @property + def optional_foreign_message(self) -> ForeignMessage: ... + + @property + def optional_import_message(self) -> ImportMessage: ... + + @property + def optional_public_import_message(self) -> PublicImportMessage: ... + + @property + def optional_lazy_message(self) -> TestAllTypes.NestedMessage: ... + + @property + def repeatedgroup( + self) -> RepeatedCompositeFieldContainer[TestAllTypes.RepeatedGroup]: ... + + @property + def repeated_nested_message( + self) -> RepeatedCompositeFieldContainer[TestAllTypes.NestedMessage]: ... + + @property + def repeated_foreign_message( + self) -> RepeatedCompositeFieldContainer[ForeignMessage]: ... + + @property + def repeated_import_message( + self) -> RepeatedCompositeFieldContainer[ImportMessage]: ... + + @property + def repeated_lazy_message( + self) -> RepeatedCompositeFieldContainer[TestAllTypes.NestedMessage]: ... + + @property + def oneof_nested_message(self) -> TestAllTypes.NestedMessage: ... + + def __init__(self, + optional_int32: Optional[int] = ..., + optional_int64: Optional[int] = ..., + optional_uint32: Optional[int] = ..., + optional_uint64: Optional[int] = ..., + optional_sint32: Optional[int] = ..., + optional_sint64: Optional[int] = ..., + optional_fixed32: Optional[int] = ..., + optional_fixed64: Optional[int] = ..., + optional_sfixed32: Optional[int] = ..., + optional_sfixed64: Optional[int] = ..., + optional_float: Optional[float] = ..., + optional_double: Optional[float] = ..., + optional_bool: Optional[bool] = ..., + optional_string: Optional[Text] = ..., + optional_bytes: Optional[str] = ..., + optionalgroup: Optional[TestAllTypes.OptionalGroup] = ..., + optional_nested_message: Optional[TestAllTypes.NestedMessage] = ..., + optional_foreign_message: Optional[ForeignMessage] = ..., + optional_import_message: Optional[ImportMessage] = ..., + optional_nested_enum: Optional[TestAllTypes.NestedEnum] = ..., + optional_foreign_enum: Optional[ForeignEnum] = ..., + optional_import_enum: Optional[ImportEnum] = ..., + optional_string_piece: Optional[Text] = ..., + optional_cord: Optional[Text] = ..., + optional_public_import_message: Optional[PublicImportMessage] = ..., + optional_lazy_message: Optional[TestAllTypes.NestedMessage] = ..., + repeated_int32: Optional[Iterable[int]] = ..., + repeated_int64: Optional[Iterable[int]] = ..., + repeated_uint32: Optional[Iterable[int]] = ..., + repeated_uint64: Optional[Iterable[int]] = ..., + repeated_sint32: Optional[Iterable[int]] = ..., + repeated_sint64: Optional[Iterable[int]] = ..., + repeated_fixed32: Optional[Iterable[int]] = ..., + repeated_fixed64: Optional[Iterable[int]] = ..., + repeated_sfixed32: Optional[Iterable[int]] = ..., + repeated_sfixed64: Optional[Iterable[int]] = ..., + repeated_float: Optional[Iterable[float]] = ..., + repeated_double: Optional[Iterable[float]] = ..., + repeated_bool: Optional[Iterable[bool]] = ..., + repeated_string: Optional[Iterable[Text]] = ..., + repeated_bytes: Optional[Iterable[str]] = ..., + repeatedgroup: Optional[Iterable[TestAllTypes.RepeatedGroup]] = ..., + repeated_nested_message: Optional[Iterable[TestAllTypes.NestedMessage]] = ..., + repeated_foreign_message: Optional[Iterable[ForeignMessage]] = ..., + repeated_import_message: Optional[Iterable[ImportMessage]] = ..., + repeated_nested_enum: Optional[Iterable[TestAllTypes.NestedEnum]] = ..., + repeated_foreign_enum: Optional[Iterable[ForeignEnum]] = ..., + repeated_import_enum: Optional[Iterable[ImportEnum]] = ..., + repeated_string_piece: Optional[Iterable[Text]] = ..., + repeated_cord: Optional[Iterable[Text]] = ..., + repeated_lazy_message: Optional[Iterable[TestAllTypes.NestedMessage]] = ..., + default_int32: Optional[int] = ..., + default_int64: Optional[int] = ..., + default_uint32: Optional[int] = ..., + default_uint64: Optional[int] = ..., + default_sint32: Optional[int] = ..., + default_sint64: Optional[int] = ..., + default_fixed32: Optional[int] = ..., + default_fixed64: Optional[int] = ..., + default_sfixed32: Optional[int] = ..., + default_sfixed64: Optional[int] = ..., + default_float: Optional[float] = ..., + default_double: Optional[float] = ..., + default_bool: Optional[bool] = ..., + default_string: Optional[Text] = ..., + default_bytes: Optional[str] = ..., + default_nested_enum: Optional[TestAllTypes.NestedEnum] = ..., + default_foreign_enum: Optional[ForeignEnum] = ..., + default_import_enum: Optional[ImportEnum] = ..., + default_string_piece: Optional[Text] = ..., + default_cord: Optional[Text] = ..., + oneof_uint32: Optional[int] = ..., + oneof_nested_message: Optional[TestAllTypes.NestedMessage] = ..., + oneof_string: Optional[Text] = ..., + oneof_bytes: Optional[str] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypes: ... + + +class NestedTestAllTypes(Message): + + @property + def child(self) -> NestedTestAllTypes: ... + + @property + def payload(self) -> TestAllTypes: ... + + @property + def repeated_child( + self) -> RepeatedCompositeFieldContainer[NestedTestAllTypes]: ... + + def __init__(self, + child: Optional[NestedTestAllTypes] = ..., + payload: Optional[TestAllTypes] = ..., + repeated_child: Optional[Iterable[NestedTestAllTypes]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> NestedTestAllTypes: ... + + +class TestDeprecatedFields(Message): + deprecated_int32 = ... # type: int + deprecated_int32_in_oneof = ... # type: int + + def __init__(self, + deprecated_int32: Optional[int] = ..., + deprecated_int32_in_oneof: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestDeprecatedFields: ... + + +class TestDeprecatedMessage(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestDeprecatedMessage: ... + + +class ForeignMessage(Message): + c = ... # type: int + d = ... # type: int + + def __init__(self, + c: Optional[int] = ..., + d: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> ForeignMessage: ... + + +class TestReservedFields(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestReservedFields: ... + + +class TestAllExtensions(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllExtensions: ... + + +class OptionalGroup_extension(Message): + a = ... # type: int + + def __init__(self, + a: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> OptionalGroup_extension: ... + + +class RepeatedGroup_extension(Message): + a = ... # type: int + + def __init__(self, + a: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> RepeatedGroup_extension: ... + + +class TestGroup(Message): + class OptionalGroup(Message): + a = ... # type: int + + def __init__(self, + a: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestGroup.OptionalGroup: ... + optional_foreign_enum = ... # type: ForeignEnum + + @property + def optionalgroup(self) -> TestGroup.OptionalGroup: ... + + def __init__(self, + optionalgroup: Optional[TestGroup.OptionalGroup] = ..., + optional_foreign_enum: Optional[ForeignEnum] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestGroup: ... + + +class TestGroupExtension(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestGroupExtension: ... + + +class TestNestedExtension(Message): + class OptionalGroup_extension(Message): + a = ... # type: int + + def __init__(self, + a: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestNestedExtension.OptionalGroup_extension: ... + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestNestedExtension: ... + + +class TestRequired(Message): + a = ... # type: int + dummy2 = ... # type: int + b = ... # type: int + dummy4 = ... # type: int + dummy5 = ... # type: int + dummy6 = ... # type: int + dummy7 = ... # type: int + dummy8 = ... # type: int + dummy9 = ... # type: int + dummy10 = ... # type: int + dummy11 = ... # type: int + dummy12 = ... # type: int + dummy13 = ... # type: int + dummy14 = ... # type: int + dummy15 = ... # type: int + dummy16 = ... # type: int + dummy17 = ... # type: int + dummy18 = ... # type: int + dummy19 = ... # type: int + dummy20 = ... # type: int + dummy21 = ... # type: int + dummy22 = ... # type: int + dummy23 = ... # type: int + dummy24 = ... # type: int + dummy25 = ... # type: int + dummy26 = ... # type: int + dummy27 = ... # type: int + dummy28 = ... # type: int + dummy29 = ... # type: int + dummy30 = ... # type: int + dummy31 = ... # type: int + dummy32 = ... # type: int + c = ... # type: int + + def __init__(self, + a: int, + b: int, + c: int, + dummy2: Optional[int] = ..., + dummy4: Optional[int] = ..., + dummy5: Optional[int] = ..., + dummy6: Optional[int] = ..., + dummy7: Optional[int] = ..., + dummy8: Optional[int] = ..., + dummy9: Optional[int] = ..., + dummy10: Optional[int] = ..., + dummy11: Optional[int] = ..., + dummy12: Optional[int] = ..., + dummy13: Optional[int] = ..., + dummy14: Optional[int] = ..., + dummy15: Optional[int] = ..., + dummy16: Optional[int] = ..., + dummy17: Optional[int] = ..., + dummy18: Optional[int] = ..., + dummy19: Optional[int] = ..., + dummy20: Optional[int] = ..., + dummy21: Optional[int] = ..., + dummy22: Optional[int] = ..., + dummy23: Optional[int] = ..., + dummy24: Optional[int] = ..., + dummy25: Optional[int] = ..., + dummy26: Optional[int] = ..., + dummy27: Optional[int] = ..., + dummy28: Optional[int] = ..., + dummy29: Optional[int] = ..., + dummy30: Optional[int] = ..., + dummy31: Optional[int] = ..., + dummy32: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestRequired: ... + + +class TestRequiredForeign(Message): + dummy = ... # type: int + + @property + def optional_message(self) -> TestRequired: ... + + @property + def repeated_message( + self) -> RepeatedCompositeFieldContainer[TestRequired]: ... + + def __init__(self, + optional_message: Optional[TestRequired] = ..., + repeated_message: Optional[Iterable[TestRequired]] = ..., + dummy: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestRequiredForeign: ... + + +class TestRequiredMessage(Message): + + @property + def optional_message(self) -> TestRequired: ... + + @property + def repeated_message( + self) -> RepeatedCompositeFieldContainer[TestRequired]: ... + + @property + def required_message(self) -> TestRequired: ... + + def __init__(self, + required_message: TestRequired, + optional_message: Optional[TestRequired] = ..., + repeated_message: Optional[Iterable[TestRequired]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestRequiredMessage: ... + + +class TestForeignNested(Message): + + @property + def foreign_nested(self) -> TestAllTypes.NestedMessage: ... + + def __init__(self, + foreign_nested: Optional[TestAllTypes.NestedMessage] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestForeignNested: ... + + +class TestEmptyMessage(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestEmptyMessage: ... + + +class TestEmptyMessageWithExtensions(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestEmptyMessageWithExtensions: ... + + +class TestMultipleExtensionRanges(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMultipleExtensionRanges: ... + + +class TestReallyLargeTagNumber(Message): + a = ... # type: int + bb = ... # type: int + + def __init__(self, + a: Optional[int] = ..., + bb: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestReallyLargeTagNumber: ... + + +class TestRecursiveMessage(Message): + i = ... # type: int + + @property + def a(self) -> TestRecursiveMessage: ... + + def __init__(self, + a: Optional[TestRecursiveMessage] = ..., + i: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestRecursiveMessage: ... + + +class TestMutualRecursionA(Message): + class SubMessage(Message): + + @property + def b(self) -> TestMutualRecursionB: ... + + def __init__(self, + b: Optional[TestMutualRecursionB] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMutualRecursionA.SubMessage: ... + + class SubGroup(Message): + + @property + def sub_message(self) -> TestMutualRecursionA.SubMessage: ... + + @property + def not_in_this_scc(self) -> TestAllTypes: ... + + def __init__(self, + sub_message: Optional[TestMutualRecursionA.SubMessage] = ..., + not_in_this_scc: Optional[TestAllTypes] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMutualRecursionA.SubGroup: ... + + @property + def bb(self) -> TestMutualRecursionB: ... + + @property + def subgroup(self) -> TestMutualRecursionA.SubGroup: ... + + def __init__(self, + bb: Optional[TestMutualRecursionB] = ..., + subgroup: Optional[TestMutualRecursionA.SubGroup] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMutualRecursionA: ... + + +class TestMutualRecursionB(Message): + optional_int32 = ... # type: int + + @property + def a(self) -> TestMutualRecursionA: ... + + def __init__(self, + a: Optional[TestMutualRecursionA] = ..., + optional_int32: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMutualRecursionB: ... + + +class TestIsInitialized(Message): + class SubMessage(Message): + class SubGroup(Message): + i = ... # type: int + + def __init__(self, + i: int, + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestIsInitialized.SubMessage.SubGroup: ... + + @property + def subgroup(self) -> TestIsInitialized.SubMessage.SubGroup: ... + + def __init__(self, + subgroup: Optional[TestIsInitialized.SubMessage.SubGroup] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestIsInitialized.SubMessage: ... + + @property + def sub_message(self) -> TestIsInitialized.SubMessage: ... + + def __init__(self, + sub_message: Optional[TestIsInitialized.SubMessage] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestIsInitialized: ... + + +class TestDupFieldNumber(Message): + class Foo(Message): + a = ... # type: int + + def __init__(self, + a: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestDupFieldNumber.Foo: ... + + class Bar(Message): + a = ... # type: int + + def __init__(self, + a: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestDupFieldNumber.Bar: ... + a = ... # type: int + + @property + def foo(self) -> TestDupFieldNumber.Foo: ... + + @property + def bar(self) -> TestDupFieldNumber.Bar: ... + + def __init__(self, + a: Optional[int] = ..., + foo: Optional[TestDupFieldNumber.Foo] = ..., + bar: Optional[TestDupFieldNumber.Bar] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestDupFieldNumber: ... + + +class TestEagerMessage(Message): + + @property + def sub_message(self) -> TestAllTypes: ... + + def __init__(self, + sub_message: Optional[TestAllTypes] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestEagerMessage: ... + + +class TestLazyMessage(Message): + + @property + def sub_message(self) -> TestAllTypes: ... + + def __init__(self, + sub_message: Optional[TestAllTypes] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestLazyMessage: ... + + +class TestNestedMessageHasBits(Message): + class NestedMessage(Message): + nestedmessage_repeated_int32 = ... # type: RepeatedScalarFieldContainer[int] + + @property + def nestedmessage_repeated_foreignmessage( + self) -> RepeatedCompositeFieldContainer[ForeignMessage]: ... + + def __init__(self, + nestedmessage_repeated_int32: Optional[Iterable[int]] = ..., + nestedmessage_repeated_foreignmessage: Optional[Iterable[ForeignMessage]] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestNestedMessageHasBits.NestedMessage: ... + + @property + def optional_nested_message( + self) -> TestNestedMessageHasBits.NestedMessage: ... + + def __init__(self, + optional_nested_message: Optional[TestNestedMessageHasBits.NestedMessage] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestNestedMessageHasBits: ... + + +class TestCamelCaseFieldNames(Message): + PrimitiveField = ... # type: int + StringField = ... # type: Text + EnumField = ... # type: ForeignEnum + StringPieceField = ... # type: Text + CordField = ... # type: Text + RepeatedPrimitiveField = ... # type: RepeatedScalarFieldContainer[int] + RepeatedStringField = ... # type: RepeatedScalarFieldContainer[Text] + RepeatedEnumField = ... # type: RepeatedScalarFieldContainer[ForeignEnum] + RepeatedStringPieceField = ... # type: RepeatedScalarFieldContainer[Text] + RepeatedCordField = ... # type: RepeatedScalarFieldContainer[Text] + + @property + def MessageField(self) -> ForeignMessage: ... + + @property + def RepeatedMessageField( + self) -> RepeatedCompositeFieldContainer[ForeignMessage]: ... + + def __init__(self, + PrimitiveField: Optional[int] = ..., + StringField: Optional[Text] = ..., + EnumField: Optional[ForeignEnum] = ..., + MessageField: Optional[ForeignMessage] = ..., + StringPieceField: Optional[Text] = ..., + CordField: Optional[Text] = ..., + RepeatedPrimitiveField: Optional[Iterable[int]] = ..., + RepeatedStringField: Optional[Iterable[Text]] = ..., + RepeatedEnumField: Optional[Iterable[ForeignEnum]] = ..., + RepeatedMessageField: Optional[Iterable[ForeignMessage]] = ..., + RepeatedStringPieceField: Optional[Iterable[Text]] = ..., + RepeatedCordField: Optional[Iterable[Text]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestCamelCaseFieldNames: ... + + +class TestFieldOrderings(Message): + class NestedMessage(Message): + oo = ... # type: int + bb = ... # type: int + + def __init__(self, + oo: Optional[int] = ..., + bb: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestFieldOrderings.NestedMessage: ... + my_string = ... # type: Text + my_int = ... # type: int + my_float = ... # type: float + + @property + def optional_nested_message(self) -> TestFieldOrderings.NestedMessage: ... + + def __init__(self, + my_string: Optional[Text] = ..., + my_int: Optional[int] = ..., + my_float: Optional[float] = ..., + optional_nested_message: Optional[TestFieldOrderings.NestedMessage] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestFieldOrderings: ... + + +class TestExtensionOrderings1(Message): + my_string = ... # type: Text + + def __init__(self, + my_string: Optional[Text] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestExtensionOrderings1: ... + + +class TestExtensionOrderings2(Message): + class TestExtensionOrderings3(Message): + my_string = ... # type: Text + + def __init__(self, + my_string: Optional[Text] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestExtensionOrderings2.TestExtensionOrderings3: ... + my_string = ... # type: Text + + def __init__(self, + my_string: Optional[Text] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestExtensionOrderings2: ... + + +class TestExtremeDefaultValues(Message): + escaped_bytes = ... # type: str + large_uint32 = ... # type: int + large_uint64 = ... # type: int + small_int32 = ... # type: int + small_int64 = ... # type: int + really_small_int32 = ... # type: int + really_small_int64 = ... # type: int + utf8_string = ... # type: Text + zero_float = ... # type: float + one_float = ... # type: float + small_float = ... # type: float + negative_one_float = ... # type: float + negative_float = ... # type: float + large_float = ... # type: float + small_negative_float = ... # type: float + inf_double = ... # type: float + neg_inf_double = ... # type: float + nan_double = ... # type: float + inf_float = ... # type: float + neg_inf_float = ... # type: float + nan_float = ... # type: float + cpp_trigraph = ... # type: Text + string_with_zero = ... # type: Text + bytes_with_zero = ... # type: str + string_piece_with_zero = ... # type: Text + cord_with_zero = ... # type: Text + replacement_string = ... # type: Text + + def __init__(self, + escaped_bytes: Optional[str] = ..., + large_uint32: Optional[int] = ..., + large_uint64: Optional[int] = ..., + small_int32: Optional[int] = ..., + small_int64: Optional[int] = ..., + really_small_int32: Optional[int] = ..., + really_small_int64: Optional[int] = ..., + utf8_string: Optional[Text] = ..., + zero_float: Optional[float] = ..., + one_float: Optional[float] = ..., + small_float: Optional[float] = ..., + negative_one_float: Optional[float] = ..., + negative_float: Optional[float] = ..., + large_float: Optional[float] = ..., + small_negative_float: Optional[float] = ..., + inf_double: Optional[float] = ..., + neg_inf_double: Optional[float] = ..., + nan_double: Optional[float] = ..., + inf_float: Optional[float] = ..., + neg_inf_float: Optional[float] = ..., + nan_float: Optional[float] = ..., + cpp_trigraph: Optional[Text] = ..., + string_with_zero: Optional[Text] = ..., + bytes_with_zero: Optional[str] = ..., + string_piece_with_zero: Optional[Text] = ..., + cord_with_zero: Optional[Text] = ..., + replacement_string: Optional[Text] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestExtremeDefaultValues: ... + + +class SparseEnumMessage(Message): + sparse_enum = ... # type: TestSparseEnum + + def __init__(self, + sparse_enum: Optional[TestSparseEnum] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> SparseEnumMessage: ... + + +class OneString(Message): + data = ... # type: Text + + def __init__(self, + data: Optional[Text] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> OneString: ... + + +class MoreString(Message): + data = ... # type: RepeatedScalarFieldContainer[Text] + + def __init__(self, + data: Optional[Iterable[Text]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> MoreString: ... + + +class OneBytes(Message): + data = ... # type: str + + def __init__(self, + data: Optional[str] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> OneBytes: ... + + +class MoreBytes(Message): + data = ... # type: RepeatedScalarFieldContainer[str] + + def __init__(self, + data: Optional[Iterable[str]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> MoreBytes: ... + + +class Int32Message(Message): + data = ... # type: int + + def __init__(self, + data: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> Int32Message: ... + + +class Uint32Message(Message): + data = ... # type: int + + def __init__(self, + data: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> Uint32Message: ... + + +class Int64Message(Message): + data = ... # type: int + + def __init__(self, + data: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> Int64Message: ... + + +class Uint64Message(Message): + data = ... # type: int + + def __init__(self, + data: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> Uint64Message: ... + + +class BoolMessage(Message): + data = ... # type: bool + + def __init__(self, + data: Optional[bool] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> BoolMessage: ... + + +class TestOneof(Message): + class FooGroup(Message): + a = ... # type: int + b = ... # type: Text + + def __init__(self, + a: Optional[int] = ..., + b: Optional[Text] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestOneof.FooGroup: ... + foo_int = ... # type: int + foo_string = ... # type: Text + + @property + def foo_message(self) -> TestAllTypes: ... + + @property + def foogroup(self) -> TestOneof.FooGroup: ... + + def __init__(self, + foo_int: Optional[int] = ..., + foo_string: Optional[Text] = ..., + foo_message: Optional[TestAllTypes] = ..., + foogroup: Optional[TestOneof.FooGroup] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestOneof: ... + + +class TestOneofBackwardsCompatible(Message): + class FooGroup(Message): + a = ... # type: int + b = ... # type: Text + + def __init__(self, + a: Optional[int] = ..., + b: Optional[Text] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestOneofBackwardsCompatible.FooGroup: ... + foo_int = ... # type: int + foo_string = ... # type: Text + + @property + def foo_message(self) -> TestAllTypes: ... + + @property + def foogroup(self) -> TestOneofBackwardsCompatible.FooGroup: ... + + def __init__(self, + foo_int: Optional[int] = ..., + foo_string: Optional[Text] = ..., + foo_message: Optional[TestAllTypes] = ..., + foogroup: Optional[TestOneofBackwardsCompatible.FooGroup] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestOneofBackwardsCompatible: ... + + +class TestOneof2(Message): + class NestedEnum(int): + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> TestOneof2.NestedEnum: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[TestOneof2.NestedEnum]: ... + + @classmethod + def items(cls) -> List[Tuple[str, TestOneof2.NestedEnum]]: ... + FOO: NestedEnum + BAR: NestedEnum + BAZ: NestedEnum + + class FooGroup(Message): + a = ... # type: int + b = ... # type: Text + + def __init__(self, + a: Optional[int] = ..., + b: Optional[Text] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestOneof2.FooGroup: ... + + class NestedMessage(Message): + qux_int = ... # type: int + corge_int = ... # type: RepeatedScalarFieldContainer[int] + + def __init__(self, + qux_int: Optional[int] = ..., + corge_int: Optional[Iterable[int]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestOneof2.NestedMessage: ... + foo_int = ... # type: int + foo_string = ... # type: Text + foo_cord = ... # type: Text + foo_string_piece = ... # type: Text + foo_bytes = ... # type: str + foo_enum = ... # type: TestOneof2.NestedEnum + bar_int = ... # type: int + bar_string = ... # type: Text + bar_cord = ... # type: Text + bar_string_piece = ... # type: Text + bar_bytes = ... # type: str + bar_enum = ... # type: TestOneof2.NestedEnum + baz_int = ... # type: int + baz_string = ... # type: Text + + @property + def foo_message(self) -> TestOneof2.NestedMessage: ... + + @property + def foogroup(self) -> TestOneof2.FooGroup: ... + + @property + def foo_lazy_message(self) -> TestOneof2.NestedMessage: ... + + def __init__(self, + foo_int: Optional[int] = ..., + foo_string: Optional[Text] = ..., + foo_cord: Optional[Text] = ..., + foo_string_piece: Optional[Text] = ..., + foo_bytes: Optional[str] = ..., + foo_enum: Optional[TestOneof2.NestedEnum] = ..., + foo_message: Optional[TestOneof2.NestedMessage] = ..., + foogroup: Optional[TestOneof2.FooGroup] = ..., + foo_lazy_message: Optional[TestOneof2.NestedMessage] = ..., + bar_int: Optional[int] = ..., + bar_string: Optional[Text] = ..., + bar_cord: Optional[Text] = ..., + bar_string_piece: Optional[Text] = ..., + bar_bytes: Optional[str] = ..., + bar_enum: Optional[TestOneof2.NestedEnum] = ..., + baz_int: Optional[int] = ..., + baz_string: Optional[Text] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestOneof2: ... + + +class TestRequiredOneof(Message): + class NestedMessage(Message): + required_double = ... # type: float + + def __init__(self, + required_double: float, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestRequiredOneof.NestedMessage: ... + foo_int = ... # type: int + foo_string = ... # type: Text + + @property + def foo_message(self) -> TestRequiredOneof.NestedMessage: ... + + def __init__(self, + foo_int: Optional[int] = ..., + foo_string: Optional[Text] = ..., + foo_message: Optional[TestRequiredOneof.NestedMessage] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestRequiredOneof: ... + + +class TestPackedTypes(Message): + packed_int32 = ... # type: RepeatedScalarFieldContainer[int] + packed_int64 = ... # type: RepeatedScalarFieldContainer[int] + packed_uint32 = ... # type: RepeatedScalarFieldContainer[int] + packed_uint64 = ... # type: RepeatedScalarFieldContainer[int] + packed_sint32 = ... # type: RepeatedScalarFieldContainer[int] + packed_sint64 = ... # type: RepeatedScalarFieldContainer[int] + packed_fixed32 = ... # type: RepeatedScalarFieldContainer[int] + packed_fixed64 = ... # type: RepeatedScalarFieldContainer[int] + packed_sfixed32 = ... # type: RepeatedScalarFieldContainer[int] + packed_sfixed64 = ... # type: RepeatedScalarFieldContainer[int] + packed_float = ... # type: RepeatedScalarFieldContainer[float] + packed_double = ... # type: RepeatedScalarFieldContainer[float] + packed_bool = ... # type: RepeatedScalarFieldContainer[bool] + packed_enum = ... # type: RepeatedScalarFieldContainer[ForeignEnum] + + def __init__(self, + packed_int32: Optional[Iterable[int]] = ..., + packed_int64: Optional[Iterable[int]] = ..., + packed_uint32: Optional[Iterable[int]] = ..., + packed_uint64: Optional[Iterable[int]] = ..., + packed_sint32: Optional[Iterable[int]] = ..., + packed_sint64: Optional[Iterable[int]] = ..., + packed_fixed32: Optional[Iterable[int]] = ..., + packed_fixed64: Optional[Iterable[int]] = ..., + packed_sfixed32: Optional[Iterable[int]] = ..., + packed_sfixed64: Optional[Iterable[int]] = ..., + packed_float: Optional[Iterable[float]] = ..., + packed_double: Optional[Iterable[float]] = ..., + packed_bool: Optional[Iterable[bool]] = ..., + packed_enum: Optional[Iterable[ForeignEnum]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestPackedTypes: ... + + +class TestUnpackedTypes(Message): + unpacked_int32 = ... # type: RepeatedScalarFieldContainer[int] + unpacked_int64 = ... # type: RepeatedScalarFieldContainer[int] + unpacked_uint32 = ... # type: RepeatedScalarFieldContainer[int] + unpacked_uint64 = ... # type: RepeatedScalarFieldContainer[int] + unpacked_sint32 = ... # type: RepeatedScalarFieldContainer[int] + unpacked_sint64 = ... # type: RepeatedScalarFieldContainer[int] + unpacked_fixed32 = ... # type: RepeatedScalarFieldContainer[int] + unpacked_fixed64 = ... # type: RepeatedScalarFieldContainer[int] + unpacked_sfixed32 = ... # type: RepeatedScalarFieldContainer[int] + unpacked_sfixed64 = ... # type: RepeatedScalarFieldContainer[int] + unpacked_float = ... # type: RepeatedScalarFieldContainer[float] + unpacked_double = ... # type: RepeatedScalarFieldContainer[float] + unpacked_bool = ... # type: RepeatedScalarFieldContainer[bool] + unpacked_enum = ... # type: RepeatedScalarFieldContainer[ForeignEnum] + + def __init__(self, + unpacked_int32: Optional[Iterable[int]] = ..., + unpacked_int64: Optional[Iterable[int]] = ..., + unpacked_uint32: Optional[Iterable[int]] = ..., + unpacked_uint64: Optional[Iterable[int]] = ..., + unpacked_sint32: Optional[Iterable[int]] = ..., + unpacked_sint64: Optional[Iterable[int]] = ..., + unpacked_fixed32: Optional[Iterable[int]] = ..., + unpacked_fixed64: Optional[Iterable[int]] = ..., + unpacked_sfixed32: Optional[Iterable[int]] = ..., + unpacked_sfixed64: Optional[Iterable[int]] = ..., + unpacked_float: Optional[Iterable[float]] = ..., + unpacked_double: Optional[Iterable[float]] = ..., + unpacked_bool: Optional[Iterable[bool]] = ..., + unpacked_enum: Optional[Iterable[ForeignEnum]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestUnpackedTypes: ... + + +class TestPackedExtensions(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestPackedExtensions: ... + + +class TestUnpackedExtensions(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestUnpackedExtensions: ... + + +class TestDynamicExtensions(Message): + class DynamicEnumType(int): + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> TestDynamicExtensions.DynamicEnumType: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[TestDynamicExtensions.DynamicEnumType]: ... + + @classmethod + def items(cls) -> List[Tuple[str, + TestDynamicExtensions.DynamicEnumType]]: ... + DYNAMIC_FOO: DynamicEnumType + DYNAMIC_BAR: DynamicEnumType + DYNAMIC_BAZ: DynamicEnumType + + class DynamicMessageType(Message): + dynamic_field = ... # type: int + + def __init__(self, + dynamic_field: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestDynamicExtensions.DynamicMessageType: ... + scalar_extension = ... # type: int + enum_extension = ... # type: ForeignEnum + dynamic_enum_extension = ... # type: TestDynamicExtensions.DynamicEnumType + repeated_extension = ... # type: RepeatedScalarFieldContainer[Text] + packed_extension = ... # type: RepeatedScalarFieldContainer[int] + + @property + def message_extension(self) -> ForeignMessage: ... + + @property + def dynamic_message_extension( + self) -> TestDynamicExtensions.DynamicMessageType: ... + + def __init__(self, + scalar_extension: Optional[int] = ..., + enum_extension: Optional[ForeignEnum] = ..., + dynamic_enum_extension: Optional[TestDynamicExtensions.DynamicEnumType] = ..., + message_extension: Optional[ForeignMessage] = ..., + dynamic_message_extension: Optional[TestDynamicExtensions.DynamicMessageType] = ..., + repeated_extension: Optional[Iterable[Text]] = ..., + packed_extension: Optional[Iterable[int]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestDynamicExtensions: ... + + +class TestRepeatedScalarDifferentTagSizes(Message): + repeated_fixed32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_int32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_fixed64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_int64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_float = ... # type: RepeatedScalarFieldContainer[float] + repeated_uint64 = ... # type: RepeatedScalarFieldContainer[int] + + def __init__(self, + repeated_fixed32: Optional[Iterable[int]] = ..., + repeated_int32: Optional[Iterable[int]] = ..., + repeated_fixed64: Optional[Iterable[int]] = ..., + repeated_int64: Optional[Iterable[int]] = ..., + repeated_float: Optional[Iterable[float]] = ..., + repeated_uint64: Optional[Iterable[int]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestRepeatedScalarDifferentTagSizes: ... + + +class TestParsingMerge(Message): + class RepeatedFieldsGenerator(Message): + class Group1(Message): + + @property + def field1(self) -> TestAllTypes: ... + + def __init__(self, + field1: Optional[TestAllTypes] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestParsingMerge.RepeatedFieldsGenerator.Group1: ... + + class Group2(Message): + + @property + def field1(self) -> TestAllTypes: ... + + def __init__(self, + field1: Optional[TestAllTypes] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestParsingMerge.RepeatedFieldsGenerator.Group2: ... + + @property + def field1(self) -> RepeatedCompositeFieldContainer[TestAllTypes]: ... + + @property + def field2(self) -> RepeatedCompositeFieldContainer[TestAllTypes]: ... + + @property + def field3(self) -> RepeatedCompositeFieldContainer[TestAllTypes]: ... + + @property + def group1( + self) -> RepeatedCompositeFieldContainer[TestParsingMerge.RepeatedFieldsGenerator.Group1]: ... + + @property + def group2( + self) -> RepeatedCompositeFieldContainer[TestParsingMerge.RepeatedFieldsGenerator.Group2]: ... + + @property + def ext1(self) -> RepeatedCompositeFieldContainer[TestAllTypes]: ... + + @property + def ext2(self) -> RepeatedCompositeFieldContainer[TestAllTypes]: ... + + def __init__(self, + field1: Optional[Iterable[TestAllTypes]] = ..., + field2: Optional[Iterable[TestAllTypes]] = ..., + field3: Optional[Iterable[TestAllTypes]] = ..., + group1: Optional[Iterable[TestParsingMerge.RepeatedFieldsGenerator.Group1]] = ..., + group2: Optional[Iterable[TestParsingMerge.RepeatedFieldsGenerator.Group2]] = ..., + ext1: Optional[Iterable[TestAllTypes]] = ..., + ext2: Optional[Iterable[TestAllTypes]] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestParsingMerge.RepeatedFieldsGenerator: ... + + class OptionalGroup(Message): + + @property + def optional_group_all_types(self) -> TestAllTypes: ... + + def __init__(self, + optional_group_all_types: Optional[TestAllTypes] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestParsingMerge.OptionalGroup: ... + + class RepeatedGroup(Message): + + @property + def repeated_group_all_types(self) -> TestAllTypes: ... + + def __init__(self, + repeated_group_all_types: Optional[TestAllTypes] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestParsingMerge.RepeatedGroup: ... + + @property + def required_all_types(self) -> TestAllTypes: ... + + @property + def optional_all_types(self) -> TestAllTypes: ... + + @property + def repeated_all_types( + self) -> RepeatedCompositeFieldContainer[TestAllTypes]: ... + + @property + def optionalgroup(self) -> TestParsingMerge.OptionalGroup: ... + + @property + def repeatedgroup( + self) -> RepeatedCompositeFieldContainer[TestParsingMerge.RepeatedGroup]: ... + + def __init__(self, + required_all_types: TestAllTypes, + optional_all_types: Optional[TestAllTypes] = ..., + repeated_all_types: Optional[Iterable[TestAllTypes]] = ..., + optionalgroup: Optional[TestParsingMerge.OptionalGroup] = ..., + repeatedgroup: Optional[Iterable[TestParsingMerge.RepeatedGroup]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestParsingMerge: ... + + +class TestCommentInjectionMessage(Message): + a = ... # type: Text + + def __init__(self, + a: Optional[Text] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestCommentInjectionMessage: ... + + +class FooRequest(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> FooRequest: ... + + +class FooResponse(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> FooResponse: ... + + +class FooClientMessage(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> FooClientMessage: ... + + +class FooServerMessage(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> FooServerMessage: ... + + +class BarRequest(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> BarRequest: ... + + +class BarResponse(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> BarResponse: ... + + +class TestJsonName(Message): + field_name1 = ... # type: int + fieldName2 = ... # type: int + FieldName3 = ... # type: int + _field_name4 = ... # type: int + FIELD_NAME5 = ... # type: int + field_name6 = ... # type: int + + def __init__(self, + field_name1: Optional[int] = ..., + fieldName2: Optional[int] = ..., + FieldName3: Optional[int] = ..., + _field_name4: Optional[int] = ..., + FIELD_NAME5: Optional[int] = ..., + field_name6: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestJsonName: ... + + +class TestHugeFieldNumbers(Message): + class OptionalGroup(Message): + group_a = ... # type: int + + def __init__(self, + group_a: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestHugeFieldNumbers.OptionalGroup: ... + + class StringStringMapEntry(Message): + key = ... # type: Text + value = ... # type: Text + + def __init__(self, + key: Optional[Text] = ..., + value: Optional[Text] = ..., + ) -> None: ... + + @classmethod + def FromString( + cls, s: str) -> TestHugeFieldNumbers.StringStringMapEntry: ... + optional_int32 = ... # type: int + fixed_32 = ... # type: int + repeated_int32 = ... # type: RepeatedScalarFieldContainer[int] + packed_int32 = ... # type: RepeatedScalarFieldContainer[int] + optional_enum = ... # type: ForeignEnum + optional_string = ... # type: Text + optional_bytes = ... # type: str + oneof_uint32 = ... # type: int + oneof_string = ... # type: Text + oneof_bytes = ... # type: str + + @property + def optional_message(self) -> ForeignMessage: ... + + @property + def optionalgroup(self) -> TestHugeFieldNumbers.OptionalGroup: ... + + @property + def string_string_map(self) -> MutableMapping[Text, Text]: ... + + @property + def oneof_test_all_types(self) -> TestAllTypes: ... + + def __init__(self, + optional_int32: Optional[int] = ..., + fixed_32: Optional[int] = ..., + repeated_int32: Optional[Iterable[int]] = ..., + packed_int32: Optional[Iterable[int]] = ..., + optional_enum: Optional[ForeignEnum] = ..., + optional_string: Optional[Text] = ..., + optional_bytes: Optional[str] = ..., + optional_message: Optional[ForeignMessage] = ..., + optionalgroup: Optional[TestHugeFieldNumbers.OptionalGroup] = ..., + string_string_map: Optional[Mapping[Text, Text]] = ..., + oneof_uint32: Optional[int] = ..., + oneof_test_all_types: Optional[TestAllTypes] = ..., + oneof_string: Optional[Text] = ..., + oneof_bytes: Optional[str] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestHugeFieldNumbers: ... + + +class TestExtensionInsideTable(Message): + field1 = ... # type: int + field2 = ... # type: int + field3 = ... # type: int + field4 = ... # type: int + field6 = ... # type: int + field7 = ... # type: int + field8 = ... # type: int + field9 = ... # type: int + field10 = ... # type: int + + def __init__(self, + field1: Optional[int] = ..., + field2: Optional[int] = ..., + field3: Optional[int] = ..., + field4: Optional[int] = ..., + field6: Optional[int] = ..., + field7: Optional[int] = ..., + field8: Optional[int] = ..., + field9: Optional[int] = ..., + field10: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestExtensionInsideTable: ... diff --git a/third_party/2/google/protobuf/unittest_proto3_arena_pb2.pyi b/third_party/2/google/protobuf/unittest_proto3_arena_pb2.pyi new file mode 100644 index 000000000..6b9eac934 --- /dev/null +++ b/third_party/2/google/protobuf/unittest_proto3_arena_pb2.pyi @@ -0,0 +1,332 @@ +from google.protobuf.internal.containers import ( + RepeatedCompositeFieldContainer, + RepeatedScalarFieldContainer, +) +from google.protobuf.message import ( + Message, +) +from google.protobuf.unittest_import_pb2 import ( + ImportMessage, +) +from google.protobuf.unittest_import_public_pb2 import ( + PublicImportMessage, +) +from typing import ( + Iterable, + List, + Optional, + Text, + Tuple, + cast, +) + + +class ForeignEnum(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> ForeignEnum: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[ForeignEnum]: ... + + @classmethod + def items(cls) -> List[Tuple[str, ForeignEnum]]: ... + + +FOREIGN_ZERO: ForeignEnum +FOREIGN_FOO: ForeignEnum +FOREIGN_BAR: ForeignEnum +FOREIGN_BAZ: ForeignEnum + + +class TestAllTypes(Message): + + class NestedEnum(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> TestAllTypes.NestedEnum: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[TestAllTypes.NestedEnum]: ... + + @classmethod + def items(cls) -> List[Tuple[str, TestAllTypes.NestedEnum]]: ... + ZERO: NestedEnum + FOO: NestedEnum + BAR: NestedEnum + BAZ: NestedEnum + NEG: NestedEnum + + class NestedMessage(Message): + bb = ... # type: int + + def __init__(self, + bb: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypes.NestedMessage: ... + optional_int32 = ... # type: int + optional_int64 = ... # type: int + optional_uint32 = ... # type: int + optional_uint64 = ... # type: int + optional_sint32 = ... # type: int + optional_sint64 = ... # type: int + optional_fixed32 = ... # type: int + optional_fixed64 = ... # type: int + optional_sfixed32 = ... # type: int + optional_sfixed64 = ... # type: int + optional_float = ... # type: float + optional_double = ... # type: float + optional_bool = ... # type: bool + optional_string = ... # type: Text + optional_bytes = ... # type: str + optional_nested_enum = ... # type: TestAllTypes.NestedEnum + optional_foreign_enum = ... # type: ForeignEnum + optional_string_piece = ... # type: Text + optional_cord = ... # type: Text + repeated_int32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_int64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_uint32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_uint64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_sint32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_sint64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_fixed32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_fixed64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_sfixed32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_sfixed64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_float = ... # type: RepeatedScalarFieldContainer[float] + repeated_double = ... # type: RepeatedScalarFieldContainer[float] + repeated_bool = ... # type: RepeatedScalarFieldContainer[bool] + repeated_string = ... # type: RepeatedScalarFieldContainer[Text] + repeated_bytes = ... # type: RepeatedScalarFieldContainer[str] + repeated_nested_enum = ... # type: RepeatedScalarFieldContainer[TestAllTypes.NestedEnum] + repeated_foreign_enum = ... # type: RepeatedScalarFieldContainer[ForeignEnum] + repeated_string_piece = ... # type: RepeatedScalarFieldContainer[Text] + repeated_cord = ... # type: RepeatedScalarFieldContainer[Text] + oneof_uint32 = ... # type: int + oneof_string = ... # type: Text + oneof_bytes = ... # type: str + + @property + def optional_nested_message(self) -> TestAllTypes.NestedMessage: ... + + @property + def optional_foreign_message(self) -> ForeignMessage: ... + + @property + def optional_import_message(self) -> ImportMessage: ... + + @property + def optional_public_import_message(self) -> PublicImportMessage: ... + + @property + def optional_lazy_message(self) -> TestAllTypes.NestedMessage: ... + + @property + def optional_lazy_import_message(self) -> ImportMessage: ... + + @property + def repeated_nested_message( + self) -> RepeatedCompositeFieldContainer[TestAllTypes.NestedMessage]: ... + + @property + def repeated_foreign_message( + self) -> RepeatedCompositeFieldContainer[ForeignMessage]: ... + + @property + def repeated_import_message( + self) -> RepeatedCompositeFieldContainer[ImportMessage]: ... + + @property + def repeated_lazy_message( + self) -> RepeatedCompositeFieldContainer[TestAllTypes.NestedMessage]: ... + + @property + def oneof_nested_message(self) -> TestAllTypes.NestedMessage: ... + + def __init__(self, + optional_int32: Optional[int] = ..., + optional_int64: Optional[int] = ..., + optional_uint32: Optional[int] = ..., + optional_uint64: Optional[int] = ..., + optional_sint32: Optional[int] = ..., + optional_sint64: Optional[int] = ..., + optional_fixed32: Optional[int] = ..., + optional_fixed64: Optional[int] = ..., + optional_sfixed32: Optional[int] = ..., + optional_sfixed64: Optional[int] = ..., + optional_float: Optional[float] = ..., + optional_double: Optional[float] = ..., + optional_bool: Optional[bool] = ..., + optional_string: Optional[Text] = ..., + optional_bytes: Optional[str] = ..., + optional_nested_message: Optional[TestAllTypes.NestedMessage] = ..., + optional_foreign_message: Optional[ForeignMessage] = ..., + optional_import_message: Optional[ImportMessage] = ..., + optional_nested_enum: Optional[TestAllTypes.NestedEnum] = ..., + optional_foreign_enum: Optional[ForeignEnum] = ..., + optional_string_piece: Optional[Text] = ..., + optional_cord: Optional[Text] = ..., + optional_public_import_message: Optional[PublicImportMessage] = ..., + optional_lazy_message: Optional[TestAllTypes.NestedMessage] = ..., + optional_lazy_import_message: Optional[ImportMessage] = ..., + repeated_int32: Optional[Iterable[int]] = ..., + repeated_int64: Optional[Iterable[int]] = ..., + repeated_uint32: Optional[Iterable[int]] = ..., + repeated_uint64: Optional[Iterable[int]] = ..., + repeated_sint32: Optional[Iterable[int]] = ..., + repeated_sint64: Optional[Iterable[int]] = ..., + repeated_fixed32: Optional[Iterable[int]] = ..., + repeated_fixed64: Optional[Iterable[int]] = ..., + repeated_sfixed32: Optional[Iterable[int]] = ..., + repeated_sfixed64: Optional[Iterable[int]] = ..., + repeated_float: Optional[Iterable[float]] = ..., + repeated_double: Optional[Iterable[float]] = ..., + repeated_bool: Optional[Iterable[bool]] = ..., + repeated_string: Optional[Iterable[Text]] = ..., + repeated_bytes: Optional[Iterable[str]] = ..., + repeated_nested_message: Optional[Iterable[TestAllTypes.NestedMessage]] = ..., + repeated_foreign_message: Optional[Iterable[ForeignMessage]] = ..., + repeated_import_message: Optional[Iterable[ImportMessage]] = ..., + repeated_nested_enum: Optional[Iterable[TestAllTypes.NestedEnum]] = ..., + repeated_foreign_enum: Optional[Iterable[ForeignEnum]] = ..., + repeated_string_piece: Optional[Iterable[Text]] = ..., + repeated_cord: Optional[Iterable[Text]] = ..., + repeated_lazy_message: Optional[Iterable[TestAllTypes.NestedMessage]] = ..., + oneof_uint32: Optional[int] = ..., + oneof_nested_message: Optional[TestAllTypes.NestedMessage] = ..., + oneof_string: Optional[Text] = ..., + oneof_bytes: Optional[str] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAllTypes: ... + + +class TestPackedTypes(Message): + packed_int32 = ... # type: RepeatedScalarFieldContainer[int] + packed_int64 = ... # type: RepeatedScalarFieldContainer[int] + packed_uint32 = ... # type: RepeatedScalarFieldContainer[int] + packed_uint64 = ... # type: RepeatedScalarFieldContainer[int] + packed_sint32 = ... # type: RepeatedScalarFieldContainer[int] + packed_sint64 = ... # type: RepeatedScalarFieldContainer[int] + packed_fixed32 = ... # type: RepeatedScalarFieldContainer[int] + packed_fixed64 = ... # type: RepeatedScalarFieldContainer[int] + packed_sfixed32 = ... # type: RepeatedScalarFieldContainer[int] + packed_sfixed64 = ... # type: RepeatedScalarFieldContainer[int] + packed_float = ... # type: RepeatedScalarFieldContainer[float] + packed_double = ... # type: RepeatedScalarFieldContainer[float] + packed_bool = ... # type: RepeatedScalarFieldContainer[bool] + packed_enum = ... # type: RepeatedScalarFieldContainer[ForeignEnum] + + def __init__(self, + packed_int32: Optional[Iterable[int]] = ..., + packed_int64: Optional[Iterable[int]] = ..., + packed_uint32: Optional[Iterable[int]] = ..., + packed_uint64: Optional[Iterable[int]] = ..., + packed_sint32: Optional[Iterable[int]] = ..., + packed_sint64: Optional[Iterable[int]] = ..., + packed_fixed32: Optional[Iterable[int]] = ..., + packed_fixed64: Optional[Iterable[int]] = ..., + packed_sfixed32: Optional[Iterable[int]] = ..., + packed_sfixed64: Optional[Iterable[int]] = ..., + packed_float: Optional[Iterable[float]] = ..., + packed_double: Optional[Iterable[float]] = ..., + packed_bool: Optional[Iterable[bool]] = ..., + packed_enum: Optional[Iterable[ForeignEnum]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestPackedTypes: ... + + +class TestUnpackedTypes(Message): + repeated_int32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_int64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_uint32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_uint64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_sint32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_sint64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_fixed32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_fixed64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_sfixed32 = ... # type: RepeatedScalarFieldContainer[int] + repeated_sfixed64 = ... # type: RepeatedScalarFieldContainer[int] + repeated_float = ... # type: RepeatedScalarFieldContainer[float] + repeated_double = ... # type: RepeatedScalarFieldContainer[float] + repeated_bool = ... # type: RepeatedScalarFieldContainer[bool] + repeated_nested_enum = ... # type: RepeatedScalarFieldContainer[TestAllTypes.NestedEnum] + + def __init__(self, + repeated_int32: Optional[Iterable[int]] = ..., + repeated_int64: Optional[Iterable[int]] = ..., + repeated_uint32: Optional[Iterable[int]] = ..., + repeated_uint64: Optional[Iterable[int]] = ..., + repeated_sint32: Optional[Iterable[int]] = ..., + repeated_sint64: Optional[Iterable[int]] = ..., + repeated_fixed32: Optional[Iterable[int]] = ..., + repeated_fixed64: Optional[Iterable[int]] = ..., + repeated_sfixed32: Optional[Iterable[int]] = ..., + repeated_sfixed64: Optional[Iterable[int]] = ..., + repeated_float: Optional[Iterable[float]] = ..., + repeated_double: Optional[Iterable[float]] = ..., + repeated_bool: Optional[Iterable[bool]] = ..., + repeated_nested_enum: Optional[Iterable[TestAllTypes.NestedEnum]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestUnpackedTypes: ... + + +class NestedTestAllTypes(Message): + + @property + def child(self) -> NestedTestAllTypes: ... + + @property + def payload(self) -> TestAllTypes: ... + + @property + def repeated_child( + self) -> RepeatedCompositeFieldContainer[NestedTestAllTypes]: ... + + def __init__(self, + child: Optional[NestedTestAllTypes] = ..., + payload: Optional[TestAllTypes] = ..., + repeated_child: Optional[Iterable[NestedTestAllTypes]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> NestedTestAllTypes: ... + + +class ForeignMessage(Message): + c = ... # type: int + + def __init__(self, + c: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> ForeignMessage: ... + + +class TestEmptyMessage(Message): + + def __init__(self, + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestEmptyMessage: ... diff --git a/third_party/2/google/protobuf/util/json_format_proto3_pb2.pyi b/third_party/2/google/protobuf/util/json_format_proto3_pb2.pyi new file mode 100644 index 000000000..22fb0aa34 --- /dev/null +++ b/third_party/2/google/protobuf/util/json_format_proto3_pb2.pyi @@ -0,0 +1,659 @@ +from google.protobuf.any_pb2 import ( + Any, +) +from google.protobuf.duration_pb2 import ( + Duration, +) +from google.protobuf.field_mask_pb2 import ( + FieldMask, +) +from google.protobuf.internal.containers import ( + RepeatedCompositeFieldContainer, + RepeatedScalarFieldContainer, +) +from google.protobuf.message import ( + Message, +) +from google.protobuf.struct_pb2 import ( + ListValue, + Struct, + Value, +) +from google.protobuf.timestamp_pb2 import ( + Timestamp, +) +from google.protobuf.unittest_pb2 import ( + TestAllExtensions, +) +from google.protobuf.wrappers_pb2 import ( + BoolValue, + BytesValue, + DoubleValue, + FloatValue, + Int32Value, + Int64Value, + StringValue, + UInt32Value, + UInt64Value, +) +from typing import ( + Iterable, + List, + Mapping, + MutableMapping, + Optional, + Text, + Tuple, + cast, +) + + +class EnumType(int): + + @classmethod + def Name(cls, number: int) -> str: ... + + @classmethod + def Value(cls, name: str) -> EnumType: ... + + @classmethod + def keys(cls) -> List[str]: ... + + @classmethod + def values(cls) -> List[EnumType]: ... + + @classmethod + def items(cls) -> List[Tuple[str, EnumType]]: ... + + +FOO: EnumType +BAR: EnumType + + +class MessageType(Message): + value = ... # type: int + + def __init__(self, + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> MessageType: ... + + +class TestMessage(Message): + bool_value = ... # type: bool + int32_value = ... # type: int + int64_value = ... # type: int + uint32_value = ... # type: int + uint64_value = ... # type: int + float_value = ... # type: float + double_value = ... # type: float + string_value = ... # type: Text + bytes_value = ... # type: str + enum_value = ... # type: EnumType + repeated_bool_value = ... # type: RepeatedScalarFieldContainer[bool] + repeated_int32_value = ... # type: RepeatedScalarFieldContainer[int] + repeated_int64_value = ... # type: RepeatedScalarFieldContainer[int] + repeated_uint32_value = ... # type: RepeatedScalarFieldContainer[int] + repeated_uint64_value = ... # type: RepeatedScalarFieldContainer[int] + repeated_float_value = ... # type: RepeatedScalarFieldContainer[float] + repeated_double_value = ... # type: RepeatedScalarFieldContainer[float] + repeated_string_value = ... # type: RepeatedScalarFieldContainer[Text] + repeated_bytes_value = ... # type: RepeatedScalarFieldContainer[str] + repeated_enum_value = ... # type: RepeatedScalarFieldContainer[EnumType] + + @property + def message_value(self) -> MessageType: ... + + @property + def repeated_message_value( + self) -> RepeatedCompositeFieldContainer[MessageType]: ... + + def __init__(self, + bool_value: Optional[bool] = ..., + int32_value: Optional[int] = ..., + int64_value: Optional[int] = ..., + uint32_value: Optional[int] = ..., + uint64_value: Optional[int] = ..., + float_value: Optional[float] = ..., + double_value: Optional[float] = ..., + string_value: Optional[Text] = ..., + bytes_value: Optional[str] = ..., + enum_value: Optional[EnumType] = ..., + message_value: Optional[MessageType] = ..., + repeated_bool_value: Optional[Iterable[bool]] = ..., + repeated_int32_value: Optional[Iterable[int]] = ..., + repeated_int64_value: Optional[Iterable[int]] = ..., + repeated_uint32_value: Optional[Iterable[int]] = ..., + repeated_uint64_value: Optional[Iterable[int]] = ..., + repeated_float_value: Optional[Iterable[float]] = ..., + repeated_double_value: Optional[Iterable[float]] = ..., + repeated_string_value: Optional[Iterable[Text]] = ..., + repeated_bytes_value: Optional[Iterable[str]] = ..., + repeated_enum_value: Optional[Iterable[EnumType]] = ..., + repeated_message_value: Optional[Iterable[MessageType]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMessage: ... + + +class TestOneof(Message): + oneof_int32_value = ... # type: int + oneof_string_value = ... # type: Text + oneof_bytes_value = ... # type: str + oneof_enum_value = ... # type: EnumType + + @property + def oneof_message_value(self) -> MessageType: ... + + def __init__(self, + oneof_int32_value: Optional[int] = ..., + oneof_string_value: Optional[Text] = ..., + oneof_bytes_value: Optional[str] = ..., + oneof_enum_value: Optional[EnumType] = ..., + oneof_message_value: Optional[MessageType] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestOneof: ... + + +class TestMap(Message): + + class BoolMapEntry(Message): + key = ... # type: bool + value = ... # type: int + + def __init__(self, + key: Optional[bool] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMap.BoolMapEntry: ... + + class Int32MapEntry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMap.Int32MapEntry: ... + + class Int64MapEntry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMap.Int64MapEntry: ... + + class Uint32MapEntry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMap.Uint32MapEntry: ... + + class Uint64MapEntry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMap.Uint64MapEntry: ... + + class StringMapEntry(Message): + key = ... # type: Text + value = ... # type: int + + def __init__(self, + key: Optional[Text] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMap.StringMapEntry: ... + + @property + def bool_map(self) -> MutableMapping[bool, int]: ... + + @property + def int32_map(self) -> MutableMapping[int, int]: ... + + @property + def int64_map(self) -> MutableMapping[int, int]: ... + + @property + def uint32_map(self) -> MutableMapping[int, int]: ... + + @property + def uint64_map(self) -> MutableMapping[int, int]: ... + + @property + def string_map(self) -> MutableMapping[Text, int]: ... + + def __init__(self, + bool_map: Optional[Mapping[bool, int]]=..., + int32_map: Optional[Mapping[int, int]]=..., + int64_map: Optional[Mapping[int, int]]=..., + uint32_map: Optional[Mapping[int, int]]=..., + uint64_map: Optional[Mapping[int, int]]=..., + string_map: Optional[Mapping[Text, int]]=..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestMap: ... + + +class TestNestedMap(Message): + + class BoolMapEntry(Message): + key = ... # type: bool + value = ... # type: int + + def __init__(self, + key: Optional[bool] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestNestedMap.BoolMapEntry: ... + + class Int32MapEntry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestNestedMap.Int32MapEntry: ... + + class Int64MapEntry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestNestedMap.Int64MapEntry: ... + + class Uint32MapEntry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestNestedMap.Uint32MapEntry: ... + + class Uint64MapEntry(Message): + key = ... # type: int + value = ... # type: int + + def __init__(self, + key: Optional[int] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestNestedMap.Uint64MapEntry: ... + + class StringMapEntry(Message): + key = ... # type: Text + value = ... # type: int + + def __init__(self, + key: Optional[Text] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestNestedMap.StringMapEntry: ... + + class MapMapEntry(Message): + key = ... # type: Text + + @property + def value(self) -> TestNestedMap: ... + + def __init__(self, + key: Optional[Text] = ..., + value: Optional[TestNestedMap] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestNestedMap.MapMapEntry: ... + + @property + def bool_map(self) -> MutableMapping[bool, int]: ... + + @property + def int32_map(self) -> MutableMapping[int, int]: ... + + @property + def int64_map(self) -> MutableMapping[int, int]: ... + + @property + def uint32_map(self) -> MutableMapping[int, int]: ... + + @property + def uint64_map(self) -> MutableMapping[int, int]: ... + + @property + def string_map(self) -> MutableMapping[Text, int]: ... + + @property + def map_map(self) -> MutableMapping[Text, TestNestedMap]: ... + + def __init__(self, + bool_map: Optional[Mapping[bool, int]]=..., + int32_map: Optional[Mapping[int, int]]=..., + int64_map: Optional[Mapping[int, int]]=..., + uint32_map: Optional[Mapping[int, int]]=..., + uint64_map: Optional[Mapping[int, int]]=..., + string_map: Optional[Mapping[Text, int]]=..., + map_map: Optional[Mapping[Text, TestNestedMap]]=..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestNestedMap: ... + + +class TestWrapper(Message): + + @property + def bool_value(self) -> BoolValue: ... + + @property + def int32_value(self) -> Int32Value: ... + + @property + def int64_value(self) -> Int64Value: ... + + @property + def uint32_value(self) -> UInt32Value: ... + + @property + def uint64_value(self) -> UInt64Value: ... + + @property + def float_value(self) -> FloatValue: ... + + @property + def double_value(self) -> DoubleValue: ... + + @property + def string_value(self) -> StringValue: ... + + @property + def bytes_value(self) -> BytesValue: ... + + @property + def repeated_bool_value( + self) -> RepeatedCompositeFieldContainer[BoolValue]: ... + + @property + def repeated_int32_value( + self) -> RepeatedCompositeFieldContainer[Int32Value]: ... + + @property + def repeated_int64_value( + self) -> RepeatedCompositeFieldContainer[Int64Value]: ... + + @property + def repeated_uint32_value( + self) -> RepeatedCompositeFieldContainer[UInt32Value]: ... + + @property + def repeated_uint64_value( + self) -> RepeatedCompositeFieldContainer[UInt64Value]: ... + + @property + def repeated_float_value( + self) -> RepeatedCompositeFieldContainer[FloatValue]: ... + + @property + def repeated_double_value( + self) -> RepeatedCompositeFieldContainer[DoubleValue]: ... + + @property + def repeated_string_value( + self) -> RepeatedCompositeFieldContainer[StringValue]: ... + + @property + def repeated_bytes_value( + self) -> RepeatedCompositeFieldContainer[BytesValue]: ... + + def __init__(self, + bool_value: Optional[BoolValue] = ..., + int32_value: Optional[Int32Value] = ..., + int64_value: Optional[Int64Value] = ..., + uint32_value: Optional[UInt32Value] = ..., + uint64_value: Optional[UInt64Value] = ..., + float_value: Optional[FloatValue] = ..., + double_value: Optional[DoubleValue] = ..., + string_value: Optional[StringValue] = ..., + bytes_value: Optional[BytesValue] = ..., + repeated_bool_value: Optional[Iterable[BoolValue]] = ..., + repeated_int32_value: Optional[Iterable[Int32Value]] = ..., + repeated_int64_value: Optional[Iterable[Int64Value]] = ..., + repeated_uint32_value: Optional[Iterable[UInt32Value]] = ..., + repeated_uint64_value: Optional[Iterable[UInt64Value]] = ..., + repeated_float_value: Optional[Iterable[FloatValue]] = ..., + repeated_double_value: Optional[Iterable[DoubleValue]] = ..., + repeated_string_value: Optional[Iterable[StringValue]] = ..., + repeated_bytes_value: Optional[Iterable[BytesValue]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestWrapper: ... + + +class TestTimestamp(Message): + + @property + def value(self) -> Timestamp: ... + + @property + def repeated_value(self) -> RepeatedCompositeFieldContainer[Timestamp]: ... + + def __init__(self, + value: Optional[Timestamp] = ..., + repeated_value: Optional[Iterable[Timestamp]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestTimestamp: ... + + +class TestDuration(Message): + + @property + def value(self) -> Duration: ... + + @property + def repeated_value(self) -> RepeatedCompositeFieldContainer[Duration]: ... + + def __init__(self, + value: Optional[Duration] = ..., + repeated_value: Optional[Iterable[Duration]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestDuration: ... + + +class TestFieldMask(Message): + + @property + def value(self) -> FieldMask: ... + + def __init__(self, + value: Optional[FieldMask] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestFieldMask: ... + + +class TestStruct(Message): + + @property + def value(self) -> Struct: ... + + @property + def repeated_value(self) -> RepeatedCompositeFieldContainer[Struct]: ... + + def __init__(self, + value: Optional[Struct] = ..., + repeated_value: Optional[Iterable[Struct]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestStruct: ... + + +class TestAny(Message): + + @property + def value(self) -> Any: ... + + @property + def repeated_value(self) -> RepeatedCompositeFieldContainer[Any]: ... + + def __init__(self, + value: Optional[Any] = ..., + repeated_value: Optional[Iterable[Any]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestAny: ... + + +class TestValue(Message): + + @property + def value(self) -> Value: ... + + @property + def repeated_value(self) -> RepeatedCompositeFieldContainer[Value]: ... + + def __init__(self, + value: Optional[Value] = ..., + repeated_value: Optional[Iterable[Value]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestValue: ... + + +class TestListValue(Message): + + @property + def value(self) -> ListValue: ... + + @property + def repeated_value(self) -> RepeatedCompositeFieldContainer[ListValue]: ... + + def __init__(self, + value: Optional[ListValue] = ..., + repeated_value: Optional[Iterable[ListValue]] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestListValue: ... + + +class TestBoolValue(Message): + + class BoolMapEntry(Message): + key = ... # type: bool + value = ... # type: int + + def __init__(self, + key: Optional[bool] = ..., + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestBoolValue.BoolMapEntry: ... + bool_value = ... # type: bool + + @property + def bool_map(self) -> MutableMapping[bool, int]: ... + + def __init__(self, + bool_value: Optional[bool] = ..., + bool_map: Optional[Mapping[bool, int]]=..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestBoolValue: ... + + +class TestCustomJsonName(Message): + value = ... # type: int + + def __init__(self, + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestCustomJsonName: ... + + +class TestExtensions(Message): + + @property + def extensions(self) -> TestAllExtensions: ... + + def __init__(self, + extensions: Optional[TestAllExtensions] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestExtensions: ... + + +class TestEnumValue(Message): + enum_value1 = ... # type: EnumType + enum_value2 = ... # type: EnumType + enum_value3 = ... # type: EnumType + + def __init__(self, + enum_value1: Optional[EnumType] = ..., + enum_value2: Optional[EnumType] = ..., + enum_value3: Optional[EnumType] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> TestEnumValue: ... diff --git a/third_party/2/google/protobuf/wrappers_pb2.pyi b/third_party/2/google/protobuf/wrappers_pb2.pyi new file mode 100644 index 000000000..1704e5423 --- /dev/null +++ b/third_party/2/google/protobuf/wrappers_pb2.pyi @@ -0,0 +1,106 @@ +from google.protobuf.message import ( + Message, +) +from typing import ( + Optional, + Text, +) + + +class DoubleValue(Message): + value = ... # type: float + + def __init__(self, + value: Optional[float] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> DoubleValue: ... + + +class FloatValue(Message): + value = ... # type: float + + def __init__(self, + value: Optional[float] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> FloatValue: ... + + +class Int64Value(Message): + value = ... # type: int + + def __init__(self, + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> Int64Value: ... + + +class UInt64Value(Message): + value = ... # type: int + + def __init__(self, + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> UInt64Value: ... + + +class Int32Value(Message): + value = ... # type: int + + def __init__(self, + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> Int32Value: ... + + +class UInt32Value(Message): + value = ... # type: int + + def __init__(self, + value: Optional[int] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> UInt32Value: ... + + +class BoolValue(Message): + value = ... # type: bool + + def __init__(self, + value: Optional[bool] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> BoolValue: ... + + +class StringValue(Message): + value = ... # type: Text + + def __init__(self, + value: Optional[Text] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> StringValue: ... + + +class BytesValue(Message): + value = ... # type: str + + def __init__(self, + value: Optional[str] = ..., + ) -> None: ... + + @classmethod + def FromString(cls, s: str) -> BytesValue: ...