File size: 5,372 Bytes
065fee7 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 |
# Copyright 2018 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from enum import EnumMeta
from google.protobuf import descriptor_pb2
from google.protobuf.internal.enum_type_wrapper import EnumTypeWrapper
from proto.primitives import ProtoType
class Field:
"""A representation of a type of field in protocol buffers."""
# Fields are NOT repeated nor maps.
# The RepeatedField overrides this values.
repeated = False
def __init__(
self,
proto_type,
*,
number: int,
message=None,
enum=None,
oneof: str = None,
json_name: str = None,
optional: bool = False
):
# This class is not intended to stand entirely alone;
# data is augmented by the metaclass for Message.
self.mcls_data = None
self.parent = None
# If the proto type sent is an object or a string, it is really
# a message or enum.
if not isinstance(proto_type, int):
# Note: We only support the "shortcut syntax" for enums
# when receiving the actual class.
if isinstance(proto_type, (EnumMeta, EnumTypeWrapper)):
enum = proto_type
proto_type = ProtoType.ENUM
else:
message = proto_type
proto_type = ProtoType.MESSAGE
# Save the direct arguments.
self.number = number
self.proto_type = proto_type
self.message = message
self.enum = enum
self.json_name = json_name
self.optional = optional
self.oneof = oneof
# Once the descriptor is accessed the first time, cache it.
# This is important because in rare cases the message or enum
# types are written later.
self._descriptor = None
@property
def descriptor(self):
"""Return the descriptor for the field."""
if not self._descriptor:
# Resolve the message type, if any, to a string.
type_name = None
if isinstance(self.message, str):
if not self.message.startswith(self.package):
self.message = "{package}.{name}".format(
package=self.package,
name=self.message,
)
type_name = self.message
elif self.message:
type_name = (
self.message.DESCRIPTOR.full_name
if hasattr(self.message, "DESCRIPTOR")
else self.message._meta.full_name
)
elif isinstance(self.enum, str):
if not self.enum.startswith(self.package):
self.enum = "{package}.{name}".format(
package=self.package,
name=self.enum,
)
type_name = self.enum
elif self.enum:
type_name = (
self.enum.DESCRIPTOR.full_name
if hasattr(self.enum, "DESCRIPTOR")
else self.enum._meta.full_name
)
# Set the descriptor.
self._descriptor = descriptor_pb2.FieldDescriptorProto(
name=self.name,
number=self.number,
label=3 if self.repeated else 1,
type=self.proto_type,
type_name=type_name,
json_name=self.json_name,
proto3_optional=self.optional,
)
# Return the descriptor.
return self._descriptor
@property
def name(self) -> str:
"""Return the name of the field."""
return self.mcls_data["name"]
@property
def package(self) -> str:
"""Return the package of the field."""
return self.mcls_data["package"]
@property
def pb_type(self):
"""Return the composite type of the field, or the primitive type if a primitive."""
# For enums, return the Python enum.
if self.enum:
return self.enum
# For primitive fields, we still want to know
# what the type is.
if not self.message:
return self.proto_type
# Return the internal protobuf message.
if hasattr(self.message, "_meta"):
return self.message.pb()
return self.message
class RepeatedField(Field):
"""A representation of a repeated field in protocol buffers."""
repeated = True
class MapField(Field):
"""A representation of a map field in protocol buffers."""
def __init__(self, key_type, value_type, *, number: int, message=None, enum=None):
super().__init__(value_type, number=number, message=message, enum=enum)
self.map_key_type = key_type
__all__ = (
"Field",
"MapField",
"RepeatedField",
)
|