crossplane-function-pythonic 0.6.2__py3-none-any.whl → 0.7.0__py3-none-any.whl

crossplane/pythonic/protobuf.py

@@ -17,81 +17,158 @@
 
 import base64
 import datetime
-import google.protobuf.struct_pb2
 import json
 import sys
-import yaml
+import typing
 
-_Unknown = object()
+import google.protobuf.descriptor
+import google.protobuf.message
+import google.protobuf.struct_pb2
+import yaml
+from google.protobuf.internal.containers import (
+    MessageMap,
+    RepeatedCompositeFieldContainer,
+    RepeatedScalarFieldContainer,
+    ScalarMap,
+)
+
+type TypeString = str | Value | FieldMessage
+_Unknown = sentinel("_Unknown")
 append = sys.maxsize
 
 
-def Map(**kwargs):
+def Map(**kwargs) -> Value:
     return Value(None, None, kwargs)
 
-def List(*args):
+
+def List(*args) -> Value:
     return Value(None, None, args)
 
-def Unknown():
+
+def Unknown() -> Value:
     return Value(None, None)
 
-def Yaml(string, readOnly=None):
+
+def Yaml(string: TypeString, readOnly: str | bool = False) -> Value | FieldMessage:
     if isinstance(string, (FieldMessage, Value)):
         if not string:
             return string
         string = str(string)
     return Value(None, None, yaml.safe_load(string), readOnly)
 
-def YamlAll(string, readOnly=None):
+
+def YamlAll(string: TypeString, readOnly: str | bool = False) -> Value | FieldMessage:
     if isinstance(string, (FieldMessage, Value)):
         if not string:
             return string
         string = str(string)
-    return Value(None, None, [document for document in yaml.safe_load_all(string)], readOnly)
+    return Value(
+        None, None, [document for document in yaml.safe_load_all(string)], readOnly
+    )
 
-def Json(string, readOnly=None):
+
+def Json(string: TypeString, readOnly: str | bool = False) -> Value | FieldMessage:
     if isinstance(string, (FieldMessage, Value)):
         if not string:
             return string
         string = str(string)
     return Value(None, None, json.loads(string), readOnly)
 
-def B64Encode(string):
+
+def B64Encode(string: TypeString) -> TypeString:
     if isinstance(string, (FieldMessage, Value)):
         if not string:
             return string
         string = str(string)
-    return base64.b64encode(string.encode('utf-8')).decode('utf-8')
+    return base64.b64encode(string.encode("utf-8")).decode("utf-8")
 
-def B64Decode(string):
+
+def B64Decode(string: TypeString) -> TypeString:
     if isinstance(string, (FieldMessage, Value)):
         if not string:
             return string
         string = str(string)
-    return base64.b64decode(string.encode('utf-8')).decode('utf-8')
+    return base64.b64decode(string.encode("utf-8")).decode("utf-8")
+
+
+class TypeProtobuf:
+    def __getattr__(self, key):
+        if key not in self.__dict__:
+            raise AttributeError(
+                f"{self.__class__.__name__} attribute does not exist: {key}"
+            )
+        return self.__dict__[key]
+
+    def __getitem__(self, key):
+        raise ValueError(f"{self.__class__.__name__} does not have dynamic items")
+
+    def __iter__(self):
+        raise ValueError(f"{self.__class__.__name__} is not iterable")
+
+    def __int__(self):
+        raise ValueError(f"{self.__class__.__name__} is not an integer")
 
+    def __float__(self):
+        raise ValueError(f"{self.__class__.__name__} is not a float")
 
-class Message:
-    def __init__(self, parent, key, descriptor, message=_Unknown, readOnly=False):
-        self._set_attribute('_parent', parent)
-        self._set_attribute('_key', key)
-        self._set_attribute('_descriptor', descriptor)
-        self._set_attribute('_message', message)
-        self._set_attribute('_readOnly', readOnly)
-        self._set_attribute('_cache', {})
+    def __call__(self, *args, **kwargs):
+        raise ValueError(f"{self.__class__.__name__} is not callable")
 
-    def _set_attribute(self, key, value):
+    def __setattr__(self, key, value):
         self.__dict__[key] = value
 
-    def __getattr__(self, key):
+    def __setitem__(self, key, value):
+        raise ValueError(f"{self.__class__.__name__} does not have dynamic items")
+
+    def __delattr__(self, key):
+        raise ValueError(f"{self.__class__.__name__} does not have dynamic attributes")
+
+    def __delitem__(self, key):
+        raise ValueError(f"{self.__class__.__name__} does not have dynamic items")
+
+    def append(self, value):
+        raise ValueError(f"{self.__class__.__name__} does not have dynamic items")
+
+
+class Message(TypeProtobuf):
+    def __init__(
+        self,
+        parent: Message | MapMessage | RepeatedMessage | None,
+        key: str | int | Value | FieldMessage | None,
+        descriptor: google.protobuf.descriptor.Descriptor,
+        message: google.protobuf.message.Message | _Unknown = _Unknown,
+        readOnly: str | bool = False,
+    ):
+        self._parent: Message | MapMessage | RepeatedMessage | None = parent
+        self._key = key
+        self._descriptor: google.protobuf.descriptor.Descriptor = descriptor
+        self._message: google.protobuf.message.Message | _Unknown = message
+        self._readOnly: str | bool = readOnly
+        self._cache: dict[str, typing.Any] = {}
+
+    def _ensure_message(self):
+        if self._message is _Unknown:
+            if self._parent is None:
+                raise ValueError(
+                    "Messages does not have parent to create internal message"
+                )
+            self._message: google.protobuf.message.Message = self._parent._create_child(
+                self._key
+            )
+
+    def __getattr__(
+        self, key
+    ) -> Message | MapMessage | RepeatedMessage | FieldMessage | Value:
         return self[key]
 
-    def __getitem__(self, key):
+    def __getitem__(
+        self, key
+    ) -> Message | MapMessage | RepeatedMessage | FieldMessage | Value:
         key = self._validate_key(key)
         if key in self._cache:
             return self._cache[key]
         field = self._descriptor.fields_by_name.get(key)
-        if not field:
+        if field is None:
             raise AttributeError(obj=self, name=key)
         if self._message is _Unknown:
             value = _Unknown
@@ -100,12 +177,22 @@ class Message:
         if value is _Unknown and field.has_default_value:
             value = field.default_value
         if field.is_repeated:
-            if field.type == field.TYPE_MESSAGE and field.message_type.GetOptions().map_entry:
-                value = MapMessage(self, key, field.message_type.fields_by_name['value'], value, self._readOnly)
+            if (
+                field.type == field.TYPE_MESSAGE
+                and field.message_type
+                and field.message_type.GetOptions().map_entry
+            ):
+                value = MapMessage(
+                    self,
+                    key,
+                    field.message_type.fields_by_name["value"],
+                    value,
+                    self._readOnly,
+                )
             else:
                 value = RepeatedMessage(self, key, field, value, self._readOnly)
-        elif field.type == field.TYPE_MESSAGE:
-            if field.message_type.name in ('Struct', 'ListValue'):
+        elif field.type == field.TYPE_MESSAGE and field.message_type:
+            if field.message_type.name in ("Struct", "ListValue"):
                 value = Value(self, key, value, self._readOnly)
             else:
                 value = Message(self, key, field.message_type, value, self._readOnly)
@@ -129,7 +216,11 @@ class Message:
 
     def __hash__(self):
         if self._message is not _Unknown:
-            return hash(tuple(hash(item) for item in sorted(iter(self), key=lambda item: item[0])))
+            return hash(
+                tuple(
+                    hash(item) for item in sorted(iter(self), key=lambda item: item[0])
+                )
+            )
         return 0
 
     def __eq__(self, other):
@@ -153,7 +244,7 @@ class Message:
     def __str__(self):
         return format(self)
 
-    def __format__(self, spec='yaml'):
+    def __format__(self, spec="yaml"):
         return _formatObject(self, spec)
 
     def _fullName(self, key=None):
@@ -163,36 +254,37 @@ class Message:
             else:
                 name = str(self._key)
             if key is not None:
-                if '.' in key:
+                if "." in key:
                     name += f"[{key}]"
                 else:
                     name += f".{key}"
             return name
         if key is not None:
             return str(key)
-        return ''
+        return ""
 
     def _create_child(self, key):
         if self._readOnly:
             raise ValueError(f"{self._readOnly} is read only")
         key = self._validate_key(key)
-        if self._message is _Unknown:
-            self.__dict__['_message'] = self._parent._create_child(self._key)
+        self._ensure_message()
         return getattr(self._message, key)
 
     def __call__(self, **kwargs):
         if self._readOnly:
             raise ValueError(f"{self._readOnly} is read only")
-        if self._message is _Unknown:
-            self.__dict__['_message'] = self._parent._create_child(self._key)
-        self._message.Clear()
+        self._ensure_message()
+        typing.cast(google.protobuf.message.Message, self._message).Clear()
         self._cache.clear()
         for key, value in kwargs.items():
             self[key] = value
         return self
 
     def __setattr__(self, key, value):
-        self[key] = value
+        if key in ("_parent", "_key", "_descriptor", "_message", "_readOnly", "_cache"):
+            self.__dict__[key] = value
+        else:
+            self[key] = value
 
     def __setitem__(self, key, value):
         if self._readOnly:
@@ -200,19 +292,34 @@ class Message:
         key = self._validate_key(key)
         if key not in self._descriptor.fields_by_name:
             raise AttributeError(obj=self, name=key)
-        field = self._descriptor.fields_by_name[key]
-        if self._message is _Unknown:
-            self.__dict__['_message'] = self._parent._create_child(self._key)
-        if isinstance(value, Message):
-            value = value._message
-        elif isinstance(value, (MapMessage, RepeatedMessage)):
-            value = value._messages
-        elif isinstance(value, FieldMessage):
+        if isinstance(value, (Message, MapMessage)):
+            for k, v in value:
+                self[key][k] = v
+            return
+        if isinstance(value, dict):
+            for k, v in value.items():
+                self[key][k] = v
+            return
+        if isinstance(value, (RepeatedMessage, list, tuple)):
+            for ix, v in enumerate(value):
+                self[key][ix] = v
+            return
+        if isinstance(value, FieldMessage):
             value = value._value
         elif isinstance(value, Value):
+            if value._isMap:
+                for k, v in value:
+                    self[key][k] = v
+                return
+            if value._isList:
+                for ix, v in enumerate(value):
+                    self[key][ix] = v
+                return
             value = value._raw
+        field = self._descriptor.fields_by_name[key]
         if field.type == field.TYPE_BYTES and isinstance(value, str):
-            value = value.encode('utf-8')
+            value = value.encode("utf-8")
+        self._ensure_message()
         setattr(self._message, key, value)
         self._cache.pop(key, None)
 
@@ -239,17 +346,21 @@ class Message:
         return key
 
 
-class MapMessage:
-    def __init__(self, parent, key, field, messages=_Unknown, readOnly=False):
-        self._set_attribute('_parent', parent)
-        self._set_attribute('_key', key)
-        self._set_attribute('_field', field)
-        self._set_attribute('_messages', messages)
-        self._set_attribute('_readOnly', readOnly)
-        self._set_attribute('_cache', {})
-
-    def _set_attribute(self, key, value):
-        self.__dict__[key] = value
+class MapMessage(TypeProtobuf):
+    def __init__(
+        self,
+        parent: Message,
+        key: str,
+        field: google.protobuf.descriptor.FieldDescriptor,
+        messages: ScalarMap | MessageMap | _Unknown = _Unknown,
+        readOnly: str | bool = False,
+    ):
+        self._parent: Message = parent
+        self._key: str = key
+        self._field: google.protobuf.descriptor.FieldDescriptor = field
+        self._messages: ScalarMap | MessageMap | _Unknown = messages
+        self._readOnly = readOnly
+        self._cache: dict[str, typing.Any] = {}
 
     def __getattr__(self, key):
         return self[key]
@@ -264,11 +375,13 @@ class MapMessage:
             value = self._messages[key]
         if value is None and self._field.has_default_value:
             value = self._field.default_value
-        if self._field.type == self._field.TYPE_MESSAGE:
-            if self._field.message_type.name in ('Struct', 'ListValue'):
+        if self._field.type == self._field.TYPE_MESSAGE and self._field.message_type:
+            if str(self._field.message_type.name) in ("Struct", "ListValue"):
                 value = Value(self, key, value, self._readOnly)
             else:
-                value = Message(self, key, self._field.message_type, value, self._readOnly)
+                value = Message(
+                    self, key, self._field.message_type, value, self._readOnly
+                )
         else:
             value = FieldMessage(self, key, self._field.type, value)
         self._cache[key] = value
@@ -281,7 +394,9 @@ class MapMessage:
         return 0 if self._messages is _Unknown else len(self._messages)
 
     def __contains__(self, key):
-        return self._messages is not _Unknown and key in self._messages
+        return (
+            self._messages is not _Unknown and self._validate_key(key) in self._messages
+        )
 
     def __iter__(self):
         if self._messages is not _Unknown:
@@ -289,8 +404,12 @@ class MapMessage:
                 yield key, self[key]
 
     def __hash__(self):
-        if self._nessages is not None:
-            return hash(tuple(hash(item) for item in sorted(iter(self), key=lambda item: item[0])))
+        if self._messages is not _Unknown:
+            return hash(
+                tuple(
+                    hash(item) for item in sorted(iter(self), key=lambda item: item[0])
+                )
+            )
         return 0
 
     def __eq__(self, other):
@@ -298,9 +417,13 @@ class MapMessage:
             return False
         if self._field.type != other._field.type:
             return False
-        if self._field.type == self._field.TYPE_MESSAGE:
-            if self._field.message_type.full_name != other._field.message_type.full_name:
-                return False
+        if (
+            self._field.type == self._field.TYPE_MESSAGE
+            and self._field.message_type
+            and self._field.message_type.full_name
+            != other._field.message_type.full_name
+        ):
+            return False
         if self._messages is _Unknown:
             return other._messages is _Unknown
         elif other._messages is _Unknown:
@@ -317,67 +440,67 @@ class MapMessage:
     def __str__(self):
         return format(self)
 
-    def __format__(self, spec='yaml'):
+    def __format__(self, spec="yaml"):
         return _formatObject(self, spec)
 
     def _fullName(self, key=None):
-        if self._key is not None:
-            if self._parent is not None:
-                name = self._parent._fullName(self._key)
-            else:
-                name = str(self._key)
-            if key is not None:
-                if '.' in key:
-                    name += f"[{key}]"
-                else:
-                    name += f".{key}"
-            return name
+        name = self._parent._fullName(self._key)
         if key is not None:
-            return str(key)
-        return ''
+            if "." in key:
+                name += f"[{key}]"
+            else:
+                name += f".{key}"
+        return name
 
     def _create_child(self, key):
         if self._readOnly:
             raise ValueError(f"{self._readOnly} is read only")
         key = self._validate_key(key)
         if self._messages is _Unknown:
-            self.__dict__['_messages'] = self._parent._create_child(self._key)
+            self._messages = self._parent._create_child(self._key)
         return self._messages[key]
 
     def __call__(self, **kwargs):
         if self._readOnly:
             raise ValueError(f"{self._readOnly} is read only")
         if self._messages is _Unknown:
-            self.__dict__['_messages'] = self._parent._create_child(self._key)
+            self._messages: ScalarMap | MessageMap = self._parent._create_child(
+                self._key
+            )
         self._messages.clear()
         self._cache.clear()
         for key, value in kwargs.items():
             self[key] = value
         return self
 
-    def __setattr__(self, key, message):
-        self[key] = message
+    def __setattr__(self, key, value):
+        if key in ("_parent", "_key", "_field", "_messages", "_readOnly", "_cache"):
+            self.__dict__[key] = value
+        else:
+            self[key] = value
 
-    def __setitem__(self, key, message):
+    def __setitem__(self, key, value):
         if self._readOnly:
             raise ValueError(f"{self._readOnly} is read only")
         key = self._validate_key(key)
         if self._messages is _Unknown:
-            self._messages = self._parent._create_child(self._key)
-        if isinstance(message, Message):
-            message = message._message
-        elif isinstance(message, (MapMessage, RepeatedMessage)):
-            message = message._messages
-        elif isinstance(message, FieldMessage):
-            message = message._value
-        elif isinstance(message, Value):
-            message = message._raw
-        if message is _Unknown:
+            self._messages: ScalarMap | MessageMap = self._parent._create_child(
+                self._key
+            )
+        if isinstance(value, Message):
+            value = value._message
+        elif isinstance(value, (MapMessage, RepeatedMessage)):
+            value = value._messages
+        elif isinstance(value, FieldMessage):
+            value = value._value
+        elif isinstance(value, Value):
+            value = value._raw
+        if value is _Unknown:
             self._messages.pop(key, None)
         else:
-            if self._field.type == self._field.TYPE_BYTES and isinstance(message, str):
-                message = message.encode('utf-8')
-            self._messages[key] = message
+            if self._field.type == self._field.TYPE_BYTES and isinstance(value, str):
+                value = value.encode("utf-8")
+            self._messages[key] = value
         self._cache.pop(key, None)
 
     def __delattr__(self, key):
@@ -402,14 +525,25 @@ class MapMessage:
         return key
 
 
-class RepeatedMessage:
-    def __init__(self, parent, key, field, messages=_Unknown, readOnly=False):
-        self._parent = parent
-        self._key = key
-        self._field = field
-        self._messages = messages
-        self._readOnly = readOnly
-        self._cache = {}
+class RepeatedMessage(TypeProtobuf):
+    def __init__(
+        self,
+        parent: Message,
+        key: str,
+        field: google.protobuf.descriptor.FieldDescriptor,
+        messages: RepeatedCompositeFieldContainer
+        | RepeatedScalarFieldContainer
+        | _Unknown = _Unknown,
+        readOnly: str | bool = False,
+    ):
+        self._parent: Message = parent
+        self._key: str = key
+        self._field: google.protobuf.descriptor.FieldDescriptor = field
+        self._messages: (
+            RepeatedCompositeFieldContainer | RepeatedScalarFieldContainer | _Unknown
+        ) = messages
+        self._readOnly: str | bool = readOnly
+        self._cache: dict[int, typing.Any] = {}
 
     def __getitem__(self, key):
         key = self._validate_key(key)
@@ -425,8 +559,7 @@ class RepeatedMessage:
                     key = 0
                 else:
                     key = len(self._messages) + key
-                    if key < 0:
-                        key = 0
+                    key = max(key, 0)
             if key in self._cache:
                 return self._cache[key]
             if self._messages is _Unknown or key >= len(self._messages):
@@ -435,11 +568,13 @@ class RepeatedMessage:
                 value = self._messages[key]
         if value is None and self._field.has_default_value:
             value = self._field.default_value
-        if self._field.type == self._field.TYPE_MESSAGE:
-            if self._field.message_type.name in ('Struct', 'ListValue'):
+        if self._field.type == self._field.TYPE_MESSAGE and self._field.message_type:
+            if self._field.message_type.name in ("Struct", "ListValue"):
                 value = Value(self, key, value, self._readOnly)
             else:
-                value = Message(self, key, self._field.message_type, value, self._readOnly)
+                value = Message(
+                    self, key, self._field.message_type, value, self._readOnly
+                )
         else:
             value = FieldMessage(self, key, self._field.type, value)
         self._cache[key] = value
@@ -473,9 +608,13 @@ class RepeatedMessage:
             return False
         if self._field.type != other._field.type:
             return False
-        if self._field.type == self._field.TYPE_MESSAGE:
-            if self._field.message_type.full_name != other._field.message_type.full_name:
-                return False
+        if (
+            self._field.type == self._field.TYPE_MESSAGE
+            and self._field.message_type
+            and self._field.message_type.full_name
+            != other._field.message_type.full_name
+        ):
+            return False
         if self._messages is _Unknown:
             return other._messages is _Unknown
         elif other._messages is _Unknown:
@@ -490,7 +629,7 @@ class RepeatedMessage:
     def __str__(self):
         return format(self)
 
-    def __format__(self, spec='yaml'):
+    def __format__(self, spec="yaml"):
         return _formatObject(self, spec)
 
     def _fullName(self, key=None):
@@ -504,34 +643,38 @@ class RepeatedMessage:
             return name
         if key is not None:
             return str(key)
-        return ''
+        return ""
 
     def _create_child(self, key):
         if self._readOnly:
             raise ValueError(f"{self._readOnly} is read only")
         key = self._validate_key(key)
         if self._messages is _Unknown:
-            self.__dict__['_messages'] = self._parent._create_child(self._key)
+            self._messages: (
+                RepeatedCompositeFieldContainer | RepeatedScalarFieldContainer
+            ) = self._parent._create_child(self._key)
         if key == append:
             key = len(self._messages)
         elif key < 0:
             key = len(self._messages) + key
         while key >= len(self._messages):
-            self._messages.add()
+            typing.cast(RepeatedCompositeFieldContainer, self._messages).add()
         return self._messages[key]
 
     def __call__(self, *args):
         if self._readOnly:
             raise ValueError(f"{self._readOnly} is read only")
         if self._messages is _Unknown:
-            self.__dict__['_messages'] = self._parent._create_child(self._key)
+            self._messages: (
+                RepeatedCompositeFieldContainer | RepeatedScalarFieldContainer
+            ) = self._parent._create_child(self._key)
         self._messages.clear()
         self._cache.clear()
         for arg in args:
             self.append(arg)
         return self
 
-    def __setitem__(self, key, message):
+    def __setitem__(self, key, value):
         if self._readOnly:
             raise ValueError(f"{self._readOnly} is read only")
         key = self._validate_key(key)
@@ -539,25 +682,25 @@ class RepeatedMessage:
             self._messages = self._parent._create_child(self._key)
         if key < 0:
             key = len(self._messages) + key
-        if isinstance(message, Message):
-            message = message._message
-        elif isinstance(message, (MapMessage, RepeatedMessage)):
-            message = message._messages
-        elif isinstance(message, FieldMessage):
-            message = message._value
-        elif isinstance(message, Value):
-            message = message._raw
-        if message is _Unknown:
+        if isinstance(value, Message):
+            value = value._message
+        elif isinstance(value, (MapMessage, RepeatedMessage)):
+            value = value._messages
+        elif isinstance(value, FieldMessage):
+            value = value._value
+        elif isinstance(value, Value):
+            value = value._raw
+        if value is _Unknown:
             if key < len(self._messages):
                 self._messages.pop(key)
                 self._cache.clear()
         else:
-            if self._field.type == self._field.TYPE_BYTES and isinstance(message, str):
-                message = message.encode('utf-8')
+            if self._field.type == self._field.TYPE_BYTES and isinstance(value, str):
+                value = value.encode("utf-8")
             if key >= len(self._messages):
-                self._messages.append(message)
+                self._messages.append(value)
             else:
-                self._messages[key] = message
+                self._messages[key] = value
             self._cache.pop(key, None)
 
     def __delitem__(self, key):
@@ -568,15 +711,27 @@ class RepeatedMessage:
             del self._messages[key]
             self._cache.pop(key, None)
 
-    def append(self, message=_Unknown):
+    def append(self, value=_Unknown) -> TypeProtobuf:
         if self._readOnly:
             raise ValueError(f"{self._readOnly} is read only")
         if self._messages is _Unknown:
-            self._messages = self._parent._create_child(self._key)
-        if message is _Unknown:
-            message = self._messages.add()
+            self._messages: RepeatedCompositeFieldContainer = (
+                self._parent._create_child(self._key)
+            )
+        if isinstance(value, Message):
+            value = value._message
+        elif isinstance(value, (MapMessage, RepeatedMessage)):
+            value = value._messages
+        elif isinstance(value, FieldMessage):
+            value = value._value
+        elif isinstance(value, Value):
+            value = value._raw
+        if value is _Unknown:
+            typing.cast(RepeatedCompositeFieldContainer, self._messages).add()
         else:
-            message = self._messages.append(message)
+            if self._field.type == self._field.TYPE_BYTES and isinstance(value, str):
+                value = value.encode("utf-8")
+            self._messages.append(value)
         return self[len(self._messages) - 1]
 
     def _validate_key(self, key):
@@ -589,23 +744,29 @@ class RepeatedMessage:
         return key
 
 
-class FieldMessage:
-    def __init__(self, parent, key, kind, value):
-        self._parent = parent
-        self._key = key
-        self._kind = kind
-        self._value = value
+class FieldMessage(TypeProtobuf):
+    def __init__(
+        self,
+        parent: Message | MapMessage | RepeatedMessage,
+        key: str | int,
+        kind: int,
+        value: typing.Any,
+    ):
+        self._parent: Message | MapMessage | RepeatedMessage = parent
+        self._key: str | int = key
+        self._kind: int = kind
+        self._value: typing.Any = value
 
     def __bool__(self):
         return self._value is not _Unknown
 
     def __len__(self):
-        if self._value is _Unknown:
+        if self._value is _Unknown or not isinstance(self._value, (bytes, str)):
             return 0
         return len(self._value)
 
     def __contains__(self, key):
-        if self._value is _Unknown:
+        if self._value is _Unknown or not isinstance(self._value, (bytes, str)):
             return False
         return key in self._value
 
@@ -618,24 +779,29 @@ class FieldMessage:
         if self._value is _Unknown:
             return False
         if isinstance(other, FieldMessage):
-            return self._value == other._value
+            other = other._value
+        if isinstance(self._value, str):
+            if isinstance(other, bytes):
+                other = other.decode("utf-8")
+        elif isinstance(self._value, bytes) and isinstance(other, str):
+            other = other.encode("utf-8")
         return self._value == other
 
     def __bytes__(self):
-        if self._value is _Unknown:
-            return None
+        if self._value is _Unknown or not isinstance(self._value, (bytes, str)):
+            return None  # noqa: PLE0308
         if isinstance(self._value, str):
-            return self._value.encode('utf-8')
+            return self._value.encode("utf-8")
         return bytes(self._value)
 
     def __str__(self):
         if self._value is _Unknown:
-            return None
+            return None  # noqa: PLE0307
         if isinstance(self._value, bytes):
-            return self._value.decode('utf-8')
+            return self._value.decode("utf-8")
         return str(self._value)
 
-    def __format__(self, spec=''):
+    def __format__(self, spec=""):
         if self._value is _Unknown:
             return None
         return format(self._value, spec)
@@ -651,20 +817,13 @@ class FieldMessage:
         return float(self._value)
 
     def _fullName(self, key=None):
-        if self._key is not None:
-            if self._parent is not None:
-                name = self._parent._fullName(self._key)
-            else:
-                name = str(self._key)
-            if key is not None:
-                if '.' in key:
-                    name += f"[{key}]"
-                else:
-                    name += f".{key}"
-            return name
+        name = self._parent._fullName(self._key)
         if key is not None:
-            return str(key)
-        return ''
+            if "." in key:
+                name += f"[{key}]"
+            else:
+                name += f".{key}"
+        return name
 
 
 class ProtobufValue:
@@ -673,20 +832,38 @@ class ProtobufValue:
         return None
 
 
-class Value:
-    def __init__(self, parent, key, value=_Unknown, readOnly=None):
-        self._set_attribute('_parent', parent)
-        self._set_attribute('_key', key)
-        self._set_attribute('_dependencies', {})
-        self._set_attribute('_unknowns', {})
-        self._set_attribute('_cache', {})
-        self._set_attribute('_readOnly', None)
-        if isinstance(value, (google.protobuf.struct_pb2.Value, google.protobuf.struct_pb2.Struct, google.protobuf.struct_pb2.ListValue)) or value is _Unknown:
-            self._set_attribute('_value', value)
+class Value(TypeProtobuf):
+    def __init__(
+        self,
+        parent: Message | MapMessage | RepeatedMessage | Value | None,
+        key: str | int | None,
+        value: typing.Any | _Unknown = _Unknown,
+        readOnly: str | bool = False,
+    ):
+        self._parent: Message | MapMessage | RepeatedMessage | Value | None = parent
+        self._key: str | int | None = key
+        self._dependencies: dict[str | int, FieldMessage | Value] = {}
+        self._unknowns: dict[str | int, FieldMessage | Value] = {}
+        self._cache: dict[str | int, Value] = {}
+        self._readOnly: str | bool = False
+        if (
+            isinstance(
+                value,
+                (
+                    google.protobuf.struct_pb2.Value,
+                    google.protobuf.struct_pb2.Struct,
+                    google.protobuf.struct_pb2.ListValue,
+                ),
+            )
+            or value is _Unknown
+        ):
+            self._value: typing.Any = value
         else:
-            self._set_attribute('_value', google.protobuf.struct_pb2.Value())
+            self._value: google.protobuf.struct_pb2.Value = (
+                google.protobuf.struct_pb2.Value()
+            )
             if value is None:
-                self._value.null_value = 0
+                self._value.null_value = google.protobuf.struct_pb2.NULL_VALUE
             elif isinstance(value, dict):
                 self._value.struct_value.Clear()
                 for k, v in value.items():
@@ -695,7 +872,7 @@ class Value:
                 self._value.list_value.Clear()
                 for ix, v in enumerate(value):
                     self[ix] = v
-            elif isinstance(value, bool): # Must be before number check
+            elif isinstance(value, bool):  # Must be before number check
                 self._value.bool_value = value
             elif isinstance(value, (int, float)):
                 self._value.number_value = value
@@ -703,10 +880,7 @@ class Value:
                 self._value.string_value = value
             else:
                 raise ValueError(f"Unexpected Value type: {value.__class__}")
-        self._set_attribute('_readOnly', readOnly)
-
-    def _set_attribute(self, key, value):
-        self.__dict__[key] = value
+        self._setReadOnly(readOnly)
 
     def __enter__(self):
         return self
@@ -714,12 +888,6 @@ class Value:
     def __exit__(self, exc_type, exc_value, traceback):
         pass
 
-    def __aenter__(self):
-        return self
-
-    def __aexit__(self, exc_type, exc_value, traceback):
-        pass
-
     def __getattr__(self, key):
         return self[key]
 
@@ -732,42 +900,40 @@ class Value:
                 return self._unknowns[key]
         if isinstance(key, str):
             match self._kind:
-                case 'struct_value':
+                case "struct_value":
                     value = self._value.struct_value.fields.get(key, _Unknown)
-                case 'Struct':
+                case "Struct":
                     value = self._value.fields.get(key, _Unknown)
-                case 'Unknown':
+                case "Unknown":
                     value = _Unknown
                 case _:
-                    raise ValueError(f"Invalid key \"{key}\" for kind: {self._kind}")
+                    raise ValueError(f'Invalid key "{key}" for kind: {self._kind}')
         elif isinstance(key, int):
             match self._kind:
-                case 'list_value':
+                case "list_value":
                     if key < 0:
                         key = len(self._value.list_value.values) + key
-                        if key < 0:
-                            key = 0
+                        key = max(key, 0)
                     if key < len(self._value.list_value.values):
                         value = self._value.list_value.values[key]
                     else:
                         if key == append:
                             key = len(self._value.list_value.values)
                         value = _Unknown
-                case 'ListValue':
+                case "ListValue":
                     if key < 0:
                         key = len(self._value.values) + key
-                        if key < 0:
-                            key = 0
+                        key = max(key, 0)
                     if key < len(self._value.values):
                         value = self._value.values[key]
                     else:
                         if key == append:
                             key = len(self._value.values)
                         value = _Unknown
-                case 'Unknown':
+                case "Unknown":
                     value = _Unknown
                 case _:
-                    raise ValueError(f"Invalid key \"{key}\" for kind: {self._kind}")
+                    raise ValueError(f'Invalid key "{key}" for kind: {self._kind}')
         else:
             raise NotImplementedError()
         value = Value(self, key, value, self._readOnly)
@@ -779,29 +945,29 @@ class Value:
 
     def __len__(self):
         match self._kind:
-            case 'struct_value':
+            case "struct_value":
                 return len(self._value.struct_value.fields) + len(self._unknowns)
-            case 'Struct':
+            case "Struct":
                 return len(self._value.fields) + len(self._unknowns)
-            case 'list_value':
+            case "list_value":
                 return len(self._value.list_value.values) + len(self._unknowns)
-            case 'ListValue':
+            case "ListValue":
                 return len(self._value.values) + len(self._unknowns)
-            case 'string_value':
+            case "string_value":
                 return len(self._value.string_value)
-            case 'bool_value':
+            case "bool_value":
                 return 1 if self._value.bool_value else 0
         return 0
 
     def __contains__(self, item):
         match self._kind:
-            case 'struct_value':
+            case "struct_value":
                 item = self._validate_key(item)
                 return item in self._value.struct_value.fields or item in self._unknowns
-            case 'Struct':
+            case "Struct":
                 item = self._validate_key(item)
                 return item in self._value.fields or item in self._unknowns
-            case 'list_value' | 'ListValue':
+            case "list_value" | "ListValue":
                 for value in self:
                     if item == value:
                         return True
@@ -809,38 +975,45 @@ class Value:
 
     def __iter__(self):
         match self._kind:
-            case 'struct_value':
-                for key in sorted(set(self._value.struct_value.fields) | set(self._unknowns.keys())):
+            case "struct_value":
+                for key in sorted(
+                    set(self._value.struct_value.fields) | set(self._unknowns.keys())
+                ):
                     yield key, self[key]
-            case 'Struct':
+            case "Struct":
                 for key in sorted(set(self._value.fields) | set(self._unknowns.keys())):
                     yield key, self[key]
-            case 'list_value':
+            case "list_value":
                 for ix in range(len(self._value.list_value.values)):
                     yield self[ix]
                 for ix in sorted(self._unknowns.keys()):
-                    if ix >= len(self._value.list_value.values):
+                    if typing.cast(int, ix) >= len(self._value.list_value.values):
                         yield self[ix]
-            case 'ListValue':
+            case "ListValue":
                 for ix in range(len(self._value.values)):
                     yield self[ix]
                 for ix in sorted(self._unknowns.keys()):
-                    if ix >= len(self._value.values):
+                    if typing.cast(int, ix) >= len(self._value.values):
                         yield self[ix]
 
     def __hash__(self):
         match self._kind:
-            case 'struct_value' | 'Struct':
-                return hash(tuple(hash(item) for item in sorted(iter(self), key=lambda item: item[0])))
-            case 'list_value' | 'ListValue':
+            case "struct_value" | "Struct":
+                return hash(
+                    tuple(
+                        hash(item)
+                        for item in sorted(iter(self), key=lambda item: item[0])
+                    )
+                )
+            case "list_value" | "ListValue":
                 return hash(tuple(hash(item) for item in self))
-            case 'string_value':
+            case "string_value":
                 return hash(self._value.string_value)
-            case 'null_value':
+            case "null_value":
                 return hash(None)
-            case 'number_value':
+            case "number_value":
                 return hash(self._value.number_value)
-            case 'bool_value':
+            case "bool_value":
                 return hash(self._value.bool_value)
         return 0
 
@@ -849,7 +1022,7 @@ class Value:
         if isinstance(other, Value) and other._kind != kind:
             return False
         match kind:
-            case 'struct_value' | 'Struct':
+            case "struct_value" | "Struct":
                 if not isinstance(other, (Value, dict)):
                     return False
                 if len(self) != len(other):
@@ -860,7 +1033,7 @@ class Value:
                     if value != other[key]:
                         return False
                 return True
-            case 'list_value' | 'ListValue':
+            case "list_value" | "ListValue":
                 if not isinstance(other, (Value, tuple, list)):
                     return False
                 if len(self) != len(other):
@@ -869,27 +1042,27 @@ class Value:
                     if value != other[ix]:
                         return False
                 return True
-            case 'Unknown':
+            case "Unknown":
                 if isinstance(other, Value):
                     return other._isUnknown
                 return False
-            case 'string_value':
+            case "string_value":
                 if isinstance(other, Value):
                     return self._value.string_value == other._value.string_value
                 if isinstance(other, str):
                     return self._value.string_value == other
                 return False
-            case 'null_value':
+            case "null_value":
                 if isinstance(other, Value):
                     return True
                 return other is None
-            case 'number_value':
+            case "number_value":
                 if isinstance(other, Value):
                     return self._value.number_value == other._value.number_value
                 if isinstance(other, (int, float)):
                     return self._value.number_value == other
                 return False
-            case 'bool_value':
+            case "bool_value":
                 if isinstance(other, Value):
                     return self._value.bool_value == other._value.bool_value
                 if isinstance(other, bool):
@@ -899,7 +1072,7 @@ class Value:
 
     def __or__(self, other):
         kind = self._kind
-        if kind not in ('struct_value', 'Struct'):
+        if kind not in ("struct_value", "Struct"):
             return NotImplemented
         if not isinstance(other, (Value, dict)):
             return NotImplemented
@@ -917,56 +1090,56 @@ class Value:
         result = Map()
         for key, value in other.items():
             result[key] = value
-        if self._kind not in ('struct_value', 'Struct'):
+        if self._kind not in ("struct_value", "Struct"):
             return NotImplemented
         for key, value in self:
             result[key] = value
         return result
 
     def __str__(self):
-        return format(self, '')
+        return format(self, "")
 
-    def __format__(self, spec='yaml'):
+    def __format__(self, spec="yaml"):
         if not spec:
             match self._kind:
-                case 'Unknown':
-                    return '<<UNKNOWN>>'
-                case 'string_value':
+                case "Unknown":
+                    return "<<UNKNOWN>>"
+                case "string_value":
                     return self._value.string_value
-                case 'null_value':
-                    return 'null'
-                case 'number_value':
+                case "null_value":
+                    return "null"
+                case "number_value":
                     value = self._value.number_value
                     if value.is_integer():
                         value = int(value)
                     return str(value)
-                case 'bool_value':
-                    return 'true' if self._value.bool_value else 'false'
+                case "bool_value":
+                    return "true" if self._value.bool_value else "false"
         return _formatObject(self, spec)
 
     def __int__(self):
         kind = self._kind
         match kind:
-            case 'string_value':
+            case "string_value":
                 return int(self._value.string_value)
-            case 'number_value':
+            case "number_value":
                 return int(self._value.number_value)
-            case 'bool_value':
+            case "bool_value":
                 return int(self._value.bool_value)
-            case 'Unknown':
+            case "Unknown":
                 return 0
         raise TypeError(f"Cannot convert kind to integer: {kind}")
 
     def __float__(self):
         kind = self._kind
         match kind:
-            case 'string_value':
+            case "string_value":
                 return float(self._value.string_value)
-            case 'number_value':
+            case "number_value":
                 return float(self._value.number_value)
-            case 'bool_value':
+            case "bool_value":
                 return float(self._value.bool_value)
-            case 'Unknown':
+            case "Unknown":
                 return 0.0
         raise TypeError(f"Cannot convert kind to float: {kind}")
 
@@ -988,25 +1161,25 @@ class Value:
                     if isinstance(key, int):
                         name += f"[{key}]"
                     else:
-                        if '.' in key:
+                        if "." in key:
                             name += f"[{key}]"
                         else:
                             name += f".{key}"
             return name
         if key is not None:
             return str(key)
-        return ''
+        return ""
 
     def __call__(self, *args, **kwargs):
         if self._readOnly:
             raise ValueError(f"{self._readOnly} is read only")
-        self.__dict__['_value'] = google.protobuf.struct_pb2.Value()
+        self.__dict__["_value"] = google.protobuf.struct_pb2.Value()
         self._cache.clear()
         self._dependencies.clear()
         self._unknowns.clear()
         if len(kwargs):
             if len(args):
-                raise ValueError('Connect specify both kwargs and args')
+                raise ValueError("Connect specify both kwargs and args")
             for key, value in kwargs.items():
                 self[key] = value
         elif len(args):
@@ -1017,19 +1190,30 @@ class Value:
         return self
 
     def __setattr__(self, key, value):
-        self[key] = value
+        if key in (
+            "_parent",
+            "_key",
+            "_value",
+            "_dependencies",
+            "_unknowns",
+            "_cache",
+            "_readOnly",
+        ):
+            self.__dict__[key] = value
+        else:
+            self[key] = value
 
     def __setitem__(self, key, value):
         if self._readOnly:
             raise ValueError(f"{self._readOnly} is read only")
         key = self._validate_key(key)
         if isinstance(key, str):
-            if self._ensure_map() == 'struct_value':
+            if self._ensure_map() == "struct_value":
                 values = self._value.struct_value.fields
             else:
                 values = self._value.fields
         elif isinstance(key, int):
-            if self._ensure_list() == 'list_value':
+            if self._ensure_list() == "list_value":
                 values = self._value.list_value.values
             else:
                 values = self._value.values
@@ -1048,10 +1232,10 @@ class Value:
             value = value._protobuf_value
         if value is None:
             values[key].null_value = 0
-        elif isinstance(value, bool): # Must be before int check
+        elif isinstance(value, bool):  # Must be before int check
             values[key].bool_value = value
         elif isinstance(value, bytes):
-            values[key].string_value = value._value.decode('utf-8')
+            values[key].string_value = value.decode("utf-8")
         elif isinstance(value, str):
             values[key].string_value = value
         elif isinstance(value, (int, float)):
@@ -1069,13 +1253,13 @@ class Value:
             if isinstance(value._value, str):
                 values[key].string_value = value._value
             elif isinstance(value._value, bytes):
-                values[key].string_value = value._value.decode('utf-8')
+                values[key].string_value = value._value.decode("utf-8")
             elif value._value is None:
                 values[key].null_value = value._value.null_value
+            elif isinstance(value._value, bool):  # Must be before number check
+                values[key].bool_value = value._value
             elif isinstance(value._value, (int, float)):
                 values[key].number_value = value._value
-            elif isinstance(value._value, bool):
-                values[key].bool_value = value._value
             elif value._value is _Unknown:
                 self._setUnknown(key, value)
             else:
@@ -1083,23 +1267,23 @@ class Value:
         elif isinstance(value, Value):
             self._dependencies[key] = value
             match value._kind:
-                case 'struct_value' | 'Struct':
+                case "struct_value" | "Struct":
                     values[key].struct_value.Clear()
                     for k, v in value:
                         self[key][k] = v
-                case 'list_value' | 'ListValue':
+                case "list_value" | "ListValue":
                     values[key].list_value.Clear()
                     for ix, v in enumerate(value):
                         self[key][ix] = v
-                case 'string_value':
+                case "string_value":
                     values[key].string_value = value._value.string_value
-                case 'null_value':
+                case "null_value":
                     values[key].null_value = value._value.null_value
-                case 'number_value':
+                case "number_value":
                     values[key].number_value = value._value.number_value
-                case 'bool_value':
+                case "bool_value":
                     values[key].bool_value = value._value.bool_value
-                case 'Unknown':
+                case "Unknown":
                     self._setUnknown(key, value)
                 case _:
                     raise ValueError(f"Unexpected value kind: {value._kind}")
@@ -1109,41 +1293,43 @@ class Value:
     @property
     def _raw(self):
         match self._kind:
-            case 'struct_value':
+            case "struct_value":
                 return self._value.struct_value
-            case 'list_value':
+            case "list_value":
                 return self._value.list_value
-            case 'string_value':
+            case "string_value":
                 return self._value.string_value
-            case 'null_value':
+            case "null_value":
                 return self._value.null_value
-            case 'number_value':
+            case "number_value":
+                if self._value.number_value.is_integer():
+                    return int(self._value.number_value)
                 return self._value.number_value
-            case 'bool_value':
+            case "bool_value":
                 return self._value.bool_value
-            case 'Struct' | 'ListValue':
+            case "Struct" | "ListValue":
                 return self._value
-            case 'Unknown':
+            case "Unknown":
                 return _Unknown
 
     def _setUnknown(self, key, value):
         self._dependencies.pop(key, None)
         self._unknowns[key] = value
         match self._kind:
-            case 'struct_value':
+            case "struct_value":
                 if key in self._value.struct_value.fields:
                     del self._value.struct_value[key]
-            case 'Struct':
+            case "Struct":
                 if key in self._value.fields:
                     del self._value[key]
-            case 'list_value':
+            case "list_value":
                 if key < len(self._value.list_value.values):
                     self._value.list_value.values[key].Clear()
                 for ix in reversed(range(len(self._value.list_value.values))):
                     if ix not in self._unknowns:
                         break
                     del self._value.list_value[ix]
-            case 'ListValue':
+            case "ListValue":
                 if key < len(self._value.values):
                     self._value.values[key].Clear()
                 for ix in reversed(range(len(self._value.values))):
@@ -1158,30 +1344,30 @@ class Value:
         if self._readOnly:
             raise ValueError(f"{self._readOnly} is read only")
         kind = self._kind
-        if kind == 'Unknown':
+        if kind == "Unknown":
             return
         key = self._validate_key(key)
         if isinstance(key, str):
             match kind:
-                case 'struct_value':
+                case "struct_value":
                     if key in self._value.struct_value.fields:
                         del self._value.struct_value[key]
-                case 'Struct':
+                case "Struct":
                     if key in self._value.fields:
                         del self._value[key]
                 case _:
-                    raise ValueError(f"Invalid key \"{key}\" for kind: {self._kind}")
+                    raise ValueError(f'Invalid key "{key}" for kind: {self._kind}')
             self._cache.pop(key, None)
             self._dependencies.pop(key, None)
             self._unknowns.pop(key, None)
         elif isinstance(key, int):
             match kind:
-                case 'list_value':
+                case "list_value":
                     values = self._value.list_value
-                case 'ListValue':
+                case "ListValue":
                     values = self._value
                 case _:
-                    raise ValueError(f"Invalid key \"{key}\" for kind: {self._kind}")
+                    raise ValueError(f'Invalid key "{key}" for kind: {self._kind}')
             if key < len(values.values):
                 del values[key]
             self._cache.pop(key, None)
@@ -1190,12 +1376,14 @@ class Value:
             for ix in sorted(self._dependencies.keys()):
                 if ix > key:
                     self._cache.pop(ix, None)
-                    self._dependencies[ix - 1] = self._dependences[ix]
+                    self._dependencies[typing.cast(int, ix) - 1] = self._dependencies[
+                        ix
+                    ]
                     del self._dependencies[ix]
             for ix in sorted(self._unknowns.keys()):
                 if ix > key:
                     self._cache.pop(ix, None)
-                    self._unknowns[ix - 1] = self._unknowns[ix]
+                    self._unknowns[typing.cast(int, ix) - 1] = self._unknowns[ix]
                     del self._unknowns[ix]
             for ix in reversed(range(len(values.values))):
                 if ix not in self._unknowns:
@@ -1209,14 +1397,14 @@ class Value:
             raise ValueError(f"{self._readOnly} is read only")
         key = self._validate_key(key)
         if isinstance(key, str):
-            if self._ensure_map() == 'struct_value':
+            if self._ensure_map() == "struct_value":
                 fields = self._value.struct_value.fields
             else:
                 fields = self._value.fields
             fields[key].Clear()
             return fields[key]
         if isinstance(key, int):
-            if self._ensure_list() == 'list_value':
+            if self._ensure_list() == "list_value":
                 values = self._value.list_value.values
             else:
                 values = self._value.values
@@ -1241,55 +1429,61 @@ class Value:
 
     def _ensure_map(self):
         kind = self._kind
-        if kind == 'Unknown':
+        if kind == "Unknown":
             if self._parent is None:
-                self.__dict__['_value'] = google.protobuf.struct_pb2.Value()
+                self.__dict__["_value"] = google.protobuf.struct_pb2.Value()
             else:
-                self.__dict__['_value'] = self._parent._create_child(self._key)
-            if isinstance(self._value, google.protobuf.struct_pb2.Value) and self._value.WhichOneof('kind') is None:
+                self.__dict__["_value"] = self._parent._create_child(self._key)
+            if (
+                isinstance(self._value, google.protobuf.struct_pb2.Value)
+                and self._value.WhichOneof("kind") is None
+            ):
                 self._value.struct_value.Clear()
             kind = self._kind
-        if kind not in ('struct_value', 'Struct'):
+        if kind not in ("struct_value", "Struct"):
             raise ValueError(f"Invalid map kind: {kind}")
         return kind
 
     def _ensure_list(self):
         kind = self._kind
-        if kind == 'Unknown':
+        if kind == "Unknown":
             if self._parent is None:
-                self.__dict__['_value'] = google.protobuf.struct_pb2.Value()
+                self.__dict__["_value"] = google.protobuf.struct_pb2.Value()
             else:
-                self.__dict__['_value'] = self._parent._create_child(self._key)
-            if isinstance(self._value, google.protobuf.struct_pb2.Value) and self._value.WhichOneof('kind') is None:
+                self.__dict__["_value"] = self._parent._create_child(self._key)
+            if (
+                isinstance(self._value, google.protobuf.struct_pb2.Value)
+                and self._value.WhichOneof("kind") is None
+            ):
                 self._value.list_value.Clear()
             kind = self._kind
-        if kind not in ('list_value', 'ListValue'):
+        if kind not in ("list_value", "ListValue"):
             raise ValueError(f"Invalid list kind: {kind}")
         return kind
 
     @property
     def _kind(self):
         if isinstance(self._value, google.protobuf.struct_pb2.Value):
-            return self._value.WhichOneof('kind') or 'Unknown'
+            return self._value.WhichOneof("kind") or "Unknown"
         if isinstance(self._value, google.protobuf.struct_pb2.Struct):
-            return 'Struct'
+            return "Struct"
         if isinstance(self._value, google.protobuf.struct_pb2.ListValue):
-            return 'ListValue'
+            return "ListValue"
         if self._value is _Unknown:
-            return 'Unknown'
+            return "Unknown"
         raise ValueError(f"Unexpected value type: {self._value.__class__}")
 
     @property
     def _isUnknown(self):
-        return self._kind == 'Unknown'
+        return self._kind == "Unknown"
 
     @property
     def _isMap(self):
-        return self._kind in ('struct_value', 'Struct')
+        return self._kind in ("struct_value", "Struct")
 
     @property
     def _isList(self):
-        return self._kind in ('list_value', 'ListValue')
+        return self._kind in ("list_value", "ListValue")
 
     @property
     def _getUnknowns(self):
@@ -1307,8 +1501,8 @@ class Value:
         return unknowns
 
     @property
-    def _getDependencies(self):
-        dependencies = {}
+    def _getDependencies(self) -> dict[str, str]:
+        dependencies: dict[str, str] = {}
         for key, dependency in self._dependencies.items():
             dependencies[self._fullName(key)] = dependency._fullName()
         for key, unknown in self._unknowns.items():
@@ -1323,6 +1517,17 @@ class Value:
                     dependencies.update(value._getDependencies)
         return dependencies
 
+    def _setReadOnly(self, readOnly: bool | str):
+        self._readOnly = readOnly
+        if self._isMap:
+            for key, value in self:
+                if isinstance(value, Value):
+                    value._setReadOnly(readOnly)
+        elif self._isList:
+            for value in enumerate(self):
+                if isinstance(value, Value):
+                    value._setReadOnly(readOnly)
+
     def _patchUnknowns(self, patches):
         for key in list(self._unknowns.keys()):
             self[key] = patches[key]
@@ -1330,13 +1535,21 @@ class Value:
             for key, value in self:
                 if isinstance(value, Value) and len(value):
                     patch = patches[key]
-                    if isinstance(patch, Value) and patch._kind == value._kind and len(patch):
+                    if (
+                        isinstance(patch, Value)
+                        and patch._kind == value._kind
+                        and len(patch)
+                    ):
                         value._patchUnknowns(patch)
         elif self._isList:
             for ix, value in enumerate(self):
                 if isinstance(value, Value) and len(value):
                     patch = patches[ix]
-                    if isinstance(patch, Value) and patch._kind == value._kind and len(patch):
+                    if (
+                        isinstance(patch, Value)
+                        and patch._kind == value._kind
+                        and len(patch)
+                    ):
                         value._patchUnknowns(patch)
 
     def _renderUnknowns(self, trimFullName):
@@ -1353,13 +1566,13 @@ class Value:
                     value._renderUnknowns(trimFullName)
 
 
-def _formatObject(object, spec='yaml'):
+def _formatObject(object, spec="yaml"):
     match spec:
-        case 'json':
+        case "json":
             return json.dumps(object, indent=2, cls=_JSONEncoder)
-        case 'jsonc':
-            return json.dumps(object, separators=(',', ':'), cls=_JSONEncoder)
-        case 'protobuf':
+        case "jsonc":
+            return json.dumps(object, separators=(",", ":"), cls=_JSONEncoder)
+        case "protobuf":
             if isinstance(object, Message):
                 return str(object._message)
             if isinstance(object, (MapMessage, RepeatedMessage)):
@@ -1372,94 +1585,98 @@ def _formatObject(object, spec='yaml'):
 
 
 class _JSONEncoder(json.JSONEncoder):
-    def default(self, object):
-        if isinstance(object, (Message, MapMessage)):
-            if object:
-                return {key: value for key, value in object}
+    def default(self, o):
+        if isinstance(o, (Message, MapMessage)):
+            if o:
+                return {key: value for key, value in o}
             return None
-        if isinstance(object, RepeatedMessage):
-            if object:
-                return [value for value in object]
+        if isinstance(o, RepeatedMessage):
+            if o:
+                return [value for value in o]
             return None
-        if isinstance(object, FieldMessage):
-            return object._value
-        if isinstance(object, Value):
-            match object._kind:
-                case 'struct_value' | 'Struc':
-                    return {key: value for key, value in object}
-                case 'list_value' | 'ListValue':
-                    return [value for value in object]
-                case 'string_value':
-                    return object._value.string_value
-                case 'null_value':
+        if isinstance(o, FieldMessage):
+            return o._value
+        if isinstance(o, Value):
+            match o._kind:
+                case "struct_value" | "Struct":
+                    return {key: value for key, value in o}
+                case "list_value" | "ListValue":
+                    return [value for value in o]
+                case "string_value":
+                    return o._value.string_value
+                case "null_value":
                     return None
-                case 'number_value':
-                    value = object._value.number_value
+                case "number_value":
+                    value = o._value.number_value
                     if value.is_integer():
                         value = int(value)
                     return value
-                case 'bool_value':
-                    return object._value.bool_value
-                case 'Unknown':
-                    return '<<UNKNOWN>>'
+                case "bool_value":
+                    return o._value.bool_value
+                case "Unknown":
+                    return "<<UNKNOWN>>"
                 case _:
-                    return '<<UNEXPECTED>>'
-        if isinstance(object, datetime.datetime):
-            return object.isoformat()
-        return super(_JSONEncoder, self).default(object)
+                    return "<<UNEXPECTED>>"
+        if isinstance(o, datetime.datetime):
+            return o.isoformat()
+        if isinstance(o, bytes):
+            return o.decode("utf-8")
+        return super().default(o)
 
 
 class _Dumper(yaml.SafeDumper):
-
     def represent_str(self, data):
-        return self.represent_scalar('tag:yaml.org,2002:str', data, '|' if '\n' in data else None)
+        return self.represent_scalar(
+            "tag:yaml.org,2002:str", data, "|" if "\n" in data else None
+        )
 
-    def represent_message_dict(self, message):
+    def represent_message_dict(self, message: Message | MapMessage):
         return self.represent_dict({key: value for key, value in message})
 
-    def represent_message_list(self, messages):
+    def represent_message_list(self, messages: RepeatedMessage):
         return self.represent_list([value for value in messages])
 
-    def represent_message_field(self, field):
+    def represent_message_field(self, field: FieldMessage):
         if isinstance(field._value, str):
             return self.represent_str(field._value)
         if isinstance(field._value, bytes):
             return self.represent_binary(field._value)
         if field._value is None:
-            return self.represent_none()
+            return self.represent_none(field._value)
+        if isinstance(field._value, bool):  # Must be before number check
+            return self.represent_bool(bool(field._value))
         if isinstance(field._value, int):
             return self.represent_int(field._value)
         if isinstance(field._value, float):
             if field._value.is_integer():
                 return self.represent_int(int(field._value))
             return self.represent_float(field._value)
-        if isinstance(field._value, bool):
-            return self.represent_bool(field._value)
         if field._value is _Unknown:
-            return self.represent_str('<<UNKNOWN>>')
-        return self.represent_str('<<UNEXPECTED>>')
+            return self.represent_str("<<UNKNOWN>>")
+        return self.represent_str("<<UNEXPECTED>>")
 
-    def represent_value(self, value):
+    def represent_value(self, value: Value):
         match value._kind:
-            case 'struct_value' | 'Struct':
-                return self.represent_dict({k:v for k,v in value})
-            case 'list_value' | 'ListValue':
+            case "struct_value" | "Struct":
+                return self.represent_dict({k: v for k, v in value})
+            case "list_value" | "ListValue":
                 return self.represent_list([v for v in value])
-            case 'string_value':
+            case "string_value":
                 return self.represent_str(value._value.string_value)
-            case 'null_value':
+            case "null_value":
                 return self.represent_none(None)
-            case 'number_value':
+            case "number_value":
                 value = value._value.number_value
                 if value.is_integer():
                     return self.represent_int(int(value))
                 return self.represent_float(value)
-            case 'bool_value':
-                return self.represent_bool(value._value.bool_value)
-            case 'Unknown':
-                return self.represent_str('<<UNKNOWN>>')
+            case "bool_value":
+                return self.represent_bool(bool(value._value.bool_value))
+            case "Unknown":
+                return self.represent_str("<<UNKNOWN>>")
             case _:
-                return self.represent_str('<<UNEXPECTED>>')
+                return self.represent_str("<<UNEXPECTED>>")
+
 
 _Dumper.add_representer(str, _Dumper.represent_str)
 _Dumper.add_representer(Message, _Dumper.represent_message_dict)