natural-agi-common 0.1.36__py3-none-any.whl → 0.1.37__py3-none-any.whl

common/model/enums.py

@@ -1,4 +1,4 @@
-from enum import Enum
+from enum import Enum, auto
 
 
 class ContourType(Enum):
@@ -13,12 +13,12 @@ class ContourDevelopment(Enum):
 
 
 class HorizontalDirection(Enum):
-    LEFT = "Left"
-    RIGHT = "Right"
-    NONE = "None"
+    LEFT = auto()
+    RIGHT = auto()
+    NONE = auto()
 
 
 class VerticalDirection(Enum):
-    TOP = "Top"
-    BOTTOM = "Bottom"
-    NONE = "None"
+    TOP = auto()
+    BOTTOM = auto()
+    NONE = auto()

common/traversal/visitors/angle_visitor.py

@@ -11,7 +11,7 @@ import networkx as nx
 class AngleVisitor(Visitor):
     def __init__(self, graph: nx.Graph):
         super().__init__(graph)
-        self.point_angles: Dict[str, set[float]] = {}
+        self.point_angles: Dict[str, List[float]] = {}
         self.line_angles: Dict[str, float] = {}
 
     def visit_point(self, point: Point) -> Dict[str, Any]:
@@ -20,10 +20,10 @@ class AngleVisitor(Visitor):
             angles = []
             for i in range(len(connected_lines)):
                 for j in range(i + 1, len(connected_lines)):
-                    angles = self._calculate_angle_between_lines(
+                    angle_pair = self._calculate_angle_between_lines(
                         connected_lines[i], connected_lines[j]
                     )
-                    angles.extend(angles)
+                    angles.extend(angle_pair)
             self.point_angles[point.id] = angles
             self.graph.nodes[point.id]["angles"] = angles
             return {"angles": angles, "point_id": point.id}
@@ -151,6 +151,10 @@ class AngleVisitor(Visitor):
         magnitude1 = math.sqrt(vector1[0] ** 2 + vector1[1] ** 2)
         magnitude2 = math.sqrt(vector2[0] ** 2 + vector2[1] ** 2)
 
+        # Handle zero-length vectors
+        if magnitude1 < 1e-10 or magnitude2 < 1e-10:
+            return [0.0, 0.0]
+
         cos_angle = dot_product / (magnitude1 * magnitude2)
         angle1 = math.degrees(math.acos(max(-1.0, min(1.0, cos_angle))))
         angle2 = 360 - angle1
@@ -169,6 +173,11 @@ class AngleVisitor(Visitor):
         vector = (end_coords[0] - start_coords[0], end_coords[1] - start_coords[1])
         dot_product = vector[0] * 1 + vector[1] * 0
         magnitude = math.sqrt(vector[0] ** 2 + vector[1] ** 2)
+
+        # Handle zero-length vectors
+        if magnitude < 1e-10:
+            return 0.0
+
         cos_angle = dot_product / magnitude
         angle = math.degrees(math.acos(max(-1.0, min(1.0, cos_angle))))
         return round(angle / 10) * 10

{natural_agi_common-0.1.36.dist-info → natural_agi_common-0.1.37.dist-info}/METADATA

@@ -1,7 +1,13 @@
 Metadata-Version: 2.1
 Name: natural-agi-common
-Version: 0.1.36
+Version: 0.1.37
+Summary: UNKNOWN
+Home-page: UNKNOWN
+License: UNKNOWN
+Platform: UNKNOWN
 Requires-Dist: pydantic
 Requires-Dist: networkx
 Requires-Dist: neo4j
 
+UNKNOWN
+

{natural_agi_common-0.1.36.dist-info → natural_agi_common-0.1.37.dist-info}/RECORD

@@ -3,12 +3,10 @@ common/critical_graph_utils.py,sha256=mqTopyoF5HELBZs4zB7RiMBL4wJy8V11zAp_OGgV_B
 common/critical_point.py,sha256=OeiAY7-WLk0o1zwWwSdbr5T1875oyE5REJ0q6et77jA,573
 common/decorator.py,sha256=ql68Rfh-sGvPUw_vVLblKkFPGgqlGbYXWrrwN5E1jh8,1423
 common/graph_utils.py,sha256=Fd9SjGrpYQ7YW8HnoyTojvXfFZmgHu2EIyAVd-AjgHg,4362
-common/minor_check.py,sha256=13lWp1x31IUrlGSii3COrBc_tGL6nsh4XXHWpTza4Zs,17735
-common/models.py,sha256=7zMzl46M1MCEG00dZV9jS2_MpHHeZQO17OfLk7VfGb8,324
 common/params.py,sha256=GjT0ZlF99D0Sn35c_cTZax0wxlKXVKSi3lMz8Y1zW04,562
 common/model/__init__.py,sha256=7wNxQtYv-JuKMP2PhoyxZT46BscxT-j8uVZlxmThSAs,644
 common/model/dlq.py,sha256=kzHcddbeOkj_YqBghldJOe9CjtO43xxC9Df3Tr5pKD4,111
-common/model/enums.py,sha256=NLQmgz2ruJfbJxb9S26C4Y1k3IpUcvDwDS8SqUypuyg,391
+common/model/enums.py,sha256=rTJLjJ1AhLkUYRL8ZQvrMuCt46bZ24_tdGMoTgUjF5w,395
 common/model/half_plane.py,sha256=AEeY79Uot-mzwe-DgSKn39K-jCJPstXatxT9zN-IUXw,146
 common/model/length_comparison_result.py,sha256=PEU5QyqpAb9sO0K42cLHILhE_VUMEsNczYhwrFB6UeA,140
 common/model/point.py,sha256=GlGTfku0K1Wfs4db7kYe6cHXyx8P9TNx0FoKZqfkspA,703
@@ -17,15 +15,13 @@ common/traversal/__init__.py,sha256=pkj_5-jsIbDoZbj2DyDePsuqICjuAJ2Rzahw-ezWqJk,
 common/traversal/graph_traversal.py,sha256=F_QBFYPyVckWkxjU-_Jos3WKSSUqaSOg1TbsU27PUPE,2535
 common/traversal/start_point_selector.py,sha256=saW8G3X3bEiXmZ_aTSCtb8hbquzae4qcaicyvsQ_mVw,4608
 common/traversal/visitors/__init__.py,sha256=ROshdBY3CJXJ3tV4xdgGv0OBok8cO4LATqroGah8vjY,639
-common/traversal/visitors/angle_visitor.py,sha256=UX3Hs0xlBBkpGRazH3NasMHy4Xk-LL3kiH8HvGvxF5c,6698
+common/traversal/visitors/angle_visitor.py,sha256=ieqQyIHfsej8JMijM9jJrZtEUhF-MDnHHzXcW7nymP0,6920
 common/traversal/visitors/direction_visitor.py,sha256=Dn4oPLmhEsL6EpWNC44X2FZU2sIoWMitEiQ5nBty2Po,5944
-common/traversal/visitors/half_plane_visitor.py,sha256=d1DUVtx4gH-dDhicTjN7lR69xvz2SXKQqaP6kzo3orM,2063
 common/traversal/visitors/length_comparison_visitor.py,sha256=hW56siLZodjsNWEFcyg9k0fclJLzT2ArneZCZZLVx9Y,2819
 common/traversal/visitors/quadrant_visitor.py,sha256=N8Vb91FqtRYoQ2G9cK91KAfDaC7u2KbPeQ3sDNqgvcw,3603
-common/traversal/visitors/relative_position_visitor.py,sha256=3VfJWiuyvC9kc4C9F65LCJ7V4ecmbdz68KMahN2cOxc,7058
 common/traversal/visitors/visitor.py,sha256=30J0GEqzgeQrOng-rjPncXlcLE16WE7sqLlJ7-8SuwU,775
 common/traversal/visitors/visitor_result_persistence_service.py,sha256=lpr6KzZt22tjTpBnepbTMZ2gi9eLLNrojEv9ABTbvhE,760
-natural_agi_common-0.1.36.dist-info/METADATA,sha256=9UThu3TvZPwMF6aQ0trzeGgx_T0v5FWSKgRyKcQIDf0,133
-natural_agi_common-0.1.36.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
-natural_agi_common-0.1.36.dist-info/top_level.txt,sha256=LOtYx8KZTmnxM_zLK4rwrcI3PRc40Ihwp5rgaQ-ceaI,7
-natural_agi_common-0.1.36.dist-info/RECORD,,
+natural_agi_common-0.1.37.dist-info/METADATA,sha256=y3BbtJ3vw9kHbirhRJ_yMtGadrwAez2zcEf5EcrrX8o,213
+natural_agi_common-0.1.37.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+natural_agi_common-0.1.37.dist-info/top_level.txt,sha256=LOtYx8KZTmnxM_zLK4rwrcI3PRc40Ihwp5rgaQ-ceaI,7
+natural_agi_common-0.1.37.dist-info/RECORD,,

{natural_agi_common-0.1.36.dist-info → natural_agi_common-0.1.37.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.5.0)
+Generator: bdist_wheel (0.41.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

common/minor_check.py

@@ -1,509 +0,0 @@
-import networkx as nx
-from itertools import combinations
-from typing import Optional
-
-
-def is_minor(graph: nx.Graph, concept: nx.Graph) -> bool:
-    """
-    Checks if 'concept' is a minor of 'graph' by enumerating possible node deletions
-    and then recursively contracting edges until the subgraph has the same number
-    of edges as 'concept'.
-
-    - Retains all node data in the subgraph/contracted graph.
-    - Only uses 'labels' field to compare nodes for isomorphism.
-    """
-
-    # Quick size checks
-    if concept.number_of_nodes() > graph.number_of_nodes():
-        return False
-    if concept.number_of_edges() > graph.number_of_edges():
-        return False
-
-    # Prune early if the graph doesn't have enough labels to match concept
-    if not _check_label_feasibility(graph, concept):
-        return False
-
-    # We'll define a node_match function that ONLY checks labels overlap.
-    # We ignore everything else in node data for the match.
-    def node_match(n1_data: dict, n2_data: dict) -> bool:
-        labels1 = n1_data.get("labels", set())
-        labels2 = n2_data.get("labels", set())
-        # Two nodes match if they share at least one label
-        return bool(labels1 & labels2)
-
-    # How many nodes must we remove from 'graph'?
-    to_remove = graph.number_of_nodes() - concept.number_of_nodes()
-
-    # For each subset of nodes to delete
-    for nodes_subset in combinations(list(graph.nodes()), to_remove):
-        # Check if removing these nodes kills feasibility of labels
-        if not _delete_feasibility_check(graph, nodes_subset, concept):
-            continue
-
-        # Build a subgraph with those nodes removed
-        G_sub = graph.copy()
-        G_sub.remove_nodes_from(nodes_subset)
-
-        # We now need to contract edges so that G_sub has the same # of edges as concept
-        needed_contractions = G_sub.number_of_edges() - concept.number_of_edges()
-
-        if needed_contractions < 0:
-            # Not enough edges to match concept's connectivity
-            continue
-        if needed_contractions == 0:
-            # Just check isomorphism right away
-            if nx.is_isomorphic(G_sub, concept, node_match=node_match):
-                return True
-            continue
-
-        # Otherwise, recursively contract the necessary number of edges
-        if _contract_recursive(G_sub, needed_contractions, concept, node_match):
-            return True
-
-    return False
-
-
-def _contract_recursive(
-    G_sub: nx.Graph, needed_contractions: int, concept: nx.Graph, node_match
-) -> bool:
-    """
-    Recursively contract 'needed_contractions' edges in G_sub.
-    Maintains a list of original node UUIDs that were merged into each node.
-    """
-    # If we have contracted enough edges, check isomorphism
-    if needed_contractions == 0:
-        return nx.is_isomorphic(G_sub, concept, node_match=node_match)
-
-    edges = list(G_sub.edges())
-    if len(edges) < needed_contractions:
-        return False
-
-    # Try each edge in turn
-    for u, v in edges:
-        G_copy = G_sub.copy()
-
-        # Merge the original_nodes lists
-        u_nodes = G_copy.nodes[u].get("original_nodes", [u])
-        v_nodes = G_copy.nodes[v].get("original_nodes", [v])
-        merged_nodes = u_nodes + v_nodes
-
-        # Do the contraction
-        G_copy = nx.contracted_nodes(G_copy, u, v, self_loops=False)
-
-        # Store the list of original nodes that were merged into this node
-        G_copy.nodes[u]["original_nodes"] = merged_nodes
-
-        # Keep only labels for isomorphism checking
-        G_copy.nodes[u]["labels"] = set(G_sub.nodes[u].get("labels", set())) | set(
-            G_sub.nodes[v].get("labels", set())
-        )
-
-        # Recurse with one fewer contraction needed
-        if _contract_recursive(G_copy, needed_contractions - 1, concept, node_match):
-            return True
-
-    return False
-
-
-def _merge_node_data(data_u: dict, data_v: dict) -> dict:
-    """
-    Merge the data dictionaries from two nodes u and v.
-    - 'labels' fields are unioned
-    - All other fields are merged according to specific rules
-    """
-    merged = {}
-
-    # Special handling for labels - always union them
-    labels_u = data_u.get("labels", set())
-    labels_v = data_v.get("labels", set())
-    merged["labels"] = labels_u.union(labels_v)
-
-    # Merge all other fields
-    all_keys = set(data_u.keys()) | set(data_v.keys())
-    for key in all_keys:
-        if key == "labels":
-            continue  # already handled
-
-        # For numeric values, take average
-        if key in data_u and key in data_v:
-            val_u = data_u[key]
-            val_v = data_v[key]
-            if isinstance(val_u, (int, float)) and isinstance(val_v, (int, float)):
-                merged[key] = (val_u + val_v) / 2
-            else:
-                # For non-numeric values, prefer data_u's value
-                merged[key] = data_u[key]
-        elif key in data_u:
-            merged[key] = data_u[key]
-        else:
-            merged[key] = data_v[key]
-
-    return merged
-
-
-def _check_label_feasibility(graph: nx.Graph, concept: nx.Graph) -> bool:
-    """
-    Quick check: If concept requires more occurrences of any label
-    than graph can provide, skip immediately.
-    """
-    from collections import Counter
-
-    graph_labels = Counter()
-    concept_labels = Counter()
-
-    # Count labels in the graph
-    for _, data in graph.nodes(data=True):
-        lbls = data.get("labels", set())
-        graph_labels.update(lbls)
-
-    # Count labels in the concept
-    for _, data in concept.nodes(data=True):
-        lbls = data.get("labels", set())
-        concept_labels.update(lbls)
-
-    # If concept needs more of any label than the graph has, return False
-    for label, needed_count in concept_labels.items():
-        if graph_labels[label] < needed_count:
-            return False
-
-    return True
-
-
-def _delete_feasibility_check(graph: nx.Graph, nodes_subset, concept: nx.Graph) -> bool:
-    """
-    If removing 'nodes_subset' from 'graph' eliminates critical labels
-    needed to match 'concept', return False immediately.
-    """
-    from collections import Counter
-
-    to_delete_set = set(nodes_subset)
-    remaining_labels = Counter()
-
-    for node in graph.nodes():
-        if node not in to_delete_set:
-            node_labels = graph.nodes[node].get("labels", set())
-            remaining_labels.update(node_labels)
-
-    concept_labels = Counter()
-    for _, data in concept.nodes(data=True):
-        concept_labels.update(data.get("labels", set()))
-
-    for label, cnt_needed in concept_labels.items():
-        if remaining_labels[label] < cnt_needed:
-            return False
-
-    return True
-
-
-#######################################
-# 2) Enumerate All Minors of a Graph  #
-#######################################
-def enumerate_minors(
-    base_graph: nx.Graph, max_nodes: int = 5, max_enumerations: int = 1000
-):
-    """
-    Generates minor graphs by enumerating all sub-node sets (up to max_nodes)
-    and recursively contracting edges to produce unique minors.
-
-    Args:
-        base_graph: The graph from which to enumerate minors
-        max_nodes: Maximum number of nodes in the enumerated minors
-        max_enumerations: How many minors to generate before stopping
-                          (just to avoid infinite blow-ups)
-
-    Returns:
-        A set of minors (each minor is returned as a "canonical" form).
-    """
-    all_minors = set()
-    enumerations_count = 0
-
-    graph_nodes = list(base_graph.nodes())
-    n = len(graph_nodes)
-
-    for subset_size in range(1, min(max_nodes, n) + 1):
-        for subset in combinations(graph_nodes, subset_size):
-            induced_sub = base_graph.subgraph(subset).copy()
-
-            # Now consider possible edge contractions
-            for minor_graph in _enumerate_contractions(induced_sub):
-                enumerations_count += 1
-                if enumerations_count > max_enumerations:
-                    return all_minors  # early exit
-                cstring = _canonical_label(minor_graph)
-                all_minors.add(cstring)
-
-    return all_minors
-
-
-def _enumerate_contractions(graph: nx.Graph):
-    """
-    Yields all possible contractions from the given graph.
-    We do a DFS: each edge can be contracted or not.
-    """
-    # Yield the original graph
-    yield graph
-
-    edges = list(graph.edges())
-    for i, (u, v) in enumerate(edges):
-        G_copy = graph.copy()
-        merged_labels = set(G_copy.nodes[u].get("labels", set())) | set(
-            G_copy.nodes[v].get("labels", set())
-        )
-        nx.contracted_nodes(G_copy, u, v, self_loops=False, copy=False)
-        G_copy.nodes[u]["labels"] = merged_labels
-
-        # Recurse
-        yield from _enumerate_contractions(G_copy)
-
-
-def _canonical_label(g: nx.Graph) -> str:
-    """
-    Create a string that uniquely identifies a graph's structure and node labels.
-    (Naive approach—real solutions might use NAUTY/Bliss for a perfect canonical form.)
-    """
-    labels_map = {}
-    for node in sorted(g.nodes()):
-        lbls = sorted(g.nodes[node].get("labels", []))
-        labels_map[node] = ",".join(lbls)
-
-    edges_sorted = []
-    for a, b in g.edges():
-        edges_sorted.append(tuple(sorted([a, b])))
-    edges_sorted.sort()
-
-    node_part = ";".join([f"{node}:{labels_map[node]}" for node in sorted(labels_map)])
-    edge_part = ",".join([f"({u}=>{v})" for (u, v) in edges_sorted])
-    return f"N[{node_part}] E[{edge_part}]"
-
-
-############################################
-# 3) Rebuild Graph from Canonical String   #
-############################################
-def parse_cstring_to_graph(cstr: str) -> nx.Graph:
-    """
-    Parse the canonical string back into a networkx.Graph with 'labels' attributes.
-    Format: N[node_entries]E[edge_entries] where:
-    - node_entries are semicolon-separated: node_info:labels
-    - edge_entries are comma-separated: (node1=>node2)
-
-    Example:
-    N[4:Point,EndPoint;5:Point,Vector]E[(4=>5),(5=>6)]
-    """
-    import re
-
-    g = nx.Graph()
-
-    match_nodes = re.search(r"N\[(.*?)\]", cstr)
-    match_edges = re.search(r"E\[(.*?)\]", cstr)
-    if not match_nodes:
-        return g
-
-    # Parse nodes
-    nodes_part = match_nodes.group(1)
-    node_entries = nodes_part.split(";") if nodes_part else []
-
-    for node_entry in node_entries:
-        if not node_entry:
-            continue
-
-        # Split by the last colon to separate labels from node info
-        parts = node_entry.rsplit(":", 1)
-        if len(parts) != 2:
-            continue
-
-        node_info, lbl_str = parts
-        labels = set(lbl_str.split(",")) if lbl_str else set()
-        g.add_node(node_info, labels=labels)
-
-    # Parse edges
-    if match_edges:
-        edges_part = match_edges.group(1)
-        # Split on closing parenthesis and remove empty strings
-        edge_entries = [e.strip() for e in edges_part.split(")") if e.strip()]
-
-        for e in edge_entries:
-            # Clean up the edge entry
-            e = e.replace("(", "").strip()
-            if "=>" not in e:
-                continue
-
-            u, v = e.split("=>")
-            u, v = u.strip(), v.strip()  # Remove any whitespace
-            if u in g.nodes and v in g.nodes:
-                g.add_edge(u, v)
-
-    return g
-
-
-############################################
-# 4) find_common_minors_in_dataset (Revised)
-############################################
-def find_common_minors_in_dataset_return_biggest(
-    graphs: list[nx.Graph], max_nodes: int = 5
-) -> Optional[nx.Graph]:
-    """
-    Modified to restore properties after finding the common minor.
-    """
-    # 1) Pick the smallest graph
-    smallest_graph = min(graphs, key=lambda g: g.number_of_nodes())
-
-    # 2) Enumerate minors (as canonical strings)
-    print("Enumerating minors from the smallest graph...")
-    candidate_minors_cstrings = enumerate_minors(
-        smallest_graph, max_nodes=max_nodes, max_enumerations=2000
-    )
-    print(
-        f"Found {len(candidate_minors_cstrings)} candidate minors (some might be duplicates)."
-    )
-
-    # 3) For each candidate, parse into a graph, and check if it's a minor of all other graphs
-    all_other_graphs = [g for g in graphs if g is not smallest_graph]
-    common_minors_as_graphs = []
-    visited_cstrings = set()
-
-    print("Checking each candidate minor against all other graphs...")
-    for cstr in candidate_minors_cstrings:
-        if cstr in visited_cstrings:
-            continue
-        visited_cstrings.add(cstr)
-
-        minor_graph = parse_cstring_to_graph(cstr)
-
-        # Check if it's a minor of all other graphs
-        is_common = True
-        for g in all_other_graphs:
-            if not is_minor(g, minor_graph):
-                is_common = False
-                break
-
-        if is_common:
-            common_minors_as_graphs.append(minor_graph)
-
-    # 4) Return the 'largest' common minor if any exist
-    if common_minors_as_graphs:
-        # Sort descending by (#nodes, #edges)
-        common_minors_as_graphs.sort(
-            key=lambda mg: (mg.number_of_nodes(), mg.number_of_edges()), reverse=True
-        )
-        biggest_minor = common_minors_as_graphs[0]
-        # Restore properties from original graphs
-        return restore_node_properties(biggest_minor, graphs)
-    else:
-        return None
-
-
-def restore_node_properties(
-    minor_graph: nx.Graph, source_graphs: list[nx.Graph]
-) -> nx.Graph:
-    """
-    Restores original node properties from source graphs based on stored original_nodes.
-    For merged nodes, properties are averaged or combined according to type.
-    """
-    result = minor_graph.copy()
-
-    for node in result.nodes():
-        original_nodes = result.nodes[node].get("original_nodes", [node])
-        merged_data = {}
-
-        # Collect all properties from original nodes across all source graphs
-        for source_graph in source_graphs:
-            for orig_node in original_nodes:
-                if orig_node in source_graph:
-                    node_data = source_graph.nodes[orig_node]
-                    for key, value in node_data.items():
-                        if key == "original_nodes":
-                            continue
-                        if key not in merged_data:
-                            merged_data[key] = []
-                        merged_data[key].append(value)
-
-        # Merge collected properties
-        final_data = {}
-        for key, values in merged_data.items():
-            if not values:
-                continue
-
-            if key == "labels":
-                # Union all label sets
-                final_data[key] = set().union(
-                    *[v if isinstance(v, set) else {v} for v in values]
-                )
-            elif all(isinstance(v, (int, float)) for v in values):
-                # Average numeric values
-                final_data[key] = sum(values) / len(values)
-            else:
-                # For other types, take the most common value
-                final_data[key] = max(set(values), key=values.count)
-
-        # Update node data
-        result.nodes[node].update(final_data)
-
-    return result
-
-
-#######################################
-# 5) Example Usage / Demo
-#######################################
-if __name__ == "__main__":
-    import time
-
-    # Graph 1: L-shape with additional properties
-    G1 = nx.Graph()
-    G1.add_node("p1", labels={"EndPoint", "Point"}, x=0, y=0, weight=1.0)
-    G1.add_node("p2", labels={"CornerPoint", "Point"}, x=0, y=1, weight=2.0)
-    G1.add_node("p3", labels={"EndPoint", "Point"}, x=0, y=2, weight=3.0)
-    G1.add_node("p4", labels={"EndPoint", "Point"}, x=1, y=1, weight=4.0)
-    G1.add_node("v1", labels={"VerticalVector", "Vector"}, length=1.0)
-    G1.add_node("v2", labels={"VerticalVector", "Vector"}, length=1.0)
-    G1.add_node("v3", labels={"HorizontalVector", "Vector"}, length=1.0)
-    G1.add_edge("p1", "v1")
-    G1.add_edge("v1", "p2")
-    G1.add_edge("p2", "v2")
-    G1.add_edge("v2", "p3")
-    G1.add_edge("p2", "v3")
-    G1.add_edge("v3", "p4")
-
-    # Graph 2: a smaller shape with properties
-    G2 = nx.Graph()
-    G2.add_node("p1", labels={"EndPoint", "Point"}, x=5, y=5, weight=10.0)
-    G2.add_node("p2", labels={"EndPoint", "Point"}, x=5, y=6, weight=20.0)
-    G2.add_node("v1", labels={"VerticalVector", "Vector"}, length=1.0)
-    G2.add_edge("p1", "v1")
-    G2.add_edge("v1", "p2")
-
-    # Graph 3: Just a single line segment with a corner and properties
-    G3 = nx.Graph()
-    G3.add_node("p1", labels={"CornerPoint", "Point"}, x=10, y=10, weight=100.0)
-    G3.add_node("p2", labels={"EndPoint", "Point"}, x=10, y=11, weight=200.0)
-    G3.add_node("v1", labels={"VerticalVector", "Vector"}, length=1.0)
-    G3.add_edge("p1", "v1")
-    G3.add_edge("v1", "p2")
-
-    dataset = [G1, G2, G3]
-
-    start = time.time()
-    common_minors_graph = find_common_minors_in_dataset_return_biggest(
-        dataset, max_nodes=3
-    )
-    elapsed = time.time() - start
-
-    print("\n=== Testing Property Retention ===")
-    print("\nCommon Minor Found:")
-    print("Nodes with all properties:")
-    for node, data in common_minors_graph.nodes(data=True):
-        print(f"\nNode {node}:")
-        for key, value in data.items():
-            print(f"  {key}: {value}")
-
-    print("\nEdges:", common_minors_graph.edges())
-    print(f"\nExecution time: {elapsed:.4f} seconds")
-
-    # Verify that properties were merged correctly
-    print("\nVerifying property merging:")
-    for node, data in common_minors_graph.nodes(data=True):
-        if "weight" in data:
-            print(f"Node {node} has weight: {data['weight']}")
-        if "x" in data and "y" in data:
-            print(f"Node {node} has coordinates: ({data['x']}, {data['y']})")
-        if "length" in data:
-            print(f"Node {node} has length: {data['length']}")

common/models.py

@@ -1,16 +0,0 @@
-from enum import Enum
-from pydantic import BaseModel
-
-class DLQModel(BaseModel):
-    source: str
-    error: dict
-    value: dict
-    
-class ContourType(Enum):
-    CLOSED = "Closed"
-    OPEN = "Open"
-    
-class ContourDevelopment(Enum):
-    MONOTONIC = "Monotonic"
-    NON_MONOTONIC = "Non-monotonic"
-    UNKNOWN = "Unknown"

common/traversal/visitors/half_plane_visitor.py

@@ -1,64 +0,0 @@
-from typing import Any, Dict
-
-from neo4j import ManagedTransaction
-from ...model.half_plane import HalfPlane
-from .visitor import Visitor
-from ...model.point import Point
-from ...model.vector import Vector
-
-
-class HalfPlaneVisitor(Visitor):
-    def __init__(self, graph):
-        super().__init__(graph)
-        self.half_planes: Dict[str, HalfPlane] = {}
-
-    def visit_point(self, _: Point) -> None:
-        # This visitor does not handle points
-        return None
-
-    def visit_line(self, line: Vector) -> Dict[str, Any]:
-        dx = line.x2 - line.x1
-        dy = line.y2 - line.y1
-        half_plane = self.determine_half_plane(dx, dy)
-        self.half_planes[line.id] = half_plane
-        self.graph.nodes[line.id]["half_plane"] = half_plane.value
-
-    def save_result(
-        self,
-        tx: ManagedTransaction,
-        image_id: str,
-        session_id: str,
-        result: Dict[str, Any],
-    ) -> None:
-        query = """
-        MATCH (v:Vector {id: $id})
-        MERGE (hp:HalfPlane:Feature {value: $half_plane, session_id: $session_id})
-        ON CREATE SET hp.samples = [$image_id], v.half_plane = $half_plane
-        ON MATCH SET hp.samples = CASE
-            WHEN NOT $image_id IN hp.samples THEN hp.samples + $image_id
-            ELSE hp.samples
-        END, v.half_plane = $half_plane
-        MERGE (v)-[:IS_IN_HALF_PLANE]->(hp)
-        """
-        tx.run(
-            query,
-            id=result["line_id"],
-            half_plane=result["half_plane"],
-            session_id=session_id,
-            image_id=image_id,
-        )
-
-    def get_results(self) -> Dict[str, str]:
-        return {k: v.value for k, v in self.half_planes.items()}
-
-    def reset(self) -> None:
-        self.half_planes.clear()
-
-    @staticmethod
-    def determine_half_plane(dx: float, dy: float) -> HalfPlane:
-        if dx == 0 and dy == 0:
-            return HalfPlane.ORIGIN
-        elif abs(dy) > abs(dx):
-            return HalfPlane.UPPER if dy > 0 else HalfPlane.LOWER
-        else:
-            return HalfPlane.RIGHT if dx > 0 else HalfPlane.LEFT

common/traversal/visitors/relative_position_visitor.py

@@ -1,209 +0,0 @@
-from dataclasses import dataclass
-from enum import Enum
-from typing import Dict, Any, List
-import math
-import networkx as nx
-from neo4j import ManagedTransaction
-
-from .visitor import Visitor
-from ...model.point import Point
-from ...model.vector import Vector
-
-
-class RelativeSegment(Enum):
-    TOP = "top"
-    BOTTOM = "bottom"
-    LEFT = "left"
-    RIGHT = "right"
-    CENTER_VERTICAL = "center_vertical"
-    CENTER_HORIZONTAL = "center_horizontal"
-
-
-@dataclass
-class RelativePosition:
-    distance_from_center: float
-    segments: List[RelativeSegment]
-    normalized_x: float  # -1 to 1
-    normalized_y: float  # -1 to 1
-
-
-class RelativePositionVisitor(Visitor):
-    def __init__(self, graph: nx.Graph):
-        super().__init__(graph)
-
-        # Find the bounding box and calculate center
-        self._calculate_bounding_box_center()
-
-        self.segment_threshold = 0.05  # 20% threshold for center segments
-        self.point_positions: Dict[str, RelativePosition] = {}
-        self.vector_positions: Dict[str, RelativePosition] = {}
-
-    def _calculate_bounding_box_center(self) -> None:
-        """Calculate the center based on the bounding box of all points in the graph."""
-        min_x = float("inf")
-        min_y = float("inf")
-        max_x = float("-inf")
-        max_y = float("-inf")
-
-        # Find min and max coordinates to determine the bounding box
-        for node_id, node_data in self.graph.nodes(data=True):
-            if "Point" not in node_data["labels"]:
-                continue
-
-            x = node_data["x"]
-            y = node_data["y"]
-            min_x = min(min_x, x)
-            min_y = min(min_y, y)
-            max_x = max(max_x, x)
-            max_y = max(max_y, y)
-
-        # Calculate center of the bounding box
-        self.center_x = (min_x + max_x) / 2
-        self.center_y = (min_y + max_y) / 2
-
-        # Calculate half-width and half-height of the bounding box
-        half_width = (max_x - min_x) / 2
-        half_height = (max_y - min_y) / 2
-
-        # Maximum distance is from center to the corner of the bounding box
-        self.max_distance = math.sqrt(half_width**2 + half_height**2)
-
-    def visit_point(self, point: Point) -> Dict[str, Any]:
-        position = self._calculate_relative_position(point.x, point.y)
-        self.point_positions[point.id] = position
-        node = self.graph.nodes[point.id]
-        node["relative_distance"] = position.distance_from_center
-        node["normalized_x"] = position.normalized_x
-        node["normalized_y"] = position.normalized_y
-        node["segments"] = [seg.value for seg in position.segments]
-
-        return {
-            "point_id": point.id,
-            "distance": position.distance_from_center,
-            "segments": [seg.value for seg in position.segments],
-            "normalized_x": position.normalized_x,
-            "normalized_y": position.normalized_y,
-        }
-
-    def visit_line(self, line: Vector) -> Dict[str, Any]:
-        # Calculate midpoint of the line
-        mid_x = (line.x1 + line.x2) / 2
-        mid_y = (line.y1 + line.y2) / 2
-
-        position = self._calculate_relative_position(mid_x, mid_y)
-        self.vector_positions[line.id] = position
-        node = self.graph.nodes[line.id]
-        node["relative_distance"] = position.distance_from_center
-        node["normalized_x"] = position.normalized_x
-        node["normalized_y"] = position.normalized_y
-        node["segments"] = [seg.value for seg in position.segments]
-
-        return {
-            "line_id": line.id,
-            "distance": position.distance_from_center,
-            "segments": [seg.value for seg in position.segments],
-            "normalized_x": position.normalized_x,
-            "normalized_y": position.normalized_y,
-        }
-
-    def _calculate_relative_position(self, x: float, y: float) -> RelativePosition:
-        # Calculate normalized coordinates (-1 to 1) relative to bounding box center
-        normalized_x = (x - self.center_x) / (
-            self.max_distance if self.max_distance > 0 else 1
-        )
-        normalized_y = (y - self.center_y) / (
-            self.max_distance if self.max_distance > 0 else 1
-        )
-
-        # Calculate distance from center
-        dx = x - self.center_x
-        dy = y - self.center_y
-        distance = math.sqrt(dx**2 + dy**2) / self.max_distance
-
-        # Determine segments
-        segments = []
-
-        # Vertical segments
-        if abs(normalized_y) < self.segment_threshold:
-            segments.append(RelativeSegment.CENTER_HORIZONTAL)
-        elif normalized_y < 0:
-            segments.append(RelativeSegment.TOP)
-        else:
-            segments.append(RelativeSegment.BOTTOM)
-
-        # Horizontal segments
-        if abs(normalized_x) < self.segment_threshold:
-            segments.append(RelativeSegment.CENTER_VERTICAL)
-        elif normalized_x < 0:
-            segments.append(RelativeSegment.LEFT)
-        else:
-            segments.append(RelativeSegment.RIGHT)
-
-        return RelativePosition(
-            distance_from_center=round(distance, 2),
-            segments=segments,
-            normalized_x=round(normalized_x, 2),
-            normalized_y=round(normalized_y, 2),
-        )
-
-    def save_result(
-        self,
-        tx: ManagedTransaction,
-        image_id: str,
-        session_id: str,
-        result: Dict[str, Any],
-    ) -> None:
-        if "point_id" in result:
-            self._save_point_position(tx, result)
-        elif "line_id" in result:
-            self._save_line_position(tx, result)
-
-    def _save_point_position(
-        self,
-        tx: ManagedTransaction,
-        result: Dict[str, Any],
-    ) -> None:
-        query = """
-        MATCH (p:Point {id: $point_id})
-        SET p.relative_distance = $distance,
-            p.normalized_x = $normalized_x,
-            p.normalized_y = $normalized_y,
-            p.segments = $segments
-        RETURN p
-        """
-        tx.run(
-            query,
-            point_id=result["point_id"],
-            distance=result["distance"],
-            normalized_x=result["normalized_x"],
-            normalized_y=result["normalized_y"],
-            segments=result["segments"],
-        )
-
-    def _save_line_position(
-        self,
-        tx: ManagedTransaction,
-        result: Dict[str, Any],
-    ) -> None:
-        query = """
-        MATCH (v:Vector {id: $line_id})
-        SET v.relative_distance = $distance,
-            v.normalized_x = $normalized_x,
-            v.normalized_y = $normalized_y,
-            v.segments = $segments
-        """
-        tx.run(
-            query,
-            line_id=result["line_id"],
-            distance=result["distance"],
-            normalized_x=result["normalized_x"],
-            normalized_y=result["normalized_y"],
-            segments=result["segments"],
-        )
-
-    def get_results(self) -> Dict[str, Dict[str, RelativePosition]]:
-        return {"points": self.point_positions, "vectors": self.vector_positions}
-
-    def reset(self) -> None:
-        self.point_positions.clear()
-        self.vector_positions.clear()