.config/coc/extensions/coc-python-data/languageServer.0.5.59/Typeshed/third_party/2and3/google/protobuf/unittest_custom_options_pb2.pyi

   1 from google.protobuf.descriptor_pb2 import (\r
   2     FileOptions,\r
   3 )\r
   4 from google.protobuf.internal.containers import (\r
   5     RepeatedCompositeFieldContainer,\r
   6     RepeatedScalarFieldContainer,\r
   7 )\r
   8 from google.protobuf.message import (\r
   9     Message,\r
  10 )\r
  11 from typing import (\r
  12     Iterable,\r
  13     List,\r
  14     Optional,\r
  15     Text,\r
  16     Tuple,\r
  17     cast,\r
  18 )\r
  19 \r
  20 \r
  21 class MethodOpt1(int):\r
  22 \r
  23     @classmethod\r
  24     def Name(cls, number: int) -> bytes: ...\r
  25 \r
  26     @classmethod\r
  27     def Value(cls, name: bytes) -> MethodOpt1: ...\r
  28 \r
  29     @classmethod\r
  30     def keys(cls) -> List[bytes]: ...\r
  31 \r
  32     @classmethod\r
  33     def values(cls) -> List[MethodOpt1]: ...\r
  34 \r
  35     @classmethod\r
  36     def items(cls) -> List[Tuple[bytes, MethodOpt1]]: ...\r
  37 \r
  38 \r
  39 METHODOPT1_VAL1: MethodOpt1\r
  40 METHODOPT1_VAL2: MethodOpt1\r
  41 \r
  42 \r
  43 class AggregateEnum(int):\r
  44 \r
  45     @classmethod\r
  46     def Name(cls, number: int) -> bytes: ...\r
  47 \r
  48     @classmethod\r
  49     def Value(cls, name: bytes) -> AggregateEnum: ...\r
  50 \r
  51     @classmethod\r
  52     def keys(cls) -> List[bytes]: ...\r
  53 \r
  54     @classmethod\r
  55     def values(cls) -> List[AggregateEnum]: ...\r
  56 \r
  57     @classmethod\r
  58     def items(cls) -> List[Tuple[bytes, AggregateEnum]]: ...\r
  59 \r
  60 \r
  61 VALUE: AggregateEnum\r
  62 \r
  63 \r
  64 class TestMessageWithCustomOptions(Message):\r
  65 \r
  66     class AnEnum(int):\r
  67 \r
  68         @classmethod\r
  69         def Name(cls, number: int) -> bytes: ...\r
  70 \r
  71         @classmethod\r
  72         def Value(cls, name: bytes) -> TestMessageWithCustomOptions.AnEnum: ...\r
  73 \r
  74         @classmethod\r
  75         def keys(cls) -> List[bytes]: ...\r
  76 \r
  77         @classmethod\r
  78         def values(cls) -> List[TestMessageWithCustomOptions.AnEnum]: ...\r
  79 \r
  80         @classmethod\r
  81         def items(cls) -> List[Tuple[bytes,\r
  82                                      TestMessageWithCustomOptions.AnEnum]]: ...\r
  83     ANENUM_VAL1: AnEnum\r
  84     ANENUM_VAL2: AnEnum\r
  85     field1 = ...  # type: Text\r
  86     oneof_field = ...  # type: int\r
  87 \r
  88     def __init__(self,\r
  89                  field1: Optional[Text] = ...,\r
  90                  oneof_field: Optional[int] = ...,\r
  91                  ) -> None: ...\r
  92 \r
  93     @classmethod\r
  94     def FromString(cls, s: bytes) -> TestMessageWithCustomOptions: ...\r
  95 \r
  96 \r
  97 class CustomOptionFooRequest(Message):\r
  98 \r
  99     def __init__(self,\r
 100                  ) -> None: ...\r
 101 \r
 102     @classmethod\r
 103     def FromString(cls, s: bytes) -> CustomOptionFooRequest: ...\r
 104 \r
 105 \r
 106 class CustomOptionFooResponse(Message):\r
 107 \r
 108     def __init__(self,\r
 109                  ) -> None: ...\r
 110 \r
 111     @classmethod\r
 112     def FromString(cls, s: bytes) -> CustomOptionFooResponse: ...\r
 113 \r
 114 \r
 115 class CustomOptionFooClientMessage(Message):\r
 116 \r
 117     def __init__(self,\r
 118                  ) -> None: ...\r
 119 \r
 120     @classmethod\r
 121     def FromString(cls, s: bytes) -> CustomOptionFooClientMessage: ...\r
 122 \r
 123 \r
 124 class CustomOptionFooServerMessage(Message):\r
 125 \r
 126     def __init__(self,\r
 127                  ) -> None: ...\r
 128 \r
 129     @classmethod\r
 130     def FromString(cls, s: bytes) -> CustomOptionFooServerMessage: ...\r
 131 \r
 132 \r
 133 class DummyMessageContainingEnum(Message):\r
 134 \r
 135     class TestEnumType(int):\r
 136 \r
 137         @classmethod\r
 138         def Name(cls, number: int) -> bytes: ...\r
 139 \r
 140         @classmethod\r
 141         def Value(cls, name: bytes) -> DummyMessageContainingEnum.TestEnumType: ...\r
 142 \r
 143         @classmethod\r
 144         def keys(cls) -> List[bytes]: ...\r
 145 \r
 146         @classmethod\r
 147         def values(cls) -> List[DummyMessageContainingEnum.TestEnumType]: ...\r
 148 \r
 149         @classmethod\r
 150         def items(cls) -> List[Tuple[bytes,\r
 151                                      DummyMessageContainingEnum.TestEnumType]]: ...\r
 152     TEST_OPTION_ENUM_TYPE1: TestEnumType\r
 153     TEST_OPTION_ENUM_TYPE2: TestEnumType\r
 154 \r
 155     def __init__(self,\r
 156                  ) -> None: ...\r
 157 \r
 158     @classmethod\r
 159     def FromString(cls, s: bytes) -> DummyMessageContainingEnum: ...\r
 160 \r
 161 \r
 162 class DummyMessageInvalidAsOptionType(Message):\r
 163 \r
 164     def __init__(self,\r
 165                  ) -> None: ...\r
 166 \r
 167     @classmethod\r
 168     def FromString(cls, s: bytes) -> DummyMessageInvalidAsOptionType: ...\r
 169 \r
 170 \r
 171 class CustomOptionMinIntegerValues(Message):\r
 172 \r
 173     def __init__(self,\r
 174                  ) -> None: ...\r
 175 \r
 176     @classmethod\r
 177     def FromString(cls, s: bytes) -> CustomOptionMinIntegerValues: ...\r
 178 \r
 179 \r
 180 class CustomOptionMaxIntegerValues(Message):\r
 181 \r
 182     def __init__(self,\r
 183                  ) -> None: ...\r
 184 \r
 185     @classmethod\r
 186     def FromString(cls, s: bytes) -> CustomOptionMaxIntegerValues: ...\r
 187 \r
 188 \r
 189 class CustomOptionOtherValues(Message):\r
 190 \r
 191     def __init__(self,\r
 192                  ) -> None: ...\r
 193 \r
 194     @classmethod\r
 195     def FromString(cls, s: bytes) -> CustomOptionOtherValues: ...\r
 196 \r
 197 \r
 198 class SettingRealsFromPositiveInts(Message):\r
 199 \r
 200     def __init__(self,\r
 201                  ) -> None: ...\r
 202 \r
 203     @classmethod\r
 204     def FromString(cls, s: bytes) -> SettingRealsFromPositiveInts: ...\r
 205 \r
 206 \r
 207 class SettingRealsFromNegativeInts(Message):\r
 208 \r
 209     def __init__(self,\r
 210                  ) -> None: ...\r
 211 \r
 212     @classmethod\r
 213     def FromString(cls, s: bytes) -> SettingRealsFromNegativeInts: ...\r
 214 \r
 215 \r
 216 class ComplexOptionType1(Message):\r
 217     foo = ...  # type: int\r
 218     foo2 = ...  # type: int\r
 219     foo3 = ...  # type: int\r
 220     foo4 = ...  # type: RepeatedScalarFieldContainer[int]\r
 221 \r
 222     def __init__(self,\r
 223                  foo: Optional[int] = ...,\r
 224                  foo2: Optional[int] = ...,\r
 225                  foo3: Optional[int] = ...,\r
 226                  foo4: Optional[Iterable[int]] = ...,\r
 227                  ) -> None: ...\r
 228 \r
 229     @classmethod\r
 230     def FromString(cls, s: bytes) -> ComplexOptionType1: ...\r
 231 \r
 232 \r
 233 class ComplexOptionType2(Message):\r
 234 \r
 235     class ComplexOptionType4(Message):\r
 236         waldo = ...  # type: int\r
 237 \r
 238         def __init__(self,\r
 239                      waldo: Optional[int] = ...,\r
 240                      ) -> None: ...\r
 241 \r
 242         @classmethod\r
 243         def FromString(\r
 244             cls, s: bytes) -> ComplexOptionType2.ComplexOptionType4: ...\r
 245     baz = ...  # type: int\r
 246 \r
 247     @property\r
 248     def bar(self) -> ComplexOptionType1: ...\r
 249 \r
 250     @property\r
 251     def fred(self) -> ComplexOptionType2.ComplexOptionType4: ...\r
 252 \r
 253     @property\r
 254     def barney(\r
 255         self) -> RepeatedCompositeFieldContainer[ComplexOptionType2.ComplexOptionType4]: ...\r
 256 \r
 257     def __init__(self,\r
 258                  bar: Optional[ComplexOptionType1] = ...,\r
 259                  baz: Optional[int] = ...,\r
 260                  fred: Optional[ComplexOptionType2.ComplexOptionType4] = ...,\r
 261                  barney: Optional[Iterable[ComplexOptionType2.ComplexOptionType4]] = ...,\r
 262                  ) -> None: ...\r
 263 \r
 264     @classmethod\r
 265     def FromString(cls, s: bytes) -> ComplexOptionType2: ...\r
 266 \r
 267 \r
 268 class ComplexOptionType3(Message):\r
 269 \r
 270     class ComplexOptionType5(Message):\r
 271         plugh = ...  # type: int\r
 272 \r
 273         def __init__(self,\r
 274                      plugh: Optional[int] = ...,\r
 275                      ) -> None: ...\r
 276 \r
 277         @classmethod\r
 278         def FromString(\r
 279             cls, s: bytes) -> ComplexOptionType3.ComplexOptionType5: ...\r
 280     qux = ...  # type: int\r
 281 \r
 282     @property\r
 283     def complexoptiontype5(self) -> ComplexOptionType3.ComplexOptionType5: ...\r
 284 \r
 285     def __init__(self,\r
 286                  qux: Optional[int] = ...,\r
 287                  complexoptiontype5: Optional[ComplexOptionType3.ComplexOptionType5] = ...,\r
 288                  ) -> None: ...\r
 289 \r
 290     @classmethod\r
 291     def FromString(cls, s: bytes) -> ComplexOptionType3: ...\r
 292 \r
 293 \r
 294 class ComplexOpt6(Message):\r
 295     xyzzy = ...  # type: int\r
 296 \r
 297     def __init__(self,\r
 298                  xyzzy: Optional[int] = ...,\r
 299                  ) -> None: ...\r
 300 \r
 301     @classmethod\r
 302     def FromString(cls, s: bytes) -> ComplexOpt6: ...\r
 303 \r
 304 \r
 305 class VariousComplexOptions(Message):\r
 306 \r
 307     def __init__(self,\r
 308                  ) -> None: ...\r
 309 \r
 310     @classmethod\r
 311     def FromString(cls, s: bytes) -> VariousComplexOptions: ...\r
 312 \r
 313 \r
 314 class AggregateMessageSet(Message):\r
 315 \r
 316     def __init__(self,\r
 317                  ) -> None: ...\r
 318 \r
 319     @classmethod\r
 320     def FromString(cls, s: bytes) -> AggregateMessageSet: ...\r
 321 \r
 322 \r
 323 class AggregateMessageSetElement(Message):\r
 324     s = ...  # type: Text\r
 325 \r
 326     def __init__(self,\r
 327                  s: Optional[Text] = ...,\r
 328                  ) -> None: ...\r
 329 \r
 330     @classmethod\r
 331     def FromString(cls, s: bytes) -> AggregateMessageSetElement: ...\r
 332 \r
 333 \r
 334 class Aggregate(Message):\r
 335     i = ...  # type: int\r
 336     s = ...  # type: Text\r
 337 \r
 338     @property\r
 339     def sub(self) -> Aggregate: ...\r
 340 \r
 341     @property\r
 342     def file(self) -> FileOptions: ...\r
 343 \r
 344     @property\r
 345     def mset(self) -> AggregateMessageSet: ...\r
 346 \r
 347     def __init__(self,\r
 348                  i: Optional[int] = ...,\r
 349                  s: Optional[Text] = ...,\r
 350                  sub: Optional[Aggregate] = ...,\r
 351                  file: Optional[FileOptions] = ...,\r
 352                  mset: Optional[AggregateMessageSet] = ...,\r
 353                  ) -> None: ...\r
 354 \r
 355     @classmethod\r
 356     def FromString(cls, s: bytes) -> Aggregate: ...\r
 357 \r
 358 \r
 359 class AggregateMessage(Message):\r
 360     fieldname = ...  # type: int\r
 361 \r
 362     def __init__(self,\r
 363                  fieldname: Optional[int] = ...,\r
 364                  ) -> None: ...\r
 365 \r
 366     @classmethod\r
 367     def FromString(cls, s: bytes) -> AggregateMessage: ...\r
 368 \r
 369 \r
 370 class NestedOptionType(Message):\r
 371 \r
 372     class NestedEnum(int):\r
 373 \r
 374         @classmethod\r
 375         def Name(cls, number: int) -> bytes: ...\r
 376 \r
 377         @classmethod\r
 378         def Value(cls, name: bytes) -> NestedOptionType.NestedEnum: ...\r
 379 \r
 380         @classmethod\r
 381         def keys(cls) -> List[bytes]: ...\r
 382 \r
 383         @classmethod\r
 384         def values(cls) -> List[NestedOptionType.NestedEnum]: ...\r
 385 \r
 386         @classmethod\r
 387         def items(cls) -> List[Tuple[bytes, NestedOptionType.NestedEnum]]: ...\r
 388     NESTED_ENUM_VALUE: NestedEnum\r
 389 \r
 390     class NestedMessage(Message):\r
 391         nested_field = ...  # type: int\r
 392 \r
 393         def __init__(self,\r
 394                      nested_field: Optional[int] = ...,\r
 395                      ) -> None: ...\r
 396 \r
 397         @classmethod\r
 398         def FromString(cls, s: bytes) -> NestedOptionType.NestedMessage: ...\r
 399 \r
 400     def __init__(self,\r
 401                  ) -> None: ...\r
 402 \r
 403     @classmethod\r
 404     def FromString(cls, s: bytes) -> NestedOptionType: ...\r
 405 \r
 406 \r
 407 class OldOptionType(Message):\r
 408 \r
 409     class TestEnum(int):\r
 410 \r
 411         @classmethod\r
 412         def Name(cls, number: int) -> bytes: ...\r
 413 \r
 414         @classmethod\r
 415         def Value(cls, name: bytes) -> OldOptionType.TestEnum: ...\r
 416 \r
 417         @classmethod\r
 418         def keys(cls) -> List[bytes]: ...\r
 419 \r
 420         @classmethod\r
 421         def values(cls) -> List[OldOptionType.TestEnum]: ...\r
 422 \r
 423         @classmethod\r
 424         def items(cls) -> List[Tuple[bytes, OldOptionType.TestEnum]]: ...\r
 425     OLD_VALUE: TestEnum\r
 426     value = ...  # type: OldOptionType.TestEnum\r
 427 \r
 428     def __init__(self,\r
 429                  value: OldOptionType.TestEnum,\r
 430                  ) -> None: ...\r
 431 \r
 432     @classmethod\r
 433     def FromString(cls, s: bytes) -> OldOptionType: ...\r
 434 \r
 435 \r
 436 class NewOptionType(Message):\r
 437 \r
 438     class TestEnum(int):\r
 439 \r
 440         @classmethod\r
 441         def Name(cls, number: int) -> bytes: ...\r
 442 \r
 443         @classmethod\r
 444         def Value(cls, name: bytes) -> NewOptionType.TestEnum: ...\r
 445 \r
 446         @classmethod\r
 447         def keys(cls) -> List[bytes]: ...\r
 448 \r
 449         @classmethod\r
 450         def values(cls) -> List[NewOptionType.TestEnum]: ...\r
 451 \r
 452         @classmethod\r
 453         def items(cls) -> List[Tuple[bytes, NewOptionType.TestEnum]]: ...\r
 454     OLD_VALUE: TestEnum\r
 455     NEW_VALUE: TestEnum\r
 456     value = ...  # type: NewOptionType.TestEnum\r
 457 \r
 458     def __init__(self,\r
 459                  value: NewOptionType.TestEnum,\r
 460                  ) -> None: ...\r
 461 \r
 462     @classmethod\r
 463     def FromString(cls, s: bytes) -> NewOptionType: ...\r
 464 \r
 465 \r
 466 class TestMessageWithRequiredEnumOption(Message):\r
 467 \r
 468     def __init__(self,\r
 469                  ) -> None: ...\r
 470 \r
 471     @classmethod\r
 472     def FromString(cls, s: bytes) -> TestMessageWithRequiredEnumOption: ...\r