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

   1 from google.protobuf.message import (\r
   2     Message,\r
   3 )\r
   4 from google.protobuf.unittest_import_pb2 import (\r
   5     ImportEnumForMap,\r
   6 )\r
   7 from typing import (\r
   8     List,\r
   9     Mapping,\r
  10     MutableMapping,\r
  11     Optional,\r
  12     Text,\r
  13     Tuple,\r
  14     cast,\r
  15 )\r
  16 \r
  17 \r
  18 class Proto2MapEnum(int):\r
  19 \r
  20     @classmethod\r
  21     def Name(cls, number: int) -> bytes: ...\r
  22 \r
  23     @classmethod\r
  24     def Value(cls, name: bytes) -> Proto2MapEnum: ...\r
  25 \r
  26     @classmethod\r
  27     def keys(cls) -> List[bytes]: ...\r
  28 \r
  29     @classmethod\r
  30     def values(cls) -> List[Proto2MapEnum]: ...\r
  31 \r
  32     @classmethod\r
  33     def items(cls) -> List[Tuple[bytes, Proto2MapEnum]]: ...\r
  34 PROTO2_MAP_ENUM_FOO: Proto2MapEnum\r
  35 PROTO2_MAP_ENUM_BAR: Proto2MapEnum\r
  36 PROTO2_MAP_ENUM_BAZ: Proto2MapEnum\r
  37 \r
  38 \r
  39 class Proto2MapEnumPlusExtra(int):\r
  40 \r
  41     @classmethod\r
  42     def Name(cls, number: int) -> bytes: ...\r
  43 \r
  44     @classmethod\r
  45     def Value(cls, name: bytes) -> Proto2MapEnumPlusExtra: ...\r
  46 \r
  47     @classmethod\r
  48     def keys(cls) -> List[bytes]: ...\r
  49 \r
  50     @classmethod\r
  51     def values(cls) -> List[Proto2MapEnumPlusExtra]: ...\r
  52 \r
  53     @classmethod\r
  54     def items(cls) -> List[Tuple[bytes, Proto2MapEnumPlusExtra]]: ...\r
  55 E_PROTO2_MAP_ENUM_FOO: Proto2MapEnumPlusExtra\r
  56 E_PROTO2_MAP_ENUM_BAR: Proto2MapEnumPlusExtra\r
  57 E_PROTO2_MAP_ENUM_BAZ: Proto2MapEnumPlusExtra\r
  58 E_PROTO2_MAP_ENUM_EXTRA: Proto2MapEnumPlusExtra\r
  59 \r
  60 \r
  61 class TestEnumMap(Message):\r
  62 \r
  63     class KnownMapFieldEntry(Message):\r
  64         key = ...  # type: int\r
  65         value = ...  # type: Proto2MapEnum\r
  66 \r
  67         def __init__(self,\r
  68                      key: Optional[int] = ...,\r
  69                      value: Optional[Proto2MapEnum] = ...,\r
  70                      ) -> None: ...\r
  71 \r
  72         @classmethod\r
  73         def FromString(cls, s: bytes) -> TestEnumMap.KnownMapFieldEntry: ...\r
  74 \r
  75     class UnknownMapFieldEntry(Message):\r
  76         key = ...  # type: int\r
  77         value = ...  # type: Proto2MapEnum\r
  78 \r
  79         def __init__(self,\r
  80                      key: Optional[int] = ...,\r
  81                      value: Optional[Proto2MapEnum] = ...,\r
  82                      ) -> None: ...\r
  83 \r
  84         @classmethod\r
  85         def FromString(cls, s: bytes) -> TestEnumMap.UnknownMapFieldEntry: ...\r
  86 \r
  87     @property\r
  88     def known_map_field(self) -> MutableMapping[int, Proto2MapEnum]: ...\r
  89 \r
  90     @property\r
  91     def unknown_map_field(self) -> MutableMapping[int, Proto2MapEnum]: ...\r
  92 \r
  93     def __init__(self,\r
  94                  known_map_field: Optional[Mapping[int, Proto2MapEnum]]=...,\r
  95                  unknown_map_field: Optional[Mapping[int, Proto2MapEnum]]=...,\r
  96                  ) -> None: ...\r
  97 \r
  98     @classmethod\r
  99     def FromString(cls, s: bytes) -> TestEnumMap: ...\r
 100 \r
 101 \r
 102 class TestEnumMapPlusExtra(Message):\r
 103 \r
 104     class KnownMapFieldEntry(Message):\r
 105         key = ...  # type: int\r
 106         value = ...  # type: Proto2MapEnumPlusExtra\r
 107 \r
 108         def __init__(self,\r
 109                      key: Optional[int] = ...,\r
 110                      value: Optional[Proto2MapEnumPlusExtra] = ...,\r
 111                      ) -> None: ...\r
 112 \r
 113         @classmethod\r
 114         def FromString(cls, s: bytes) -> TestEnumMapPlusExtra.KnownMapFieldEntry: ...\r
 115 \r
 116     class UnknownMapFieldEntry(Message):\r
 117         key = ...  # type: int\r
 118         value = ...  # type: Proto2MapEnumPlusExtra\r
 119 \r
 120         def __init__(self,\r
 121                      key: Optional[int] = ...,\r
 122                      value: Optional[Proto2MapEnumPlusExtra] = ...,\r
 123                      ) -> None: ...\r
 124 \r
 125         @classmethod\r
 126         def FromString(cls, s: bytes) -> TestEnumMapPlusExtra.UnknownMapFieldEntry: ...\r
 127 \r
 128     @property\r
 129     def known_map_field(self) -> MutableMapping[int, Proto2MapEnumPlusExtra]: ...\r
 130 \r
 131     @property\r
 132     def unknown_map_field(self) -> MutableMapping[int, Proto2MapEnumPlusExtra]: ...\r
 133 \r
 134     def __init__(self,\r
 135                  known_map_field: Optional[Mapping[int, Proto2MapEnumPlusExtra]]=...,\r
 136                  unknown_map_field: Optional[Mapping[int, Proto2MapEnumPlusExtra]]=...,\r
 137                  ) -> None: ...\r
 138 \r
 139     @classmethod\r
 140     def FromString(cls, s: bytes) -> TestEnumMapPlusExtra: ...\r
 141 \r
 142 \r
 143 class TestImportEnumMap(Message):\r
 144 \r
 145     class ImportEnumAmpEntry(Message):\r
 146         key = ...  # type: int\r
 147         value = ...  # type: ImportEnumForMap\r
 148 \r
 149         def __init__(self,\r
 150                      key: Optional[int] = ...,\r
 151                      value: Optional[ImportEnumForMap] = ...,\r
 152                      ) -> None: ...\r
 153 \r
 154         @classmethod\r
 155         def FromString(cls, s: bytes) -> TestImportEnumMap.ImportEnumAmpEntry: ...\r
 156 \r
 157     @property\r
 158     def import_enum_amp(self) -> MutableMapping[int, ImportEnumForMap]: ...\r
 159 \r
 160     def __init__(self,\r
 161                  import_enum_amp: Optional[Mapping[int, ImportEnumForMap]]=...,\r
 162                  ) -> None: ...\r
 163 \r
 164     @classmethod\r
 165     def FromString(cls, s: bytes) -> TestImportEnumMap: ...\r
 166 \r
 167 \r
 168 class TestIntIntMap(Message):\r
 169 \r
 170     class MEntry(Message):\r
 171         key = ...  # type: int\r
 172         value = ...  # type: int\r
 173 \r
 174         def __init__(self,\r
 175                      key: Optional[int] = ...,\r
 176                      value: Optional[int] = ...,\r
 177                      ) -> None: ...\r
 178 \r
 179         @classmethod\r
 180         def FromString(cls, s: bytes) -> TestIntIntMap.MEntry: ...\r
 181 \r
 182     @property\r
 183     def m(self) -> MutableMapping[int, int]: ...\r
 184 \r
 185     def __init__(self,\r
 186                  m: Optional[Mapping[int, int]]=...,\r
 187                  ) -> None: ...\r
 188 \r
 189     @classmethod\r
 190     def FromString(cls, s: bytes) -> TestIntIntMap: ...\r
 191 \r
 192 \r
 193 class TestMaps(Message):\r
 194 \r
 195     class MInt32Entry(Message):\r
 196         key = ...  # type: int\r
 197 \r
 198         @property\r
 199         def value(self) -> TestIntIntMap: ...\r
 200 \r
 201         def __init__(self,\r
 202                      key: Optional[int] = ...,\r
 203                      value: Optional[TestIntIntMap] = ...,\r
 204                      ) -> None: ...\r
 205 \r
 206         @classmethod\r
 207         def FromString(cls, s: bytes) -> TestMaps.MInt32Entry: ...\r
 208 \r
 209     class MInt64Entry(Message):\r
 210         key = ...  # type: int\r
 211 \r
 212         @property\r
 213         def value(self) -> TestIntIntMap: ...\r
 214 \r
 215         def __init__(self,\r
 216                      key: Optional[int] = ...,\r
 217                      value: Optional[TestIntIntMap] = ...,\r
 218                      ) -> None: ...\r
 219 \r
 220         @classmethod\r
 221         def FromString(cls, s: bytes) -> TestMaps.MInt64Entry: ...\r
 222 \r
 223     class MUint32Entry(Message):\r
 224         key = ...  # type: int\r
 225 \r
 226         @property\r
 227         def value(self) -> TestIntIntMap: ...\r
 228 \r
 229         def __init__(self,\r
 230                      key: Optional[int] = ...,\r
 231                      value: Optional[TestIntIntMap] = ...,\r
 232                      ) -> None: ...\r
 233 \r
 234         @classmethod\r
 235         def FromString(cls, s: bytes) -> TestMaps.MUint32Entry: ...\r
 236 \r
 237     class MUint64Entry(Message):\r
 238         key = ...  # type: int\r
 239 \r
 240         @property\r
 241         def value(self) -> TestIntIntMap: ...\r
 242 \r
 243         def __init__(self,\r
 244                      key: Optional[int] = ...,\r
 245                      value: Optional[TestIntIntMap] = ...,\r
 246                      ) -> None: ...\r
 247 \r
 248         @classmethod\r
 249         def FromString(cls, s: bytes) -> TestMaps.MUint64Entry: ...\r
 250 \r
 251     class MSint32Entry(Message):\r
 252         key = ...  # type: int\r
 253 \r
 254         @property\r
 255         def value(self) -> TestIntIntMap: ...\r
 256 \r
 257         def __init__(self,\r
 258                      key: Optional[int] = ...,\r
 259                      value: Optional[TestIntIntMap] = ...,\r
 260                      ) -> None: ...\r
 261 \r
 262         @classmethod\r
 263         def FromString(cls, s: bytes) -> TestMaps.MSint32Entry: ...\r
 264 \r
 265     class MSint64Entry(Message):\r
 266         key = ...  # type: int\r
 267 \r
 268         @property\r
 269         def value(self) -> TestIntIntMap: ...\r
 270 \r
 271         def __init__(self,\r
 272                      key: Optional[int] = ...,\r
 273                      value: Optional[TestIntIntMap] = ...,\r
 274                      ) -> None: ...\r
 275 \r
 276         @classmethod\r
 277         def FromString(cls, s: bytes) -> TestMaps.MSint64Entry: ...\r
 278 \r
 279     class MFixed32Entry(Message):\r
 280         key = ...  # type: int\r
 281 \r
 282         @property\r
 283         def value(self) -> TestIntIntMap: ...\r
 284 \r
 285         def __init__(self,\r
 286                      key: Optional[int] = ...,\r
 287                      value: Optional[TestIntIntMap] = ...,\r
 288                      ) -> None: ...\r
 289 \r
 290         @classmethod\r
 291         def FromString(cls, s: bytes) -> TestMaps.MFixed32Entry: ...\r
 292 \r
 293     class MFixed64Entry(Message):\r
 294         key = ...  # type: int\r
 295 \r
 296         @property\r
 297         def value(self) -> TestIntIntMap: ...\r
 298 \r
 299         def __init__(self,\r
 300                      key: Optional[int] = ...,\r
 301                      value: Optional[TestIntIntMap] = ...,\r
 302                      ) -> None: ...\r
 303 \r
 304         @classmethod\r
 305         def FromString(cls, s: bytes) -> TestMaps.MFixed64Entry: ...\r
 306 \r
 307     class MSfixed32Entry(Message):\r
 308         key = ...  # type: int\r
 309 \r
 310         @property\r
 311         def value(self) -> TestIntIntMap: ...\r
 312 \r
 313         def __init__(self,\r
 314                      key: Optional[int] = ...,\r
 315                      value: Optional[TestIntIntMap] = ...,\r
 316                      ) -> None: ...\r
 317 \r
 318         @classmethod\r
 319         def FromString(cls, s: bytes) -> TestMaps.MSfixed32Entry: ...\r
 320 \r
 321     class MSfixed64Entry(Message):\r
 322         key = ...  # type: int\r
 323 \r
 324         @property\r
 325         def value(self) -> TestIntIntMap: ...\r
 326 \r
 327         def __init__(self,\r
 328                      key: Optional[int] = ...,\r
 329                      value: Optional[TestIntIntMap] = ...,\r
 330                      ) -> None: ...\r
 331 \r
 332         @classmethod\r
 333         def FromString(cls, s: bytes) -> TestMaps.MSfixed64Entry: ...\r
 334 \r
 335     class MBoolEntry(Message):\r
 336         key = ...  # type: bool\r
 337 \r
 338         @property\r
 339         def value(self) -> TestIntIntMap: ...\r
 340 \r
 341         def __init__(self,\r
 342                      key: Optional[bool] = ...,\r
 343                      value: Optional[TestIntIntMap] = ...,\r
 344                      ) -> None: ...\r
 345 \r
 346         @classmethod\r
 347         def FromString(cls, s: bytes) -> TestMaps.MBoolEntry: ...\r
 348 \r
 349     class MStringEntry(Message):\r
 350         key = ...  # type: Text\r
 351 \r
 352         @property\r
 353         def value(self) -> TestIntIntMap: ...\r
 354 \r
 355         def __init__(self,\r
 356                      key: Optional[Text] = ...,\r
 357                      value: Optional[TestIntIntMap] = ...,\r
 358                      ) -> None: ...\r
 359 \r
 360         @classmethod\r
 361         def FromString(cls, s: bytes) -> TestMaps.MStringEntry: ...\r
 362 \r
 363     @property\r
 364     def m_int32(self) -> MutableMapping[int, TestIntIntMap]: ...\r
 365 \r
 366     @property\r
 367     def m_int64(self) -> MutableMapping[int, TestIntIntMap]: ...\r
 368 \r
 369     @property\r
 370     def m_uint32(self) -> MutableMapping[int, TestIntIntMap]: ...\r
 371 \r
 372     @property\r
 373     def m_uint64(self) -> MutableMapping[int, TestIntIntMap]: ...\r
 374 \r
 375     @property\r
 376     def m_sint32(self) -> MutableMapping[int, TestIntIntMap]: ...\r
 377 \r
 378     @property\r
 379     def m_sint64(self) -> MutableMapping[int, TestIntIntMap]: ...\r
 380 \r
 381     @property\r
 382     def m_fixed32(self) -> MutableMapping[int, TestIntIntMap]: ...\r
 383 \r
 384     @property\r
 385     def m_fixed64(self) -> MutableMapping[int, TestIntIntMap]: ...\r
 386 \r
 387     @property\r
 388     def m_sfixed32(self) -> MutableMapping[int, TestIntIntMap]: ...\r
 389 \r
 390     @property\r
 391     def m_sfixed64(self) -> MutableMapping[int, TestIntIntMap]: ...\r
 392 \r
 393     @property\r
 394     def m_bool(self) -> MutableMapping[bool, TestIntIntMap]: ...\r
 395 \r
 396     @property\r
 397     def m_string(self) -> MutableMapping[Text, TestIntIntMap]: ...\r
 398 \r
 399     def __init__(self,\r
 400                  m_int32: Optional[Mapping[int, TestIntIntMap]]=...,\r
 401                  m_int64: Optional[Mapping[int, TestIntIntMap]]=...,\r
 402                  m_uint32: Optional[Mapping[int, TestIntIntMap]]=...,\r
 403                  m_uint64: Optional[Mapping[int, TestIntIntMap]]=...,\r
 404                  m_sint32: Optional[Mapping[int, TestIntIntMap]]=...,\r
 405                  m_sint64: Optional[Mapping[int, TestIntIntMap]]=...,\r
 406                  m_fixed32: Optional[Mapping[int, TestIntIntMap]]=...,\r
 407                  m_fixed64: Optional[Mapping[int, TestIntIntMap]]=...,\r
 408                  m_sfixed32: Optional[Mapping[int, TestIntIntMap]]=...,\r
 409                  m_sfixed64: Optional[Mapping[int, TestIntIntMap]]=...,\r
 410                  m_bool: Optional[Mapping[bool, TestIntIntMap]]=...,\r
 411                  m_string: Optional[Mapping[Text, TestIntIntMap]]=...,\r
 412                  ) -> None: ...\r
 413 \r
 414     @classmethod\r
 415     def FromString(cls, s: bytes) -> TestMaps: ...\r
 416 \r
 417 \r
 418 class TestSubmessageMaps(Message):\r
 419 \r
 420     @property\r
 421     def m(self) -> TestMaps: ...\r
 422 \r
 423     def __init__(self,\r
 424                  m: Optional[TestMaps] = ...,\r
 425                  ) -> None: ...\r
 426 \r
 427     @classmethod\r
 428     def FromString(cls, s: bytes) -> TestSubmessageMaps: ...\r