Computer vision that keeps your code visible.

"""Example 1: open and display the camera."""

import cvgo as go


camera = go.Camera()

while True:
    frame = camera.read()

    if frame is None:
        break

    if not camera.show(frame):
        break

camera.close()

"""CLI example 1: read camera information without a preview window."""

import cvgo as go


camera = go.Camera()
fps = go.FPS()

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        height, width = frame.shape[:2]
        info = f"Camera: ON | Size: {width}x{height} | FPS: {fps.read():.1f}"
        print(f"\r{info:<70}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close()

"""Example 2: detect faces."""

import cvgo as go


camera = go.Camera()
detector = go.FaceDetector()

while True:
    frame = camera.read()

    if frame is None:
        break

    faces = detector.detect(frame)

    for face in faces:
        face.draw(frame)

    if not camera.show(frame):
        break

camera.close()
detector.close()

"""CLI example 2: print face detection status."""

import cvgo as go


camera = go.Camera()
detector = go.FaceDetector()
fps = go.FPS()

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        faces = detector.detect(frame)
        status = "DETECTED" if faces else "NOT DETECTED"
        info = (
            f"Face: {status} | Count: {len(faces)} | "
            f"FPS: {fps.read():.1f}"
        )
        print(f"\r{info:<70}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close()
    detector.close()

"""Example 3: display face landmarks."""

import cvgo as go


camera = go.Camera()
landmarker = go.FaceLandmarks()

while True:
    frame = camera.read()

    if frame is None:
        break

    faces = landmarker.detect(frame)

    for face in faces:
        face.draw(frame)

    if not camera.show(frame):
        break

camera.close()
landmarker.close()

"""CLI example 3: print face and landmark counts."""

import cvgo as go


camera = go.Camera()
landmarker = go.FaceLandmarks()
fps = go.FPS()

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        faces = landmarker.detect(frame)
        points = sum(len(face) for face in faces)
        info = (
            f"Faces: {len(faces)} | Landmarks: {points} | "
            f"FPS: {fps.read():.1f}"
        )
        print(f"\r{info:<70}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close()
    landmarker.close()

"""Example 4: read EAR, yaw, and pitch."""

import cvgo as go


camera = go.Camera()
landmarker = go.FaceLandmarks()

while True:
    frame = camera.read()

    if frame is None:
        break

    faces = landmarker.detect(frame)

    if faces:
        face = faces[0]

        ear = go.eye_ratio(face)
        yaw = go.yaw_ratio(face)
        pitch = go.pitch_ratio(face)

        go.put_text(frame, f"EAR: {ear:.3f}")
        go.put_text(frame, f"Yaw: {yaw:.3f}", (20, 70))
        go.put_text(frame, f"Pitch: {pitch:.3f}", (20, 105))

        face.draw(frame)

    if not camera.show(frame):
        break

camera.close()
landmarker.close()

"""CLI example 4: print EAR, yaw, and pitch values."""

import cvgo as go


camera = go.Camera()
landmarker = go.FaceLandmarks()
fps = go.FPS()

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        faces = landmarker.detect(frame)

        if faces:
            face = faces[0]
            ear = f"{go.eye_ratio(face):.3f}"
            yaw = f"{go.yaw_ratio(face):.3f}"
            pitch = f"{go.pitch_ratio(face):.3f}"
        else:
            ear = yaw = pitch = "---"

        info = (
            f"EAR: {ear} | Yaw: {yaw} | Pitch: {pitch} | "
            f"FPS: {fps.read():.1f}"
        )
        print(f"\r{info:<80}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close()
    landmarker.close()

"""Example 5: send data to Arduino."""

import cvgo as go


arduino = go.Serial()

if arduino.connected:
    arduino.send("1")

arduino.close()

"""CLI example 5: send terminal input to Arduino."""

import cvgo as go


arduino = go.Serial()

try:
    if not arduino.connected:
        print("Arduino: NOT CONNECTED")
    else:
        print(f"Arduino: CONNECTED | Port: {arduino.port}")
        print("Type a value and press Enter. Type q to quit.")

        while True:
            value = input("Send > ").strip()

            if value.lower() == "q":
                break

            if value:
                status = "SENT" if arduino.send(value) else "FAILED"
                print(f"{status}: {value}")
except KeyboardInterrupt:
    print()
finally:
    arduino.close()

"""Example 6: send face detection status to Arduino."""

import cvgo as go


camera = go.Camera()
detector = go.FaceDetector()
arduino = go.Serial()
last_status = None

while True:
    frame = camera.read()

    if frame is None:
        break

    faces = detector.detect(frame)
    status = 1 if faces else 0

    if status != last_status:
        if arduino.send(status):
            last_status = status

    for face in faces:
        face.draw(frame)

    if not camera.show(frame):
        break

camera.close()
detector.close()
arduino.close()

"""CLI example 6: send face presence to Arduino."""

import cvgo as go


camera = go.Camera()
detector = go.FaceDetector()
arduino = go.Serial()
fps = go.FPS()
last_status = None

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        faces = detector.detect(frame)
        status = 1 if faces else 0

        if status != last_status and arduino.send(status):
            last_status = status

        face_text = "DETECTED" if status else "NOT DETECTED"
        serial_text = "CONNECTED" if arduino.connected else "DISCONNECTED"
        info = (
            f"Face: {face_text} | Arduino: {serial_text} | "
            f"Sent: {last_status} | FPS: {fps.read():.1f}"
        )
        print(f"\r{info:<100}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close()
    detector.close()
    arduino.close()

"""Example 7: detect drowsiness based on EAR and duration."""

import cvgo as go


EAR_THRESHOLD = 0.20

camera = go.Camera()
landmarker = go.FaceLandmarks()
eye_timer = go.Timer(1.5)
ear_smoother = go.Smoother()
alarm = go.Alarm()

while True:
    frame = camera.read()

    if frame is None:
        break

    faces = landmarker.detect(frame)
    drowsy = False

    if faces:
        face = faces[0]
        ear = ear_smoother.update(go.eye_ratio(face))
        eyes_closed = ear < EAR_THRESHOLD
        drowsy = eye_timer.check(eyes_closed)

        status = "DROWSY" if drowsy else "NORMAL"
        color = (0, 0, 255) if drowsy else (0, 255, 0)

        go.put_text(frame, f"Status: {status}", color=color)
        go.put_text(frame, f"EAR: {ear:.3f}", (20, 70))
        face.draw(frame, color=color)
    else:
        eye_timer.reset()
        ear_smoother.reset()

    alarm.trigger(drowsy)

    if not camera.show(frame):
        break

camera.close()
landmarker.close()

"""CLI example 7: detect drowsiness and print the result."""

import cvgo as go


EAR_THRESHOLD = 0.30

camera = go.Camera()
landmarker = go.FaceLandmarks()
eye_timer = go.Timer(0.5)
ear_smoother = go.Smoother()
alarm = go.Alarm()
fps = go.FPS()

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        faces = landmarker.detect(frame)
        drowsy = False
        status = "NO FACE"
        ear_text = "---"

        if faces:
            ear = ear_smoother.update(go.eye_ratio(faces[0]))
            drowsy = eye_timer.check(ear < EAR_THRESHOLD)
            status = "DROWSY" if drowsy else "NORMAL"
            ear_text = f"{ear:.3f}"
        else:
            eye_timer.reset()
            ear_smoother.reset()

        alarm.trigger(drowsy)

        info = (
            f"Status: {status} | EAR: {ear_text} | "
            f"FPS: {fps.read():.1f}"
        )
        print(f"\r{info:<70}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close()
    landmarker.close()

"""Example 8: final driver monitor project that is still easy to study."""

import cvgo as go


# Detection thresholds
EAR_THRESHOLD = 0.20
YAW_NORMAL = 0.50
YAW_LIMIT = 0.12
PITCH_NORMAL = 0.50
PITCH_LIMIT = 0.055

# Components
camera = go.Camera()
landmarker = go.FaceLandmarks()
arduino = go.Serial()
alarm = go.Alarm()
fps_counter = go.FPS()

# Condition timers
eye_timer = go.Timer(1.5)
turn_timer = go.Timer(0.7)
down_timer = go.Timer(0.7)
missing_timer = go.Timer(2.0)

# Eye value smoother
ear_smoother = go.Smoother()

# Last serial status
last_mask = None

while True:
    frame = camera.read()

    if frame is None:
        break

    faces = landmarker.detect(frame)
    fps = fps_counter.read()

    ear = None
    yaw = None
    pitch = None

    drowsy = False
    looking_away = False
    head_down = False
    face_missing = False

    if faces:
        face = faces[0]

        ear = ear_smoother.update(go.eye_ratio(face))
        yaw = go.yaw_ratio(face)
        pitch = go.pitch_ratio(face)

        eyes_closed = ear < EAR_THRESHOLD
        turn_condition = abs(yaw - YAW_NORMAL) > YAW_LIMIT
        down_condition = pitch - PITCH_NORMAL > PITCH_LIMIT

        drowsy = eye_timer.check(eyes_closed)
        looking_away = turn_timer.check(turn_condition)
        head_down = down_timer.check(down_condition)

        missing_timer.reset()
        face.draw(frame)
    else:
        eye_timer.reset()
        turn_timer.reset()
        down_timer.reset()
        ear_smoother.reset()

        face_missing = missing_timer.check(True)

    mask = 0

    if drowsy:
        mask |= go.BIT_DROWSY

    if looking_away:
        mask |= go.BIT_LOOKING_AWAY

    if head_down:
        mask |= go.BIT_HEAD_DOWN

    if face_missing:
        mask |= go.BIT_FACE_MISSING

    if mask != last_mask:
        if arduino.send(f"{mask:X}"):
            last_mask = mask

    alerts = []

    if drowsy:
        alerts.append("DROWSY")

    if looking_away:
        alerts.append("LOOKING_AWAY")

    if head_down:
        alerts.append("HEAD_DOWN")

    if face_missing:
        alerts.append("FACE_MISSING")

    status = " | ".join(alerts) if alerts else "NORMAL"
    color = (0, 0, 255) if alerts else (0, 255, 0)

    ear_text = "-" if ear is None else f"{ear:.3f}"
    yaw_text = "-" if yaw is None else f"{yaw:.3f}"
    pitch_text = "-" if pitch is None else f"{pitch:.3f}"

    go.put_text(
        frame,
        f"Status: {status}",
        (20, 35),
        color=color,
        background=True,
    )
    go.put_text(frame, f"EAR: {ear_text}", (20, 70))
    go.put_text(frame, f"Yaw: {yaw_text}", (20, 105))
    go.put_text(frame, f"Pitch: {pitch_text}", (20, 140))
    go.put_text(frame, f"FPS: {fps:.1f} | Mask: {mask:X}", (20, 175))

    alarm.trigger(mask != 0)

    if not camera.show(frame, title="CVGO Driver Monitor"):
        break

camera.close()
landmarker.close()
arduino.close()

"""CLI example 8: complete modular driver monitoring."""

import cvgo as go


EAR_THRESHOLD = 0.20
YAW_NORMAL = 0.50
YAW_LIMIT = 0.12
PITCH_NORMAL = 0.50
PITCH_LIMIT = 0.055

camera = go.Camera()
landmarker = go.FaceLandmarks()
arduino = go.Serial()
alarm = go.Alarm()
fps = go.FPS()

eye_timer = go.Timer(1.5)
turn_timer = go.Timer(0.7)
down_timer = go.Timer(0.7)
missing_timer = go.Timer(2.0)
ear_smoother = go.Smoother()
last_mask = None

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        faces = landmarker.detect(frame)
        ear = yaw = pitch = None
        drowsy = looking_away = head_down = face_missing = False

        if faces:
            face = faces[0]
            ear = ear_smoother.update(go.eye_ratio(face))
            yaw = go.yaw_ratio(face)
            pitch = go.pitch_ratio(face)

            drowsy = eye_timer.check(ear < EAR_THRESHOLD)
            looking_away = turn_timer.check(
                abs(yaw - YAW_NORMAL) > YAW_LIMIT
            )
            head_down = down_timer.check(
                pitch - PITCH_NORMAL > PITCH_LIMIT
            )
            missing_timer.reset()
        else:
            eye_timer.reset()
            turn_timer.reset()
            down_timer.reset()
            ear_smoother.reset()
            face_missing = missing_timer.check(True)

        mask = 0

        if drowsy:
            mask |= go.BIT_DROWSY
        if looking_away:
            mask |= go.BIT_LOOKING_AWAY
        if head_down:
            mask |= go.BIT_HEAD_DOWN
        if face_missing:
            mask |= go.BIT_FACE_MISSING

        if mask != last_mask and arduino.send(f"{mask:X}"):
            last_mask = mask

        alerts = []

        if drowsy:
            alerts.append("DROWSY")
        if looking_away:
            alerts.append("LOOKING AWAY")
        if head_down:
            alerts.append("HEAD DOWN")
        if face_missing:
            alerts.append("FACE MISSING")

        status = ", ".join(alerts) if alerts else "NORMAL"
        ear_text = "---" if ear is None else f"{ear:.3f}"
        yaw_text = "---" if yaw is None else f"{yaw:.3f}"
        pitch_text = "---" if pitch is None else f"{pitch:.3f}"
        alarm.trigger(mask != 0)

        info = (
            f"Status: {status} | EAR: {ear_text} | Yaw: {yaw_text} | "
            f"Pitch: {pitch_text} | FPS: {fps.read():.1f} | Mask: {mask:X}"
        )
        print(f"\r{info:<130}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close()
    landmarker.close()
    arduino.close()

"""Example 9: hand tracking, hand labels, and FPS."""

import cvgo as go


camera = go.Camera()
tracker = go.HandTracker()
fps = go.FPS()

while True:
    frame = camera.read()

    if frame is None:
        break

    hands = tracker.detect(frame)

    for hand in hands:
        hand.draw(frame)
        label = f"{hand.handedness}: {hand.confidence:.2f}"
        hand.box().draw(frame, label=label)

    go.put_text(frame, f"Hands: {len(hands)}")
    go.put_text(frame, f"FPS: {fps.read():.1f}", (20, 70))

    if not camera.show(frame, title="CVGO Hand Tracking"):
        break

camera.close()
tracker.close()

"""CLI example 9: print hand tracking results."""

import cvgo as go


camera = go.Camera()
tracker = go.HandTracker()
fps = go.FPS()

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        hands = tracker.detect(frame)
        labels = [
            f"{hand.handedness} ({hand.confidence:.2f})"
            for hand in hands
        ]
        details = ", ".join(labels) if labels else "NONE"
        info = (
            f"Hands: {len(hands)} | Detail: {details} | "
            f"FPS: {fps.read():.1f}"
        )
        print(f"\r{info:<100}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close()
    tracker.close()

"""Example 10: body pose tracking."""

import cvgo as go


camera = go.Camera()
tracker = go.PoseTracker()
fps = go.FPS()

while True:
    frame = camera.read()

    if frame is None:
        break

    pose = tracker.detect(frame)
    person_detected = pose is not None

    if pose:
        pose.draw(frame)

    status = "POSE DETECTED" if person_detected else "NO POSE"
    color = (0, 255, 0) if person_detected else (0, 0, 255)

    go.put_text(frame, status, color=color)
    go.put_text(frame, f"FPS: {fps.read():.1f}", (20, 70))

    if not camera.show(frame, title="CVGO Pose Tracking"):
        break

camera.close()
tracker.close()

"""CLI example 10: print body pose status."""

import cvgo as go


camera = go.Camera()
tracker = go.PoseTracker()
fps = go.FPS()

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        pose = tracker.detect(frame)
        status = "DETECTED" if pose else "NOT DETECTED"
        points = len(pose) if pose else 0
        info = (
            f"Pose: {status} | Landmarks: {points} | "
            f"FPS: {fps.read():.1f}"
        )
        print(f"\r{info:<80}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close()
    tracker.close()

"""Example 11: lightweight person security with a pose bounding box."""

import cvgo as go


camera = go.Camera()
tracker = go.PoseTracker(model_complexity=0)
presence_timer = go.Timer(0.5)
alarm = go.Alarm()
fps = go.FPS()

while True:
    frame = camera.read()

    if frame is None:
        break

    pose = tracker.detect(frame)
    person_detected = pose is not None
    alert = presence_timer.check(person_detected)

    status = "ALERT" if alert else "SAFE"
    color = (0, 0, 255) if alert else (0, 255, 0)

    if pose:
        pose.box(
            padding=30,
        ).draw(
            frame,
            color=color,
            label="Person",
        )

    go.put_text(frame, f"Status: {status}", color=color)
    go.put_text(frame, f"FPS: {fps.read():.1f}", (20, 70))
    alarm.trigger(alert)

    if not camera.show(frame, title="CVGO Person Security Lite"):
        break

camera.close()
tracker.close()

"""CLI example 11: run lightweight person security with Pose Lite."""

import cvgo as go


camera = go.Camera()
tracker = go.PoseTracker(model_complexity=0)
presence_timer = go.Timer(0.5)
alarm = go.Alarm()
fps = go.FPS()

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        pose = tracker.detect(frame)
        alert = presence_timer.check(pose is not None)
        status = "ALERT" if alert else "SAFE"
        info = f"Security: {status} | FPS: {fps.read():.1f}"

        alarm.trigger(alert)
        print(f"\r{info:<60}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close()
    tracker.close()

"""Example 12: general object detection."""

import cvgo as go


camera = go.Camera()
detector = go.ObjectDetector(mode="live")
fps = go.FPS()

while True:
    frame = camera.read()

    if frame is None:
        break

    objects = detector.detect(frame)

    for item in objects:
        item.draw(frame)

    go.put_text(frame, f"Objects: {len(objects)}")
    go.put_text(frame, f"Loop FPS: {fps.read():.1f}", (20, 70))

    if not camera.show(frame, title="CVGO Object Detection"):
        break

camera.close()
detector.close()

"""CLI example 12: print detected object labels and scores."""

import cvgo as go


camera = go.Camera()
detector = go.ObjectDetector(mode="live")
fps = go.FPS()

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        objects = detector.detect(frame)
        labels = [
            f"{item.label} ({item.score:.2f})"
            for item in objects[:3]
        ]
        details = ", ".join(labels) if labels else "NONE"
        info = (
            f"Objects: {len(objects)} | Top: {details} | "
            f"Loop FPS: {fps.read():.1f}"
        )
        print(f"\r{info:<120}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close()
    detector.close()

"""Example 13: detect multiple people for simple security."""

import cvgo as go


camera = go.Camera()
detector = go.ObjectDetector(allow=["person"], mode="live")
presence_timer = go.Timer(0.5)
alarm = go.Alarm()

while True:
    frame = camera.read()

    if frame is None:
        break

    people = detector.detect(frame)
    alert = presence_timer.check(bool(people))

    for person in people:
        person.draw(frame, color=(0, 0, 255))

    status = "ALERT" if alert else "SAFE"
    color = (0, 0, 255) if alert else (0, 255, 0)

    go.put_text(frame, f"Status: {status}", color=color)
    go.put_text(frame, f"Count: {len(people)}", (20, 70))
    alarm.trigger(alert)

    if not camera.show(frame, title="CVGO Person Security"):
        break

camera.close()
detector.close()

"""CLI example 13: detect people for a terminal security monitor."""

import cvgo as go


camera = go.Camera()
detector = go.ObjectDetector(allow=["person"], mode="live")
presence_timer = go.Timer(0.5)
alarm = go.Alarm()
fps = go.FPS()

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        people = detector.detect(frame)
        alert = presence_timer.check(bool(people))
        status = "ALERT" if alert else "SAFE"
        info = (
            f"Security: {status} | People: {len(people)} | "
            f"Loop FPS: {fps.read():.1f}"
        )

        alarm.trigger(alert)
        print(f"\r{info:<70}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close()
    detector.close()

"""Example 14: hand gesture recognition."""

import cvgo as go


camera = go.Camera()
recognizer = go.GestureRecognizer(mode="live")

while True:
    frame = camera.read()

    if frame is None:
        break

    gestures = recognizer.detect(frame)

    for gesture in gestures:
        gesture.draw(frame)

    if not camera.show(frame, title="CVGO Gesture Recognition"):
        break

camera.close()
recognizer.close()

"""CLI example 14: print recognized hand gestures."""

import cvgo as go


camera = go.Camera()
recognizer = go.GestureRecognizer(mode="live")
fps = go.FPS()

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        gestures = recognizer.detect(frame)
        labels = [
            f"{gesture.label} ({gesture.score:.2f})"
            for gesture in gestures
            if gesture.recognized
        ]
        details = ", ".join(labels) if labels else "NONE"
        info = f"Gestures: {details} | Loop FPS: {fps.read():.1f}"
        print(f"\r{info:<100}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close()
    recognizer.close()

"""Example 15: face, pose, and hands in one pipeline."""

import cvgo as go


camera = go.Camera()
tracker = go.HolisticTracker()

while True:
    frame = camera.read()

    if frame is None:
        break

    result = tracker.detect(frame)
    result.draw(frame)

    if not camera.show(frame, title="CVGO Holistic Tracking"):
        break

camera.close()
tracker.close()

"""CLI example 15: print face, pose, and hand status."""

import cvgo as go


camera = go.Camera()
tracker = go.HolisticTracker()
fps = go.FPS()

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        result = tracker.detect(frame)
        face = "YES" if result.face else "NO"
        pose = "YES" if result.pose else "NO"
        info = (
            f"Face: {face} | Pose: {pose} | Hands: {len(result.hands)} | "
            f"FPS: {fps.read():.1f}"
        )
        print(f"\r{info:<80}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close()
    tracker.close()

"""Example 16: blur the webcam background."""

import cvgo as go


camera = go.Camera()
segmenter = go.SelfieSegmenter()

while True:
    frame = camera.read()

    if frame is None:
        break

    result = segmenter.segment(frame)
    frame = result.blur(frame)

    if not camera.show(frame, title="CVGO Selfie Segmentation"):
        break

camera.close()
segmenter.close()

"""CLI example 16: print foreground coverage from segmentation."""

import cvgo as go


camera = go.Camera()
segmenter = go.SelfieSegmenter()
fps = go.FPS()

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        result = segmenter.segment(frame)
        coverage = result.foreground().mean() * 100
        info = (
            f"Person coverage: {coverage:.1f}% | "
            f"FPS: {fps.read():.1f}"
        )
        print(f"\r{info:<70}", end="", flush=True)
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close()
    segmenter.close()

"""Example 17: send a Telegram photo when a person is detected."""

import cvgo as go


camera = go.Camera()
detector = go.ObjectDetector(allow=["person"], mode="live")
telegram = go.Telegram()
presence_timer = go.Timer(0.5)
notified = False
pending = None

while True:
    frame = camera.read()

    if frame is None:
        break

    people = detector.detect(frame)
    alert = presence_timer.check(bool(people))

    if pending is not None and pending.done():
        if not pending.result():
            print(f"Telegram: {telegram.last_error}")
        pending = None

    for person in people:
        person.draw(frame, color=(0, 0, 255))

    status = "PERSON DETECTED" if alert else "SAFE"
    color = (0, 0, 255) if alert else (0, 255, 0)
    go.put_text(frame, f"Status: {status}", color=color)

    if alert and not notified and pending is None:
        pending = telegram.send_photo_async(
            frame,
            f"Warning: {len(people)} person(s) detected.",
            key="security",
        )

    notified = alert

    if not camera.show(frame, title="CVGO Telegram Security"):
        break

camera.close()
detector.close()
telegram.close()

"""CLI example 17: send a Telegram photo when a person is detected."""

import cvgo as go


camera = go.Camera()
detector = go.ObjectDetector(allow=["person"], mode="live")
telegram = go.Telegram()
presence_timer = go.Timer(0.5)
fps = go.FPS()
notified = False
telegram_status = "WAITING"
pending = None

try:
    while True:
        frame = camera.read()

        if frame is None:
            break

        people = detector.detect(frame)
        alert = presence_timer.check(bool(people))

        if pending is not None and pending.done():
            sent = pending.result()
            telegram_status = "SENT" if sent else "FAILED"
            pending = None

        if alert and not notified and pending is None:
            pending = telegram.send_photo_async(
                frame,
                f"Warning: {len(people)} person(s) detected.",
                key="security",
            )
            telegram_status = "QUEUED"
            notified = True
        elif not alert:
            notified = False
            telegram_status = "WAITING"

        status = "PERSON DETECTED" if alert else "SAFE"
        info = (
            f"Security: {status} | People: {len(people)} | "
            f"Telegram: {telegram_status} | "
            f"Loop FPS: {fps.read():.1f}"
        )
        print(f"\r{info:<110}", end="", flush=True)

        if telegram_status == "FAILED":
            print(f"\nTelegram: {telegram.last_error}")
            telegram_status = "ERROR SHOWN"
except KeyboardInterrupt:
    pass
finally:
    print()
    camera.close()
    detector.close()
    telegram.close()