def get_socket( wire: WireSpec, message_classes: Dict[str, Type[Message]], config: Message ) -> Optional[Socket]: if wire.optional: if not config.HasField(wire.name): return None else: assert config.HasField(wire.name), f"Config unset: {wire.name}" wire_type = message_classes[wire.type] socket_type_fd = next( ( fd for fd in wire_type.DESCRIPTOR.fields if fd.type == FieldDescriptor.TYPE_MESSAGE and fd.message_type.full_name == net_pb2.Socket.DESCRIPTOR.full_name ), None, ) if socket_type_fd is None: return None protocol = wire_pb2.Mark.TCP for _, option in socket_type_fd.GetOptions().ListFields(): if isinstance(option, wire_pb2.Mark): protocol = option.protocol wire_value = getattr(config, wire.name) socket_value = getattr(wire_value, socket_type_fd.name) return Socket(host=socket_value.host, port=socket_value.port, _protocol=protocol)
def _from_proto(self, proto: message.Message) -> "BaseModelCardField": """Convert proto to this class object.""" if not isinstance(proto, self._proto_type): raise TypeError("%s is expected. However %s is provided." % (self._proto_type, type(proto))) for field_descriptor in proto.DESCRIPTOR.fields: field_name = field_descriptor.name if not hasattr(self, field_name): raise ValueError("%s has no such field named '%s.'" % (self, field_name)) # Process Message type. if field_descriptor.type == descriptor.FieldDescriptor.TYPE_MESSAGE: if field_descriptor.label == descriptor.FieldDescriptor.LABEL_REPEATED: # Clean the list first. setattr(self, field_name, []) for p in getattr(proto, field_name): # To get the type hint of a list is not easy. field = self.__annotations__[field_name].__args__[0]() # pytype: disable=attribute-error field._from_proto(p) # pylint: disable=protected-access getattr(self, field_name).append(field) elif proto.HasField(field_name): getattr(self, field_name)._from_proto(getattr(proto, field_name)) # pylint: disable=protected-access # Process Non-Message type else: if field_descriptor.label == descriptor.FieldDescriptor.LABEL_REPEATED: setattr(self, field_name, getattr(proto, field_name)[:]) elif proto.HasField(field_name): setattr(self, field_name, getattr(proto, field_name)) return self
def set_value( self, instance: 'ObjectBase', pb: protobuf.Message, pool: 'Pool', value: OBJECT ) -> None: if value is not None: _checktype(value, self.otype) elif not self.allow_none: raise ValueError("None not allowed for '%s'." % self.name) if pb.HasField(self.name): old_id = getattr(pb, self.name) else: old_id = None new_id = value.id if value is not None else None if new_id == old_id: return old_value = pool[old_id] if old_id is not None else None if value is None: pb.ClearField(self.name) else: setattr(pb, self.name, value.id) if not instance.in_setup: instance.property_changed(PropertyValueChange(instance, self.name, old_value, value))
def get_value(self, instance: 'ObjectBase', pb: protobuf.Message, pool: 'Pool') -> PROTO: if pb.HasField(self.name): return getattr(pb, self.name) if self.default is not None: return self.default if self.allow_none: return None raise ValueNotSetError("Value '%s' has not been set." % self.name)
def _is_field_present(msg: message.Message, field_name: str, error_msgs: List[str], error_prefix: str = '') -> bool: """Checks whether a message field in a proto is present.""" if not msg.HasField(field_name): error_msgs.append('{}{} field is missing'.format(error_prefix, field_name)) return False return True
def get_value(self, instance: 'ObjectBase', pb: protobuf.Message, pool: 'Pool') -> OBJECT: if pb.HasField(self.name): obj_id = getattr(pb, self.name) try: return cast(OBJECT, pool[obj_id]) except KeyError: raise InvalidReferenceError("%s.%s" % (type(instance).__name__, self.name)) if self.allow_none: return None raise ValueNotSetError("Value '%s' has not been set." % self.name)
def dispatch(self, rules: Message) -> None: for field in self.rule_descriptor.fields: if field.label == FieldDescriptor.LABEL_REPEATED: rule_value = getattr(rules, field.name) if not rule_value: continue else: if not rules.HasField(field.name): continue rule_value = getattr(rules, field.name) try: visit_fn = getattr(self, f"visit_{field.name}") except AttributeError: raise NotImplementedError(field.full_name) visit_fn(rule_value)
def field_content_length(msg: message.Message, field: Union[descriptor.FieldDescriptor, str]) -> int: """Returns the size of the field. Args: msg: The Message whose fields to examine. field: The FieldDescriptor or name of the field to examine. Returns: The number of elements at the provided field. If field describes a singular protobuf field, this will return 1. If the field is not set, returns 0. """ if isinstance(field, str): field = _field_descriptor_for_name(msg, field) if field_is_repeated(field): return len(getattr(msg, field.name)) return 1 if msg.HasField(field.name) else 0
def set_value( self, instance: 'ObjectBase', pb: protobuf.Message, pool: 'Pool', value: VALUE ) -> None: if pb.HasField(self.name): old_value = getattr(pb, self.name) else: old_value = self.default if value is None: if self.allow_none: pb.ClearField(self.name) else: raise ValueError("None not allowed for '%s'." % self.name) else: setattr(pb, self.name, value) if value != old_value and not instance.in_setup: instance.property_changed(PropertyValueChange(instance, self.name, old_value, value))
def set_value( self, instance: 'ObjectBase', pb: protobuf.Message, pool: 'Pool', value: PROTOVAL ) -> None: if pb.HasField(self.name): old_value = self.ptype.from_proto(getattr(pb, self.name)) else: old_value = self.default if value is None: if self.allow_none: pb.ClearField(self.name) else: raise ValueError("None not allowed for '%s'." % self.name) else: _checktype(value, self.ptype) getattr(pb, self.name).CopyFrom(value.to_proto()) if value != old_value and not instance.in_setup: instance.property_changed(PropertyValueChange(instance, self.name, old_value, value))
def get_field(msg: Message, field_name): '''return field by name or None''' if msg.HasField(field_name): return msg.__getattribute__(field_name) return None
def __call__(self, message: Message) -> Any: if message.HasField("type_id"): return self.conversion_map[message.type_id](message) else: return self.default_converter(message)
def _recurse_validate( message: Message, name: str, validators: List[AbstractArgumentValidator], leading_parts_name: str = None, is_optional: bool = False, ): errors = [] field_name_raw, *remaining_fields = name.split(".") field_name = field_name_raw.rstrip("[]") remaining_fields = [f for f in remaining_fields if f != ""] if leading_parts_name is None and field_name == "": field_value = message field_descriptor: FieldDescriptor = message.DESCRIPTOR # type: ignore full_name = message.DESCRIPTOR.name else: field_descriptor = message.DESCRIPTOR.fields_by_name[field_name] full_name = field_name if leading_parts_name is None else f"{leading_parts_name}.{field_name}" if (field_descriptor.label != FieldDescriptor.LABEL_REPEATED and field_descriptor.type == FieldDescriptor.TYPE_MESSAGE and not message.HasField(field_name)): if is_optional: return [] return [f"request must have {full_name}"] field_value = getattr(message, field_name) if remaining_fields: if field_descriptor.label == FieldDescriptor.LABEL_REPEATED: for i, elem in enumerate(field_value): # type: ignore errors.extend( _recurse_validate( message=elem, name=".".join(remaining_fields), leading_parts_name=f"{full_name}[{i}]", validators=validators, is_optional=is_optional, )) else: errors.extend( _recurse_validate( message=field_value, name=".".join(remaining_fields), leading_parts_name=full_name, validators=validators, is_optional=is_optional, )) else: for v in validators: if field_name_raw.endswith( "[]" ) and field_descriptor.label == FieldDescriptor.LABEL_REPEATED: for i, field_value_elem in enumerate( field_value): # type: ignore validation_result = v.check(f"{full_name}[{i}]", field_value_elem, field_descriptor) if not validation_result.valid: errors.append(validation_result.invalid_reason) else: validation_result = v.check(full_name, field_value, field_descriptor) if not validation_result.valid: errors.append(validation_result.invalid_reason) return errors