natural-agi-common 0.1.33__tar.gz → 0.1.35__tar.gz

{natural_agi_common-0.1.33 → natural_agi_common-0.1.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: natural-agi-common
-Version: 0.1.33
+Version: 0.1.35
 Requires-Dist: pydantic
 Requires-Dist: networkx
 Requires-Dist: neo4j

{natural_agi_common-0.1.33 → natural_agi_common-0.1.35}/common/model/point.py

@@ -6,6 +6,8 @@ class Point:
     id: str
     x: float
     y: float
+    normalized_x: float
+    normalized_y: float
 
     @classmethod
     def from_node_data(cls, node_data: dict) -> "Point":
@@ -13,6 +15,8 @@ class Point:
             x=node_data["x"],
             y=node_data["y"],
             id=node_data["id"],
+            normalized_x=node_data["normalized_x"],
+            normalized_y=node_data["normalized_y"],
         )
 
     def __hash__(self):

natural_agi_common-0.1.35/common/traversal/graph_traversal.py

@@ -0,0 +1,73 @@
+from typing import Generator, Any, Tuple, Optional, List
+from dataclasses import dataclass
+import networkx as nx
+import logging
+from ..model.point import Point
+from ..model.vector import Vector
+
+
+@dataclass
+class TraversalSequence:
+    start_point: Point
+    vector: Vector
+    end_point: Point
+
+
+class GraphTraversal:
+    def __init__(self, graph: nx.Graph):
+        self.graph = graph
+        self.logger = logging.getLogger(__name__)
+
+    def dfs_traversal(
+        self, start_node: Any
+    ) -> Generator[TraversalSequence, None, None]:
+        visited_vectors = set()
+        visited_nodes = set()
+
+        def dfs_recursive(current_node: Any, path: List[Any]) -> None:
+            if current_node in visited_nodes:
+                return
+
+            visited_nodes.add(current_node)
+            path.append(current_node)
+
+            # If we have a sequence of 3 nodes, check if it follows point-vector-point pattern
+            if len(path) >= 3:
+                start_node_id = path[-3]
+                vector_node_id = path[-2]
+                end_node_id = path[-1]
+
+                start_data = self.graph.nodes[start_node_id]
+                vector_data = self.graph.nodes[vector_node_id]
+                end_data = self.graph.nodes[end_node_id]
+
+                # Check if sequence follows point-vector-point pattern
+                if (
+                    self._is_point(start_data)
+                    and self._is_vector(vector_data)
+                    and self._is_point(end_data)
+                    and vector_node_id not in visited_vectors
+                ):
+                    self.logger.info(
+                        f"Found sequence: {start_node_id} -> {vector_node_id} -> {end_node_id}"
+                    )
+                    visited_vectors.add(vector_node_id)
+
+                    start_point = Point.from_node_data(start_data)
+                    vector = Vector.from_node_data(vector_data)
+                    end_point = Point.from_node_data(end_data)
+
+                    yield TraversalSequence(start_point, vector, end_point)
+
+            # Continue DFS to neighbors
+            for neighbor in self.graph.neighbors(current_node):
+                if neighbor not in visited_nodes:
+                    yield from dfs_recursive(neighbor, path.copy())
+
+        yield from dfs_recursive(start_node, [])
+
+    def _is_vector(self, node_data: dict) -> bool:
+        return "Vector" in node_data["labels"]
+
+    def _is_point(self, node_data: dict) -> bool:
+        return "Point" in node_data["labels"]

{natural_agi_common-0.1.33 → natural_agi_common-0.1.35}/common/traversal/visitors/angle_visitor.py

@@ -29,8 +29,8 @@ class AngleVisitor(Visitor):
             return {"angles": angles, "point_id": point.id}
         return None
 
-    def visit_line(self, line: Vector) -> Dict[str, Any]:
-        angle_with_ox = self._calculate_angle_with_ox(line)
+    def visit_line(self, line: Vector, start_point: Point) -> Dict[str, Any]:
+        angle_with_ox = self._calculate_angle_with_ox(line, start_point)
         self.line_angles[line.id] = angle_with_ox
         self.graph.nodes[line.id]["angle_with_ox"] = angle_with_ox
         return {"angle_with_ox": angle_with_ox, "line_id": line.id}
@@ -159,8 +159,14 @@ class AngleVisitor(Visitor):
         angle2 = round(angle2 / 10) * 10
         return [angle1, angle2]
 
-    def _calculate_angle_with_ox(self, line: Vector) -> float:
-        vector = (line.x2 - line.x1, line.y2 - line.y1)
+    def _calculate_angle_with_ox(self, line: Vector, start_point: Point) -> float:
+        start_coords = (start_point.x, start_point.y)
+        end_coords = (
+            (line.x2, line.y2)
+            if line.x1 == start_point.x and line.y1 == start_point.y
+            else (line.x1, line.y1)
+        )
+        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)
         cos_angle = dot_product / magnitude

{natural_agi_common-0.1.33 → natural_agi_common-0.1.35}/common/traversal/visitors/direction_visitor.py

@@ -53,10 +53,16 @@ class DirectionVisitor(Visitor):
         # No specific operation for points in this visitor
         return None
 
-    def visit_line(self, line: Vector) -> Dict[str, Any]:
+    def visit_line(self, line: Vector, start_point: Point) -> Dict[str, Any]:
         # Extract direction information
+        start_coords = (start_point.x, start_point.y)
+        end_coords = (
+            (line.x2, line.y2)
+            if line.x1 == start_point.x and line.y1 == start_point.y
+            else (line.x1, line.y1)
+        )
         h_direction, v_direction = self.calculate_direction(
-            line.x1, line.y1, line.x2, line.y2
+            start_coords[0], start_coords[1], end_coords[0], end_coords[1]
         )
         line.horizontal_direction = h_direction
         line.vertical_direction = v_direction

{natural_agi_common-0.1.33 → natural_agi_common-0.1.35}/common/traversal/visitors/length_comparison_visitor.py

@@ -2,6 +2,7 @@ from typing import Dict, Any, List
 
 from neo4j import ManagedTransaction
 from .visitor import Visitor
+from ...model.point import Point
 from ...model.vector import Vector
 from ...model.length_comparison_result import LengthComparisonResult
 
@@ -16,7 +17,7 @@ class LengthComparisonVisitor(Visitor):
         # This visitor does not handle points
         return None
 
-    def visit_line(self, line: Vector) -> Dict[str, Any]:
+    def visit_line(self, line: Vector, start_point: Point) -> Dict[str, Any]:
         comparison = LengthComparisonResult.N_A
         if self.previous_length:
             if line.length > self.previous_length:

{natural_agi_common-0.1.33 → natural_agi_common-0.1.35}/common/traversal/visitors/quadrant_visitor.py

@@ -13,8 +13,10 @@ class QuadrantVisitor(Visitor):
         self.quadrants: Dict[str, int] = {}
 
     def visit_point(self, point: Point) -> None:
-        # Implementation for point-related operations
-        return None
+        x = point.normalized_x
+        y = point.normalized_y
+        quadrant = self.determine_quadrant(x, y)
+        self.graph.nodes[point.id]["quadrant"] = quadrant
 
     def determine_vector_type(self, dx: float, dy: float) -> str:
         """Determine vector type based on relative dimensions.
@@ -37,9 +39,15 @@ class QuadrantVisitor(Visitor):
         else:
             return "VerticalVector"
 
-    def visit_line(self, line: Vector) -> Dict[str, Any]:
-        dx = line.x2 - line.x1
-        dy = line.y2 - line.y1
+    def visit_line(self, line: Vector, start_point: Point) -> Dict[str, Any]:
+        start_coords = (start_point.x, start_point.y)
+        end_coords = (
+            (line.x2, line.y2)
+            if line.x1 == start_point.x and line.y1 == start_point.y
+            else (line.x1, line.y1)
+        )
+        dx = end_coords[0] - start_coords[0]
+        dy = end_coords[1] - start_coords[1]
         quadrant = self.determine_quadrant(dx, dy)
         vector_type = self.determine_vector_type(dx, dy)
 

{natural_agi_common-0.1.33 → natural_agi_common-0.1.35}/common/traversal/visitors/visitor.py

@@ -16,7 +16,7 @@ class Visitor(ABC):
         pass
 
     @abstractmethod
-    def visit_line(self, line: Vector) -> Any:
+    def visit_line(self, line: Vector, start_point: Point) -> Any:
         pass
 
     @abstractmethod

{natural_agi_common-0.1.33 → natural_agi_common-0.1.35}/natural_agi_common.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: natural-agi-common
-Version: 0.1.33
+Version: 0.1.35
 Requires-Dist: pydantic
 Requires-Dist: networkx
 Requires-Dist: neo4j

{natural_agi_common-0.1.33 → natural_agi_common-0.1.35}/natural_agi_common.egg-info/SOURCES.txt

@@ -20,10 +20,8 @@ common/traversal/start_point_selector.py
 common/traversal/visitors/__init__.py
 common/traversal/visitors/angle_visitor.py
 common/traversal/visitors/direction_visitor.py
-common/traversal/visitors/half_plane_visitor.py
 common/traversal/visitors/length_comparison_visitor.py
 common/traversal/visitors/quadrant_visitor.py
-common/traversal/visitors/relative_position_visitor.py
 common/traversal/visitors/visitor.py
 common/traversal/visitors/visitor_result_persistence_service.py
 natural_agi_common.egg-info/PKG-INFO

{natural_agi_common-0.1.33 → natural_agi_common-0.1.35}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="natural-agi-common",
-    version="0.1.33",
+    version="0.1.35",
     packages=find_packages(include=["common", "common.*"]),
     install_requires=["pydantic", "networkx", "neo4j"],
 )

natural_agi_common-0.1.33/common/traversal/graph_traversal.py

@@ -1,52 +0,0 @@
-from typing import Generator, Any, Tuple, Optional
-import networkx as nx
-import logging
-from ..model.point import Point
-from ..model.vector import Vector
-
-
-class GraphTraversal:
-    def __init__(self, graph: nx.Graph):
-        self.graph = graph
-        self.logger = logging.getLogger(__name__)
-
-    def dfs_traversal(
-        self, start_node: Any
-    ) -> Generator[Tuple[Point, Optional[Vector]], None, None]:
-        visited_vector = set()
-        for edge in nx.dfs_edges(self.graph, start_node):
-            self.logger.info(f"Visiting edge: {edge}")
-            source_node, target_node = edge
-            if source_node in visited_vector or target_node in visited_vector:
-                self.logger.info(f"Skipping edge: {edge} because vector was already visited")
-                continue
-
-            # Convert to your Point and Vector objects
-            source_data = self.graph.nodes[source_node]
-            target_data = self.graph.nodes[target_node]
-
-            point = None
-            vector = None
-
-            if self._is_point(source_data):
-                point = Point.from_node_data(source_data)
-            elif self._is_vector(source_data):
-                vector = Vector.from_node_data(source_data)
-                visited_vector.add(source_node)
-
-            if self._is_point(target_data):
-                point = Point.from_node_data(target_data)
-            elif self._is_vector(target_data):
-                vector = Vector.from_node_data(target_data)
-                visited_vector.add(target_node)
-
-            if point is None and vector is None:
-                raise ValueError(f"Invalid node data: {source_data} or {target_data}")
-
-            yield point, vector
-
-    def _is_vector(self, node_data: dict) -> bool:
-        return "Vector" in node_data["labels"]
-
-    def _is_point(self, node_data: dict) -> bool:
-        return "Point" in node_data["labels"]

natural_agi_common-0.1.33/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

natural_agi_common-0.1.33/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()