photo-stack-finder 0.1.7__py3-none-any.whl → 0.1.8__py3-none-any.whl

utils/channel.py

@@ -1,74 +1,74 @@
-"""Typed data channels connecting pipeline stages.
-
-A Channel connects an OutputPort to an InputPort, establishing a typed
-dependency edge in the pipeline graph. The Generic[T] type parameter
-ensures compile-time type safety - the output and input must have
-matching types.
-
-Architecture:
-- Auto-registration: Channels register themselves with the active graph
-- Type safety: Generic[T] enforces matching port types
-- Binding: Constructor automatically binds input port to output port
-
-Analogous to: Channels in SystemC, wires connecting modules in Verilog
-"""
-
-from __future__ import annotations
-
-from typing import TypeVar
-
-from .base_ports import BaseChannel
-from .graph_context import get_active_graph
-from .ports import InputPort, OutputPort
-
-T = TypeVar("T")
-
-
-class Channel[T](BaseChannel):
-    """Typed data connection between pipeline stages.
-
-    Creates a dependency edge from producer (output port) to consumer
-    (input port). The Generic[T] type parameter ensures type safety:
-    both ports must handle the same data type.
-
-    The channel automatically:
-    1. Binds the input port to the output port
-    2. Registers itself with the active PipelineGraph (if within PipelineBuilder context)
-
-    Type parameter T specifies the data type flowing through this channel.
-
-    Example:
-        # Connect stages with type safety
-        sha_bins_o: OutputPort[dict[str, list[str]]] = stage1.sha_bins_o
-        sha_bins_input: InputPort[dict[str, list[str]]] = stage2.sha_bins_i
-
-        # This will type-check correctly
-        channel = Channel(sha_bins_o, sha_bins_input)
-
-        # This would fail mypy type checking if types don't match
-        # channel = Channel(different_type_output, sha_bins_input)  # Error!
-    """
-
-    def __init__(self, port_o: OutputPort[T], port_i: InputPort[T]) -> None:
-        """Create a typed channel connecting two ports.
-
-        Args:
-            port_o: The producer port (where data comes from)
-            port_i: The consumer port (where data goes to)
-
-        Note:
-            If called within a PipelineBuilder context (i.e., when
-            PipelineStage._graph is set), this channel will auto-register
-            with the graph.
-        """
-        self.output = port_o
-        self.input = port_i
-
-        # Bind the input port to the output port
-        # This establishes the data flow connection
-        port_i.bind(port_o)
-
-        # Auto-register this edge if we're within a PipelineBuilder context
-        active_graph = get_active_graph()
-        if active_graph is not None:
-            active_graph.add_edge(self)
+"""Typed data channels connecting pipeline stages.
+
+A Channel connects an OutputPort to an InputPort, establishing a typed
+dependency edge in the pipeline graph. The Generic[T] type parameter
+ensures compile-time type safety - the output and input must have
+matching types.
+
+Architecture:
+- Auto-registration: Channels register themselves with the active graph
+- Type safety: Generic[T] enforces matching port types
+- Binding: Constructor automatically binds input port to output port
+
+Analogous to: Channels in SystemC, wires connecting modules in Verilog
+"""
+
+from __future__ import annotations
+
+from typing import TypeVar
+
+from .base_ports import BaseChannel
+from .graph_context import get_active_graph
+from .ports import InputPort, OutputPort
+
+T = TypeVar("T")
+
+
+class Channel[T](BaseChannel):
+    """Typed data connection between pipeline stages.
+
+    Creates a dependency edge from producer (output port) to consumer
+    (input port). The Generic[T] type parameter ensures type safety:
+    both ports must handle the same data type.
+
+    The channel automatically:
+    1. Binds the input port to the output port
+    2. Registers itself with the active PipelineGraph (if within PipelineBuilder context)
+
+    Type parameter T specifies the data type flowing through this channel.
+
+    Example:
+        # Connect stages with type safety
+        sha_bins_o: OutputPort[dict[str, list[str]]] = stage1.sha_bins_o
+        sha_bins_input: InputPort[dict[str, list[str]]] = stage2.sha_bins_i
+
+        # This will type-check correctly
+        channel = Channel(sha_bins_o, sha_bins_input)
+
+        # This would fail mypy type checking if types don't match
+        # channel = Channel(different_type_output, sha_bins_input)  # Error!
+    """
+
+    def __init__(self, port_o: OutputPort[T], port_i: InputPort[T]) -> None:
+        """Create a typed channel connecting two ports.
+
+        Args:
+            port_o: The producer port (where data comes from)
+            port_i: The consumer port (where data goes to)
+
+        Note:
+            If called within a PipelineBuilder context (i.e., when
+            PipelineStage._graph is set), this channel will auto-register
+            with the graph.
+        """
+        self.output = port_o
+        self.input = port_i
+
+        # Bind the input port to the output port
+        # This establishes the data flow connection
+        port_i.bind(port_o)
+
+        # Auto-register this edge if we're within a PipelineBuilder context
+        active_graph = get_active_graph()
+        if active_graph is not None:
+            active_graph.add_edge(self)

utils/comparison_gates.py

@@ -291,8 +291,8 @@ class AspectRatioGate(BaseGate):
         """
         # Get aspect ratios (may trigger lazy dimension extraction)
         # This may load pixels if dimensions not yet cached
-        ratio1 = img1.get_aspect_ratio()
-        ratio2 = img2.get_aspect_ratio()
+        ratio1 = img1._photo.aspect_ratio
+        ratio2 = img2._photo.aspect_ratio
 
         # Normalize to portrait orientation (AR < 1.0)
         # This allows matching landscape ↔ portrait photos
@@ -372,8 +372,14 @@ class GateSequence:
                     # MethodGate: check if pixels needed (cache miss detection)
                     # Only load pixels if we'll actually need them
                     # Note: cache keys are (method_name, rotation) tuples, always tuples even for rotation=0
-                    will_need_pixels1 = (photo1.id, 0) not in gate.cache and (gate._name, 0) not in photo1.cache
-                    will_need_pixels2 = (photo2.id, 0) not in gate.cache and (gate._name, 0) not in photo2.cache
+                    will_need_pixels1 = (photo1.id, 0) not in gate.cache and (
+                        gate._name,
+                        0,
+                    ) not in photo1.cache
+                    will_need_pixels2 = (photo2.id, 0) not in gate.cache and (
+                        gate._name,
+                        0,
+                    ) not in photo2.cache
 
                     if will_need_pixels1 or will_need_pixels2:
                         # Cache miss detected - load pixels if not already loaded
@@ -430,29 +436,24 @@ class GateSequence:
         # Flexible ImageData management: create contexts only for photos that don't have pre-created ImageData
         # Case 1: Both provided - use directly
         if ref_img is not None and cand_img is not None:
-            return self._compare_with_rotation_impl(
-                reference, candidate, ref_img, cand_img, short_circuit
-            )
+            return self._compare_with_rotation_impl(reference, candidate, ref_img, cand_img, short_circuit)
 
         # Case 2: Only ref provided - create context for candidate
         if ref_img is not None and cand_img is None:
             with candidate.image_data() as cand_img_ctx:
-                return self._compare_with_rotation_impl(
-                    reference, candidate, ref_img, cand_img_ctx, short_circuit
-                )
+                return self._compare_with_rotation_impl(reference, candidate, ref_img, cand_img_ctx, short_circuit)
 
         # Case 3: Only cand provided - create context for reference
         if ref_img is None and cand_img is not None:
             with reference.image_data() as ref_img_ctx:
-                return self._compare_with_rotation_impl(
-                    reference, candidate, ref_img_ctx, cand_img, short_circuit
-                )
+                return self._compare_with_rotation_impl(reference, candidate, ref_img_ctx, cand_img, short_circuit)
 
         # Case 4: Neither provided - create contexts for both (original pattern)
-        with reference.image_data() as ref_img_new, candidate.image_data() as cand_img_new:
-            return self._compare_with_rotation_impl(
-                reference, candidate, ref_img_new, cand_img_new, short_circuit
-            )
+        with (
+            reference.image_data() as ref_img_new,
+            candidate.image_data() as cand_img_new,
+        ):
+            return self._compare_with_rotation_impl(reference, candidate, ref_img_new, cand_img_new, short_circuit)
 
     def _compare_with_rotation_impl(
         self,
@@ -508,7 +509,13 @@ class GateSequence:
         # Second attempt: try 180° rotation ONLY if first failed
         if not overall_pass:
             ref_rotation_180 = ref_norm_rotation + 180
-            scores_180, overall_pass_180, final_gate_score_180, ref_pixels, cand_pixels = self._attempt_comparison(
+            (
+                scores_180,
+                overall_pass_180,
+                final_gate_score_180,
+                ref_pixels,
+                cand_pixels,
+            ) = self._attempt_comparison(
                 reference,
                 candidate,
                 ref_img,
@@ -539,7 +546,13 @@ class GateSequence:
         ref_pixels: npt.NDArray[np.uint8] | None,
         cand_pixels: npt.NDArray[np.uint8] | None,
         short_circuit: bool,
-    ) -> tuple[dict[str, float], bool, float, npt.NDArray[np.uint8] | None, npt.NDArray[np.uint8] | None]:
+    ) -> tuple[
+        dict[str, float],
+        bool,
+        float,
+        npt.NDArray[np.uint8] | None,
+        npt.NDArray[np.uint8] | None,
+    ]:
         """Attempt comparison at specific rotation angles.
 
         Args:
@@ -569,11 +582,17 @@ class GateSequence:
             elif isinstance(gate, MethodGate):
                 # Check if we need to load pixels (cache miss detection)
                 # Cache keys are always (method_name, rotation) tuples
-                will_need_ref_pixels = (reference.id, ref_rotation) not in gate.cache and (
+                will_need_ref_pixels = (
+                    reference.id,
+                    ref_rotation,
+                ) not in gate.cache and (
                     gate._name,
                     ref_rotation,
                 ) not in reference.cache
-                will_need_cand_pixels = (candidate.id, cand_rotation) not in gate.cache and (
+                will_need_cand_pixels = (
+                    candidate.id,
+                    cand_rotation,
+                ) not in gate.cache and (
                     gate._name,
                     cand_rotation,
                 ) not in candidate.cache