피파가 청하는 카메라

# backend/services/device_look.py:43-54 (cwkPippa)
def _camera_request(arguments: dict) -> dict:
    lens = arguments.get("lens")
    if lens not in ("front", "back", "current"):
        raise LookUnavailable("Choose front, back, or current.")
    return {"lens": lens, "reason": str(arguments.get("reason") or "Look at the scene")[:300]}


def _camera_check(request: dict, result: dict) -> None:
    if result.get("lens") not in ("front", "back") or (
        request["lens"] != "current" and request["lens"] != result["lens"]
    ):
        raise LookUnavailable("The photo came from a different lens.")

// cwkSiblingKit CwkKit/Sources/CwkKitMedia/VoiceCamera.swift:129-148
    /// Only a brain tool request selects a lens automatically. Always wait for a frame
    /// captured AFTER the request, never an old onset or the opposite lens.
    public func captureForBrain(lens: String) async throws -> VoiceCameraFrame {
      guard enabled, !suspended, ["front", "back", "current"].contains(lens) else {
        throw CancellationError()
      }
      if lens != "current" { select(front: lens == "front") }
      let token = captureGeneration
      let requestedAt = Date()
      for _ in 0..<100 {
        try Task.checkCancellation()
        guard enabled, !suspended, captureGeneration == token else { throw CancellationError() }
        if let frame = frames.latest, frame.front == front, frame.capturedAt >= requestedAt {
          return frame
        }
        if problem != nil { throw CancellationError() }
        try await Task.sleep(for: .milliseconds(50))
      }
      throw CancellationError()
    }

from __future__ import annotations

from dataclasses import dataclass

FRESH_SECONDS = 3.0      # a camera whose latest view is older contributes nothing
SCENE_DIFFERENCE = 0.12  # how far two views must differ to count as two scenes


@dataclass(frozen=True)
class Frame:
    at: float     # seconds since the talk began
    scene: float  # a stand-in for the picture: two views differ by |a - b|
    name: str

    def difference(self, other: "Frame") -> float:
        return abs(self.scene - other.scene)


class TurnFrames:
    """Keep the onset, one changed scene and the latest view, never a movie."""

    def __init__(self) -> None:
        self.latest: Frame | None = None
        self.onset: Frame | None = None
        self.changed: Frame | None = None
        self.speaking = False

    def accept(self, frame: Frame, keep_looking: bool) -> None:
        if self.speaking and keep_looking and self.latest is not None \
                and frame.difference(self.latest) >= SCENE_DIFFERENCE:
            # Keep the scene that just went away; the new view has its own slot.
            # Like the kit, this checks only that it is not the onset, never its
            # age: a view older than the turn can still land here.
            if self.onset is None or self.latest.name != self.onset.name:
                self.changed = self.latest
        self.latest = frame

    def speech_began(self, now: float) -> None:
        if self.speaking:
            return
        self.speaking = True
        fresh = self.latest is not None and now - self.latest.at <= FRESH_SECONDS
        self.onset = self.latest if fresh else None
        self.changed = None

    def take(self, keep_looking: bool, now: float) -> list[str]:
        latest, onset, changed = self.latest, self.onset, self.changed
        self.onset = self.changed = None
        self.speaking = False
        if latest is None or now - latest.at > FRESH_SECONDS:
            return []                                   # a frozen camera adds nothing
        picked = []
        if onset is not None and onset.difference(latest) >= SCENE_DIFFERENCE:
            picked.append(onset)
        if keep_looking and changed is not None and changed.difference(latest) >= SCENE_DIFFERENCE:
            picked.append(changed)
        picked.append(latest)
        names: list[str] = []
        for frame in sorted(picked, key=lambda f: f.at):
            if frame.name not in names:
                names.append(frame.name)
        return names


def utterance(scenes: list[float], keep_looking: bool, stop_camera_at: int | None = None) -> list[str]:
    """One JPEG a second while Dad talks for len(scenes) seconds."""
    frames = TurnFrames()
    frames.accept(Frame(0.0, scenes[0], "before"), keep_looking)
    frames.speech_began(now=0.5)
    for second, scene in enumerate(scenes, start=1):
        if stop_camera_at is None or second < stop_camera_at:
            frames.accept(Frame(float(second), scene, f"t{second}"), keep_looking)
    return frames.take(keep_looking, now=len(scenes) + 0.5)


walk = [0.1] * 40 + [0.5] * 40 + [0.9] * 40     # two minutes, three scenes
print("when speaking, 2 min, 3 scenes:", utterance(walk, keep_looking=False))
print("keep looking,  2 min, 3 scenes:", utterance(walk, keep_looking=True))
print("one scene the whole time      :", utterance([0.3] * 20, keep_looking=True))
print("camera froze 5 s before the end:", utterance([0.3] * 20, keep_looking=True, stop_camera_at=16))

# Output:
# when speaking, 2 min, 3 scenes: ['before', 't120']
# keep looking,  2 min, 3 scenes: ['before', 't80', 't120']
# one scene the whole time      : ['t20']
# camera froze 5 s before the end: []