name = Blackboard.absolute_name(super().__getattribute__("namespace"), name)
if (name not in super().__getattribute__("write")) and (
    name not in super().__getattribute__("exclusive")
):
    if Blackboard.activity_stream is not None:
        Blackboard.activity_stream.push(
            self._generate_activity_item(name, ActivityType.ACCESS_DENIED)
        )
    raise AttributeError(
        "client '{}' does not have write access to '{}'".format(self.name, name)
    )
remapped_name = super().__getattribute__("remappings")[name]
if Blackboard.activity_stream is not None:
    if remapped_name in Blackboard.storage.keys():
        Blackboard.activity_stream.push(
            self._generate_activity_item(
                key=remapped_name,
                activity_type=ActivityType.WRITE,
                previous_value=Blackboard.storage[remapped_name],
                current_value=value,
            )
        )
    else:
        Blackboard.activity_stream.push(
            self._generate_activity_item(
                key=remapped_name,
                activity_type=ActivityType.INITIALISED,
                current_value=value,
            )
        )
Blackboard.storage[remapped_name] = value

name = Blackboard.absolute_name(super().__getattribute__("namespace"), name)
read_key = False
write_key = False
if name in super().__getattribute__("read"):
    read_key = True
elif name in super().__getattribute__("write"):
    write_key = True
elif name in super().__getattribute__("exclusive"):
    write_key = True
else:
    if name in super().__getattribute__("namespaces"):
        return IntermediateVariableFetcher(blackboard=self, namespace=name)
    if Blackboard.activity_stream is not None:
        Blackboard.activity_stream.push(
            self._generate_activity_item(name, ActivityType.ACCESS_DENIED)
        )
    raise AttributeError(
        "client '{}' does not have read/write access to '{}'".format(
            self.name, name
        )
    )
remapped_name = super().__getattribute__("remappings")[name]
try:
    if write_key:
        if Blackboard.activity_stream is not None:
            if utilities.is_primitive(Blackboard.storage[remapped_name]):
                activity_type = ActivityType.READ
            else:  # could be a nested class object being accessed to write an attribute
                activity_type = ActivityType.ACCESSED
            Blackboard.activity_stream.push(
                self._generate_activity_item(
                    key=remapped_name,
                    activity_type=activity_type,
                    current_value=Blackboard.storage[remapped_name],
                )
            )
        return Blackboard.storage[remapped_name]
    if read_key:
        if Blackboard.activity_stream is not None:
            Blackboard.activity_stream.push(
                self._generate_activity_item(
                    key=remapped_name,
                    activity_type=ActivityType.READ,
                    current_value=Blackboard.storage[remapped_name],
                )
            )
        return Blackboard.storage[remapped_name]
except KeyError as e:
    if Blackboard.activity_stream is not None:
        Blackboard.activity_stream.push(
            self._generate_activity_item(remapped_name, ActivityType.NO_KEY)
        )
    raise KeyError(
        f"client '{self.name}' tried to access '{remapped_name}' but it does not yet exist on the blackboard"
    ) from e

name = Blackboard.absolute_name(super().__getattribute__("namespace"), name)
name_components = name.split(".")
key = name_components[0]
key_attributes = ".".join(name_components[1:])
if (key not in super().__getattribute__("write")) and (
    key not in super().__getattribute__("exclusive")
):
    if Blackboard.activity_stream is not None:
        Blackboard.activity_stream.push(
            self._generate_activity_item(key, ActivityType.ACCESS_DENIED)
        )
    raise AttributeError(
        "client '{}' does not have write access to '{}'".format(self.name, name)
    )
remapped_key = super().__getattribute__("remappings")[key]
if not overwrite:
    if remapped_key in Blackboard.storage:
        if Blackboard.activity_stream is not None:
            Blackboard.activity_stream.push(
                self._generate_activity_item(
                    key=remapped_key,
                    activity_type=ActivityType.NO_OVERWRITE,
                    current_value=Blackboard.storage[remapped_key],
                )
            )
        return False
if not key_attributes:
    setattr(self, key, value)
    return True
else:
    blackboard_object = getattr(self, key)
    try:
        setattr(blackboard_object, key_attributes, value)
        return True
    except AttributeError:  # when the object doesn't have the attributes
        return False

# 1.解析并获取映射key
key = Blackboard.absolute_name(super().__getattribute__("namespace"), key)
super().__getattribute__("remappings")[key] = (
    key if remap_to is None else remap_to
)
remapped_key = super().__getattribute__("remappings")[key]
# 2.判断权限并把key加入权限集合
if access == common.Access.READ:
    super().__getattribute__("read").add(key)
    Blackboard.metadata.setdefault(remapped_key, KeyMetaData())
    Blackboard.metadata[remapped_key].read.add(
        super().__getattribute__("unique_identifier")
    )
# 如果是写权限，则判断key是否存在于`exclusive`即互斥写中，如果存在则抛异常
elif access == common.Access.WRITE:
    conflicts = set()
    try:
        for unique_identifier in Blackboard.metadata[remapped_key].exclusive:
            conflicts.add(Blackboard.clients[unique_identifier])
            if conflicts:
                raise AttributeError(
                    (
                        f"'{super().__getattribute__('name')}' requested write on key '{remapped_key}', "
                        f"but this key is already associated with an exclusive writer[{conflicts}]"
                    )
                )
    except KeyError:
        pass  # no readers or writers on the key yet
    # 更新写权限集合，更新metadata
    super().__getattribute__("write").add(key)
    Blackboard.metadata.setdefault(remapped_key, KeyMetaData())
    Blackboard.metadata[remapped_key].write.add(
        super().__getattribute__("unique_identifier")
    )
# 如果是互斥写权限，则判断key是否存在于写、互斥写中，如果存在抛异常
elif access == common.Access.EXCLUSIVE_WRITE:
    try:
        key_metadata = Blackboard.metadata[remapped_key]
        conflicts = set()
        for unique_identifier in key_metadata.write | key_metadata.exclusive:
            conflicts.add(Blackboard.clients[unique_identifier])
        if conflicts:
            raise AttributeError(
                "'{}' requested exclusive write on key '{}', but this key is already associated [{}]".format(
                    super().__getattribute__("name"), remapped_key, conflicts
                )
            )
    except KeyError:
        pass  # no readers or writers on the key yet
    # 更新互斥写权限集合，更新metadata
    super().__getattribute__("exclusive").add(key)
    Blackboard.metadata.setdefault(remapped_key, KeyMetaData())
    Blackboard.metadata[remapped_key].exclusive.add(
        super().__getattribute__("unique_identifier")
    )
else:
    raise TypeError(
        "access argument is of incorrect type [{}]".format(type(access))
    )
# 如果required为True，则为必要字段，存于required变量内
if required:
    super().__getattribute__("required").add(key)
# 更新命名空间
self._update_namespaces(added_key=key)

key = Blackboard.absolute_name(super().__getattribute__("namespace"), key)
remapped_key = super().__getattribute__("remappings")[key]
super().__getattribute__("read").discard(
    key
)  # doesn't throw exceptions if it not present
super().__getattribute__("write").discard(key)
super().__getattribute__("exclusive").discard(key)
Blackboard.metadata[remapped_key].read.discard(
    super().__getattribute__("unique_identifier")
)
Blackboard.metadata[remapped_key].write.discard(
    super().__getattribute__("unique_identifier")
)
Blackboard.metadata[remapped_key].exclusive.discard(
    super().__getattribute__("unique_identifier")
)
if (
    (not Blackboard.metadata[remapped_key].read)
    and (not Blackboard.metadata[remapped_key].write)
    and (not Blackboard.metadata[remapped_key].exclusive)
):
    del Blackboard.metadata[remapped_key]
    if clear:
        try:
            del Blackboard.storage[remapped_key]
        except KeyError:
            pass  # perfectly legitimate for a registered key to not exist on the blackboard
del super().__getattribute__("remappings")[key]
if update_namespace_cache:
    self._update_namespaces()

import py_trees

a = py_trees.blackboard.Client(name="a", namespace="na")
b = py_trees.blackboard.Client(name="b", namespace="na")

a.register_key("x", access=py_trees.common.Access.WRITE)
b.register_key("x", access=py_trees.common.Access.WRITE)

a.x = 20

print(a.x)  # >> 20
print(b.x)  # >> 20 可以看出针对同样的命名空间和key，则设置的值是一样的

a.unregister_key("x", False) 
print(a.x) # >> KeyError 如果注销key，首先a客户端已无此属性
print(b.x) # >> 20 而b客户端仍有此属性 这说明了Blackboard.metadata[remapped_key].xx为集合的重要性

# 接下来我们看clear参数
a.unregister_key("x", True)  # 如果clear=True，注意此时客户端a和b都拥有x的读权限，那么这里即使设置clear为True，则仍未清理x因为Blackboard.metadata[remapped_key].write仍有b客户端id
# 如果此时重新注册,不用赋值，a.x仍然存在
a.register_key("x", access=py_trees.common.Access.WRITE)
print(a.x)  # >> 20

# 如果
a.register_key("y", access=py_trees.common.Access.WRITE)
a.y = 10
a.unregister_key("y", True)
a.register_key("y", access=py_trees.common.Access.WRITE)
print(a.y) # >> KeyError 已经清理y，没有重新赋值，则报错