Interlinks

abses.human.links._LinkProxy

_LinkProxy(node, model)

用于管理节点上链接的代理类。

提供创建、检查和移除链接的便捷方法。

使用节点的唯一 ID 来优化链接操作。

Attributes:

Name	Type	Description
node	_LinkNode	此代理管理链接的节点。
model	MainModel	主模型实例。
human	LinkContainerProtocol	链接容器实例。

Source code in abses/human/links.py

def __init__(self, node: _LinkNode, model: MainModel) -> None:
    self.node: _LinkNode = node
    self.model: MainModel = model
    self.human: LinkContainerProtocol = model.human
    # 确保节点已缓存
    self.human._cache_node(node)

owning

owning(direction=None)

此对象拥有的链接。

Parameters:

Name	Type	Description	Default
direction	Direction	链接的方向（'in' 或 'out'）。 如果为 None，则返回出向链接和入向链接。	None

Returns:

Type	Description
Tuple[str, ...]	此对象拥有的链接。

Source code in abses/human/links.py

def owning(self, direction: Direction = None) -> Tuple[str, ...]:
    """此对象拥有的链接。

    Parameters:
        direction:
            链接的方向（'in' 或 'out'）。
            如果为 None，则返回出向链接和入向链接。

    Returns:
        此对象拥有的链接。
    """
    return self.human.owns_links(self.node, direction=direction)

get

get(link_name=None, direction=None, default=...)

获取链接的节点。

Parameters:

Name	Type	Description	Default
link_name	Optional[Union[str, List[str]]]	要获取的链接类型。如果为 None，则获取所有类型。	None
direction	Optional[str]	要获取的链接方向: - "out": 出向链接 - "in": 入向链接 - None: 两个方向	None
default	Any	如果未找到链接类型，则返回的值。	...

Returns:

Type	Description
ActorsList	链接节点的列表。

Source code in abses/human/links.py

def get(
    self,
    link_name: Optional[Union[str, List[str]]] = None,
    direction: Optional[str] = None,
    default: Any = ...,
) -> ActorsList:
    """获取链接的节点。

    Args:
        link_name: 要获取的链接类型。如果为 None，则获取所有类型。
        direction: 要获取的链接方向:
            - "out": 出向链接
            - "in": 入向链接
            - None: 两个方向
        default: 如果未找到链接类型，则返回的值。

    Returns:
        链接节点的列表。
    """
    agents = self.human.linked(
        self.node, link_name, direction=direction, default=default
    )

    # 确保agents是可迭代的
    if hasattr(agents, "__iter__"):
        return ActorsList(self.model, agents)
    else:
        # 如果是Mock对象或其他不可迭代对象，返回空列表
        return ActorsList(self.model, [])

has

has(link_name, node=None)

检查当前节点是否有特定类型的链接，或者是否与另一个节点有链接。

Parameters:

Name	Type	Description	Default
link_name	str	要检查的链接类型。	required
node	Optional[LinkingNode]	要检查是否与当前节点有链接的节点。 如果为 None，则检查当前节点是否有任何链接。	None

Returns:

Name	Type	Description
tuple	Tuple[bool, bool]	两个布尔值的元组。 如果从我到其他存在链接，则第一个元素为 True。 如果从其他到我存在链接，则第二个元素为 True。

Source code in abses/human/links.py

def has(
    self, link_name: str, node: Optional[LinkingNode] = None
) -> Tuple[bool, bool]:
    """检查当前节点是否有特定类型的链接，或者是否与另一个节点有链接。

    Parameters:
        link_name:
            要检查的链接类型。
        node:
            要检查是否与当前节点有链接的节点。
            如果为 None，则检查当前节点是否有任何链接。

    Returns:
        tuple:
            两个布尔值的元组。
            如果从我到其他存在链接，则第一个元素为 True。
            如果从其他到我存在链接，则第二个元素为 True。
    """
    if node is None:
        try:
            has_in = link_name in self.owning("in")
            has_out = link_name in self.owning("out")
        except TypeError:
            # 如果owning返回的不是可迭代对象，则假设没有链接
            has_in = False
            has_out = False
        return has_out, has_in

    # 直接调用human.has_link并确保返回元组
    result = self.human.has_link(link_name, self.node, node)
    # 如果结果不是元组，则创建一个默认元组
    if not isinstance(result, tuple):
        return (False, False)
    return result

to

to(node, link_name, mutual=False)

创建到另一个节点的出向链接。

Parameters:

Name	Type	Description	Default
node	LinkingNode	要链接到的目标节点。	required
link_name	str	要创建的链接类型。	required
mutual	bool	如果为 True，则在两个方向上创建链接。	False

Source code in abses/human/links.py

def to(self, node: LinkingNode, link_name: str, mutual: bool = False) -> None:
    """创建到另一个节点的出向链接。

    Args:
        node: 要链接到的目标节点。
        link_name: 要创建的链接类型。
        mutual: 如果为 True，则在两个方向上创建链接。
    """
    self.human.add_a_link(
        link_name=link_name, source=self.node, target=node, mutual=mutual
    )

by

by(node, link_name, mutual=False)

使此节点被另一个节点链接。

Parameters:

Name	Type	Description	Default
node	LinkingNode	要链接的节点。	required
link_name	str	链接的名称。	required
mutual	bool	链接是否是互相的。默认为 False。	False

Source code in abses/human/links.py

def by(self, node: LinkingNode, link_name: str, mutual: bool = False) -> None:
    """使此节点被另一个节点链接。

    Parameters:
        node:
            要链接的节点。
        link_name:
            链接的名称。
        mutual:
            链接是否是互相的。默认为 False。
    """
    self.human.add_a_link(
        link_name=link_name, source=node, target=self.node, mutual=mutual
    )

unlink

unlink(node, link_name, mutual=False)

移除我和另一个节点之间的链接。

Parameters:

Name	Type	Description	Default
node	LinkingNode	要解除链接的节点。	required
link_name	str	链接的名称。	required
mutual	bool	是否互相删除链接。默认为 False。	False

Raises:

Type	Description
ABSESpyError	如果从源到目标的链接不存在。

Source code in abses/human/links.py

def unlink(self, node: LinkingNode, link_name: str, mutual: bool = False):
    """移除我和另一个节点之间的链接。

    Parameters:
        node:
            要解除链接的节点。
        link_name:
            链接的名称。
        mutual:
            是否互相删除链接。默认为 False。

    Raises:
        ABSESpyError:
            如果从源到目标的链接不存在。
    """
    # 检查链接是否存在
    has_in, has_out = self.has(link_name, node)
    if not has_in and not has_out:
        from abses.utils.errors import ABSESpyError

        raise ABSESpyError(
            f"Link '{link_name}' between {self.node} and {node} not found."
        )

    self.human.remove_a_link(
        link_name=link_name, source=self.node, target=node, mutual=mutual
    )

clean

clean(link_name=None, direction=None)

清理此节点的所有相关链接。

Parameters:

Name	Type	Description	Default
link_name	Optional[str]	链接的名称。 如果为 None，则清理节点的所有相关链接。	None
direction	Direction	链接的方向（'in' 或 'out'）。 如果为 None，则清理两个方向（出向链接和入向链接）。	None

Raises:

Type	Description
ValueError	如果方向不是 'in' 或 'out'。

Source code in abses/human/links.py

def clean(self, link_name: Optional[str] = None, direction: Direction = None):
    """清理此节点的所有相关链接。

    Parameters:
        link_name:
            链接的名称。
            如果为 None，则清理节点的所有相关链接。
        direction:
            链接的方向（'in' 或 'out'）。
            如果为 None，则清理两个方向（出向链接和入向链接）。

    Raises:
        ValueError:
            如果方向不是 'in' 或 'out'。
    """
    self.human.clean_links_of(self.node, link_name=link_name, direction=direction)