From 7204fa22b9d48541e970c3b526d9fd8b28a288d3 Mon Sep 17 00:00:00 2001 From: NikitaZotov Date: Thu, 14 Nov 2024 15:41:49 +0300 Subject: [PATCH] Review fixes --- README.md | 42 ++++++++++------------ docs/changelog.md | 4 +-- src/sc_kpm/sc_agent.py | 4 +-- src/sc_kpm/sc_keynodes.py | 5 ++- src/sc_kpm/sc_sets/sc_numbered_set.py | 2 +- src/sc_kpm/sc_sets/sc_oriented_set.py | 44 ++++++++++++------------ src/sc_kpm/sc_sets/sc_set.py | 10 +++--- src/sc_kpm/sc_sets/sc_structure.py | 2 +- src/sc_kpm/utils/__init__.py | 17 ++++++++- src/sc_kpm/utils/action_utils.py | 4 +-- src/sc_kpm/utils/common_utils.py | 8 ++--- tests/test_utils/test_action_utils.py | 2 +- tests/test_utils/test_common_utils.py | 6 ++-- tests/test_utils/test_iteration_utils.py | 4 +-- 14 files changed, 84 insertions(+), 70 deletions(-) diff --git a/README.md b/README.md index f6f4095..ce201c3 100644 --- a/README.md +++ b/README.md @@ -78,12 +78,9 @@ class ScAgentClassicTest(ScAgentClassic): For the ScAgent initialization you should define the sc-element and the type of the ScEvent. -For the ScAgentClassic initialization -you should define the identifier of the action class node and arguments of the ScAgent. -`event_class` is set to the `action_initiated` keynode by default. -`event_type` is set to the `ScEventType.AFTER_GENERATE_OUTGOING_ARC` type by default. +For the ScAgentClassic initialization you should define the identifier of the action class node and arguments of the ScAgent. `subscription_element` is set to the `action_initiated` keynode by default. `event_class` is set to the `ScEventType.AFTER_GENERATE_OUTGOING_ARC` type by default. -**ClassicScAgent checks its action element automatically and doesn't run `on_event` method if checking fails.** +**ScAgentClassic checks its action element automatically and doesn't run `on_event` method if checking fails.** ```python from sc_client.constants import sc_type @@ -94,7 +91,7 @@ action_class = ScKeynodes.resolve("test_class", sc_type.CONST_NODE_CLASS) agent = ScAgentTest(action_class, ScEventType.AFTER_GENERATE_OUTGOING_ARC) classic_agent = ScAgentClassicTest("classic_test_class") -classic_agent_ingoing = ScAgentClassicTest("classic_test_class", ScEventType.AFTER_GENERATE_INCOMING_ARC) +classic_agent_incoming = ScAgentClassicTest("classic_test_class", ScEventType.AFTER_GENERATE_INCOMING_ARC) ``` ### ScModule @@ -376,7 +373,7 @@ assert numbered_set.elements_list == elements ![numbered_set_example](docs/schemes/png/numbered_set.png) Class for handling sc-numbered-set construction. -Set-node is connectord with numerating each element with rrel node. +Set-node is set with numerating each element with rrel node. Easy access to elements by index (index i is marked with rrel(i + 1)) ```python @@ -462,14 +459,14 @@ For generating links with string type content (by default) use these functions: def generate_link( content: Union[str, int], content_type: ScLinkContentType = ScLinkContentType.STRING, - link_type: ScType = sc_type.LINK_CONST + link_type: ScType = sc_type.CONST_NODE_LINK ) -> ScAddr: ... def generate_links( *contents: Union[str, int], content_type: ScLinkContentType = ScLinkContentType.STRING, - link_type: ScType = sc_type.LINK_CONST, + link_type: ScType = sc_type.CONST_NODE_LINK, ) -> List[ScAddr]: ... ``` @@ -482,7 +479,7 @@ from sc_kpm.utils import generate_link, generate_links msg = generate_link("hello") # ScAddr(...) four = generate_link(4, ScLinkContentType.INT) # ScAddr(...) -water = generate_link("water", link_type=sc_type.LINK_VAR) # ScAddr(...) +water = generate_link("water", link_type=sc_type.VAR_NODE_LINK) # ScAddr(...) names = generate_links("Sam", "Pit") # [ScAddr(...), ScAddr(...)] ``` @@ -500,6 +497,8 @@ def generate_role_relation(src: ScAddr, trg: ScAddr, *rrel_nodes: ScAddr) -> ScA def generate_non_role_relation(src: ScAddr, trg: ScAddr, *nrel_nodes: ScAddr) -> ScAddr: ... ``` +These methods return ScAddr of sc-arc generated between `src` and `trg` sc-elements. + ```python from sc_client.constants import sc_type from sc_kpm import ScKeynodes @@ -514,9 +513,9 @@ rrel = generate_role_relation(src, trg, ScKeynodes.rrel_index(1)) # ScAddr(...) nrel = generate_non_role_relation(src, trg, generate_node(sc_type.CONST_NODE_NON_ROLE)) # ScAddr(...) ``` -### Deleting utils +### Erasing utils -If you want to remove all connectors between two nodes, which define by their type use +If you want to erase all connectors between two elements, which define by their type use ```python def erase_connectors(source: ScAddr, target: ScAddr, *connector_types: ScType) -> bool: ... @@ -536,7 +535,7 @@ erase_connectors(src, trg, sc_type.CONST_PERM_POS_ARC) # True ### Getting connectors -For getting connector or connectors between two nodes use: +For getting connector or connectors between two elements use: ```python def get_connector(source: ScAddr, target: ScAddr, connector_type: ScType) -> ScAddr: ... @@ -570,7 +569,7 @@ Get target element by source element and relation: def get_element_by_role_relation(src: ScAddr, rrel_node: ScAddr) -> ScAddr: ... -def get_element_by_non_role_relation(src: ScAddr, nrel_node: ScAddr) -> ScAddr: ... +def search_element_by_non_role_relation(src: ScAddr, nrel_node: ScAddr) -> ScAddr: ... ``` ```python @@ -578,7 +577,7 @@ from sc_client.constants import sc_type from sc_kpm import ScKeynodes from sc_kpm.identifiers import CommonIdentifiers from sc_kpm.utils import generate_nodes, generate_role_relation, generate_non_role_relation -from sc_kpm.utils import get_element_by_role_relation, get_element_by_non_role_relation +from sc_kpm.utils import get_element_by_role_relation, search_element_by_non_role_relation src, trg_rrel, trg_nrel = generate_nodes(*[sc_type.CONST_NODE] * 3) rrel = generate_role_relation(src, trg_rrel, ScKeynodes.rrel_index(1)) # ScAddr(...) @@ -586,7 +585,7 @@ nrel = generate_non_role_relation(src, trg_nrel, ScKeynodes[CommonIdentifiers.NR result_rrel = get_element_by_role_relation(src, ScKeynodes.rrel_index(1)) # ScAddr(...) assert result_rrel == trg_rrel -result_nrel = get_element_by_non_role_relation(src, ScKeynodes[CommonIdentifiers.NREL_SYSTEM_IDENTIFIER]) # ScAddr(...) +result_nrel = search_element_by_non_role_relation(src, ScKeynodes[CommonIdentifiers.NREL_SYSTEM_IDENTIFIER]) # ScAddr(...) assert result_nrel == trg_nrel ``` @@ -608,7 +607,7 @@ content = get_link_content_data(water) # "water" ### Getting element system identifier -For getting element system identifier of keynode use: +For getting system identifier of keynode use: ```python def get_element_system_identifier(addr: ScAddr) -> str: ... @@ -617,12 +616,9 @@ def get_element_system_identifier(addr: ScAddr) -> str: ... ```python from sc_client.constants import sc_type from sc_kpm import ScKeynodes -from sc_kpm.utils import generate_node from sc_kpm.utils import get_element_system_identifier -lang_en = generate_node(sc_type.CONST_NODE_CLASS) # ScAddr(...) idtf = get_element_system_identifier(lang_en) # "lang_en" -assert ScKeynodes[idtf] == lang_en ``` ## Action utils @@ -713,8 +709,8 @@ from sc_kpm.utils import generate_node from sc_kpm.utils.action_utils import generate_action_result, get_action_result from sc_kpm.sc_sets import ScStructure -action_node = generate_node(sc_type.CONST_NODE_STRUCTURE) -result_element = generate_node(sc_type.CONST_NODE_STRUCTURE) +action_node = generate_node(sc_type.CONST_NODE) +result_element = generate_node(sc_type.CONST_NODE) generate_action_result(action_node, result_element) result = get_action_result(action_node) result_elements = ScStructure(result).elements_set @@ -734,7 +730,7 @@ def call_agent( ) -> ScAddr: ... ``` -Agent wait function: Waits for generation of arc to reaction node for some seconds. +Agent wait function: Waits for generation of arc from reaction node for some seconds. Default reaction_node is `action_finished`. ```python diff --git a/docs/changelog.md b/docs/changelog.md index 403de35..2debc57 100644 --- a/docs/changelog.md +++ b/docs/changelog.md @@ -26,13 +26,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 | get_edges | get_connectors | | get_system_idtf | get_element_system_identifier | | search_norole_relation_template | search_non_role_relation_template | - | get_element_by_norole_relation | get_element_by_non_role_relation | + | get_element_by_norole_relation | search_element_by_non_role_relation | | delete_edges | erase_connectors | | delete | erase | ### Added - ScKeynodes method `erase` -- Common utils methods: `generate_nodes`, `generate_node`, `generate_links`, `generate_link`, `generate_connectors`, `generate_connector`, `generate_binary_relation`, `generate_role_relation`, `generate_non_role_relation`, `check_connector`, `get_connector`, `get_connectors`, `get_element_system_identifier`, `search_non_role_relation_template`, `get_element_by_non_role_relation`, `erase_connectors` +- Common utils methods: `generate_nodes`, `generate_node`, `generate_links`, `generate_link`, `generate_connectors`, `generate_connector`, `generate_binary_relation`, `generate_role_relation`, `generate_non_role_relation`, `check_connector`, `get_connector`, `get_connectors`, `get_element_system_identifier`, `search_non_role_relation_template`, `search_element_by_non_role_relation`, `erase_connectors` - Action utils methods: `generate_action_result`, `generate_action` ### Deprecated diff --git a/src/sc_kpm/sc_agent.py b/src/sc_kpm/sc_agent.py index b08745d..165426f 100644 --- a/src/sc_kpm/sc_agent.py +++ b/src/sc_kpm/sc_agent.py @@ -12,7 +12,7 @@ from sc_client.constants import sc_type from sc_client.constants.common import ScEventType from sc_client.constants.exceptions import InvalidValueError -from sc_client.models import ScAddr, ScEvent, ScEventSubscriptionParams +from sc_client.models import ScAddr, ScEventSubscription, ScEventSubscriptionParams from sc_kpm.identifiers import ActionStatus from sc_kpm.sc_keynodes import Idtf, ScKeynodes @@ -24,7 +24,7 @@ class ScAgentAbstract(ABC): def __init__(self, event_element: ScAddr, event_type: ScEventType) -> None: self._event_element = event_element self._event_type = event_type - self._event: Optional[ScEvent] = None + self._event: Optional[ScEventSubscription] = None self.logger = getLogger(f"{self.__module__}.{self.__class__.__name__}") @abstractmethod diff --git a/src/sc_kpm/sc_keynodes.py b/src/sc_kpm/sc_keynodes.py index cfdc9b7..afcfe5e 100644 --- a/src/sc_kpm/sc_keynodes.py +++ b/src/sc_kpm/sc_keynodes.py @@ -24,6 +24,7 @@ def __init__(cls, *args, **kwargs) -> None: super().__init__(*args, **kwargs) cls._dict: Dict[Idtf, ScAddr] = {} cls._logger: Logger = getLogger(f"{__name__}.{cls.__name__}") + cls._min_rrel_index: int = 1 cls._max_rrel_index: int = 10 def __call__(cls, *args, **kwargs) -> None: @@ -71,11 +72,13 @@ def resolve(cls, identifier: Idtf, sc_type: Optional[ScType]) -> ScAddr: return addr def rrel_index(cls, index: int) -> ScAddr: - """Get rrel_i node. Max rrel index is 10""" + """Get rrel_i node. Max rrel index is 10. Min rrel is 1.""" if not isinstance(index, int): raise TypeError("Index of rrel node must be int") if index > cls._max_rrel_index: raise KeyError(f"You cannot use rrel more than {cls._max_rrel_index}") + if index < 1: + raise KeyError(f"You cannot use rrel less than {cls._min_rrel_index}") return cls.resolve(f"rrel_{index}", CONST_NODE_ROLE) # pylint: disable=no-value-for-parameter diff --git a/src/sc_kpm/sc_sets/sc_numbered_set.py b/src/sc_kpm/sc_sets/sc_numbered_set.py index 7fc5429..1ad525d 100644 --- a/src/sc_kpm/sc_sets/sc_numbered_set.py +++ b/src/sc_kpm/sc_sets/sc_numbered_set.py @@ -13,7 +13,7 @@ class ScNumberedSet(ScSet): ScNumberedSet is a class for handling numbered set structure in kb. It has main set_node and arc elements: - Edge to each element marked with 'rrel_1', 'rrel_2', and so on nodes. + Arcs to each element marked with 'rrel_1', 'rrel_2', and so on nodes. """ def add(self, *elements: ScAddr) -> None: diff --git a/src/sc_kpm/sc_sets/sc_oriented_set.py b/src/sc_kpm/sc_sets/sc_oriented_set.py index 98bddda..f3380c1 100644 --- a/src/sc_kpm/sc_sets/sc_oriented_set.py +++ b/src/sc_kpm/sc_sets/sc_oriented_set.py @@ -15,7 +15,7 @@ class ScOrientedSet(ScSet): ScOrientedSet is a class for handling oriented set structure in kb. It has main set_node and arc elements: - Edge to the first element marked with 'rrel_1' node. + Arc to the first element marked with 'rrel_1' node. The other have arcs between arcs from set_node marked with 'nrel_basic_sequence'. """ @@ -23,14 +23,14 @@ def add(self, *elements: ScAddr) -> None: """Add elements to ScOrientedSet""" if elements: elements_iterator = iter(elements) - current_connector = ( + current_arc = ( self._generate_first_element_arc(next(elements_iterator)) if self.is_empty() else self._get_last_arc_and_erase_rrel_last() ) for element in elements_iterator: - current_connector = self._generate_next_arc(current_connector, element) - self._mark_connector_with_rrel_last(current_connector) + current_arc = self._generate_next_arc(current_arc, element) + self._mark_arc_with_rrel_last(current_arc) def __iter__(self) -> Iterator[ScAddr]: """Iterate by ScOrientedSet elements""" @@ -38,13 +38,13 @@ def __iter__(self) -> Iterator[ScAddr]: if not start_template: return yield start_template.get(ScAlias.ELEMENT) - next_connector = start_template.get(ScAlias.MEMBERSHIP_ARC) + next_arc = start_template.get(ScAlias.MEMBERSHIP_ARC) while True: - elem_search_result = self._search_next_element_template(next_connector) + elem_search_result = self._search_next_element_template(next_arc) if elem_search_result is None: return yield elem_search_result.get(ScAlias.ELEMENT) - next_connector = elem_search_result.get(ScAlias.MEMBERSHIP_ARC) + next_arc = elem_search_result.get(ScAlias.MEMBERSHIP_ARC) @property def elements_list(self) -> List[ScAddr]: @@ -59,12 +59,12 @@ def remove(self, *elements: ScAddr) -> None: self.add(*elements_new) def _generate_first_element_arc(self, element: ScAddr) -> ScAddr: - """Create marked with rrel_1 arc to first element""" + """Generate marked with rrel_1 arc to first element""" return generate_role_relation(self._set_node, element, ScKeynodes[CommonIdentifiers.RREL_ONE]) def _get_last_arc_and_erase_rrel_last(self) -> Optional[ScAddr]: - """Search last connector of ScOrientedSet is it exists""" - # Search marked last connector + """Search last arc of ScOrientedSet if it exists""" + # Search marked last arc template = ScTemplate() template.quintuple( self._set_node, @@ -76,19 +76,19 @@ def _get_last_arc_and_erase_rrel_last(self) -> Optional[ScAddr]: last_elem_templates = search_by_template(template) if last_elem_templates: last_elem_template = last_elem_templates[0] - erase_elements(last_elem_template.get(ScAlias.RELATION_ARC)) # Erase arc between rrel_last and connector + erase_elements(last_elem_template.get(ScAlias.RELATION_ARC)) # Erase arc between rrel_last and arc return last_elem_template.get(ScAlias.MEMBERSHIP_ARC) - # Search unmarked last connector + # Search unmarked last arc next_elem_result = search_role_relation_template(self._set_node, ScKeynodes[CommonIdentifiers.RREL_ONE]) while True: - next_connector = next_elem_result.get(ScAlias.MEMBERSHIP_ARC) - next_elem_result = self._search_next_element_template(next_connector) + next_arc = next_elem_result.get(ScAlias.MEMBERSHIP_ARC) + next_elem_result = self._search_next_element_template(next_arc) if next_elem_result is None: - return next_connector + return next_arc - def _generate_next_arc(self, previous_connector: ScAddr, element: ScAddr) -> ScAddr: - """Create connector to element and connect with previous connector""" + def _generate_next_arc(self, previous_arc: ScAddr, element: ScAddr) -> ScAddr: + """Generate arc to element and connect with previous arc""" template = ScTemplate() template.triple( self._set_node, @@ -96,7 +96,7 @@ def _generate_next_arc(self, previous_connector: ScAddr, element: ScAddr) -> ScA element, ) template.quintuple( - previous_connector, + previous_arc, sc_type.VAR_COMMON_ARC, ScAlias.MEMBERSHIP_ARC, sc_type.VAR_PERM_POS_ARC, @@ -105,17 +105,17 @@ def _generate_next_arc(self, previous_connector: ScAddr, element: ScAddr) -> ScA return generate_by_template(template).get(ScAlias.MEMBERSHIP_ARC) @staticmethod - def _mark_connector_with_rrel_last(last_connector: ScAddr) -> None: + def _mark_arc_with_rrel_last(last_arc: ScAddr) -> None: generate_connector( sc_type.CONST_PERM_POS_ARC, ScKeynodes[CommonIdentifiers.RREL_LAST], - last_connector, + last_arc, ) - def _search_next_element_template(self, cur_element_connector: ScAddr) -> Optional[ScTemplateResult]: + def _search_next_element_template(self, cur_element_arc: ScAddr) -> Optional[ScTemplateResult]: templ = ScTemplate() templ.quintuple( - cur_element_connector, + cur_element_arc, sc_type.VAR_COMMON_ARC, sc_type.VAR_PERM_POS_ARC >> ScAlias.MEMBERSHIP_ARC, sc_type.VAR_PERM_POS_ARC, diff --git a/src/sc_kpm/sc_sets/sc_set.py b/src/sc_kpm/sc_sets/sc_set.py index b9d1e5f..7cd2c64 100644 --- a/src/sc_kpm/sc_sets/sc_set.py +++ b/src/sc_kpm/sc_sets/sc_set.py @@ -13,18 +13,18 @@ class ScSet: """ ScSet is a class for handling set construction in kb. - It has main set_node and arc elements. + It has main set_node and elements. """ def __init__(self, *elements: ScAddr, set_node: ScAddr = None, set_node_type: ScType = None) -> None: """ Initialize ScSet. - Receive or create set_node and add elements. + Receive or generate set_node and add elements. :param elements: Elements of a set to initialize it. - :param set_node: Set node has connectors to each element. - Optional parameter: it will be created if it doesn't exist. + :param set_node: Set node has arcs to each element. + Optional parameter: it will be generated if it doesn't exist. :param set_node_type: ScType for creating set node. """ @@ -79,7 +79,7 @@ def __contains__(self, element: ScAddr) -> bool: return element in self.elements_set def remove(self, *elements: ScAddr) -> None: - """Remove the connections between set_node and elements""" + """Erase the connections between set_node and elements""" templ = ScTemplate() for element in elements: templ.triple(self._set_node, sc_type.VAR_PERM_POS_ARC, element) diff --git a/src/sc_kpm/sc_sets/sc_structure.py b/src/sc_kpm/sc_sets/sc_structure.py index f91343a..a6a2dc0 100644 --- a/src/sc_kpm/sc_sets/sc_structure.py +++ b/src/sc_kpm/sc_sets/sc_structure.py @@ -10,7 +10,7 @@ class ScStructure(ScSet): """ ScStructure is a class for handling structure construction in kb. - It has main set_node with type CONST_NODE_STRUCTURE and arc elements. + It has main set_node with type CONST_NODE_STRUCTURE and elements. """ def __init__(self, *elements: ScAddr, set_node: ScAddr = None, set_node_type: ScType = None) -> None: diff --git a/src/sc_kpm/utils/__init__.py b/src/sc_kpm/utils/__init__.py index 8f00ab4..4c51aad 100644 --- a/src/sc_kpm/utils/__init__.py +++ b/src/sc_kpm/utils/__init__.py @@ -7,6 +7,17 @@ from sc_kpm.utils import action_utils from sc_kpm.utils.common_utils import ( check_connector, + check_edge, + create_binary_relation, + create_edge, + create_edges, + create_link, + create_links, + create_node, + create_nodes, + create_norole_relation, + create_role_relation, + delete_edges, erase_connectors, generate_binary_relation, generate_connector, @@ -19,9 +30,13 @@ generate_role_relation, get_connector, get_connectors, - get_element_by_non_role_relation, + get_edge, + get_edges, + get_element_by_norole_relation, get_element_by_role_relation, get_element_system_identifier, get_link_content_data, + get_system_idtf, + search_element_by_non_role_relation, search_role_relation_template, ) diff --git a/src/sc_kpm/utils/action_utils.py b/src/sc_kpm/utils/action_utils.py index d53220f..899b3c3 100644 --- a/src/sc_kpm/utils/action_utils.py +++ b/src/sc_kpm/utils/action_utils.py @@ -10,7 +10,7 @@ from sc_client import client from sc_client.client import create_elementary_event_subscriptions, destroy_elementary_event_subscriptions -from sc_client.constants import sc_types +from sc_client.constants import sc_type from sc_client.constants.common import ScEventType from sc_client.models import ScAddr, ScConstruction, ScEventSubscriptionParams, ScTemplate @@ -163,7 +163,7 @@ def event_callback(_: ScAddr, __: ScAddr, trg: ScAddr) -> ScResult: finish_event.set() return ScResult.OK - event_params = ScEventSubscriptionParams(action_node, ScEventType.ADD_INGOING_EDGE, event_callback) + event_params = ScEventSubscriptionParams(action_node, ScEventType.AFTER_GENERATE_INCOMING_ARC, event_callback) sc_event = create_elementary_event_subscriptions(event_params)[0] if not check_connector(sc_type.VAR_PERM_POS_ARC, reaction_node, action_node): finish_event.wait(seconds) diff --git a/src/sc_kpm/utils/common_utils.py b/src/sc_kpm/utils/common_utils.py index 6710966..341be6c 100644 --- a/src/sc_kpm/utils/common_utils.py +++ b/src/sc_kpm/utils/common_utils.py @@ -205,7 +205,7 @@ def get_element_system_identifier(addr: ScAddr) -> Idtf: templ.quintuple( addr, sc_type.VAR_COMMON_ARC, - sc_type.LINK_VAR >> ScAlias.LINK, + sc_type.VAR_NODE_LINK >> ScAlias.LINK, sc_type.VAR_PERM_POS_ARC, nrel_system_idtf, ) @@ -257,17 +257,17 @@ def get_element_by_role_relation(src: ScAddr, rrel_node: ScAddr) -> ScAddr: return search_result.get(ScAlias.ELEMENT) if search_result else ScAddr(0) -def get_element_by_non_role_relation(src: ScAddr, nrel_node: ScAddr) -> ScAddr: +def search_element_by_non_role_relation(src: ScAddr, nrel_node: ScAddr) -> ScAddr: search_result = search_non_role_relation_template(src, nrel_node) return search_result.get(ScAlias.ELEMENT) if search_result else ScAddr(0) def get_element_by_norole_relation(src: ScAddr, nrel_node: ScAddr) -> ScAddr: warnings.warn( - "Common utils 'get_element_by_norole_relation' method is deprecated. Use `get_element_by_non_role_relation` method instead.", + "Common utils 'get_element_by_norole_relation' method is deprecated. Use `search_element_by_non_role_relation` method instead.", DeprecationWarning, ) - return get_element_by_non_role_relation(src, nrel_node) + return search_element_by_non_role_relation(src, nrel_node) def get_link_content_data(link: ScAddr) -> ScLinkContentData: diff --git a/tests/test_utils/test_action_utils.py b/tests/test_utils/test_action_utils.py index 8f84e5e..f0baa3e 100644 --- a/tests/test_utils/test_action_utils.py +++ b/tests/test_utils/test_action_utils.py @@ -40,7 +40,7 @@ class ScModuleTest(ScModule): def __init__(self): super().__init__( ScAgentTest(test_node_idtf, ScEventType.AFTER_GENERATE_OUTGOING_ARC), - ScAgentTest(test_node_idtf, ScEventType.ADD_INGOING_EDGE), + ScAgentTest(test_node_idtf, ScEventType.AFTER_GENERATE_INCOMING_ARC), ) diff --git a/tests/test_utils/test_common_utils.py b/tests/test_utils/test_common_utils.py index c2964ab..de04463 100644 --- a/tests/test_utils/test_common_utils.py +++ b/tests/test_utils/test_common_utils.py @@ -23,7 +23,7 @@ erase_connectors, get_connector, get_connectors, - get_element_by_non_role_relation, + search_element_by_non_role_relation, get_element_by_role_relation, get_link_content_data, get_element_system_identifier, @@ -119,8 +119,8 @@ def test_relation_utils(self): assert expected_rrel_target.value == rrel_trg.value assert expected_empty.is_valid() is False - expected_nrel_target = get_element_by_non_role_relation(src, nrel_node) - expected_empty = get_element_by_non_role_relation(src, rrel_node) + expected_nrel_target = search_element_by_non_role_relation(src, nrel_node) + expected_empty = search_element_by_non_role_relation(src, rrel_node) assert expected_nrel_target.is_valid() assert expected_nrel_target.value == nrel_trg.value assert expected_empty.is_valid() is False diff --git a/tests/test_utils/test_iteration_utils.py b/tests/test_utils/test_iteration_utils.py index 8dbd838..5a84dea 100644 --- a/tests/test_utils/test_iteration_utils.py +++ b/tests/test_utils/test_iteration_utils.py @@ -14,8 +14,8 @@ def test_iter_link_contents_data(self): contents = [content1, content2] data = [content1_data, content2_data] construction = ScConstruction() - construction.generate_link(sc_type.LINK_CONST, content1) - construction.generate_link(sc_type.LINK_CONST, content2) + construction.generate_link(sc_type.CONST_NODE_LINK, content1) + construction.generate_link(sc_type.CONST_NODE_LINK, content2) links = generate_elements(construction) links_data_from_iterator = list(iter_link_contents_data(contents)) self.assertEqual(links_data_from_iterator, data)