htmlgraph 0.9.3__py3-none-any.whl → 0.27.5__py3-none-any.whl

htmlgraph/find_api.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 """
 BeautifulSoup-style Find API for HtmlGraph.
 
@@ -22,9 +24,10 @@ Example:
     nodes = graph.find_all(properties__effort__gt=8)
 """
 
-from __future__ import annotations
+
 import re
-from typing import TYPE_CHECKING, Any, Callable, Iterator
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from htmlgraph.graph import HtmlGraph
@@ -56,14 +59,10 @@ class FindAPI:
         nodes = graph.find_all(title__contains="auth")
     """
 
-    def __init__(self, graph: 'HtmlGraph'):
+    def __init__(self, graph: HtmlGraph):
         self._graph = graph
 
-    def find(
-        self,
-        type: str | None = None,
-        **kwargs
-    ) -> 'Node | None':
+    def find(self, type: str | None = None, **kwargs: Any) -> Node | None:
         """
         Find the first node matching the given criteria.
 
@@ -80,7 +79,7 @@ class FindAPI:
             node = graph.find(properties__effort__gt=8)
         """
         if type is not None:
-            kwargs['type'] = type
+            kwargs["type"] = type
 
         for node in self._graph:
             if self._matches(node, kwargs):
@@ -88,11 +87,8 @@ class FindAPI:
         return None
 
     def find_all(
-        self,
-        type: str | None = None,
-        limit: int | None = None,
-        **kwargs
-    ) -> list['Node']:
+        self, type: str | None = None, limit: int | None = None, **kwargs: Any
+    ) -> list[Node]:
         """
         Find all nodes matching the given criteria.
 
@@ -109,7 +105,7 @@ class FindAPI:
             nodes = graph.find_all(status__in=["todo", "blocked"], limit=10)
         """
         if type is not None:
-            kwargs['type'] = type
+            kwargs["type"] = type
 
         results = []
         for node in self._graph:
@@ -119,7 +115,7 @@ class FindAPI:
                     break
         return results
 
-    def find_by_id(self, node_id: str) -> 'Node | None':
+    def find_by_id(self, node_id: str) -> Node | None:
         """
         Find node by exact ID.
 
@@ -131,7 +127,7 @@ class FindAPI:
         """
         return self._graph.get(node_id)
 
-    def find_by_title(self, title: str, exact: bool = False) -> list['Node']:
+    def find_by_title(self, title: str, exact: bool = False) -> list[Node]:
         """
         Find nodes by title.
 
@@ -148,11 +144,8 @@ class FindAPI:
             return self.find_all(title__icontains=title)
 
     def find_related(
-        self,
-        node_id: str,
-        relationship: str | None = None,
-        direction: str = "outgoing"
-    ) -> list['Node']:
+        self, node_id: str, relationship: str | None = None, direction: str = "outgoing"
+    ) -> list[Node]:
         """
         Find nodes related to a given node.
 
@@ -165,9 +158,10 @@ class FindAPI:
             List of related nodes
         """
         neighbor_ids = self._graph.get_neighbors(node_id, relationship, direction)
-        return [self._graph.get(nid) for nid in neighbor_ids if self._graph.get(nid)]
+        nodes = [self._graph.get(nid) for nid in neighbor_ids]
+        return [n for n in nodes if n is not None]
 
-    def find_blocking(self, node_id: str) -> list['Node']:
+    def find_blocking(self, node_id: str) -> list[Node]:
         """
         Find nodes that are blocking the given node.
 
@@ -177,9 +171,11 @@ class FindAPI:
         Returns:
             List of blocking nodes
         """
-        return self.find_related(node_id, relationship="blocked_by", direction="outgoing")
+        return self.find_related(
+            node_id, relationship="blocked_by", direction="outgoing"
+        )
 
-    def find_blocked_by(self, node_id: str) -> list['Node']:
+    def find_blocked_by(self, node_id: str) -> list[Node]:
         """
         Find nodes that are blocked by the given node.
 
@@ -191,9 +187,10 @@ class FindAPI:
         """
         # Nodes that have blocked_by pointing to this node
         incoming = self._graph.get_incoming_edges(node_id, "blocked_by")
-        return [self._graph.get(ref.source_id) for ref in incoming if self._graph.get(ref.source_id)]
+        nodes = [self._graph.get(ref.source_id) for ref in incoming]
+        return [n for n in nodes if n is not None]
 
-    def _matches(self, node: 'Node', filters: dict[str, Any]) -> bool:
+    def _matches(self, node: Node, filters: dict[str, Any]) -> bool:
         """
         Check if a node matches all filters.
 
@@ -209,7 +206,7 @@ class FindAPI:
                 return False
         return True
 
-    def _check_filter(self, node: 'Node', key: str, expected: Any) -> bool:
+    def _check_filter(self, node: Node, key: str, expected: Any) -> bool:
         """
         Check a single filter against a node.
 
@@ -223,33 +220,34 @@ class FindAPI:
         """
         # Parse lookup type from key
         # Check if the last part is a lookup keyword
-        parts = key.split('__')
+        parts = key.split("__")
 
         if len(parts) == 1:
             # Simple attribute
             attr_path = parts[0]
-            lookup = 'exact'
+            lookup = "exact"
         elif parts[-1] in self._lookups:
             # Last part is a lookup
-            attr_path = '__'.join(parts[:-1])
+            attr_path = "__".join(parts[:-1])
             lookup = parts[-1]
         else:
             # All parts are attribute path, use exact match
             attr_path = key
-            lookup = 'exact'
+            lookup = "exact"
 
         # Get actual value
         actual = self._get_attr(node, attr_path)
 
         # Apply lookup
         lookup_fn = self._lookups.get(lookup, self._exact)
-        return lookup_fn(actual, expected)
+        result: bool = lookup_fn(actual, expected)
+        return result
 
-    def _get_attr(self, node: 'Node', path: str) -> Any:
+    def _get_attr(self, node: Node, path: str) -> Any:
         """Get attribute value supporting nested access with double underscore."""
         # Convert double underscore to dot notation for nested access
-        path = path.replace('__', '.')
-        parts = path.split('.')
+        path = path.replace("__", ".")
+        parts = path.split(".")
         current = node
 
         for part in parts:
@@ -266,12 +264,14 @@ class FindAPI:
 
     # Lookup functions
     def _exact(self, actual: Any, expected: Any) -> bool:
-        return actual == expected
+        result: bool = actual == expected
+        return result
 
     def _iexact(self, actual: Any, expected: Any) -> bool:
         if actual is None:
             return expected is None
-        return str(actual).lower() == str(expected).lower()
+        result: bool = str(actual).lower() == str(expected).lower()
+        return result
 
     def _contains(self, actual: Any, expected: Any) -> bool:
         if actual is None:
@@ -312,7 +312,11 @@ class FindAPI:
     def _iregex(self, actual: Any, expected: Any) -> bool:
         if actual is None:
             return False
-        pattern = expected if isinstance(expected, re.Pattern) else re.compile(expected, re.IGNORECASE)
+        pattern = (
+            expected
+            if isinstance(expected, re.Pattern)
+            else re.compile(expected, re.IGNORECASE)
+        )
         return bool(pattern.search(str(actual)))
 
     def _gt(self, actual: Any, expected: Any) -> bool:
@@ -342,38 +346,44 @@ class FindAPI:
         if actual is None:
             return False
         try:
-            actual_num = float(actual) if not isinstance(actual, (int, float)) else actual
-            expected_num = float(expected) if not isinstance(expected, (int, float)) else expected
-            return op(actual_num, expected_num)
+            actual_num = (
+                float(actual) if not isinstance(actual, (int, float)) else actual
+            )
+            expected_num = (
+                float(expected) if not isinstance(expected, (int, float)) else expected
+            )
+            result: bool = op(actual_num, expected_num)
+            return result
         except (ValueError, TypeError):
-            return op(str(actual), str(expected))
+            result2: bool = op(str(actual), str(expected))
+            return result2
 
     @property
     def _lookups(self) -> dict[str, Callable]:
         """Available lookup functions."""
         return {
-            'exact': self._exact,
-            'iexact': self._iexact,
-            'contains': self._contains,
-            'icontains': self._icontains,
-            'startswith': self._startswith,
-            'istartswith': self._istartswith,
-            'endswith': self._endswith,
-            'iendswith': self._iendswith,
-            'regex': self._regex,
-            'iregex': self._iregex,
-            'gt': self._gt,
-            'gte': self._gte,
-            'lt': self._lt,
-            'lte': self._lte,
-            'in': self._in,
-            'not_in': self._not_in,
-            'isnull': self._isnull,
+            "exact": self._exact,
+            "iexact": self._iexact,
+            "contains": self._contains,
+            "icontains": self._icontains,
+            "startswith": self._startswith,
+            "istartswith": self._istartswith,
+            "endswith": self._endswith,
+            "iendswith": self._iendswith,
+            "regex": self._regex,
+            "iregex": self._iregex,
+            "gt": self._gt,
+            "gte": self._gte,
+            "lt": self._lt,
+            "lte": self._lte,
+            "in": self._in,
+            "not_in": self._not_in,
+            "isnull": self._isnull,
         }
 
 
 # Convenience functions for direct import
-def find(graph: 'HtmlGraph', type: str | None = None, **kwargs) -> 'Node | None':
+def find(graph: HtmlGraph, type: str | None = None, **kwargs: Any) -> Node | None:
     """
     Find first node matching criteria.
 
@@ -388,7 +398,9 @@ def find(graph: 'HtmlGraph', type: str | None = None, **kwargs) -> 'Node | None'
     return FindAPI(graph).find(type=type, **kwargs)
 
 
-def find_all(graph: 'HtmlGraph', type: str | None = None, limit: int | None = None, **kwargs) -> list['Node']:
+def find_all(
+    graph: HtmlGraph, type: str | None = None, limit: int | None = None, **kwargs: Any
+) -> list[Node]:
     """
     Find all nodes matching criteria.