Renamed Hyperedge.normalized to normalise

Author: telmomenezes

CHANGELOG.md

@@ -22,6 +22,7 @@
 - Hyperedge.insert_argrole now private, renamed to Hyperedge._insert_argrole.
 - Renamed Hyperedge.insert_edge_with_argrole to add_argument, pos optional (default to add at the end).
 - Renamed Hyperedge.edges_with_argrole to arguments_with_role.
+- Renamed Hyperedge.normalized to normalise.
 
 ### Removed
 - function patterns.edge_matches_pattern.
@@ -92,7 +93,7 @@
 - Hypergraph.text().
 - Parser.parse_and_add().
 - Parser.sentences().
-- Hyperedge.normalized().
+- Hyperedge.normalise().
 - New package graphbrain.readers, for text readers from various sources.
 - New package graphbrain.processors, for miscellaneous processors.
 - Processor class.

docs/manual/hyperedges.md

@@ -469,13 +469,13 @@ Returns a dictionary of structural errors found in the edge. Each key is the pro
 
 The checks include connector type validation, modifier and builder structure, trigger structure, predicate argument types, conjunction arity, and argument role counts and validity.
 
-### normalized()
+### normalise()
 
 Returns a normalized version of the edge where argument roles (and their corresponding arguments) are sorted into a canonical order:
 
 ```pycon
 >>> edge = hedge('(is/P.cs nice/C berlin/C)')
->>> edge.normalized()
+>>> edge.normalise()
 (is/P.sc berlin/C nice/C)
 ```
 

src/hyperbase/hyperedge.py

@@ -712,7 +712,7 @@ def check_correctness(self) -> dict[Hyperedge, list[tuple[str, str]]]:
 
         return output
 
-    def normalized(self) -> Hyperedge:
+    def normalise(self) -> Hyperedge:
         edge: Hyperedge = self
         conn = edge[0]
         ar = conn.argroles()
@@ -724,7 +724,7 @@ def normalized(self) -> Hyperedge:
                 key=lambda role_edge: argrole_order[role_edge[0]],
             )
             edge = hedge([conn, *[role_edge[1] for role_edge in roles_edges_sorted]])
-        return hedge([subedge.normalized() for subedge in edge])
+        return hedge([subedge.normalise() for subedge in edge])
 
     def __add__(self, other: Hyperedge | tuple[Any, ...] | list[Any]) -> Hyperedge:
         if isinstance(other, (list, tuple)) and not isinstance(other, Hyperedge):
@@ -1054,7 +1054,7 @@ def check_correctness(self) -> dict[Hyperedge, list[tuple[str, str]]]:
 
         return output
 
-    def normalized(self) -> Atom:
+    def normalise(self) -> Atom:
         if self.mtype() in {"B", "P"}:
             ar = self.argroles()
             if len(ar) > 0:

src/hyperbase/patterns/common.py

@@ -40,7 +40,7 @@ def common_pattern_argroles(edge1: Hyperedge, edge2: Hyperedge) -> Hyperedge | N
     if best_pattern is None:
         return None
 
-    return best_pattern.normalized()
+    return best_pattern.normalise()
 
 
 def common_type(edges: Sequence[Hyperedge]) -> str | None:

src/hyperbase/patterns/counter.py

@@ -103,7 +103,7 @@ def _list2patterns(
     def _edge2patterns(self, edge: Hyperedge) -> list[Hyperedge]:
         force_subtypes = self._force_subtypes(edge)
         force_root, _ = self._force_root_expansion(edge)
-        normalized = edge.normalized()
+        normalized = edge.normalise()
         return [
             hedge(pattern)
             for pattern in self._list2patterns(

tests/test_hyperedge.py

@@ -1066,33 +1066,33 @@ def test_check_correctness_wrong_argroles6(self):
 
     def test_normalized_1(self):
         edge = hedge("(plays/Pd.os chess/C mary/C)")
-        assert edge.normalized() == hedge("(plays/Pd.so mary/C chess/C)")
+        assert edge.normalise() == hedge("(plays/Pd.so mary/C chess/C)")
 
     def test_normalized_2(self):
         edge = hedge("(plays/Pd chess/C mary/C)")
-        assert edge.normalized() == hedge("(plays/Pd chess/C mary/C)")
+        assert edge.normalise() == hedge("(plays/Pd chess/C mary/C)")
 
     def test_normalized_3(self):
         edge = hedge("(plays/Pd.os (of/B.am chess/C games/C) mary/C)")
-        assert edge.normalized() == hedge(
+        assert edge.normalise() == hedge(
             "(plays/Pd.so mary/C (of/B.ma games/C chess/C))"
         )
 
     def test_normalized_4(self):
         edge = hedge("(plays/Pd.os.xxx/en chess/C mary/C)")
-        assert edge.normalized() == hedge("(plays/Pd.so.xxx/en mary/C chess/C)")
+        assert edge.normalise() == hedge("(plays/Pd.so.xxx/en mary/C chess/C)")
 
     def test_normalized_5(self):
         edge = hedge("plays/Pd.os.xxx/en")
-        assert edge.normalized() == hedge("plays/Pd.so.xxx/en")
+        assert edge.normalise() == hedge("plays/Pd.so.xxx/en")
 
     def test_normalized_6(self):
         edge = hedge("of/Br.am/en")
-        assert edge.normalized() == hedge("of/Br.ma/en")
+        assert edge.normalise() == hedge("of/Br.ma/en")
 
     def test_normalized_7(self):
         edge = hedge("plays/Pd.{os}.xxx/en")
-        assert edge.normalized() == hedge("plays/Pd.{so}.xxx/en")
+        assert edge.normalise() == hedge("plays/Pd.{so}.xxx/en")
 
     def test_bug_fix1(self):
         edge_str = "((ahead/M/en (would/Mm/en go/P..-i-----/en)))"