Add Camera Capture overlay (F6) with multi-trigger capture pipeline
Camera backend abstraction wrapping fswebcam/ffmpeg/libcamera-still via subprocess, with DemoCamera fallback generating valid JPEG from raw bytes. Capture pipeline writes JPEG + JSON sidecar always, optional FITS (astropy) and EXIF (Pillow) when available. Thread-safe orchestrator with session tracking, sequence numbering, and date-based output directories. Trigger system: manual capture, configurable interval timer, and pass event detection (AOS/TCA/LOS) with 0.5-degree TCA hysteresis. PassEventDetector runs in the Craft tracking loop, fires callbacks to the camera overlay. F6 overlay follows the F5 ConsoleOverlay pattern — ModalScreen with install_screen persistence. Status panel, scrollable capture log, interval controls, and AOS/TCA/LOS toggle buttons. Tagline: "a generic AZ/EL positioner that doesn't care about wavelength" added to TUI header subtitle. 51 new tests (77 total passing).
This commit is contained in:
parent
6c1e9da773
commit
7035d814a1
@ -14,6 +14,9 @@ dependencies = [
|
||||
"textual>=1.0.0",
|
||||
]
|
||||
|
||||
[project.optional-dependencies]
|
||||
camera = ["Pillow>=10.0", "astropy>=6.0"]
|
||||
|
||||
[project.scripts]
|
||||
birdcage-tui = "birdcage_tui.app:main"
|
||||
|
||||
|
||||
@ -16,6 +16,7 @@ from textual.binding import Binding
|
||||
from textual.containers import Horizontal
|
||||
from textual.widgets import Button, ContentSwitcher, Footer, Header
|
||||
|
||||
from birdcage_tui.screens.camera import CameraOverlay
|
||||
from birdcage_tui.screens.console import ConsoleOverlay
|
||||
from birdcage_tui.screens.control import ControlScreen
|
||||
from birdcage_tui.screens.dashboard import DashboardScreen
|
||||
@ -45,6 +46,7 @@ class BirdcageApp(App):
|
||||
Binding("f3", "switch_tab('signal')", "Signal"),
|
||||
Binding("f4", "switch_tab('system')", "System"),
|
||||
Binding("f5", "toggle_console", "Console"),
|
||||
Binding("f6", "toggle_camera", "Camera"),
|
||||
Binding("q", "quit", "Quit"),
|
||||
Binding("d", "toggle_dark", "Dark"),
|
||||
]
|
||||
@ -55,6 +57,8 @@ class BirdcageApp(App):
|
||||
firmware_name: str = "g2"
|
||||
skip_init: bool = False
|
||||
craft_url: str = "https://space.warehack.ing"
|
||||
capture_dir: str = "captures"
|
||||
camera_device: str = "auto"
|
||||
device: object = None
|
||||
shutdown_event: threading.Event = threading.Event()
|
||||
|
||||
@ -64,12 +68,15 @@ class BirdcageApp(App):
|
||||
_prev_az: float = 0.0
|
||||
_prev_el: float = 0.0
|
||||
_console_visible: bool = False
|
||||
_camera_visible: bool = False
|
||||
_pass_detector: object = None # PassEventDetector, set by CameraOverlay
|
||||
|
||||
@property
|
||||
def SUB_TITLE(self) -> str: # noqa: N802
|
||||
tag = "a generic AZ/EL positioner that doesn't care about wavelength"
|
||||
if self.demo_mode:
|
||||
return "DEMO"
|
||||
return self.serial_port
|
||||
return f"{tag} · DEMO"
|
||||
return f"{tag} · {self.serial_port}"
|
||||
|
||||
def compose(self) -> ComposeResult:
|
||||
yield Header()
|
||||
@ -114,6 +121,7 @@ class BirdcageApp(App):
|
||||
self._setup_craft_client()
|
||||
self._update_status_strip_connection()
|
||||
self._install_console()
|
||||
self._install_camera()
|
||||
self._start_position_poll()
|
||||
|
||||
async def _initialize_device(self) -> None:
|
||||
@ -159,6 +167,10 @@ class BirdcageApp(App):
|
||||
"""Pre-install the console overlay so it persists across open/close."""
|
||||
self.install_screen(ConsoleOverlay(), name="console-overlay")
|
||||
|
||||
def _install_camera(self) -> None:
|
||||
"""Pre-install the camera overlay so it persists across open/close."""
|
||||
self.install_screen(CameraOverlay(), name="camera-overlay")
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# App-level position poll
|
||||
# ------------------------------------------------------------------
|
||||
@ -246,6 +258,25 @@ class BirdcageApp(App):
|
||||
"""Called when the console overlay is dismissed."""
|
||||
self._console_visible = False
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Camera overlay
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def action_toggle_camera(self) -> None:
|
||||
"""Push or pop the camera capture overlay."""
|
||||
if self._camera_visible:
|
||||
try:
|
||||
self.pop_screen()
|
||||
except Exception:
|
||||
self._camera_visible = False
|
||||
else:
|
||||
self.push_screen("camera-overlay", callback=self._on_camera_dismissed)
|
||||
self._camera_visible = True
|
||||
|
||||
def _on_camera_dismissed(self, _result=None) -> None:
|
||||
"""Called when the camera overlay is dismissed."""
|
||||
self._camera_visible = False
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Tab bar button handling
|
||||
# ------------------------------------------------------------------
|
||||
@ -329,6 +360,16 @@ def main() -> None:
|
||||
default="https://space.warehack.ing",
|
||||
help="Craft API base URL",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--capture-dir",
|
||||
default="captures",
|
||||
help="Output directory for camera captures",
|
||||
)
|
||||
parser.add_argument(
|
||||
"--camera-device",
|
||||
default="auto",
|
||||
help="Camera device (e.g., /dev/video0) or 'auto'",
|
||||
)
|
||||
args = parser.parse_args()
|
||||
|
||||
app = BirdcageApp()
|
||||
@ -337,6 +378,8 @@ def main() -> None:
|
||||
app.firmware_name = args.firmware
|
||||
app.skip_init = args.skip_init
|
||||
app.craft_url = args.craft_url
|
||||
app.capture_dir = args.capture_dir
|
||||
app.camera_device = args.camera_device
|
||||
try:
|
||||
app.run()
|
||||
except KeyboardInterrupt:
|
||||
|
||||
375
tui/src/birdcage_tui/camera.py
Normal file
375
tui/src/birdcage_tui/camera.py
Normal file
@ -0,0 +1,375 @@
|
||||
"""Camera backend abstraction — capture images from USB/CSI cameras.
|
||||
|
||||
Wraps fswebcam/ffmpeg/libcamera-still via subprocess for zero-dependency
|
||||
operation. DemoCamera generates placeholder frames without hardware.
|
||||
|
||||
No TUI dependency. All methods are blocking — designed for
|
||||
@work(thread=True) workers in the TUI.
|
||||
"""
|
||||
|
||||
import glob
|
||||
import logging
|
||||
import shutil
|
||||
import struct
|
||||
import subprocess
|
||||
import time
|
||||
from abc import ABC, abstractmethod
|
||||
from dataclasses import dataclass, field
|
||||
from pathlib import Path
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
|
||||
@dataclass
|
||||
class CameraConfig:
|
||||
"""Camera hardware and capture settings."""
|
||||
|
||||
device: str = "/dev/video0"
|
||||
resolution: tuple[int, int] = (1280, 720)
|
||||
backend_cmd: str = "fswebcam" # fswebcam | ffmpeg | libcamera-still
|
||||
extra_args: list[str] = field(default_factory=list)
|
||||
|
||||
|
||||
@dataclass
|
||||
class CaptureResult:
|
||||
"""Outcome of a single capture attempt."""
|
||||
|
||||
path: Path
|
||||
timestamp: str # ISO-8601 UTC
|
||||
duration_ms: float
|
||||
success: bool
|
||||
error: str = ""
|
||||
|
||||
|
||||
class CameraBackend(ABC):
|
||||
"""Abstract camera backend. Subclasses wrap specific capture tools."""
|
||||
|
||||
@abstractmethod
|
||||
def capture(self, output_path: Path) -> CaptureResult:
|
||||
"""Capture a single frame to output_path. Blocking."""
|
||||
|
||||
@abstractmethod
|
||||
def is_available(self) -> bool:
|
||||
"""Check if the backend tool and device are accessible."""
|
||||
|
||||
@property
|
||||
@abstractmethod
|
||||
def name(self) -> str:
|
||||
"""Human-readable backend identifier."""
|
||||
|
||||
|
||||
class SubprocessCamera(CameraBackend):
|
||||
"""Camera backend wrapping fswebcam/ffmpeg/libcamera-still.
|
||||
|
||||
Each tool is invoked via subprocess.run() with a 10-second timeout.
|
||||
The caller provides the output path; the backend builds the command.
|
||||
"""
|
||||
|
||||
_COMMANDS: dict[str, list[str]] = {
|
||||
"fswebcam": [
|
||||
"fswebcam",
|
||||
"-r",
|
||||
"{width}x{height}",
|
||||
"--no-banner",
|
||||
"-d",
|
||||
"{device}",
|
||||
"{output}",
|
||||
],
|
||||
"ffmpeg": [
|
||||
"ffmpeg",
|
||||
"-y",
|
||||
"-f",
|
||||
"v4l2",
|
||||
"-video_size",
|
||||
"{width}x{height}",
|
||||
"-i",
|
||||
"{device}",
|
||||
"-frames:v",
|
||||
"1",
|
||||
"{output}",
|
||||
],
|
||||
"libcamera-still": [
|
||||
"libcamera-still",
|
||||
"--width",
|
||||
"{width}",
|
||||
"--height",
|
||||
"{height}",
|
||||
"-t",
|
||||
"1",
|
||||
"-o",
|
||||
"{output}",
|
||||
],
|
||||
}
|
||||
|
||||
def __init__(self, config: CameraConfig) -> None:
|
||||
self._config = config
|
||||
|
||||
def capture(self, output_path: Path) -> CaptureResult:
|
||||
ts = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
|
||||
t0 = time.monotonic()
|
||||
|
||||
template = self._COMMANDS.get(self._config.backend_cmd)
|
||||
if template is None:
|
||||
return CaptureResult(
|
||||
path=output_path,
|
||||
timestamp=ts,
|
||||
duration_ms=0.0,
|
||||
success=False,
|
||||
error=f"Unknown backend: {self._config.backend_cmd}",
|
||||
)
|
||||
|
||||
w, h = self._config.resolution
|
||||
cmd = [
|
||||
part.format(
|
||||
width=w,
|
||||
height=h,
|
||||
device=self._config.device,
|
||||
output=str(output_path),
|
||||
)
|
||||
for part in template
|
||||
]
|
||||
cmd.extend(self._config.extra_args)
|
||||
|
||||
try:
|
||||
result = subprocess.run(
|
||||
cmd,
|
||||
capture_output=True,
|
||||
timeout=10,
|
||||
check=False,
|
||||
)
|
||||
elapsed = (time.monotonic() - t0) * 1000
|
||||
if result.returncode != 0:
|
||||
stderr = result.stderr.decode(errors="replace")[:200]
|
||||
return CaptureResult(
|
||||
path=output_path,
|
||||
timestamp=ts,
|
||||
duration_ms=elapsed,
|
||||
success=False,
|
||||
error=f"Exit {result.returncode}: {stderr}",
|
||||
)
|
||||
return CaptureResult(
|
||||
path=output_path,
|
||||
timestamp=ts,
|
||||
duration_ms=elapsed,
|
||||
success=True,
|
||||
)
|
||||
except subprocess.TimeoutExpired:
|
||||
elapsed = (time.monotonic() - t0) * 1000
|
||||
return CaptureResult(
|
||||
path=output_path,
|
||||
timestamp=ts,
|
||||
duration_ms=elapsed,
|
||||
success=False,
|
||||
error="Capture timed out (10s)",
|
||||
)
|
||||
except FileNotFoundError:
|
||||
return CaptureResult(
|
||||
path=output_path,
|
||||
timestamp=ts,
|
||||
duration_ms=0.0,
|
||||
success=False,
|
||||
error=f"{self._config.backend_cmd} not found",
|
||||
)
|
||||
|
||||
def is_available(self) -> bool:
|
||||
return shutil.which(self._config.backend_cmd) is not None
|
||||
|
||||
@property
|
||||
def name(self) -> str:
|
||||
return f"{self._config.backend_cmd} ({self._config.device})"
|
||||
|
||||
|
||||
class DemoCamera(CameraBackend):
|
||||
"""Generates a minimal valid JPEG without external dependencies.
|
||||
|
||||
When Pillow is available, renders a placeholder frame with a timestamp
|
||||
overlay. Otherwise creates a tiny valid JPEG (gray 1x1 pixel). Always
|
||||
available — used in --demo mode.
|
||||
"""
|
||||
|
||||
def __init__(self, resolution: tuple[int, int] = (1280, 720)) -> None:
|
||||
self._resolution = resolution
|
||||
|
||||
def capture(self, output_path: Path) -> CaptureResult:
|
||||
ts = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
|
||||
t0 = time.monotonic()
|
||||
|
||||
try:
|
||||
self._write_frame(output_path, ts)
|
||||
elapsed = (time.monotonic() - t0) * 1000
|
||||
return CaptureResult(
|
||||
path=output_path,
|
||||
timestamp=ts,
|
||||
duration_ms=elapsed,
|
||||
success=True,
|
||||
)
|
||||
except Exception as exc:
|
||||
elapsed = (time.monotonic() - t0) * 1000
|
||||
return CaptureResult(
|
||||
path=output_path,
|
||||
timestamp=ts,
|
||||
duration_ms=elapsed,
|
||||
success=False,
|
||||
error=str(exc),
|
||||
)
|
||||
|
||||
def _write_frame(self, output_path: Path, timestamp: str) -> None:
|
||||
"""Try Pillow first, fall back to minimal JPEG."""
|
||||
try:
|
||||
from PIL import Image, ImageDraw
|
||||
|
||||
w, h = self._resolution
|
||||
img = Image.new("RGB", (w, h), color=(14, 20, 32))
|
||||
draw = ImageDraw.Draw(img)
|
||||
draw.text((20, 20), "DEMO CAPTURE", fill=(0, 212, 170))
|
||||
draw.text((20, 50), timestamp, fill=(200, 208, 216))
|
||||
draw.text((20, 80), f"{w}x{h}", fill=(80, 104, 120))
|
||||
img.save(output_path, "JPEG", quality=85)
|
||||
except ImportError:
|
||||
self._write_minimal_jpeg(output_path)
|
||||
|
||||
def _write_minimal_jpeg(self, output_path: Path) -> None:
|
||||
"""Write a valid 1x1 gray JPEG (smallest possible valid file)."""
|
||||
# Minimal JFIF: SOI + APP0 + DQT + SOF0 + DHT + SOS + data + EOI
|
||||
# This is a pre-computed 1x1 gray pixel JPEG.
|
||||
data = bytes(
|
||||
[
|
||||
0xFF,
|
||||
0xD8, # SOI
|
||||
0xFF,
|
||||
0xE0, # APP0 (JFIF)
|
||||
]
|
||||
)
|
||||
app0_payload = b"JFIF\x00\x01\x01\x00\x00\x01\x00\x01\x00\x00"
|
||||
data += struct.pack(">H", len(app0_payload) + 2) + app0_payload
|
||||
|
||||
# Quantization table (all 1s for simplicity)
|
||||
dqt = bytes([0xFF, 0xDB, 0x00, 0x43, 0x00]) + bytes([1] * 64)
|
||||
data += dqt
|
||||
|
||||
# SOF0 (baseline, 1x1, 1 component, Y only)
|
||||
sof0 = bytes(
|
||||
[
|
||||
0xFF,
|
||||
0xC0,
|
||||
0x00,
|
||||
0x0B,
|
||||
0x08,
|
||||
0x00,
|
||||
0x01,
|
||||
0x00,
|
||||
0x01, # height=1, width=1
|
||||
0x01,
|
||||
0x01,
|
||||
0x11,
|
||||
0x00, # 1 component, sampling 1x1, quant table 0
|
||||
]
|
||||
)
|
||||
data += sof0
|
||||
|
||||
# DHT (minimal Huffman table for DC)
|
||||
dht = bytes(
|
||||
[
|
||||
0xFF,
|
||||
0xC4,
|
||||
0x00,
|
||||
0x1F,
|
||||
0x00,
|
||||
0x00,
|
||||
0x01,
|
||||
0x05,
|
||||
0x01,
|
||||
0x01,
|
||||
0x01,
|
||||
0x01,
|
||||
0x01,
|
||||
0x01,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x01,
|
||||
0x02,
|
||||
0x03,
|
||||
0x04,
|
||||
0x05,
|
||||
0x06,
|
||||
0x07,
|
||||
0x08,
|
||||
0x09,
|
||||
0x0A,
|
||||
0x0B,
|
||||
]
|
||||
)
|
||||
data += dht
|
||||
|
||||
# SOS + encoded data (gray pixel value 128)
|
||||
sos = bytes(
|
||||
[
|
||||
0xFF,
|
||||
0xDA,
|
||||
0x00,
|
||||
0x08,
|
||||
0x01,
|
||||
0x01,
|
||||
0x00,
|
||||
0x00,
|
||||
0x3F,
|
||||
0x00,
|
||||
0x7F,
|
||||
0x49, # encoded pixel data
|
||||
]
|
||||
)
|
||||
data += sos
|
||||
|
||||
# EOI
|
||||
data += bytes([0xFF, 0xD9])
|
||||
|
||||
output_path.write_bytes(data)
|
||||
|
||||
def is_available(self) -> bool:
|
||||
return True
|
||||
|
||||
@property
|
||||
def name(self) -> str:
|
||||
return "demo"
|
||||
|
||||
|
||||
def detect_cameras() -> list[str]:
|
||||
"""Discover available video capture devices."""
|
||||
devices = sorted(glob.glob("/dev/video*"))
|
||||
return devices
|
||||
|
||||
|
||||
def auto_select_backend(config: CameraConfig) -> CameraBackend:
|
||||
"""Pick the best available backend for the given config.
|
||||
|
||||
Tries the configured backend first, then falls through alternatives.
|
||||
Falls back to DemoCamera if nothing is available.
|
||||
"""
|
||||
# Try configured backend first
|
||||
candidate = SubprocessCamera(config)
|
||||
if candidate.is_available():
|
||||
log.info("Using %s backend", config.backend_cmd)
|
||||
return candidate
|
||||
|
||||
# Try alternatives in preference order
|
||||
for alt_cmd in ("fswebcam", "ffmpeg", "libcamera-still"):
|
||||
if alt_cmd == config.backend_cmd:
|
||||
continue
|
||||
alt_config = CameraConfig(
|
||||
device=config.device,
|
||||
resolution=config.resolution,
|
||||
backend_cmd=alt_cmd,
|
||||
)
|
||||
alt = SubprocessCamera(alt_config)
|
||||
if alt.is_available():
|
||||
log.info("Falling back to %s backend", alt_cmd)
|
||||
return alt
|
||||
|
||||
log.info("No camera backend available, using demo")
|
||||
return DemoCamera(config.resolution)
|
||||
286
tui/src/birdcage_tui/capture_manager.py
Normal file
286
tui/src/birdcage_tui/capture_manager.py
Normal file
@ -0,0 +1,286 @@
|
||||
"""Capture orchestrator — coordinates camera backend + metadata + output files.
|
||||
|
||||
Thread-safe (internal lock). All methods blocking — designed for
|
||||
@work(thread=True) workers. Writes JPEG + JSON sidecar always;
|
||||
optionally adds EXIF (Pillow) and FITS (astropy) when available.
|
||||
"""
|
||||
|
||||
import json
|
||||
import logging
|
||||
import re
|
||||
import threading
|
||||
import time
|
||||
import uuid
|
||||
from dataclasses import asdict, dataclass, field
|
||||
from pathlib import Path
|
||||
|
||||
from birdcage_tui.camera import CameraBackend, CaptureResult
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
# Optional dependencies — graceful degradation
|
||||
try:
|
||||
from PIL import Image
|
||||
|
||||
HAS_PILLOW = True
|
||||
except ImportError:
|
||||
HAS_PILLOW = False
|
||||
|
||||
try:
|
||||
from astropy.io import fits as astropy_fits
|
||||
|
||||
HAS_ASTROPY = True
|
||||
except ImportError:
|
||||
HAS_ASTROPY = False
|
||||
|
||||
# Filename-safe character filter
|
||||
_SAFE_RE = re.compile(r"[^a-zA-Z0-9_\-]")
|
||||
|
||||
|
||||
@dataclass
|
||||
class CaptureMetadata:
|
||||
"""Everything we know about a capture at the moment the shutter fires."""
|
||||
|
||||
# Timing
|
||||
timestamp: str = "" # ISO-8601 UTC
|
||||
capture_duration_ms: float = 0.0
|
||||
|
||||
# Mount position (actual dish position at capture time)
|
||||
mount_az: float = 0.0
|
||||
mount_el: float = 0.0
|
||||
|
||||
# Target info (from active tracking, if any)
|
||||
target_name: str = ""
|
||||
target_type: str = "" # satellite, planet, star, comet, ""
|
||||
target_id: str = ""
|
||||
target_az: float | None = None
|
||||
target_el: float | None = None
|
||||
target_distance_km: float | None = None
|
||||
target_range_rate: float | None = None
|
||||
|
||||
# Context
|
||||
tracking_mode: str = "manual" # manual, craft, rotctld
|
||||
tracking_status: str = "" # TRACKING, WAITING, IDLE
|
||||
trigger: str = "manual" # manual, interval, aos, tca, los
|
||||
|
||||
# Sequence
|
||||
sequence_number: int = 0
|
||||
session_id: str = ""
|
||||
|
||||
# Camera
|
||||
camera_backend: str = ""
|
||||
camera_device: str = ""
|
||||
resolution: tuple[int, int] = (0, 0)
|
||||
|
||||
# Device
|
||||
firmware_version: str = ""
|
||||
|
||||
|
||||
@dataclass
|
||||
class CaptureSession:
|
||||
"""Tracks a capture session with sequential numbering."""
|
||||
|
||||
session_id: str = field(default_factory=lambda: uuid.uuid4().hex[:12])
|
||||
start_time: str = field(
|
||||
default_factory=lambda: time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
|
||||
)
|
||||
capture_count: int = 0
|
||||
output_dir: Path = Path("captures")
|
||||
|
||||
def next_sequence(self) -> int:
|
||||
self.capture_count += 1
|
||||
return self.capture_count
|
||||
|
||||
|
||||
def _sanitize_name(name: str) -> str:
|
||||
"""Make a target name filesystem-safe."""
|
||||
if not name:
|
||||
return "manual"
|
||||
cleaned = name.replace(" ", "-")
|
||||
cleaned = _SAFE_RE.sub("", cleaned)
|
||||
return cleaned[:40] or "capture"
|
||||
|
||||
|
||||
def _build_filename(metadata: CaptureMetadata, ext: str) -> str:
|
||||
"""Generate filename: {target}_{az:06.2f}_{el:05.2f}_{timestamp}.{ext}"""
|
||||
name = _sanitize_name(metadata.target_name)
|
||||
az = f"{metadata.mount_az:06.2f}"
|
||||
el = f"{metadata.mount_el:05.2f}"
|
||||
# Compact timestamp: 20260216T082500Z
|
||||
ts = metadata.timestamp.replace("-", "").replace(":", "").replace(" ", "")
|
||||
return f"{name}_{az}_{el}_{ts}.{ext}"
|
||||
|
||||
|
||||
class CaptureManager:
|
||||
"""Orchestrates capture → metadata → output pipeline.
|
||||
|
||||
Usage:
|
||||
manager = CaptureManager(backend, output_dir=Path("captures"))
|
||||
result = manager.capture(metadata) # blocking
|
||||
|
||||
Output files per capture:
|
||||
- JPEG (always) — from camera backend
|
||||
- JSON sidecar (always) — full metadata
|
||||
- FITS (when astropy available) — with WCS headers
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self, backend: CameraBackend, output_dir: Path = Path("captures")
|
||||
) -> None:
|
||||
self._backend = backend
|
||||
self._output_dir = output_dir
|
||||
self._session = CaptureSession(output_dir=output_dir)
|
||||
self._lock = threading.Lock()
|
||||
|
||||
def capture(self, metadata: CaptureMetadata) -> CaptureResult:
|
||||
"""Execute a full capture cycle. Blocking, thread-safe."""
|
||||
with self._lock:
|
||||
seq = self._session.next_sequence()
|
||||
|
||||
metadata.sequence_number = seq
|
||||
metadata.session_id = self._session.session_id
|
||||
metadata.camera_backend = self._backend.name
|
||||
|
||||
# Date-based subdirectory
|
||||
date_str = time.strftime("%Y-%m-%d", time.gmtime())
|
||||
capture_dir = self._output_dir / date_str
|
||||
capture_dir.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
# Capture the frame
|
||||
jpeg_name = _build_filename(metadata, "jpg")
|
||||
jpeg_path = capture_dir / jpeg_name
|
||||
|
||||
result = self._backend.capture(jpeg_path)
|
||||
|
||||
# Populate timing metadata from result
|
||||
metadata.timestamp = result.timestamp
|
||||
metadata.capture_duration_ms = result.duration_ms
|
||||
|
||||
# Always write JSON sidecar
|
||||
self._write_json_sidecar(capture_dir, metadata)
|
||||
|
||||
if result.success:
|
||||
# EXIF embedding (optional)
|
||||
if HAS_PILLOW:
|
||||
self._add_jpeg_exif(jpeg_path, metadata)
|
||||
|
||||
# FITS output (optional)
|
||||
if HAS_ASTROPY:
|
||||
fits_name = _build_filename(metadata, "fits")
|
||||
fits_path = capture_dir / fits_name
|
||||
self._write_fits(jpeg_path, fits_path, metadata)
|
||||
|
||||
log.info(
|
||||
"Capture #%d: %s (%.1fms)",
|
||||
seq,
|
||||
jpeg_name,
|
||||
result.duration_ms,
|
||||
)
|
||||
else:
|
||||
log.warning("Capture #%d failed: %s", seq, result.error)
|
||||
|
||||
return result
|
||||
|
||||
@property
|
||||
def session(self) -> CaptureSession:
|
||||
return self._session
|
||||
|
||||
@property
|
||||
def has_pillow(self) -> bool:
|
||||
return HAS_PILLOW
|
||||
|
||||
@property
|
||||
def has_astropy(self) -> bool:
|
||||
return HAS_ASTROPY
|
||||
|
||||
def _write_json_sidecar(self, capture_dir: Path, metadata: CaptureMetadata) -> None:
|
||||
"""Write metadata as a JSON sidecar file. Always succeeds or logs."""
|
||||
try:
|
||||
json_name = _build_filename(metadata, "json")
|
||||
json_path = capture_dir / json_name
|
||||
data = asdict(metadata)
|
||||
# Convert tuple to list for JSON serialization
|
||||
data["resolution"] = list(data["resolution"])
|
||||
json_path.write_text(json.dumps(data, indent=2, default=str))
|
||||
except Exception:
|
||||
log.exception("Failed to write JSON sidecar")
|
||||
|
||||
def _add_jpeg_exif(self, jpeg_path: Path, metadata: CaptureMetadata) -> None:
|
||||
"""Embed metadata into JPEG EXIF. Requires Pillow."""
|
||||
try:
|
||||
import piexif
|
||||
|
||||
exif_dict = piexif.load(str(jpeg_path))
|
||||
# UserComment field for metadata
|
||||
comment = json.dumps(
|
||||
{
|
||||
"mount_az": metadata.mount_az,
|
||||
"mount_el": metadata.mount_el,
|
||||
"target": metadata.target_name,
|
||||
"trigger": metadata.trigger,
|
||||
"session": metadata.session_id,
|
||||
}
|
||||
)
|
||||
exif_dict["Exif"][piexif.ExifIFD.UserComment] = (
|
||||
piexif.helper.UserComment.dump(comment, encoding="unicode")
|
||||
)
|
||||
exif_bytes = piexif.dump(exif_dict)
|
||||
piexif.insert(exif_bytes, str(jpeg_path))
|
||||
except Exception:
|
||||
# piexif not available or EXIF write failed — non-fatal
|
||||
log.debug("EXIF embedding skipped", exc_info=True)
|
||||
|
||||
def _write_fits(
|
||||
self, jpeg_path: Path, fits_path: Path, metadata: CaptureMetadata
|
||||
) -> None:
|
||||
"""Write FITS file with WCS headers. Requires astropy."""
|
||||
try:
|
||||
if HAS_PILLOW:
|
||||
img = Image.open(jpeg_path)
|
||||
import numpy as np
|
||||
|
||||
data = np.array(img)
|
||||
else:
|
||||
# Without Pillow, create a minimal FITS with no image data
|
||||
data = None
|
||||
|
||||
hdu = astropy_fits.PrimaryHDU(data=data)
|
||||
hdr = hdu.header
|
||||
|
||||
# Standard FITS keywords
|
||||
hdr["DATE-OBS"] = metadata.timestamp
|
||||
hdr["OBJECT"] = metadata.target_name or "MANUAL"
|
||||
hdr["TELESCOP"] = "Birdcage/Winegard"
|
||||
hdr["INSTRUME"] = metadata.camera_backend
|
||||
|
||||
# WCS — AZ/EL tangent plane projection
|
||||
hdr["CTYPE1"] = "AZ---TAN"
|
||||
hdr["CTYPE2"] = "EL---TAN"
|
||||
hdr["CRVAL1"] = metadata.mount_az
|
||||
hdr["CRVAL2"] = metadata.mount_el
|
||||
hdr["CRPIX1"] = metadata.resolution[0] / 2 if metadata.resolution[0] else 1
|
||||
hdr["CRPIX2"] = metadata.resolution[1] / 2 if metadata.resolution[1] else 1
|
||||
|
||||
# Custom headers
|
||||
hdr["MOUNT-AZ"] = (metadata.mount_az, "Mount azimuth (deg)")
|
||||
hdr["MOUNT-EL"] = (metadata.mount_el, "Mount elevation (deg)")
|
||||
hdr["TRIGGER"] = (metadata.trigger, "Capture trigger type")
|
||||
hdr["SEQNUM"] = (metadata.sequence_number, "Capture sequence number")
|
||||
hdr["SESSID"] = (metadata.session_id, "Capture session ID")
|
||||
|
||||
if metadata.target_name:
|
||||
hdr["TGT-NAME"] = (metadata.target_name, "Target name")
|
||||
hdr["TGT-TYPE"] = (metadata.target_type, "Target type")
|
||||
hdr["TGT-ID"] = (metadata.target_id, "Target ID")
|
||||
if metadata.target_distance_km is not None:
|
||||
hdr["TGT-DIST"] = (metadata.target_distance_km, "Target distance (km)")
|
||||
if metadata.target_range_rate is not None:
|
||||
hdr["TGT-RATE"] = (
|
||||
metadata.target_range_rate,
|
||||
"Target range rate (km/s)",
|
||||
)
|
||||
|
||||
hdu.writeto(str(fits_path), overwrite=True)
|
||||
log.debug("FITS written: %s", fits_path.name)
|
||||
except Exception:
|
||||
log.exception("Failed to write FITS file")
|
||||
212
tui/src/birdcage_tui/capture_triggers.py
Normal file
212
tui/src/birdcage_tui/capture_triggers.py
Normal file
@ -0,0 +1,212 @@
|
||||
"""Capture trigger system — manual, interval, and pass-event triggers.
|
||||
|
||||
Decoupled from TUI — operates on callbacks. The PassEventDetector is a
|
||||
stateful edge detector: call update() from the tracking loop each iteration,
|
||||
and it fires callbacks on AOS/TCA/LOS transitions.
|
||||
|
||||
IntervalTimer runs a daemon thread that fires at configurable intervals.
|
||||
"""
|
||||
|
||||
import logging
|
||||
import threading
|
||||
import time
|
||||
from enum import Enum, auto
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class TriggerType(Enum):
|
||||
"""Types of capture triggers."""
|
||||
|
||||
MANUAL = auto()
|
||||
INTERVAL = auto()
|
||||
AOS = auto() # Acquisition of Signal: WAITING/IDLE -> TRACKING
|
||||
TCA = auto() # Time of Closest Approach: elevation peak during TRACKING
|
||||
LOS = auto() # Loss of Signal: TRACKING -> WAITING/IDLE
|
||||
|
||||
|
||||
class TriggerEvent:
|
||||
"""A trigger event with type, timestamp, and optional detail."""
|
||||
|
||||
__slots__ = ("trigger_type", "timestamp", "detail")
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
trigger_type: TriggerType,
|
||||
timestamp: str = "",
|
||||
detail: str = "",
|
||||
) -> None:
|
||||
self.trigger_type = trigger_type
|
||||
self.timestamp = timestamp or time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
|
||||
self.detail = detail
|
||||
|
||||
|
||||
class IntervalTimer:
|
||||
"""Background thread that fires a callback every N seconds.
|
||||
|
||||
Thread-safe start/stop/pause. Daemon thread — doesn't block shutdown.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
callback: "callable",
|
||||
interval_seconds: float = 10.0,
|
||||
) -> None:
|
||||
self._callback = callback
|
||||
self._interval = interval_seconds
|
||||
self._running = False
|
||||
self._thread: threading.Thread | None = None
|
||||
self._stop_event = threading.Event()
|
||||
|
||||
def start(self) -> None:
|
||||
"""Start firing at the configured interval."""
|
||||
if self._running:
|
||||
return
|
||||
self._running = True
|
||||
self._stop_event.clear()
|
||||
self._thread = threading.Thread(
|
||||
target=self._loop,
|
||||
name="capture-interval",
|
||||
daemon=True,
|
||||
)
|
||||
self._thread.start()
|
||||
|
||||
def stop(self) -> None:
|
||||
"""Stop the timer. Safe to call multiple times."""
|
||||
self._running = False
|
||||
self._stop_event.set()
|
||||
if self._thread is not None:
|
||||
self._thread.join(timeout=2.0)
|
||||
self._thread = None
|
||||
|
||||
def set_interval(self, seconds: float) -> None:
|
||||
"""Update the interval. Takes effect on the next cycle."""
|
||||
self._interval = max(1.0, seconds)
|
||||
|
||||
@property
|
||||
def is_running(self) -> bool:
|
||||
return self._running
|
||||
|
||||
@property
|
||||
def interval(self) -> float:
|
||||
return self._interval
|
||||
|
||||
def _loop(self) -> None:
|
||||
while self._running and not self._stop_event.is_set():
|
||||
self._stop_event.wait(self._interval)
|
||||
if not self._running:
|
||||
break
|
||||
try:
|
||||
event = TriggerEvent(
|
||||
trigger_type=TriggerType.INTERVAL,
|
||||
detail=f"interval={self._interval:.0f}s",
|
||||
)
|
||||
self._callback(event)
|
||||
except Exception:
|
||||
log.exception("Interval trigger callback failed")
|
||||
|
||||
|
||||
class PassEventDetector:
|
||||
"""Stateful edge detector for satellite pass events.
|
||||
|
||||
Call update() each tracking iteration with the current status, target
|
||||
name, and elevation. The detector fires callbacks on state transitions:
|
||||
|
||||
- AOS: status transitions from WAITING/IDLE to TRACKING
|
||||
- LOS: status transitions from TRACKING to WAITING/IDLE
|
||||
- TCA: during TRACKING, elevation stops ascending and drops by >0.5 deg
|
||||
from the observed peak (hysteresis prevents jitter false triggers)
|
||||
|
||||
The detector tracks per-target state and resets on target change.
|
||||
"""
|
||||
|
||||
# Minimum elevation drop from peak before we fire TCA (hysteresis)
|
||||
TCA_HYSTERESIS_DEG = 0.5
|
||||
|
||||
def __init__(self, on_event: "callable") -> None:
|
||||
self._on_event = on_event
|
||||
self._enabled: set[TriggerType] = set()
|
||||
self._prev_status: str = ""
|
||||
self._prev_target: str = ""
|
||||
self._peak_el: float = -90.0
|
||||
self._tca_fired: bool = False
|
||||
|
||||
def enable(self, *trigger_types: TriggerType) -> None:
|
||||
"""Enable one or more trigger types."""
|
||||
for tt in trigger_types:
|
||||
self._enabled.add(tt)
|
||||
|
||||
def disable(self, *trigger_types: TriggerType) -> None:
|
||||
"""Disable one or more trigger types."""
|
||||
for tt in trigger_types:
|
||||
self._enabled.discard(tt)
|
||||
|
||||
def is_enabled(self, trigger_type: TriggerType) -> bool:
|
||||
return trigger_type in self._enabled
|
||||
|
||||
def update(self, status: str, target_name: str, elevation: float) -> None:
|
||||
"""Feed current tracking state. Call each iteration (~1 Hz)."""
|
||||
# Reset on target change
|
||||
if target_name != self._prev_target:
|
||||
self._peak_el = -90.0
|
||||
self._tca_fired = False
|
||||
self._prev_status = ""
|
||||
self._prev_target = target_name
|
||||
|
||||
# AOS detection: non-tracking -> TRACKING
|
||||
if (
|
||||
TriggerType.AOS in self._enabled
|
||||
and status == "TRACKING"
|
||||
and self._prev_status in ("WAITING", "IDLE", "")
|
||||
):
|
||||
self._fire(
|
||||
TriggerType.AOS,
|
||||
f"AOS: {target_name} at EL {elevation:.1f}\u00b0",
|
||||
)
|
||||
self._peak_el = elevation
|
||||
self._tca_fired = False
|
||||
|
||||
# LOS detection: TRACKING -> non-tracking
|
||||
if (
|
||||
TriggerType.LOS in self._enabled
|
||||
and self._prev_status == "TRACKING"
|
||||
and status in ("WAITING", "IDLE")
|
||||
):
|
||||
self._fire(
|
||||
TriggerType.LOS,
|
||||
f"LOS: {target_name} at EL {elevation:.1f}\u00b0",
|
||||
)
|
||||
|
||||
# TCA detection: elevation peak with hysteresis
|
||||
if status == "TRACKING":
|
||||
if elevation > self._peak_el:
|
||||
self._peak_el = elevation
|
||||
self._tca_fired = False
|
||||
elif (
|
||||
TriggerType.TCA in self._enabled
|
||||
and not self._tca_fired
|
||||
and (self._peak_el - elevation) > self.TCA_HYSTERESIS_DEG
|
||||
):
|
||||
self._fire(
|
||||
TriggerType.TCA,
|
||||
f"TCA: {target_name} peak EL {self._peak_el:.1f}\u00b0",
|
||||
)
|
||||
self._tca_fired = True
|
||||
|
||||
self._prev_status = status
|
||||
|
||||
def reset(self) -> None:
|
||||
"""Reset all state. Call when tracking stops."""
|
||||
self._prev_status = ""
|
||||
self._prev_target = ""
|
||||
self._peak_el = -90.0
|
||||
self._tca_fired = False
|
||||
|
||||
def _fire(self, trigger_type: TriggerType, detail: str) -> None:
|
||||
"""Dispatch a trigger event."""
|
||||
try:
|
||||
event = TriggerEvent(trigger_type=trigger_type, detail=detail)
|
||||
self._on_event(event)
|
||||
log.info("Pass event: %s — %s", trigger_type.name, detail)
|
||||
except Exception:
|
||||
log.exception("Pass event callback failed for %s", trigger_type.name)
|
||||
426
tui/src/birdcage_tui/screens/camera.py
Normal file
426
tui/src/birdcage_tui/screens/camera.py
Normal file
@ -0,0 +1,426 @@
|
||||
"""Camera capture overlay — F6 slide-up modal for image acquisition.
|
||||
|
||||
Follows the ConsoleOverlay pattern: ModalScreen pushed via F6, dismissed
|
||||
via Escape or F6 again. Pre-installed via install_screen() for persistence.
|
||||
|
||||
Provides manual capture, interval timer, and AOS/TCA/LOS pass-event
|
||||
triggers. Each capture writes JPEG + JSON sidecar (+ optional FITS).
|
||||
"""
|
||||
|
||||
import logging
|
||||
import time
|
||||
|
||||
from textual import work
|
||||
from textual.app import ComposeResult
|
||||
from textual.binding import Binding
|
||||
from textual.containers import Container, Horizontal
|
||||
from textual.screen import ModalScreen
|
||||
from textual.widgets import Button, Input, RichLog, Static
|
||||
|
||||
from birdcage_tui.camera import CaptureResult
|
||||
from birdcage_tui.capture_manager import CaptureManager, CaptureMetadata
|
||||
from birdcage_tui.capture_triggers import (
|
||||
IntervalTimer,
|
||||
PassEventDetector,
|
||||
TriggerEvent,
|
||||
TriggerType,
|
||||
)
|
||||
|
||||
log = logging.getLogger(__name__)
|
||||
|
||||
# Map trigger types to display colors (Rich markup)
|
||||
_TRIGGER_COLORS: dict[TriggerType, str] = {
|
||||
TriggerType.MANUAL: "#00d4aa",
|
||||
TriggerType.INTERVAL: "#00b8c8",
|
||||
TriggerType.AOS: "#00e060",
|
||||
TriggerType.TCA: "#e8c020",
|
||||
TriggerType.LOS: "#e04040",
|
||||
}
|
||||
|
||||
|
||||
class CaptureStatusPanel(Static):
|
||||
"""Top status bar showing camera state, capture count, and formats."""
|
||||
|
||||
def __init__(self, **kwargs) -> None:
|
||||
super().__init__(**kwargs)
|
||||
self._camera_name = "none"
|
||||
self._capture_count = 0
|
||||
self._last_capture = ""
|
||||
self._formats = "JPEG + JSON"
|
||||
self._triggers_text = "none"
|
||||
self._auto_interval = 0.0
|
||||
|
||||
def update_status(
|
||||
self,
|
||||
camera_name: str = "",
|
||||
capture_count: int = 0,
|
||||
last_capture: str = "",
|
||||
formats: str = "",
|
||||
triggers_text: str = "",
|
||||
auto_interval: float = 0.0,
|
||||
) -> None:
|
||||
if camera_name:
|
||||
self._camera_name = camera_name
|
||||
self._capture_count = capture_count
|
||||
if last_capture:
|
||||
self._last_capture = last_capture
|
||||
if formats:
|
||||
self._formats = formats
|
||||
if triggers_text:
|
||||
self._triggers_text = triggers_text
|
||||
self._auto_interval = auto_interval
|
||||
self._refresh_display()
|
||||
|
||||
def _refresh_display(self) -> None:
|
||||
last = self._last_capture or "---"
|
||||
auto = f" Auto: {self._auto_interval:.0f}s" if self._auto_interval > 0 else ""
|
||||
self.update(
|
||||
f" Camera: {self._camera_name} | "
|
||||
f"Captures: {self._capture_count} | "
|
||||
f"Last: {last}\n"
|
||||
f" Formats: {self._formats} | "
|
||||
f"Triggers: {self._triggers_text}{auto}"
|
||||
)
|
||||
|
||||
|
||||
class CameraOverlay(ModalScreen):
|
||||
"""F6: Camera capture overlay as a slide-up panel.
|
||||
|
||||
Slides up from the bottom of the terminal, taking ~45% of the viewport.
|
||||
Provides manual capture, interval timer, and pass-event trigger controls.
|
||||
"""
|
||||
|
||||
BINDINGS = [
|
||||
Binding("escape", "dismiss_overlay", "Close", priority=True),
|
||||
Binding("f6", "dismiss_overlay", "Close", priority=True),
|
||||
Binding("c", "manual_capture", "Capture", priority=True),
|
||||
]
|
||||
|
||||
def __init__(self) -> None:
|
||||
super().__init__()
|
||||
self._capture_manager: CaptureManager | None = None
|
||||
self._interval_timer: IntervalTimer | None = None
|
||||
self._pass_detector: PassEventDetector | None = None
|
||||
self._auto_running = False
|
||||
|
||||
def compose(self) -> ComposeResult:
|
||||
with Container(id="camera-overlay"):
|
||||
yield CaptureStatusPanel(id="capture-status")
|
||||
yield RichLog(id="capture-log", markup=True, wrap=True)
|
||||
with Horizontal(classes="camera-controls"):
|
||||
yield Button("Capture", id="btn-capture", variant="primary")
|
||||
yield Static("Interval:", classes="label")
|
||||
yield Input(
|
||||
value="10",
|
||||
id="camera-interval-input",
|
||||
type="integer",
|
||||
)
|
||||
yield Static("s", classes="label")
|
||||
yield Button("Start", id="btn-auto-start")
|
||||
yield Button("Stop", id="btn-auto-stop")
|
||||
with Horizontal(classes="camera-trigger-bar"):
|
||||
yield Static("Triggers:", classes="label")
|
||||
yield Button("AOS", id="btn-trigger-aos", classes="trigger-btn")
|
||||
yield Button("TCA", id="btn-trigger-tca", classes="trigger-btn")
|
||||
yield Button("LOS", id="btn-trigger-los", classes="trigger-btn")
|
||||
yield Static(" Cam:", classes="label")
|
||||
yield Static("---", id="camera-backend-label")
|
||||
|
||||
def on_mount(self) -> None:
|
||||
"""Initialize camera system on first mount."""
|
||||
self._setup_camera()
|
||||
|
||||
def on_screen_resume(self) -> None:
|
||||
"""Refresh status when the overlay is re-opened."""
|
||||
self._refresh_status()
|
||||
|
||||
def action_dismiss_overlay(self) -> None:
|
||||
self.dismiss()
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Camera setup
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def _setup_camera(self) -> None:
|
||||
"""Initialize camera backend and capture manager."""
|
||||
from pathlib import Path
|
||||
|
||||
from birdcage_tui.camera import CameraConfig, auto_select_backend
|
||||
|
||||
capture_dir = getattr(self.app, "capture_dir", "captures")
|
||||
camera_device = getattr(self.app, "camera_device", "auto")
|
||||
|
||||
config = CameraConfig()
|
||||
if camera_device != "auto":
|
||||
config.device = camera_device
|
||||
|
||||
# In demo mode, always use the demo camera
|
||||
is_demo = getattr(self.app, "demo_mode", False)
|
||||
if is_demo:
|
||||
from birdcage_tui.camera import DemoCamera
|
||||
|
||||
backend = DemoCamera(config.resolution)
|
||||
else:
|
||||
backend = auto_select_backend(config)
|
||||
|
||||
output_dir = Path(capture_dir)
|
||||
self._capture_manager = CaptureManager(backend, output_dir)
|
||||
|
||||
# Set up interval timer
|
||||
self._interval_timer = IntervalTimer(
|
||||
callback=self._on_interval_trigger,
|
||||
interval_seconds=10.0,
|
||||
)
|
||||
|
||||
# Set up pass event detector (shared at app level)
|
||||
self._pass_detector = getattr(self.app, "_pass_detector", None)
|
||||
if self._pass_detector is None:
|
||||
self._pass_detector = PassEventDetector(
|
||||
on_event=self._on_pass_trigger,
|
||||
)
|
||||
# Store at app level so control.py can feed it
|
||||
self.app._pass_detector = self._pass_detector
|
||||
|
||||
self._refresh_status()
|
||||
|
||||
# Update backend label
|
||||
try:
|
||||
label = self.query_one("#camera-backend-label", Static)
|
||||
label.update(backend.name)
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
# Log welcome
|
||||
capture_log = self.query_one("#capture-log", RichLog)
|
||||
capture_log.write(f"[#506878]Camera ready: {backend.name}[/]")
|
||||
formats = self._format_list()
|
||||
capture_log.write(f"[#506878]Output: {formats}[/]")
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Manual capture
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def action_manual_capture(self) -> None:
|
||||
"""Trigger a manual capture via keyboard shortcut."""
|
||||
self._do_capture(TriggerType.MANUAL)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Capture execution
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
@work(thread=True)
|
||||
def _do_capture(self, trigger_type: TriggerType) -> None:
|
||||
"""Execute a capture in a worker thread."""
|
||||
if self._capture_manager is None:
|
||||
return
|
||||
|
||||
metadata = self._collect_metadata(trigger_type)
|
||||
result = self._capture_manager.capture(metadata)
|
||||
self.app.call_from_thread(self._on_capture_complete, result, metadata)
|
||||
|
||||
def _collect_metadata(self, trigger_type: TriggerType) -> CaptureMetadata:
|
||||
"""Snapshot current app state into capture metadata."""
|
||||
meta = CaptureMetadata(
|
||||
mount_az=getattr(self.app, "_current_az", 0.0),
|
||||
mount_el=getattr(self.app, "_current_el", 0.0),
|
||||
trigger=trigger_type.name.lower(),
|
||||
)
|
||||
|
||||
# Try to get tracking info from the Craft tracking state
|
||||
try:
|
||||
control = self.app.query_one("#control")
|
||||
if hasattr(control, "_craft_state") and control._craft_tracking:
|
||||
state = control._craft_state
|
||||
meta.target_name = state.target_name
|
||||
meta.target_az = state.azimuth
|
||||
meta.target_el = state.elevation
|
||||
meta.target_distance_km = state.distance_km
|
||||
meta.target_range_rate = state.range_rate
|
||||
meta.tracking_mode = "craft"
|
||||
meta.tracking_status = state.status
|
||||
meta.target_type = getattr(control, "_craft_target_type", "")
|
||||
meta.target_id = getattr(control, "_craft_target_id", "")
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
# Camera info
|
||||
if self._capture_manager:
|
||||
meta.camera_backend = self._capture_manager._backend.name
|
||||
mgr = self._capture_manager
|
||||
meta.resolution = (
|
||||
getattr(mgr._backend, "_resolution", (0, 0))
|
||||
if hasattr(mgr._backend, "_resolution")
|
||||
else (0, 0)
|
||||
)
|
||||
|
||||
return meta
|
||||
|
||||
def _on_capture_complete(
|
||||
self, result: CaptureResult, metadata: CaptureMetadata
|
||||
) -> None:
|
||||
"""Update UI after capture completes (main thread)."""
|
||||
capture_log = self.query_one("#capture-log", RichLog)
|
||||
ts = time.strftime("%H:%M:%S", time.gmtime())
|
||||
trigger_name = metadata.trigger.upper()
|
||||
color = (
|
||||
_TRIGGER_COLORS.get(TriggerType[trigger_name], "#506878")
|
||||
if trigger_name in TriggerType.__members__
|
||||
else "#506878"
|
||||
)
|
||||
|
||||
if result.success:
|
||||
name = result.path.name
|
||||
if len(name) > 45:
|
||||
name = name[:42] + "..."
|
||||
capture_log.write(
|
||||
f"[{color}][{ts}] {trigger_name:<8}[/] "
|
||||
f"[#c8d0d8]{name}[/] "
|
||||
f"[#506878]{result.duration_ms:.0f}ms[/]"
|
||||
)
|
||||
else:
|
||||
capture_log.write(
|
||||
f"[{color}][{ts}] {trigger_name:<8}[/] "
|
||||
f"[#e04040]FAILED: {result.error}[/]"
|
||||
)
|
||||
|
||||
self._refresh_status()
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Interval timer
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def _on_interval_trigger(self, event: TriggerEvent) -> None:
|
||||
"""Called from the interval timer thread."""
|
||||
self.app.call_from_thread(self._do_capture, TriggerType.INTERVAL)
|
||||
|
||||
def _start_auto(self) -> None:
|
||||
"""Start the interval timer."""
|
||||
if self._interval_timer is None or self._auto_running:
|
||||
return
|
||||
|
||||
try:
|
||||
interval_input = self.query_one("#camera-interval-input", Input)
|
||||
seconds = float(interval_input.value)
|
||||
if seconds < 1:
|
||||
seconds = 1
|
||||
self._interval_timer.set_interval(seconds)
|
||||
except (ValueError, Exception):
|
||||
self._interval_timer.set_interval(10.0)
|
||||
|
||||
self._interval_timer.start()
|
||||
self._auto_running = True
|
||||
self._refresh_status()
|
||||
|
||||
capture_log = self.query_one("#capture-log", RichLog)
|
||||
interval = self._interval_timer.interval
|
||||
capture_log.write(f"[#00b8c8]Auto-capture started ({interval:.0f}s)[/]")
|
||||
|
||||
def _stop_auto(self) -> None:
|
||||
"""Stop the interval timer."""
|
||||
if self._interval_timer is None or not self._auto_running:
|
||||
return
|
||||
|
||||
self._interval_timer.stop()
|
||||
self._auto_running = False
|
||||
self._refresh_status()
|
||||
|
||||
capture_log = self.query_one("#capture-log", RichLog)
|
||||
capture_log.write("[#506878]Auto-capture stopped[/]")
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Pass event triggers
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def _on_pass_trigger(self, event: TriggerEvent) -> None:
|
||||
"""Called from the tracking loop thread via PassEventDetector."""
|
||||
self.app.call_from_thread(self._do_capture, event.trigger_type)
|
||||
|
||||
def _toggle_trigger(self, trigger_type: TriggerType, button: Button) -> None:
|
||||
"""Toggle a pass event trigger on/off."""
|
||||
if self._pass_detector is None:
|
||||
return
|
||||
|
||||
if self._pass_detector.is_enabled(trigger_type):
|
||||
self._pass_detector.disable(trigger_type)
|
||||
button.remove_class("active")
|
||||
else:
|
||||
self._pass_detector.enable(trigger_type)
|
||||
button.add_class("active")
|
||||
|
||||
self._refresh_status()
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Button handlers
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def on_button_pressed(self, event: Button.Pressed) -> None:
|
||||
button_id = event.button.id or ""
|
||||
|
||||
if button_id == "btn-capture":
|
||||
self._do_capture(TriggerType.MANUAL)
|
||||
elif button_id == "btn-auto-start":
|
||||
self._start_auto()
|
||||
elif button_id == "btn-auto-stop":
|
||||
self._stop_auto()
|
||||
elif button_id == "btn-trigger-aos":
|
||||
self._toggle_trigger(TriggerType.AOS, event.button)
|
||||
elif button_id == "btn-trigger-tca":
|
||||
self._toggle_trigger(TriggerType.TCA, event.button)
|
||||
elif button_id == "btn-trigger-los":
|
||||
self._toggle_trigger(TriggerType.LOS, event.button)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Status helpers
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def _refresh_status(self) -> None:
|
||||
"""Update the status panel with current state."""
|
||||
try:
|
||||
panel = self.query_one("#capture-status", CaptureStatusPanel)
|
||||
except Exception:
|
||||
return
|
||||
|
||||
if self._capture_manager is None:
|
||||
return
|
||||
|
||||
session = self._capture_manager.session
|
||||
formats = self._format_list()
|
||||
|
||||
triggers = []
|
||||
if self._pass_detector:
|
||||
for tt in (TriggerType.AOS, TriggerType.TCA, TriggerType.LOS):
|
||||
if self._pass_detector.is_enabled(tt):
|
||||
triggers.append(tt.name)
|
||||
triggers_text = " ".join(triggers) if triggers else "none"
|
||||
|
||||
auto_interval = self._interval_timer.interval if self._auto_running else 0.0
|
||||
|
||||
panel.update_status(
|
||||
camera_name=(
|
||||
self._capture_manager._backend.name if self._capture_manager else "none"
|
||||
),
|
||||
capture_count=session.capture_count,
|
||||
last_capture="",
|
||||
formats=formats,
|
||||
triggers_text=triggers_text,
|
||||
auto_interval=auto_interval,
|
||||
)
|
||||
|
||||
def _format_list(self) -> str:
|
||||
"""Build a string describing available output formats."""
|
||||
parts = ["JPEG", "JSON"]
|
||||
if self._capture_manager:
|
||||
if self._capture_manager.has_pillow:
|
||||
parts.append("EXIF")
|
||||
if self._capture_manager.has_astropy:
|
||||
parts.append("FITS")
|
||||
return " + ".join(parts)
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Cleanup
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
def on_unmount(self) -> None:
|
||||
"""Stop timers on teardown."""
|
||||
if self._interval_timer:
|
||||
self._interval_timer.stop()
|
||||
@ -687,6 +687,9 @@ class ControlScreen(Container):
|
||||
state.target_name = name
|
||||
state.error = ""
|
||||
|
||||
# Hook into pass event detector for camera triggers (if installed)
|
||||
pass_detector = getattr(self.app, "_pass_detector", None)
|
||||
|
||||
self.app.call_from_thread(self._apply_craft_state, state)
|
||||
|
||||
while self._craft_tracking and not shutdown.is_set():
|
||||
@ -739,6 +742,11 @@ class ControlScreen(Container):
|
||||
state.error = "Motor command failed"
|
||||
|
||||
self.app.call_from_thread(self._apply_craft_state, state)
|
||||
|
||||
# Feed pass event detector for camera triggers
|
||||
if pass_detector is not None:
|
||||
pass_detector.update(state.status, name, state.elevation)
|
||||
|
||||
shutdown.wait(1.0)
|
||||
|
||||
# Clean exit
|
||||
@ -746,6 +754,11 @@ class ControlScreen(Container):
|
||||
state.error = ""
|
||||
self.app.call_from_thread(self._apply_craft_state, state)
|
||||
|
||||
# Signal LOS on tracking stop
|
||||
if pass_detector is not None:
|
||||
pass_detector.update("IDLE", name, 0.0)
|
||||
pass_detector.reset()
|
||||
|
||||
def _apply_craft_state(self, state: CraftTrackingState) -> None:
|
||||
try:
|
||||
panel = self.query_one("#ctrl-craft-panel", CraftPanel)
|
||||
|
||||
@ -774,6 +774,102 @@ ProgressBar PercentageStatus {
|
||||
margin-right: 1;
|
||||
}
|
||||
|
||||
/* ── Camera Overlay (ModalScreen) ─────────────────── */
|
||||
|
||||
CameraOverlay {
|
||||
background: rgba(10, 10, 18, 0.6);
|
||||
}
|
||||
|
||||
#camera-overlay {
|
||||
dock: bottom;
|
||||
height: 45%;
|
||||
width: 100%;
|
||||
background: #0a0a12;
|
||||
border-top: double #00b8c8;
|
||||
padding: 0;
|
||||
}
|
||||
|
||||
#capture-status {
|
||||
height: auto;
|
||||
min-height: 2;
|
||||
padding: 0 1;
|
||||
background: #0e1420;
|
||||
color: #c8d0d8;
|
||||
border-bottom: solid #1a2a38;
|
||||
}
|
||||
|
||||
#capture-log {
|
||||
height: 1fr;
|
||||
}
|
||||
|
||||
.camera-controls {
|
||||
dock: bottom;
|
||||
height: auto;
|
||||
width: 100%;
|
||||
layout: horizontal;
|
||||
padding: 0 1;
|
||||
background: #0e1420;
|
||||
border-top: solid #1a2a38;
|
||||
}
|
||||
|
||||
.camera-controls .label {
|
||||
width: auto;
|
||||
padding: 1 1 0 0;
|
||||
}
|
||||
|
||||
#camera-interval-input {
|
||||
width: 6;
|
||||
margin-right: 0;
|
||||
}
|
||||
|
||||
.camera-controls Button {
|
||||
margin-right: 1;
|
||||
}
|
||||
|
||||
.camera-trigger-bar {
|
||||
dock: bottom;
|
||||
height: auto;
|
||||
width: 100%;
|
||||
layout: horizontal;
|
||||
padding: 0 1;
|
||||
background: #0e1420;
|
||||
border-top: solid #1a2a38;
|
||||
}
|
||||
|
||||
.camera-trigger-bar .label {
|
||||
width: auto;
|
||||
padding: 1 1 0 0;
|
||||
}
|
||||
|
||||
#camera-backend-label {
|
||||
width: auto;
|
||||
padding: 1 1 0 0;
|
||||
color: #506878;
|
||||
}
|
||||
|
||||
.trigger-btn {
|
||||
min-width: 8;
|
||||
height: 3;
|
||||
margin: 0 0 0 0;
|
||||
background: #121c2a;
|
||||
color: #7090a8;
|
||||
border: round #1a3050;
|
||||
text-align: center;
|
||||
}
|
||||
|
||||
.trigger-btn:hover {
|
||||
background: #1a2a40;
|
||||
color: #00b8c8;
|
||||
border: round #00b8c8;
|
||||
}
|
||||
|
||||
.trigger-btn.active {
|
||||
background: #0a2a3a;
|
||||
color: #00b8c8;
|
||||
border: round #00b8c8;
|
||||
text-style: bold;
|
||||
}
|
||||
|
||||
/* ── Scrollbar Styling ─────────────────────────────── */
|
||||
|
||||
* {
|
||||
|
||||
113
tui/tests/test_camera_backend.py
Normal file
113
tui/tests/test_camera_backend.py
Normal file
@ -0,0 +1,113 @@
|
||||
"""Test camera backend abstraction — DemoCamera, SubprocessCamera, detection.
|
||||
|
||||
DemoCamera is always available and produces valid output files.
|
||||
SubprocessCamera reports unavailable when the tool doesn't exist.
|
||||
"""
|
||||
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from birdcage_tui.camera import (
|
||||
CameraConfig,
|
||||
DemoCamera,
|
||||
SubprocessCamera,
|
||||
auto_select_backend,
|
||||
detect_cameras,
|
||||
)
|
||||
|
||||
|
||||
def test_demo_camera_captures_file(tmp_path: Path):
|
||||
"""DemoCamera should produce a file at the requested path."""
|
||||
camera = DemoCamera()
|
||||
output = tmp_path / "test.jpg"
|
||||
|
||||
result = camera.capture(output)
|
||||
|
||||
assert result.success
|
||||
assert output.exists()
|
||||
assert output.stat().st_size > 0
|
||||
assert result.timestamp # ISO-8601 UTC string
|
||||
assert result.duration_ms >= 0
|
||||
|
||||
|
||||
def test_demo_camera_always_available():
|
||||
"""DemoCamera.is_available() should always return True."""
|
||||
camera = DemoCamera()
|
||||
assert camera.is_available()
|
||||
|
||||
|
||||
def test_demo_camera_name():
|
||||
"""DemoCamera.name should be 'demo'."""
|
||||
camera = DemoCamera()
|
||||
assert camera.name == "demo"
|
||||
|
||||
|
||||
def test_demo_camera_valid_jpeg(tmp_path: Path):
|
||||
"""DemoCamera should produce a file starting with JPEG SOI marker."""
|
||||
camera = DemoCamera()
|
||||
output = tmp_path / "test.jpg"
|
||||
|
||||
result = camera.capture(output)
|
||||
assert result.success
|
||||
|
||||
data = output.read_bytes()
|
||||
# JPEG files start with SOI marker: FF D8
|
||||
assert data[:2] == b"\xff\xd8"
|
||||
|
||||
|
||||
def test_demo_camera_custom_resolution():
|
||||
"""DemoCamera should accept custom resolution."""
|
||||
camera = DemoCamera(resolution=(640, 480))
|
||||
assert camera._resolution == (640, 480)
|
||||
|
||||
|
||||
def test_subprocess_camera_not_available():
|
||||
"""SubprocessCamera with nonexistent tool should be unavailable."""
|
||||
config = CameraConfig(backend_cmd="nonexistent_camera_tool_xyz")
|
||||
camera = SubprocessCamera(config)
|
||||
assert not camera.is_available()
|
||||
|
||||
|
||||
def test_subprocess_camera_capture_missing_tool(tmp_path: Path):
|
||||
"""Capture with missing tool should return failure."""
|
||||
config = CameraConfig(backend_cmd="nonexistent_camera_tool_xyz")
|
||||
camera = SubprocessCamera(config)
|
||||
output = tmp_path / "test.jpg"
|
||||
|
||||
result = camera.capture(output)
|
||||
assert not result.success
|
||||
assert result.error # Has a meaningful error message
|
||||
|
||||
|
||||
def test_subprocess_camera_name():
|
||||
"""SubprocessCamera.name should include tool and device."""
|
||||
config = CameraConfig(backend_cmd="fswebcam", device="/dev/video0")
|
||||
camera = SubprocessCamera(config)
|
||||
assert "fswebcam" in camera.name
|
||||
assert "/dev/video0" in camera.name
|
||||
|
||||
|
||||
def test_detect_cameras_returns_list():
|
||||
"""detect_cameras() should return a list (may be empty in CI)."""
|
||||
devices = detect_cameras()
|
||||
assert isinstance(devices, list)
|
||||
|
||||
|
||||
def test_auto_select_returns_available_backend():
|
||||
"""auto_select should return an available backend (demo or real)."""
|
||||
config = CameraConfig(backend_cmd="nonexistent_tool_xyz")
|
||||
backend = auto_select_backend(config)
|
||||
# Should always return something available
|
||||
assert backend.is_available()
|
||||
# If no real backends exist, should be demo; otherwise a real one
|
||||
assert backend.name # Has a name
|
||||
|
||||
|
||||
@pytest.mark.parametrize("backend_cmd", ["fswebcam", "ffmpeg", "libcamera-still"])
|
||||
def test_subprocess_unknown_backend_fails(tmp_path: Path, backend_cmd: str):
|
||||
"""Unknown backend command pattern should be in the lookup table."""
|
||||
config = CameraConfig(backend_cmd=backend_cmd)
|
||||
SubprocessCamera(config)
|
||||
# The command template should exist even if the tool isn't installed
|
||||
assert backend_cmd in SubprocessCamera._COMMANDS
|
||||
273
tui/tests/test_camera_overlay.py
Normal file
273
tui/tests/test_camera_overlay.py
Normal file
@ -0,0 +1,273 @@
|
||||
"""Test camera overlay — F6 toggle, manual capture, trigger controls.
|
||||
|
||||
Uses the same testing pattern as test_craft_mode.py:
|
||||
- app.demo_mode = True for DemoDevice
|
||||
- async with app.run_test() for headless rendering
|
||||
- post_message() for button events (avoids coordinate issues)
|
||||
|
||||
Note: ModalScreen widgets are on the screen stack, not the app's regular
|
||||
DOM. Use app.screen to get the active overlay, then query within it.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from birdcage_tui.app import BirdcageApp
|
||||
from birdcage_tui.screens.camera import CameraOverlay, CaptureStatusPanel
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_f6_opens_camera_overlay(tmp_path: Path):
|
||||
"""F6 should push the camera overlay."""
|
||||
app = BirdcageApp()
|
||||
app.demo_mode = True
|
||||
app.capture_dir = str(tmp_path / "captures")
|
||||
|
||||
async with app.run_test(size=(120, 40)) as pilot:
|
||||
await pilot.pause()
|
||||
|
||||
assert not app._camera_visible
|
||||
await pilot.press("f6")
|
||||
await pilot.pause()
|
||||
|
||||
assert app._camera_visible
|
||||
# The top screen should be the camera overlay
|
||||
assert isinstance(app.screen, CameraOverlay)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_f6_closes_camera_overlay(tmp_path: Path):
|
||||
"""F6 again should dismiss the camera overlay."""
|
||||
app = BirdcageApp()
|
||||
app.demo_mode = True
|
||||
app.capture_dir = str(tmp_path / "captures")
|
||||
|
||||
async with app.run_test(size=(120, 40)) as pilot:
|
||||
await pilot.pause()
|
||||
|
||||
await pilot.press("f6")
|
||||
await pilot.pause()
|
||||
assert app._camera_visible
|
||||
|
||||
await pilot.press("f6")
|
||||
await pilot.pause()
|
||||
assert not app._camera_visible
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_escape_closes_camera_overlay(tmp_path: Path):
|
||||
"""Escape should dismiss the camera overlay."""
|
||||
app = BirdcageApp()
|
||||
app.demo_mode = True
|
||||
app.capture_dir = str(tmp_path / "captures")
|
||||
|
||||
async with app.run_test(size=(120, 40)) as pilot:
|
||||
await pilot.pause()
|
||||
|
||||
await pilot.press("f6")
|
||||
await pilot.pause()
|
||||
assert app._camera_visible
|
||||
|
||||
await pilot.press("escape")
|
||||
await pilot.pause()
|
||||
assert not app._camera_visible
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_manual_capture_creates_file(tmp_path: Path):
|
||||
"""Pressing 'c' should create a capture file."""
|
||||
app = BirdcageApp()
|
||||
app.demo_mode = True
|
||||
app.capture_dir = str(tmp_path / "captures")
|
||||
|
||||
async with app.run_test(size=(120, 40)) as pilot:
|
||||
await pilot.pause()
|
||||
|
||||
await pilot.press("f6")
|
||||
await pilot.pause()
|
||||
|
||||
# Trigger manual capture
|
||||
await pilot.press("c")
|
||||
await asyncio.sleep(0.5)
|
||||
|
||||
# Check captures directory
|
||||
capture_dir = tmp_path / "captures"
|
||||
jpg_files = list(capture_dir.rglob("*.jpg"))
|
||||
json_files = list(capture_dir.rglob("*.json"))
|
||||
|
||||
assert len(jpg_files) >= 1
|
||||
assert len(json_files) >= 1
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_capture_button(tmp_path: Path):
|
||||
"""Capture button should trigger a capture."""
|
||||
app = BirdcageApp()
|
||||
app.demo_mode = True
|
||||
app.capture_dir = str(tmp_path / "captures")
|
||||
|
||||
async with app.run_test(size=(120, 40)) as pilot:
|
||||
await pilot.pause()
|
||||
|
||||
await pilot.press("f6")
|
||||
await pilot.pause()
|
||||
|
||||
# Get the overlay from the screen stack
|
||||
overlay = app.screen
|
||||
assert isinstance(overlay, CameraOverlay)
|
||||
|
||||
from textual.widgets import Button
|
||||
|
||||
btn = overlay.query_one("#btn-capture", Button)
|
||||
btn.post_message(Button.Pressed(btn))
|
||||
await asyncio.sleep(0.5)
|
||||
|
||||
capture_dir = tmp_path / "captures"
|
||||
jpg_files = list(capture_dir.rglob("*.jpg"))
|
||||
assert len(jpg_files) >= 1
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_capture_log_updates(tmp_path: Path):
|
||||
"""Capture log should show entries after captures."""
|
||||
app = BirdcageApp()
|
||||
app.demo_mode = True
|
||||
app.capture_dir = str(tmp_path / "captures")
|
||||
|
||||
async with app.run_test(size=(120, 40)) as pilot:
|
||||
await pilot.pause()
|
||||
|
||||
await pilot.press("f6")
|
||||
await pilot.pause()
|
||||
|
||||
# Two captures
|
||||
await pilot.press("c")
|
||||
await asyncio.sleep(0.3)
|
||||
await pilot.press("c")
|
||||
await asyncio.sleep(0.3)
|
||||
|
||||
# Status panel should show count
|
||||
overlay = app.screen
|
||||
assert isinstance(overlay, CameraOverlay)
|
||||
panel = overlay.query_one("#capture-status", CaptureStatusPanel)
|
||||
assert panel._capture_count >= 2
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_trigger_toggles(tmp_path: Path):
|
||||
"""AOS/TCA/LOS trigger buttons should toggle active state."""
|
||||
app = BirdcageApp()
|
||||
app.demo_mode = True
|
||||
app.capture_dir = str(tmp_path / "captures")
|
||||
|
||||
async with app.run_test(size=(120, 40)) as pilot:
|
||||
await pilot.pause()
|
||||
|
||||
await pilot.press("f6")
|
||||
await pilot.pause()
|
||||
|
||||
overlay = app.screen
|
||||
assert isinstance(overlay, CameraOverlay)
|
||||
|
||||
from textual.widgets import Button
|
||||
|
||||
from birdcage_tui.capture_triggers import TriggerType
|
||||
|
||||
# Toggle AOS on
|
||||
aos_btn = overlay.query_one("#btn-trigger-aos", Button)
|
||||
aos_btn.post_message(Button.Pressed(aos_btn))
|
||||
await pilot.pause()
|
||||
assert overlay._pass_detector.is_enabled(TriggerType.AOS)
|
||||
|
||||
# Toggle AOS off
|
||||
aos_btn.post_message(Button.Pressed(aos_btn))
|
||||
await pilot.pause()
|
||||
assert not overlay._pass_detector.is_enabled(TriggerType.AOS)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_auto_interval_start_stop(tmp_path: Path):
|
||||
"""Auto interval start/stop should control the timer."""
|
||||
app = BirdcageApp()
|
||||
app.demo_mode = True
|
||||
app.capture_dir = str(tmp_path / "captures")
|
||||
|
||||
async with app.run_test(size=(120, 40)) as pilot:
|
||||
await pilot.pause()
|
||||
|
||||
await pilot.press("f6")
|
||||
await pilot.pause()
|
||||
|
||||
overlay = app.screen
|
||||
assert isinstance(overlay, CameraOverlay)
|
||||
|
||||
from textual.widgets import Button
|
||||
|
||||
# Start auto
|
||||
start_btn = overlay.query_one("#btn-auto-start", Button)
|
||||
start_btn.post_message(Button.Pressed(start_btn))
|
||||
await pilot.pause()
|
||||
assert overlay._auto_running
|
||||
|
||||
# Stop auto
|
||||
stop_btn = overlay.query_one("#btn-auto-stop", Button)
|
||||
stop_btn.post_message(Button.Pressed(stop_btn))
|
||||
await pilot.pause()
|
||||
assert not overlay._auto_running
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_camera_overlay_with_console(tmp_path: Path):
|
||||
"""F5 and F6 should open independent overlays."""
|
||||
app = BirdcageApp()
|
||||
app.demo_mode = True
|
||||
app.capture_dir = str(tmp_path / "captures")
|
||||
|
||||
async with app.run_test(size=(120, 40)) as pilot:
|
||||
await pilot.pause()
|
||||
|
||||
# Open camera first
|
||||
await pilot.press("f6")
|
||||
await pilot.pause()
|
||||
assert app._camera_visible
|
||||
assert not app._console_visible
|
||||
|
||||
# Close camera
|
||||
await pilot.press("f6")
|
||||
await pilot.pause()
|
||||
assert not app._camera_visible
|
||||
|
||||
# Open console
|
||||
await pilot.press("f5")
|
||||
await pilot.pause()
|
||||
assert app._console_visible
|
||||
assert not app._camera_visible
|
||||
|
||||
# Close console
|
||||
await pilot.press("f5")
|
||||
await pilot.pause()
|
||||
assert not app._console_visible
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_status_panel_shows_formats(tmp_path: Path):
|
||||
"""Status panel should list available output formats."""
|
||||
app = BirdcageApp()
|
||||
app.demo_mode = True
|
||||
app.capture_dir = str(tmp_path / "captures")
|
||||
|
||||
async with app.run_test(size=(120, 40)) as pilot:
|
||||
await pilot.pause()
|
||||
|
||||
await pilot.press("f6")
|
||||
await pilot.pause()
|
||||
|
||||
overlay = app.screen
|
||||
assert isinstance(overlay, CameraOverlay)
|
||||
|
||||
panel = overlay.query_one("#capture-status", CaptureStatusPanel)
|
||||
# Should always have JPEG + JSON at minimum
|
||||
assert "JPEG" in panel._formats
|
||||
assert "JSON" in panel._formats
|
||||
171
tui/tests/test_capture_manager.py
Normal file
171
tui/tests/test_capture_manager.py
Normal file
@ -0,0 +1,171 @@
|
||||
"""Test capture manager — file naming, JSON sidecars, session tracking.
|
||||
|
||||
All tests use DemoCamera for zero-hardware-dependency captures.
|
||||
"""
|
||||
|
||||
import json
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from birdcage_tui.camera import DemoCamera
|
||||
from birdcage_tui.capture_manager import (
|
||||
CaptureManager,
|
||||
CaptureMetadata,
|
||||
CaptureSession,
|
||||
_build_filename,
|
||||
_sanitize_name,
|
||||
)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def manager(tmp_path: Path) -> CaptureManager:
|
||||
"""CaptureManager with DemoCamera in a temp directory."""
|
||||
backend = DemoCamera()
|
||||
return CaptureManager(backend, output_dir=tmp_path)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def tracking_metadata() -> CaptureMetadata:
|
||||
"""Metadata simulating an active tracking capture."""
|
||||
return CaptureMetadata(
|
||||
mount_az=245.30,
|
||||
mount_el=34.20,
|
||||
target_name="ISS (ZARYA)",
|
||||
target_type="satellite",
|
||||
target_id="25544",
|
||||
target_az=245.30,
|
||||
target_el=34.20,
|
||||
target_distance_km=420.0,
|
||||
target_range_rate=-2.1,
|
||||
tracking_mode="craft",
|
||||
tracking_status="TRACKING",
|
||||
trigger="manual",
|
||||
)
|
||||
|
||||
|
||||
def test_capture_writes_jpeg(manager: CaptureManager, tracking_metadata):
|
||||
"""Capture should produce a JPEG file."""
|
||||
result = manager.capture(tracking_metadata)
|
||||
assert result.success
|
||||
assert result.path.exists()
|
||||
assert result.path.suffix == ".jpg"
|
||||
|
||||
|
||||
def test_capture_writes_json_sidecar(manager: CaptureManager, tracking_metadata):
|
||||
"""JSON sidecar should always be written alongside JPEG."""
|
||||
result = manager.capture(tracking_metadata)
|
||||
assert result.success
|
||||
|
||||
# Find the JSON sidecar
|
||||
json_files = list(result.path.parent.glob("*.json"))
|
||||
assert len(json_files) == 1
|
||||
|
||||
data = json.loads(json_files[0].read_text())
|
||||
assert data["mount_az"] == 245.30
|
||||
assert data["mount_el"] == 34.20
|
||||
assert data["target_name"] == "ISS (ZARYA)"
|
||||
assert data["trigger"] == "manual"
|
||||
|
||||
|
||||
def test_filename_generation():
|
||||
"""Filenames should follow the naming convention."""
|
||||
meta = CaptureMetadata(
|
||||
mount_az=245.30,
|
||||
mount_el=34.20,
|
||||
target_name="ISS (ZARYA)",
|
||||
timestamp="2026-02-16T08:25:00Z",
|
||||
)
|
||||
name = _build_filename(meta, "jpg")
|
||||
assert name.startswith("ISS-ZARYA_")
|
||||
assert "245.30" in name
|
||||
assert "34.20" in name
|
||||
assert name.endswith(".jpg")
|
||||
|
||||
|
||||
def test_filename_sanitization():
|
||||
"""Special characters should be stripped from target names."""
|
||||
assert _sanitize_name("ISS (ZARYA)") == "ISS-ZARYA"
|
||||
assert _sanitize_name("NOAA 19") == "NOAA-19"
|
||||
assert _sanitize_name("") == "manual"
|
||||
assert _sanitize_name("a/b\\c:d") == "abcd"
|
||||
|
||||
|
||||
def test_filename_no_target():
|
||||
"""Without a target name, filename should use 'manual'."""
|
||||
meta = CaptureMetadata(
|
||||
mount_az=180.0,
|
||||
mount_el=45.0,
|
||||
timestamp="2026-02-16T12:00:00Z",
|
||||
)
|
||||
name = _build_filename(meta, "jpg")
|
||||
assert name.startswith("manual_")
|
||||
|
||||
|
||||
def test_session_counter():
|
||||
"""Session sequence should increment monotonically."""
|
||||
session = CaptureSession()
|
||||
assert session.next_sequence() == 1
|
||||
assert session.next_sequence() == 2
|
||||
assert session.next_sequence() == 3
|
||||
assert session.capture_count == 3
|
||||
|
||||
|
||||
def test_session_id_unique():
|
||||
"""Each session should have a unique ID."""
|
||||
s1 = CaptureSession()
|
||||
s2 = CaptureSession()
|
||||
assert s1.session_id != s2.session_id
|
||||
|
||||
|
||||
def test_subdirectory_creation(manager: CaptureManager, tracking_metadata):
|
||||
"""Captures should go into date-based subdirectories."""
|
||||
result = manager.capture(tracking_metadata)
|
||||
assert result.success
|
||||
# The parent should be a date directory like "2026-02-16"
|
||||
parent = result.path.parent.name
|
||||
assert len(parent) == 10 # YYYY-MM-DD
|
||||
assert parent.count("-") == 2
|
||||
|
||||
|
||||
def test_multiple_captures_increment(manager: CaptureManager, tracking_metadata):
|
||||
"""Multiple captures should increment the session counter."""
|
||||
r1 = manager.capture(tracking_metadata)
|
||||
r2 = manager.capture(tracking_metadata)
|
||||
assert r1.success and r2.success
|
||||
assert manager.session.capture_count == 2
|
||||
# Filenames should differ
|
||||
assert r1.path.name != r2.path.name
|
||||
|
||||
|
||||
def test_pillow_fallback(manager: CaptureManager):
|
||||
"""Manager should report Pillow status without crashing."""
|
||||
# This test just verifies the property doesn't throw
|
||||
_ = manager.has_pillow # True if installed, False if not
|
||||
|
||||
|
||||
def test_astropy_fallback(manager: CaptureManager):
|
||||
"""Manager should report astropy status without crashing."""
|
||||
_ = manager.has_astropy # True if installed, False if not
|
||||
|
||||
|
||||
def test_metadata_session_populated(manager: CaptureManager, tracking_metadata):
|
||||
"""After capture, metadata should have session info populated."""
|
||||
manager.capture(tracking_metadata)
|
||||
assert tracking_metadata.session_id == manager.session.session_id
|
||||
assert tracking_metadata.sequence_number == 1
|
||||
|
||||
|
||||
def test_manual_capture_no_target(manager: CaptureManager):
|
||||
"""Capture without tracking should work with minimal metadata."""
|
||||
meta = CaptureMetadata(
|
||||
mount_az=180.0,
|
||||
mount_el=45.0,
|
||||
trigger="manual",
|
||||
)
|
||||
result = manager.capture(meta)
|
||||
assert result.success
|
||||
|
||||
# JSON sidecar should exist
|
||||
json_files = list(result.path.parent.glob("*.json"))
|
||||
assert len(json_files) >= 1
|
||||
283
tui/tests/test_capture_triggers.py
Normal file
283
tui/tests/test_capture_triggers.py
Normal file
@ -0,0 +1,283 @@
|
||||
"""Test capture triggers — interval timer and pass event detection.
|
||||
|
||||
IntervalTimer fires at configurable intervals.
|
||||
PassEventDetector detects AOS/TCA/LOS transitions with hysteresis.
|
||||
"""
|
||||
|
||||
import threading
|
||||
import time
|
||||
|
||||
from birdcage_tui.capture_triggers import (
|
||||
IntervalTimer,
|
||||
PassEventDetector,
|
||||
TriggerEvent,
|
||||
TriggerType,
|
||||
)
|
||||
|
||||
|
||||
class _EventCollector:
|
||||
"""Collects trigger events for test assertions."""
|
||||
|
||||
def __init__(self):
|
||||
self.events: list[TriggerEvent] = []
|
||||
self._lock = threading.Lock()
|
||||
|
||||
def __call__(self, event: TriggerEvent) -> None:
|
||||
with self._lock:
|
||||
self.events.append(event)
|
||||
|
||||
@property
|
||||
def count(self) -> int:
|
||||
with self._lock:
|
||||
return len(self.events)
|
||||
|
||||
def types(self) -> list[TriggerType]:
|
||||
with self._lock:
|
||||
return [e.trigger_type for e in self.events]
|
||||
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# IntervalTimer tests
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
|
||||
def test_interval_timer_fires():
|
||||
"""Timer should fire at least once within 2x the interval."""
|
||||
collector = _EventCollector()
|
||||
timer = IntervalTimer(callback=collector, interval_seconds=0.2)
|
||||
timer.start()
|
||||
time.sleep(0.5)
|
||||
timer.stop()
|
||||
|
||||
assert collector.count >= 1
|
||||
assert all(e.trigger_type == TriggerType.INTERVAL for e in collector.events)
|
||||
|
||||
|
||||
def test_interval_timer_stop():
|
||||
"""Timer should stop cleanly and not fire after stop()."""
|
||||
collector = _EventCollector()
|
||||
timer = IntervalTimer(callback=collector, interval_seconds=0.1)
|
||||
timer.start()
|
||||
time.sleep(0.25)
|
||||
timer.stop()
|
||||
|
||||
count_at_stop = collector.count
|
||||
time.sleep(0.3)
|
||||
assert collector.count == count_at_stop # No new events
|
||||
|
||||
|
||||
def test_interval_timer_set_interval():
|
||||
"""set_interval should update the interval property."""
|
||||
collector = _EventCollector()
|
||||
timer = IntervalTimer(callback=collector, interval_seconds=10.0)
|
||||
assert timer.interval == 10.0
|
||||
|
||||
timer.set_interval(5.0)
|
||||
assert timer.interval == 5.0
|
||||
|
||||
# Minimum clamp
|
||||
timer.set_interval(0.5)
|
||||
assert timer.interval >= 0.5
|
||||
|
||||
|
||||
def test_interval_timer_double_start():
|
||||
"""Starting twice should be safe (no duplicate threads)."""
|
||||
collector = _EventCollector()
|
||||
timer = IntervalTimer(callback=collector, interval_seconds=0.2)
|
||||
timer.start()
|
||||
timer.start() # Should be no-op
|
||||
time.sleep(0.5)
|
||||
timer.stop()
|
||||
|
||||
assert collector.count >= 1
|
||||
|
||||
|
||||
def test_interval_timer_is_running():
|
||||
"""is_running property should reflect timer state."""
|
||||
collector = _EventCollector()
|
||||
timer = IntervalTimer(callback=collector, interval_seconds=1.0)
|
||||
assert not timer.is_running
|
||||
|
||||
timer.start()
|
||||
assert timer.is_running
|
||||
|
||||
timer.stop()
|
||||
assert not timer.is_running
|
||||
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# PassEventDetector tests
|
||||
# ------------------------------------------------------------------
|
||||
|
||||
|
||||
def test_pass_detector_aos():
|
||||
"""WAITING -> TRACKING should fire AOS."""
|
||||
collector = _EventCollector()
|
||||
detector = PassEventDetector(on_event=collector)
|
||||
detector.enable(TriggerType.AOS)
|
||||
|
||||
detector.update("WAITING", "ISS", 0.0)
|
||||
detector.update("TRACKING", "ISS", 20.0)
|
||||
|
||||
assert collector.count == 1
|
||||
assert collector.events[0].trigger_type == TriggerType.AOS
|
||||
assert "ISS" in collector.events[0].detail
|
||||
|
||||
|
||||
def test_pass_detector_los():
|
||||
"""TRACKING -> WAITING should fire LOS."""
|
||||
collector = _EventCollector()
|
||||
detector = PassEventDetector(on_event=collector)
|
||||
detector.enable(TriggerType.LOS)
|
||||
|
||||
detector.update("TRACKING", "ISS", 45.0)
|
||||
detector.update("WAITING", "ISS", 5.0)
|
||||
|
||||
assert collector.count == 1
|
||||
assert collector.events[0].trigger_type == TriggerType.LOS
|
||||
|
||||
|
||||
def test_pass_detector_tca():
|
||||
"""Elevation peak detection with hysteresis."""
|
||||
collector = _EventCollector()
|
||||
detector = PassEventDetector(on_event=collector)
|
||||
detector.enable(TriggerType.TCA)
|
||||
|
||||
# Simulate ascending pass
|
||||
detector.update("TRACKING", "ISS", 20.0)
|
||||
detector.update("TRACKING", "ISS", 30.0)
|
||||
detector.update("TRACKING", "ISS", 40.0)
|
||||
detector.update("TRACKING", "ISS", 45.0) # Peak
|
||||
detector.update("TRACKING", "ISS", 44.8) # Small jitter, no trigger
|
||||
detector.update("TRACKING", "ISS", 44.4) # Below threshold
|
||||
detector.update("TRACKING", "ISS", 43.0) # Well below peak
|
||||
|
||||
assert collector.count == 1
|
||||
assert collector.events[0].trigger_type == TriggerType.TCA
|
||||
assert "45.0" in collector.events[0].detail
|
||||
|
||||
|
||||
def test_pass_detector_hysteresis():
|
||||
"""Small jitter around peak should NOT trigger TCA."""
|
||||
collector = _EventCollector()
|
||||
detector = PassEventDetector(on_event=collector)
|
||||
detector.enable(TriggerType.TCA)
|
||||
|
||||
# Simulate noisy plateau at peak
|
||||
detector.update("TRACKING", "ISS", 44.8)
|
||||
detector.update("TRACKING", "ISS", 45.0)
|
||||
detector.update("TRACKING", "ISS", 44.9) # -0.1 from peak
|
||||
detector.update("TRACKING", "ISS", 44.8) # -0.2 from peak
|
||||
detector.update("TRACKING", "ISS", 44.7) # -0.3 from peak
|
||||
|
||||
# Still within hysteresis threshold (0.5 deg)
|
||||
assert collector.count == 0
|
||||
|
||||
|
||||
def test_pass_detector_tca_fires_once():
|
||||
"""TCA should fire only once per pass."""
|
||||
collector = _EventCollector()
|
||||
detector = PassEventDetector(on_event=collector)
|
||||
detector.enable(TriggerType.TCA)
|
||||
|
||||
detector.update("TRACKING", "ISS", 45.0) # Peak
|
||||
detector.update("TRACKING", "ISS", 44.0) # -1.0, triggers TCA
|
||||
detector.update("TRACKING", "ISS", 43.0) # Should NOT trigger again
|
||||
detector.update("TRACKING", "ISS", 42.0)
|
||||
|
||||
assert collector.count == 1
|
||||
|
||||
|
||||
def test_pass_detector_full_pass():
|
||||
"""Full pass should generate AOS + TCA + LOS in order."""
|
||||
collector = _EventCollector()
|
||||
detector = PassEventDetector(on_event=collector)
|
||||
detector.enable(TriggerType.AOS, TriggerType.TCA, TriggerType.LOS)
|
||||
|
||||
# Pre-pass
|
||||
detector.update("WAITING", "ISS", 0.0)
|
||||
|
||||
# AOS
|
||||
detector.update("TRACKING", "ISS", 5.0)
|
||||
|
||||
# Ascending
|
||||
detector.update("TRACKING", "ISS", 20.0)
|
||||
detector.update("TRACKING", "ISS", 35.0)
|
||||
detector.update("TRACKING", "ISS", 45.0) # Peak
|
||||
|
||||
# Descending (triggers TCA)
|
||||
detector.update("TRACKING", "ISS", 44.0)
|
||||
detector.update("TRACKING", "ISS", 30.0)
|
||||
detector.update("TRACKING", "ISS", 10.0)
|
||||
|
||||
# LOS
|
||||
detector.update("WAITING", "ISS", 2.0)
|
||||
|
||||
types = collector.types()
|
||||
assert types == [TriggerType.AOS, TriggerType.TCA, TriggerType.LOS]
|
||||
|
||||
|
||||
def test_pass_detector_disabled_triggers():
|
||||
"""Disabled triggers should not fire."""
|
||||
collector = _EventCollector()
|
||||
detector = PassEventDetector(on_event=collector)
|
||||
# Enable only AOS, not TCA or LOS
|
||||
detector.enable(TriggerType.AOS)
|
||||
|
||||
detector.update("WAITING", "ISS", 0.0)
|
||||
detector.update("TRACKING", "ISS", 45.0)
|
||||
detector.update("TRACKING", "ISS", 30.0)
|
||||
detector.update("WAITING", "ISS", 0.0)
|
||||
|
||||
# Only AOS should fire
|
||||
assert collector.count == 1
|
||||
assert collector.events[0].trigger_type == TriggerType.AOS
|
||||
|
||||
|
||||
def test_pass_detector_target_change_resets():
|
||||
"""Changing target should reset peak tracking."""
|
||||
collector = _EventCollector()
|
||||
detector = PassEventDetector(on_event=collector)
|
||||
detector.enable(TriggerType.TCA)
|
||||
|
||||
# First target peaks at 45
|
||||
detector.update("TRACKING", "ISS", 45.0)
|
||||
|
||||
# Switch to new target — peak resets
|
||||
detector.update("TRACKING", "NOAA 19", 30.0)
|
||||
detector.update("TRACKING", "NOAA 19", 35.0) # New peak
|
||||
detector.update("TRACKING", "NOAA 19", 34.0) # -1.0, triggers TCA
|
||||
|
||||
assert collector.count == 1
|
||||
assert "NOAA 19" in collector.events[0].detail
|
||||
|
||||
|
||||
def test_pass_detector_reset():
|
||||
"""reset() should clear all internal state."""
|
||||
collector = _EventCollector()
|
||||
detector = PassEventDetector(on_event=collector)
|
||||
detector.enable(TriggerType.AOS)
|
||||
|
||||
detector.update("TRACKING", "ISS", 45.0)
|
||||
detector.reset()
|
||||
|
||||
# After reset, a new TRACKING should fire AOS again
|
||||
detector.update("WAITING", "ISS", 0.0)
|
||||
detector.update("TRACKING", "ISS", 20.0)
|
||||
|
||||
assert collector.count == 2 # Initial + after reset
|
||||
|
||||
|
||||
def test_pass_detector_enable_disable():
|
||||
"""enable/disable should toggle trigger states."""
|
||||
collector = _EventCollector()
|
||||
detector = PassEventDetector(on_event=collector)
|
||||
|
||||
detector.enable(TriggerType.AOS, TriggerType.LOS)
|
||||
assert detector.is_enabled(TriggerType.AOS)
|
||||
assert detector.is_enabled(TriggerType.LOS)
|
||||
assert not detector.is_enabled(TriggerType.TCA)
|
||||
|
||||
detector.disable(TriggerType.AOS)
|
||||
assert not detector.is_enabled(TriggerType.AOS)
|
||||
assert detector.is_enabled(TriggerType.LOS)
|
||||
280
tui/uv.lock
generated
280
tui/uv.lock
generated
@ -2,6 +2,38 @@ version = 1
|
||||
revision = 3
|
||||
requires-python = ">=3.11"
|
||||
|
||||
[[package]]
|
||||
name = "astropy"
|
||||
version = "7.2.0"
|
||||
source = { registry = "https://pypi.org/simple" }
|
||||
dependencies = [
|
||||
{ name = "astropy-iers-data" },
|
||||
{ name = "numpy" },
|
||||
{ name = "packaging" },
|
||||
{ name = "pyerfa" },
|
||||
{ name = "pyyaml" },
|
||||
]
|
||||
sdist = { url = "https://files.pythonhosted.org/packages/7b/92/2dce2d48347efc3346d08ca7995b152d242ebd170c571f7c9346468d8427/astropy-7.2.0.tar.gz", hash = "sha256:ae48bc26b1feaeb603cd94bd1fa1aa39137a115fe931b7f13787ab420e8c3070", size = 7057774, upload-time = "2025-11-25T22:36:41.916Z" }
|
||||
wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/b4/6d/6330a844bad8dfc4875e0f2fa1db1fee87837ba9805aa8a8d048c071363a/astropy-7.2.0-cp311-abi3-macosx_10_9_x86_64.whl", hash = "sha256:efac04df4cc488efe630c2fff1992d6516dfb16a06e197fb68bc9e8e3b85def1", size = 6442332, upload-time = "2025-11-25T22:36:23.6Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/a6/ba/3418133ba144dfcd1530bca5a6b695f4cdd21a8abaaa2ac4e5450d11b028/astropy-7.2.0-cp311-abi3-macosx_11_0_arm64.whl", hash = "sha256:52e9a7d9c86b21f1af911a2930cd0c4a275fb302d455c89e11eedaffef6f2ad0", size = 6413656, upload-time = "2025-11-25T22:36:26.548Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/be/ba/05e43b5a7d738316a097fa78524d3eaaff5986294b4a052d4adb3c45e7c0/astropy-7.2.0-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97c370421b9bb13d4c762c7af06d172bad7c01bd5bcf88314f6913c3c235b770", size = 9758867, upload-time = "2025-11-25T22:36:28.661Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/c3/1c/f06ad85180e7dd9855aa5ede901bfc2be858d7bee17d4e978a14c0ecec14/astropy-7.2.0-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2f39ce2c80211fbceb005d377a5478cd0d66c42aa1498d252f2239fe5a025c24", size = 9789007, upload-time = "2025-11-25T22:36:31.063Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/f8/fb/e4d35194a5009d7a73333079481a4ef1380a255d67b9c1db578151a5fb50/astropy-7.2.0-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:ad4d71db994d45f046a1a5449000cf0f88ab6367cb67658500654a0586d6ab19", size = 9748547, upload-time = "2025-11-25T22:36:33.154Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/36/ea/f990730978ae0a7a34705f885d2f3806928c5f0bc22eefd6a1a23539cc32/astropy-7.2.0-cp311-abi3-win32.whl", hash = "sha256:95161f26602433176483e8bde8ab1a8ca09148f5b4bf5190569a26d381091598", size = 6237228, upload-time = "2025-11-25T22:36:35.236Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/ec/bc/f4378f586dd63902c37d16f68f35f7d555b3b32e08ac6b1d633eb0a48805/astropy-7.2.0-cp311-abi3-win_amd64.whl", hash = "sha256:dc7c340ba1713e55c93071b32033f3153470a0f663a4d539c03a7c9b44020790", size = 6362868, upload-time = "2025-11-25T22:36:37.784Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/77/79/b6d4bf01913cfd4ce0cd4c1be5916beccdb92b2970bab8c827984231eae6/astropy-7.2.0-cp311-abi3-win_arm64.whl", hash = "sha256:0c428735a3f15b05c2095bc6ccb5f98a64bc99fb7015866af19ff8492420ddaf", size = 6221756, upload-time = "2025-11-25T22:36:39.852Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "astropy-iers-data"
|
||||
version = "0.2026.2.16.0.48.25"
|
||||
source = { registry = "https://pypi.org/simple" }
|
||||
sdist = { url = "https://files.pythonhosted.org/packages/dc/ce/9aed8765e4dcb2e12afd545c7ce63f2b9bcad592afcb9a0d5437d872060d/astropy_iers_data-0.2026.2.16.0.48.25.tar.gz", hash = "sha256:be14512844e71536a15e165d729385f3cb4865d7822172509e68c4ac79322067", size = 1926145, upload-time = "2026-02-16T00:49:11.138Z" }
|
||||
wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/49/94/dcdac330d2c26776956555610ef584147584acc6b060e451aa65dd9142d9/astropy_iers_data-0.2026.2.16.0.48.25-py3-none-any.whl", hash = "sha256:180d1c3f59d18aa616345560799c2d88ec6e5164b8c45c746380acf892946136", size = 1982562, upload-time = "2026-02-16T00:49:09.602Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "birdcage"
|
||||
version = "2026.2.12.1"
|
||||
@ -26,6 +58,12 @@ dependencies = [
|
||||
{ name = "textual" },
|
||||
]
|
||||
|
||||
[package.optional-dependencies]
|
||||
camera = [
|
||||
{ name = "astropy" },
|
||||
{ name = "pillow" },
|
||||
]
|
||||
|
||||
[package.dev-dependencies]
|
||||
dev = [
|
||||
{ name = "pytest" },
|
||||
@ -34,9 +72,12 @@ dev = [
|
||||
|
||||
[package.metadata]
|
||||
requires-dist = [
|
||||
{ name = "astropy", marker = "extra == 'camera'", specifier = ">=6.0" },
|
||||
{ name = "birdcage", editable = "../" },
|
||||
{ name = "pillow", marker = "extra == 'camera'", specifier = ">=10.0" },
|
||||
{ name = "textual", specifier = ">=1.0.0" },
|
||||
]
|
||||
provides-extras = ["camera"]
|
||||
|
||||
[package.metadata.requires-dev]
|
||||
dev = [
|
||||
@ -124,6 +165,85 @@ wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "numpy"
|
||||
version = "2.4.2"
|
||||
source = { registry = "https://pypi.org/simple" }
|
||||
sdist = { url = "https://files.pythonhosted.org/packages/57/fd/0005efbd0af48e55eb3c7208af93f2862d4b1a56cd78e84309a2d959208d/numpy-2.4.2.tar.gz", hash = "sha256:659a6107e31a83c4e33f763942275fd278b21d095094044eb35569e86a21ddae", size = 20723651, upload-time = "2026-01-31T23:13:10.135Z" }
|
||||
wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/d3/44/71852273146957899753e69986246d6a176061ea183407e95418c2aa4d9a/numpy-2.4.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e7e88598032542bd49af7c4747541422884219056c268823ef6e5e89851c8825", size = 16955478, upload-time = "2026-01-31T23:10:25.623Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/74/41/5d17d4058bd0cd96bcbd4d9ff0fb2e21f52702aab9a72e4a594efa18692f/numpy-2.4.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7edc794af8b36ca37ef5fcb5e0d128c7e0595c7b96a2318d1badb6fcd8ee86b1", size = 14965467, upload-time = "2026-01-31T23:10:28.186Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/49/48/fb1ce8136c19452ed15f033f8aee91d5defe515094e330ce368a0647846f/numpy-2.4.2-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:6e9f61981ace1360e42737e2bae58b27bf28a1b27e781721047d84bd754d32e7", size = 5475172, upload-time = "2026-01-31T23:10:30.848Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/40/a9/3feb49f17bbd1300dd2570432961f5c8a4ffeff1db6f02c7273bd020a4c9/numpy-2.4.2-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:cb7bbb88aa74908950d979eeaa24dbdf1a865e3c7e45ff0121d8f70387b55f73", size = 6805145, upload-time = "2026-01-31T23:10:32.352Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/3f/39/fdf35cbd6d6e2fcad42fcf85ac04a85a0d0fbfbf34b30721c98d602fd70a/numpy-2.4.2-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4f069069931240b3fc703f1e23df63443dbd6390614c8c44a87d96cd0ec81eb1", size = 15966084, upload-time = "2026-01-31T23:10:34.502Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/1b/46/6fa4ea94f1ddf969b2ee941290cca6f1bfac92b53c76ae5f44afe17ceb69/numpy-2.4.2-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c02ef4401a506fb60b411467ad501e1429a3487abca4664871d9ae0b46c8ba32", size = 16899477, upload-time = "2026-01-31T23:10:37.075Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/09/a1/2a424e162b1a14a5bd860a464ab4e07513916a64ab1683fae262f735ccd2/numpy-2.4.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2653de5c24910e49c2b106499803124dde62a5a1fe0eedeaecf4309a5f639390", size = 17323429, upload-time = "2026-01-31T23:10:39.704Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/ce/a2/73014149ff250628df72c58204822ac01d768697913881aacf839ff78680/numpy-2.4.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1ae241bbfc6ae276f94a170b14785e561cb5e7f626b6688cf076af4110887413", size = 18635109, upload-time = "2026-01-31T23:10:41.924Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/6c/0c/73e8be2f1accd56df74abc1c5e18527822067dced5ec0861b5bb882c2ce0/numpy-2.4.2-cp311-cp311-win32.whl", hash = "sha256:df1b10187212b198dd45fa943d8985a3c8cf854aed4923796e0e019e113a1bda", size = 6237915, upload-time = "2026-01-31T23:10:45.26Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/76/ae/e0265e0163cf127c24c3969d29f1c4c64551a1e375d95a13d32eab25d364/numpy-2.4.2-cp311-cp311-win_amd64.whl", hash = "sha256:b9c618d56a29c9cb1c4da979e9899be7578d2e0b3c24d52079c166324c9e8695", size = 12607972, upload-time = "2026-01-31T23:10:47.021Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/29/a5/c43029af9b8014d6ea157f192652c50042e8911f4300f8f6ed3336bf437f/numpy-2.4.2-cp311-cp311-win_arm64.whl", hash = "sha256:47c5a6ed21d9452b10227e5e8a0e1c22979811cad7dcc19d8e3e2fb8fa03f1a3", size = 10485763, upload-time = "2026-01-31T23:10:50.087Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/51/6e/6f394c9c77668153e14d4da83bcc247beb5952f6ead7699a1a2992613bea/numpy-2.4.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:21982668592194c609de53ba4933a7471880ccbaadcc52352694a59ecc860b3a", size = 16667963, upload-time = "2026-01-31T23:10:52.147Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/1f/f8/55483431f2b2fd015ae6ed4fe62288823ce908437ed49db5a03d15151678/numpy-2.4.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40397bda92382fcec844066efb11f13e1c9a3e2a8e8f318fb72ed8b6db9f60f1", size = 14693571, upload-time = "2026-01-31T23:10:54.789Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/2f/20/18026832b1845cdc82248208dd929ca14c9d8f2bac391f67440707fff27c/numpy-2.4.2-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:b3a24467af63c67829bfaa61eecf18d5432d4f11992688537be59ecd6ad32f5e", size = 5203469, upload-time = "2026-01-31T23:10:57.343Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/7d/33/2eb97c8a77daaba34eaa3fa7241a14ac5f51c46a6bd5911361b644c4a1e2/numpy-2.4.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:805cc8de9fd6e7a22da5aed858e0ab16be5a4db6c873dde1d7451c541553aa27", size = 6550820, upload-time = "2026-01-31T23:10:59.429Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/b1/91/b97fdfd12dc75b02c44e26c6638241cc004d4079a0321a69c62f51470c4c/numpy-2.4.2-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6d82351358ffbcdcd7b686b90742a9b86632d6c1c051016484fa0b326a0a1548", size = 15663067, upload-time = "2026-01-31T23:11:01.291Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/f5/c6/a18e59f3f0b8071cc85cbc8d80cd02d68aa9710170b2553a117203d46936/numpy-2.4.2-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9e35d3e0144137d9fdae62912e869136164534d64a169f86438bc9561b6ad49f", size = 16619782, upload-time = "2026-01-31T23:11:03.669Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/b7/83/9751502164601a79e18847309f5ceec0b1446d7b6aa12305759b72cf98b2/numpy-2.4.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:adb6ed2ad29b9e15321d167d152ee909ec73395901b70936f029c3bc6d7f4460", size = 17013128, upload-time = "2026-01-31T23:11:05.913Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/61/c4/c4066322256ec740acc1c8923a10047818691d2f8aec254798f3dd90f5f2/numpy-2.4.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8906e71fd8afcb76580404e2a950caef2685df3d2a57fe82a86ac8d33cc007ba", size = 18345324, upload-time = "2026-01-31T23:11:08.248Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/ab/af/6157aa6da728fa4525a755bfad486ae7e3f76d4c1864138003eb84328497/numpy-2.4.2-cp312-cp312-win32.whl", hash = "sha256:ec055f6dae239a6299cace477b479cca2fc125c5675482daf1dd886933a1076f", size = 5960282, upload-time = "2026-01-31T23:11:10.497Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/92/0f/7ceaaeaacb40567071e94dbf2c9480c0ae453d5bb4f52bea3892c39dc83c/numpy-2.4.2-cp312-cp312-win_amd64.whl", hash = "sha256:209fae046e62d0ce6435fcfe3b1a10537e858249b3d9b05829e2a05218296a85", size = 12314210, upload-time = "2026-01-31T23:11:12.176Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/2f/a3/56c5c604fae6dd40fa2ed3040d005fca97e91bd320d232ac9931d77ba13c/numpy-2.4.2-cp312-cp312-win_arm64.whl", hash = "sha256:fbde1b0c6e81d56f5dccd95dd4a711d9b95df1ae4009a60887e56b27e8d903fa", size = 10220171, upload-time = "2026-01-31T23:11:14.684Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/a1/22/815b9fe25d1d7ae7d492152adbc7226d3eff731dffc38fe970589fcaaa38/numpy-2.4.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:25f2059807faea4b077a2b6837391b5d830864b3543627f381821c646f31a63c", size = 16663696, upload-time = "2026-01-31T23:11:17.516Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/09/f0/817d03a03f93ba9c6c8993de509277d84e69f9453601915e4a69554102a1/numpy-2.4.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bd3a7a9f5847d2fb8c2c6d1c862fa109c31a9abeca1a3c2bd5a64572955b2979", size = 14688322, upload-time = "2026-01-31T23:11:19.883Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/da/b4/f805ab79293c728b9a99438775ce51885fd4f31b76178767cfc718701a39/numpy-2.4.2-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:8e4549f8a3c6d13d55041925e912bfd834285ef1dd64d6bc7d542583355e2e98", size = 5198157, upload-time = "2026-01-31T23:11:22.375Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/74/09/826e4289844eccdcd64aac27d13b0fd3f32039915dd5b9ba01baae1f436c/numpy-2.4.2-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:aea4f66ff44dfddf8c2cffd66ba6538c5ec67d389285292fe428cb2c738c8aef", size = 6546330, upload-time = "2026-01-31T23:11:23.958Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/19/fb/cbfdbfa3057a10aea5422c558ac57538e6acc87ec1669e666d32ac198da7/numpy-2.4.2-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c3cd545784805de05aafe1dde61752ea49a359ccba9760c1e5d1c88a93bbf2b7", size = 15660968, upload-time = "2026-01-31T23:11:25.713Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/04/dc/46066ce18d01645541f0186877377b9371b8fa8017fa8262002b4ef22612/numpy-2.4.2-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d0d9b7c93578baafcbc5f0b83eaf17b79d345c6f36917ba0c67f45226911d499", size = 16607311, upload-time = "2026-01-31T23:11:28.117Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/14/d9/4b5adfc39a43fa6bf918c6d544bc60c05236cc2f6339847fc5b35e6cb5b0/numpy-2.4.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f74f0f7779cc7ae07d1810aab8ac6b1464c3eafb9e283a40da7309d5e6e48fbb", size = 17012850, upload-time = "2026-01-31T23:11:30.888Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/b7/20/adb6e6adde6d0130046e6fdfb7675cc62bc2f6b7b02239a09eb58435753d/numpy-2.4.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:c7ac672d699bf36275c035e16b65539931347d68b70667d28984c9fb34e07fa7", size = 18334210, upload-time = "2026-01-31T23:11:33.214Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/78/0e/0a73b3dff26803a8c02baa76398015ea2a5434d9b8265a7898a6028c1591/numpy-2.4.2-cp313-cp313-win32.whl", hash = "sha256:8e9afaeb0beff068b4d9cd20d322ba0ee1cecfb0b08db145e4ab4dd44a6b5110", size = 5958199, upload-time = "2026-01-31T23:11:35.385Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/43/bc/6352f343522fcb2c04dbaf94cb30cca6fd32c1a750c06ad6231b4293708c/numpy-2.4.2-cp313-cp313-win_amd64.whl", hash = "sha256:7df2de1e4fba69a51c06c28f5a3de36731eb9639feb8e1cf7e4a7b0daf4cf622", size = 12310848, upload-time = "2026-01-31T23:11:38.001Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/6e/8d/6da186483e308da5da1cc6918ce913dcfe14ffde98e710bfeff2a6158d4e/numpy-2.4.2-cp313-cp313-win_arm64.whl", hash = "sha256:0fece1d1f0a89c16b03442eae5c56dc0be0c7883b5d388e0c03f53019a4bfd71", size = 10221082, upload-time = "2026-01-31T23:11:40.392Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/25/a1/9510aa43555b44781968935c7548a8926274f815de42ad3997e9e83680dd/numpy-2.4.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5633c0da313330fd20c484c78cdd3f9b175b55e1a766c4a174230c6b70ad8262", size = 14815866, upload-time = "2026-01-31T23:11:42.495Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/36/30/6bbb5e76631a5ae46e7923dd16ca9d3f1c93cfa8d4ed79a129814a9d8db3/numpy-2.4.2-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:d9f64d786b3b1dd742c946c42d15b07497ed14af1a1f3ce840cce27daa0ce913", size = 5325631, upload-time = "2026-01-31T23:11:44.7Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/46/00/3a490938800c1923b567b3a15cd17896e68052e2145d8662aaf3e1ffc58f/numpy-2.4.2-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:b21041e8cb6a1eb5312dd1d2f80a94d91efffb7a06b70597d44f1bd2dfc315ab", size = 6646254, upload-time = "2026-01-31T23:11:46.341Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/d3/e9/fac0890149898a9b609caa5af7455a948b544746e4b8fe7c212c8edd71f8/numpy-2.4.2-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:00ab83c56211a1d7c07c25e3217ea6695e50a3e2f255053686b081dc0b091a82", size = 15720138, upload-time = "2026-01-31T23:11:48.082Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/ea/5c/08887c54e68e1e28df53709f1893ce92932cc6f01f7c3d4dc952f61ffd4e/numpy-2.4.2-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2fb882da679409066b4603579619341c6d6898fc83a8995199d5249f986e8e8f", size = 16655398, upload-time = "2026-01-31T23:11:50.293Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/4d/89/253db0fa0e66e9129c745e4ef25631dc37d5f1314dad2b53e907b8538e6d/numpy-2.4.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:66cb9422236317f9d44b67b4d18f44efe6e9c7f8794ac0462978513359461554", size = 17079064, upload-time = "2026-01-31T23:11:52.927Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/2a/d5/cbade46ce97c59c6c3da525e8d95b7abe8a42974a1dc5c1d489c10433e88/numpy-2.4.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:0f01dcf33e73d80bd8dc0f20a71303abbafa26a19e23f6b68d1aa9990af90257", size = 18379680, upload-time = "2026-01-31T23:11:55.22Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/40/62/48f99ae172a4b63d981babe683685030e8a3df4f246c893ea5c6ef99f018/numpy-2.4.2-cp313-cp313t-win32.whl", hash = "sha256:52b913ec40ff7ae845687b0b34d8d93b60cb66dcee06996dd5c99f2fc9328657", size = 6082433, upload-time = "2026-01-31T23:11:58.096Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/07/38/e054a61cfe48ad9f1ed0d188e78b7e26859d0b60ef21cd9de4897cdb5326/numpy-2.4.2-cp313-cp313t-win_amd64.whl", hash = "sha256:5eea80d908b2c1f91486eb95b3fb6fab187e569ec9752ab7d9333d2e66bf2d6b", size = 12451181, upload-time = "2026-01-31T23:11:59.782Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/6e/a4/a05c3a6418575e185dd84d0b9680b6bb2e2dc3e4202f036b7b4e22d6e9dc/numpy-2.4.2-cp313-cp313t-win_arm64.whl", hash = "sha256:fd49860271d52127d61197bb50b64f58454e9f578cb4b2c001a6de8b1f50b0b1", size = 10290756, upload-time = "2026-01-31T23:12:02.438Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/18/88/b7df6050bf18fdcfb7046286c6535cabbdd2064a3440fca3f069d319c16e/numpy-2.4.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:444be170853f1f9d528428eceb55f12918e4fda5d8805480f36a002f1415e09b", size = 16663092, upload-time = "2026-01-31T23:12:04.521Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/25/7a/1fee4329abc705a469a4afe6e69b1ef7e915117747886327104a8493a955/numpy-2.4.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:d1240d50adff70c2a88217698ca844723068533f3f5c5fa6ee2e3220e3bdb000", size = 14698770, upload-time = "2026-01-31T23:12:06.96Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/fb/0b/f9e49ba6c923678ad5bc38181c08ac5e53b7a5754dbca8e581aa1a56b1ff/numpy-2.4.2-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:7cdde6de52fb6664b00b056341265441192d1291c130e99183ec0d4b110ff8b1", size = 5208562, upload-time = "2026-01-31T23:12:09.632Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/7d/12/d7de8f6f53f9bb76997e5e4c069eda2051e3fe134e9181671c4391677bb2/numpy-2.4.2-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:cda077c2e5b780200b6b3e09d0b42205a3d1c68f30c6dceb90401c13bff8fe74", size = 6543710, upload-time = "2026-01-31T23:12:11.969Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/09/63/c66418c2e0268a31a4cf8a8b512685748200f8e8e8ec6c507ce14e773529/numpy-2.4.2-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d30291931c915b2ab5717c2974bb95ee891a1cf22ebc16a8006bd59cd210d40a", size = 15677205, upload-time = "2026-01-31T23:12:14.33Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/5d/6c/7f237821c9642fb2a04d2f1e88b4295677144ca93285fd76eff3bcba858d/numpy-2.4.2-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bba37bc29d4d85761deed3954a1bc62be7cf462b9510b51d367b769a8c8df325", size = 16611738, upload-time = "2026-01-31T23:12:16.525Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/c2/a7/39c4cdda9f019b609b5c473899d87abff092fc908cfe4d1ecb2fcff453b0/numpy-2.4.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b2f0073ed0868db1dcd86e052d37279eef185b9c8db5bf61f30f46adac63c909", size = 17028888, upload-time = "2026-01-31T23:12:19.306Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/da/b3/e84bb64bdfea967cc10950d71090ec2d84b49bc691df0025dddb7c26e8e3/numpy-2.4.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:7f54844851cdb630ceb623dcec4db3240d1ac13d4990532446761baede94996a", size = 18339556, upload-time = "2026-01-31T23:12:21.816Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/88/f5/954a291bc1192a27081706862ac62bb5920fbecfbaa302f64682aa90beed/numpy-2.4.2-cp314-cp314-win32.whl", hash = "sha256:12e26134a0331d8dbd9351620f037ec470b7c75929cb8a1537f6bfe411152a1a", size = 6006899, upload-time = "2026-01-31T23:12:24.14Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/05/cb/eff72a91b2efdd1bc98b3b8759f6a1654aa87612fc86e3d87d6fe4f948c4/numpy-2.4.2-cp314-cp314-win_amd64.whl", hash = "sha256:068cdb2d0d644cdb45670810894f6a0600797a69c05f1ac478e8d31670b8ee75", size = 12443072, upload-time = "2026-01-31T23:12:26.33Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/37/75/62726948db36a56428fce4ba80a115716dc4fad6a3a4352487f8bb950966/numpy-2.4.2-cp314-cp314-win_arm64.whl", hash = "sha256:6ed0be1ee58eef41231a5c943d7d1375f093142702d5723ca2eb07db9b934b05", size = 10494886, upload-time = "2026-01-31T23:12:28.488Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/36/2f/ee93744f1e0661dc267e4b21940870cabfae187c092e1433b77b09b50ac4/numpy-2.4.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:98f16a80e917003a12c0580f97b5f875853ebc33e2eaa4bccfc8201ac6869308", size = 14818567, upload-time = "2026-01-31T23:12:30.709Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/a7/24/6535212add7d76ff938d8bdc654f53f88d35cddedf807a599e180dcb8e66/numpy-2.4.2-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:20abd069b9cda45874498b245c8015b18ace6de8546bf50dfa8cea1696ed06ef", size = 5328372, upload-time = "2026-01-31T23:12:32.962Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/5e/9d/c48f0a035725f925634bf6b8994253b43f2047f6778a54147d7e213bc5a7/numpy-2.4.2-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:e98c97502435b53741540a5717a6749ac2ada901056c7db951d33e11c885cc7d", size = 6649306, upload-time = "2026-01-31T23:12:34.797Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/81/05/7c73a9574cd4a53a25907bad38b59ac83919c0ddc8234ec157f344d57d9a/numpy-2.4.2-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:da6cad4e82cb893db4b69105c604d805e0c3ce11501a55b5e9f9083b47d2ffe8", size = 15722394, upload-time = "2026-01-31T23:12:36.565Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/35/fa/4de10089f21fc7d18442c4a767ab156b25c2a6eaf187c0db6d9ecdaeb43f/numpy-2.4.2-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9e4424677ce4b47fe73c8b5556d876571f7c6945d264201180db2dc34f676ab5", size = 16653343, upload-time = "2026-01-31T23:12:39.188Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/b8/f9/d33e4ffc857f3763a57aa85650f2e82486832d7492280ac21ba9efda80da/numpy-2.4.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2b8f157c8a6f20eb657e240f8985cc135598b2b46985c5bccbde7616dc9c6b1e", size = 17078045, upload-time = "2026-01-31T23:12:42.041Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/c8/b8/54bdb43b6225badbea6389fa038c4ef868c44f5890f95dd530a218706da3/numpy-2.4.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5daf6f3914a733336dab21a05cdec343144600e964d2fcdabaac0c0269874b2a", size = 18380024, upload-time = "2026-01-31T23:12:44.331Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/a5/55/6e1a61ded7af8df04016d81b5b02daa59f2ea9252ee0397cb9f631efe9e5/numpy-2.4.2-cp314-cp314t-win32.whl", hash = "sha256:8c50dd1fc8826f5b26a5ee4d77ca55d88a895f4e4819c7ecc2a9f5905047a443", size = 6153937, upload-time = "2026-01-31T23:12:47.229Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/45/aa/fa6118d1ed6d776b0983f3ceac9b1a5558e80df9365b1c3aa6d42bf9eee4/numpy-2.4.2-cp314-cp314t-win_amd64.whl", hash = "sha256:fcf92bee92742edd401ba41135185866f7026c502617f422eb432cfeca4fe236", size = 12631844, upload-time = "2026-01-31T23:12:48.997Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/32/0a/2ec5deea6dcd158f254a7b372fb09cfba5719419c8d66343bab35237b3fb/numpy-2.4.2-cp314-cp314t-win_arm64.whl", hash = "sha256:1f92f53998a17265194018d1cc321b2e96e900ca52d54c7c77837b71b9465181", size = 10565379, upload-time = "2026-01-31T23:12:51.345Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/f4/f8/50e14d36d915ef64d8f8bc4a087fc8264d82c785eda6711f80ab7e620335/numpy-2.4.2-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:89f7268c009bc492f506abd6f5265defa7cb3f7487dc21d357c3d290add45082", size = 16833179, upload-time = "2026-01-31T23:12:53.5Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/17/17/809b5cad63812058a8189e91a1e2d55a5a18fd04611dbad244e8aeae465c/numpy-2.4.2-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:e6dee3bb76aa4009d5a912180bf5b2de012532998d094acee25d9cb8dee3e44a", size = 14889755, upload-time = "2026-01-31T23:12:55.933Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/3e/ea/181b9bcf7627fc8371720316c24db888dcb9829b1c0270abf3d288b2e29b/numpy-2.4.2-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:cd2bd2bbed13e213d6b55dc1d035a4f91748a7d3edc9480c13898b0353708920", size = 5399500, upload-time = "2026-01-31T23:12:58.671Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/33/9f/413adf3fc955541ff5536b78fcf0754680b3c6d95103230252a2c9408d23/numpy-2.4.2-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:cf28c0c1d4c4bf00f509fa7eb02c58d7caf221b50b467bcb0d9bbf1584d5c821", size = 6714252, upload-time = "2026-01-31T23:13:00.518Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/91/da/643aad274e29ccbdf42ecd94dafe524b81c87bcb56b83872d54827f10543/numpy-2.4.2-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e04ae107ac591763a47398bb45b568fc38f02dbc4aa44c063f67a131f99346cb", size = 15797142, upload-time = "2026-01-31T23:13:02.219Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/66/27/965b8525e9cb5dc16481b30a1b3c21e50c7ebf6e9dbd48d0c4d0d5089c7e/numpy-2.4.2-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:602f65afdef699cda27ec0b9224ae5dc43e328f4c24c689deaf77133dbee74d0", size = 16727979, upload-time = "2026-01-31T23:13:04.62Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/de/e5/b7d20451657664b07986c2f6e3be564433f5dcaf3482d68eaecd79afaf03/numpy-2.4.2-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:be71bf1edb48ebbbf7f6337b5bfd2f895d1902f6335a5830b20141fc126ffba0", size = 12502577, upload-time = "2026-01-31T23:13:07.08Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "packaging"
|
||||
version = "26.0"
|
||||
@ -133,6 +253,93 @@ wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "pillow"
|
||||
version = "12.1.1"
|
||||
source = { registry = "https://pypi.org/simple" }
|
||||
sdist = { url = "https://files.pythonhosted.org/packages/1f/42/5c74462b4fd957fcd7b13b04fb3205ff8349236ea74c7c375766d6c82288/pillow-12.1.1.tar.gz", hash = "sha256:9ad8fa5937ab05218e2b6a4cff30295ad35afd2f83ac592e68c0d871bb0fdbc4", size = 46980264, upload-time = "2026-02-11T04:23:07.146Z" }
|
||||
wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/2b/46/5da1ec4a5171ee7bf1a0efa064aba70ba3d6e0788ce3f5acd1375d23c8c0/pillow-12.1.1-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:e879bb6cd5c73848ef3b2b48b8af9ff08c5b71ecda8048b7dd22d8a33f60be32", size = 5304084, upload-time = "2026-02-11T04:20:27.501Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/78/93/a29e9bc02d1cf557a834da780ceccd54e02421627200696fcf805ebdc3fb/pillow-12.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:365b10bb9417dd4498c0e3b128018c4a624dc11c7b97d8cc54effe3b096f4c38", size = 4657866, upload-time = "2026-02-11T04:20:29.827Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/13/84/583a4558d492a179d31e4aae32eadce94b9acf49c0337c4ce0b70e0a01f2/pillow-12.1.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d4ce8e329c93845720cd2014659ca67eac35f6433fd3050393d85f3ecef0dad5", size = 6232148, upload-time = "2026-02-11T04:20:31.329Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/d5/e2/53c43334bbbb2d3b938978532fbda8e62bb6e0b23a26ce8592f36bcc4987/pillow-12.1.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc354a04072b765eccf2204f588a7a532c9511e8b9c7f900e1b64e3e33487090", size = 8038007, upload-time = "2026-02-11T04:20:34.225Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/b8/a6/3d0e79c8a9d58150dd98e199d7c1c56861027f3829a3a60b3c2784190180/pillow-12.1.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7e7976bf1910a8116b523b9f9f58bf410f3e8aa330cd9a2bb2953f9266ab49af", size = 6345418, upload-time = "2026-02-11T04:20:35.858Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/a2/c8/46dfeac5825e600579157eea177be43e2f7ff4a99da9d0d0a49533509ac5/pillow-12.1.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:597bd9c8419bc7c6af5604e55847789b69123bbe25d65cc6ad3012b4f3c98d8b", size = 7034590, upload-time = "2026-02-11T04:20:37.91Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/af/bf/e6f65d3db8a8bbfeaf9e13cc0417813f6319863a73de934f14b2229ada18/pillow-12.1.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2c1fc0f2ca5f96a3c8407e41cca26a16e46b21060fe6d5b099d2cb01412222f5", size = 6458655, upload-time = "2026-02-11T04:20:39.496Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/f9/c2/66091f3f34a25894ca129362e510b956ef26f8fb67a0e6417bc5744e56f1/pillow-12.1.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:578510d88c6229d735855e1f278aa305270438d36a05031dfaae5067cc8eb04d", size = 7159286, upload-time = "2026-02-11T04:20:41.139Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/7b/5a/24bc8eb526a22f957d0cec6243146744966d40857e3d8deb68f7902ca6c1/pillow-12.1.1-cp311-cp311-win32.whl", hash = "sha256:7311c0a0dcadb89b36b7025dfd8326ecfa36964e29913074d47382706e516a7c", size = 6328663, upload-time = "2026-02-11T04:20:43.184Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/31/03/bef822e4f2d8f9d7448c133d0a18185d3cce3e70472774fffefe8b0ed562/pillow-12.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:fbfa2a7c10cc2623f412753cddf391c7f971c52ca40a3f65dc5039b2939e8563", size = 7031448, upload-time = "2026-02-11T04:20:44.696Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/49/70/f76296f53610bd17b2e7d31728b8b7825e3ac3b5b3688b51f52eab7c0818/pillow-12.1.1-cp311-cp311-win_arm64.whl", hash = "sha256:b81b5e3511211631b3f672a595e3221252c90af017e399056d0faabb9538aa80", size = 2453651, upload-time = "2026-02-11T04:20:46.243Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/07/d3/8df65da0d4df36b094351dce696f2989bec731d4f10e743b1c5f4da4d3bf/pillow-12.1.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ab323b787d6e18b3d91a72fc99b1a2c28651e4358749842b8f8dfacd28ef2052", size = 5262803, upload-time = "2026-02-11T04:20:47.653Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/d6/71/5026395b290ff404b836e636f51d7297e6c83beceaa87c592718747e670f/pillow-12.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:adebb5bee0f0af4909c30db0d890c773d1a92ffe83da908e2e9e720f8edf3984", size = 4657601, upload-time = "2026-02-11T04:20:49.328Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/b1/2e/1001613d941c67442f745aff0f7cc66dd8df9a9c084eb497e6a543ee6f7e/pillow-12.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:bb66b7cc26f50977108790e2456b7921e773f23db5630261102233eb355a3b79", size = 6234995, upload-time = "2026-02-11T04:20:51.032Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/07/26/246ab11455b2549b9233dbd44d358d033a2f780fa9007b61a913c5b2d24e/pillow-12.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aee2810642b2898bb187ced9b349e95d2a7272930796e022efaf12e99dccd293", size = 8045012, upload-time = "2026-02-11T04:20:52.882Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/b2/8b/07587069c27be7535ac1fe33874e32de118fbd34e2a73b7f83436a88368c/pillow-12.1.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a0b1cd6232e2b618adcc54d9882e4e662a089d5768cd188f7c245b4c8c44a397", size = 6349638, upload-time = "2026-02-11T04:20:54.444Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/ff/79/6df7b2ee763d619cda2fb4fea498e5f79d984dae304d45a8999b80d6cf5c/pillow-12.1.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7aac39bcf8d4770d089588a2e1dd111cbaa42df5a94be3114222057d68336bd0", size = 7041540, upload-time = "2026-02-11T04:20:55.97Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/2c/5e/2ba19e7e7236d7529f4d873bdaf317a318896bac289abebd4bb00ef247f0/pillow-12.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ab174cd7d29a62dd139c44bf74b698039328f45cb03b4596c43473a46656b2f3", size = 6462613, upload-time = "2026-02-11T04:20:57.542Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/03/03/31216ec124bb5c3dacd74ce8efff4cc7f52643653bad4825f8f08c697743/pillow-12.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:339ffdcb7cbeaa08221cd401d517d4b1fe7a9ed5d400e4a8039719238620ca35", size = 7166745, upload-time = "2026-02-11T04:20:59.196Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/1f/e7/7c4552d80052337eb28653b617eafdef39adfb137c49dd7e831b8dc13bc5/pillow-12.1.1-cp312-cp312-win32.whl", hash = "sha256:5d1f9575a12bed9e9eedd9a4972834b08c97a352bd17955ccdebfeca5913fa0a", size = 6328823, upload-time = "2026-02-11T04:21:01.385Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/3d/17/688626d192d7261bbbf98846fc98995726bddc2c945344b65bec3a29d731/pillow-12.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:21329ec8c96c6e979cd0dfd29406c40c1d52521a90544463057d2aaa937d66a6", size = 7033367, upload-time = "2026-02-11T04:21:03.536Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/ed/fe/a0ef1f73f939b0eca03ee2c108d0043a87468664770612602c63266a43c4/pillow-12.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:af9a332e572978f0218686636610555ae3defd1633597be015ed50289a03c523", size = 2453811, upload-time = "2026-02-11T04:21:05.116Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/d5/11/6db24d4bd7685583caeae54b7009584e38da3c3d4488ed4cd25b439de486/pillow-12.1.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:d242e8ac078781f1de88bf823d70c1a9b3c7950a44cdf4b7c012e22ccbcd8e4e", size = 4062689, upload-time = "2026-02-11T04:21:06.804Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/33/c0/ce6d3b1fe190f0021203e0d9b5b99e57843e345f15f9ef22fcd43842fd21/pillow-12.1.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:02f84dfad02693676692746df05b89cf25597560db2857363a208e393429f5e9", size = 4138535, upload-time = "2026-02-11T04:21:08.452Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/a0/c6/d5eb6a4fb32a3f9c21a8c7613ec706534ea1cf9f4b3663e99f0d83f6fca8/pillow-12.1.1-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:e65498daf4b583091ccbb2556c7000abf0f3349fcd57ef7adc9a84a394ed29f6", size = 3601364, upload-time = "2026-02-11T04:21:10.194Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/14/a1/16c4b823838ba4c9c52c0e6bbda903a3fe5a1bdbf1b8eb4fff7156f3e318/pillow-12.1.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:6c6db3b84c87d48d0088943bf33440e0c42370b99b1c2a7989216f7b42eede60", size = 5262561, upload-time = "2026-02-11T04:21:11.742Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/bb/ad/ad9dc98ff24f485008aa5cdedaf1a219876f6f6c42a4626c08bc4e80b120/pillow-12.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8b7e5304e34942bf62e15184219a7b5ad4ff7f3bb5cca4d984f37df1a0e1aee2", size = 4657460, upload-time = "2026-02-11T04:21:13.786Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/9e/1b/f1a4ea9a895b5732152789326202a82464d5254759fbacae4deea3069334/pillow-12.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:18e5bddd742a44b7e6b1e773ab5db102bd7a94c32555ba656e76d319d19c3850", size = 6232698, upload-time = "2026-02-11T04:21:15.949Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/95/f4/86f51b8745070daf21fd2e5b1fe0eb35d4db9ca26e6d58366562fb56a743/pillow-12.1.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc44ef1f3de4f45b50ccf9136999d71abb99dca7706bc75d222ed350b9fd2289", size = 8041706, upload-time = "2026-02-11T04:21:17.723Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/29/9b/d6ecd956bb1266dd1045e995cce9b8d77759e740953a1c9aad9502a0461e/pillow-12.1.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5a8eb7ed8d4198bccbd07058416eeec51686b498e784eda166395a23eb99138e", size = 6346621, upload-time = "2026-02-11T04:21:19.547Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/71/24/538bff45bde96535d7d998c6fed1a751c75ac7c53c37c90dc2601b243893/pillow-12.1.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:47b94983da0c642de92ced1702c5b6c292a84bd3a8e1d1702ff923f183594717", size = 7038069, upload-time = "2026-02-11T04:21:21.378Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/94/0e/58cb1a6bc48f746bc4cb3adb8cabff73e2742c92b3bf7a220b7cf69b9177/pillow-12.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:518a48c2aab7ce596d3bf79d0e275661b846e86e4d0e7dec34712c30fe07f02a", size = 6460040, upload-time = "2026-02-11T04:21:23.148Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/6c/57/9045cb3ff11eeb6c1adce3b2d60d7d299d7b273a2e6c8381a524abfdc474/pillow-12.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a550ae29b95c6dc13cf69e2c9dc5747f814c54eeb2e32d683e5e93af56caa029", size = 7164523, upload-time = "2026-02-11T04:21:25.01Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/73/f2/9be9cb99f2175f0d4dbadd6616ce1bf068ee54a28277ea1bf1fbf729c250/pillow-12.1.1-cp313-cp313-win32.whl", hash = "sha256:a003d7422449f6d1e3a34e3dd4110c22148336918ddbfc6a32581cd54b2e0b2b", size = 6332552, upload-time = "2026-02-11T04:21:27.238Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/3f/eb/b0834ad8b583d7d9d42b80becff092082a1c3c156bb582590fcc973f1c7c/pillow-12.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:344cf1e3dab3be4b1fa08e449323d98a2a3f819ad20f4b22e77a0ede31f0faa1", size = 7040108, upload-time = "2026-02-11T04:21:29.462Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/d5/7d/fc09634e2aabdd0feabaff4a32f4a7d97789223e7c2042fd805ea4b4d2c2/pillow-12.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:5c0dd1636633e7e6a0afe7bf6a51a14992b7f8e60de5789018ebbdfae55b040a", size = 2453712, upload-time = "2026-02-11T04:21:31.072Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/19/2a/b9d62794fc8a0dd14c1943df68347badbd5511103e0d04c035ffe5cf2255/pillow-12.1.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0330d233c1a0ead844fc097a7d16c0abff4c12e856c0b325f231820fee1f39da", size = 5264880, upload-time = "2026-02-11T04:21:32.865Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/26/9d/e03d857d1347fa5ed9247e123fcd2a97b6220e15e9cb73ca0a8d91702c6e/pillow-12.1.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5dae5f21afb91322f2ff791895ddd8889e5e947ff59f71b46041c8ce6db790bc", size = 4660616, upload-time = "2026-02-11T04:21:34.97Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/f7/ec/8a6d22afd02570d30954e043f09c32772bfe143ba9285e2fdb11284952cd/pillow-12.1.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2e0c664be47252947d870ac0d327fea7e63985a08794758aa8af5b6cb6ec0c9c", size = 6269008, upload-time = "2026-02-11T04:21:36.623Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/3d/1d/6d875422c9f28a4a361f495a5f68d9de4a66941dc2c619103ca335fa6446/pillow-12.1.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:691ab2ac363b8217f7d31b3497108fb1f50faab2f75dfb03284ec2f217e87bf8", size = 8073226, upload-time = "2026-02-11T04:21:38.585Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/a1/cd/134b0b6ee5eda6dc09e25e24b40fdafe11a520bc725c1d0bbaa5e00bf95b/pillow-12.1.1-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e9e8064fb1cc019296958595f6db671fba95209e3ceb0c4734c9baf97de04b20", size = 6380136, upload-time = "2026-02-11T04:21:40.562Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/7a/a9/7628f013f18f001c1b98d8fffe3452f306a70dc6aba7d931019e0492f45e/pillow-12.1.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:472a8d7ded663e6162dafdf20015c486a7009483ca671cece7a9279b512fcb13", size = 7067129, upload-time = "2026-02-11T04:21:42.521Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/1e/f8/66ab30a2193b277785601e82ee2d49f68ea575d9637e5e234faaa98efa4c/pillow-12.1.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:89b54027a766529136a06cfebeecb3a04900397a3590fd252160b888479517bf", size = 6491807, upload-time = "2026-02-11T04:21:44.22Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/da/0b/a877a6627dc8318fdb84e357c5e1a758c0941ab1ddffdafd231983788579/pillow-12.1.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:86172b0831b82ce4f7877f280055892b31179e1576aa00d0df3bb1bbf8c3e524", size = 7190954, upload-time = "2026-02-11T04:21:46.114Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/83/43/6f732ff85743cf746b1361b91665d9f5155e1483817f693f8d57ea93147f/pillow-12.1.1-cp313-cp313t-win32.whl", hash = "sha256:44ce27545b6efcf0fdbdceb31c9a5bdea9333e664cda58a7e674bb74608b3986", size = 6336441, upload-time = "2026-02-11T04:21:48.22Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/3b/44/e865ef3986611bb75bfabdf94a590016ea327833f434558801122979cd0e/pillow-12.1.1-cp313-cp313t-win_amd64.whl", hash = "sha256:a285e3eb7a5a45a2ff504e31f4a8d1b12ef62e84e5411c6804a42197c1cf586c", size = 7045383, upload-time = "2026-02-11T04:21:50.015Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/a8/c6/f4fb24268d0c6908b9f04143697ea18b0379490cb74ba9e8d41b898bd005/pillow-12.1.1-cp313-cp313t-win_arm64.whl", hash = "sha256:cc7d296b5ea4d29e6570dabeaed58d31c3fea35a633a69679fb03d7664f43fb3", size = 2456104, upload-time = "2026-02-11T04:21:51.633Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/03/d0/bebb3ffbf31c5a8e97241476c4cf8b9828954693ce6744b4a2326af3e16b/pillow-12.1.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:417423db963cb4be8bac3fc1204fe61610f6abeed1580a7a2cbb2fbda20f12af", size = 4062652, upload-time = "2026-02-11T04:21:53.19Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/2d/c0/0e16fb0addda4851445c28f8350d8c512f09de27bbb0d6d0bbf8b6709605/pillow-12.1.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:b957b71c6b2387610f556a7eb0828afbe40b4a98036fc0d2acfa5a44a0c2036f", size = 4138823, upload-time = "2026-02-11T04:22:03.088Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/6b/fb/6170ec655d6f6bb6630a013dd7cf7bc218423d7b5fa9071bf63dc32175ae/pillow-12.1.1-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:097690ba1f2efdeb165a20469d59d8bb03c55fb6621eb2041a060ae8ea3e9642", size = 3601143, upload-time = "2026-02-11T04:22:04.909Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/59/04/dc5c3f297510ba9a6837cbb318b87dd2b8f73eb41a43cc63767f65cb599c/pillow-12.1.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2815a87ab27848db0321fb78c7f0b2c8649dee134b7f2b80c6a45c6831d75ccd", size = 5266254, upload-time = "2026-02-11T04:22:07.656Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/05/30/5db1236b0d6313f03ebf97f5e17cda9ca060f524b2fcc875149a8360b21c/pillow-12.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:f7ed2c6543bad5a7d5530eb9e78c53132f93dfa44a28492db88b41cdab885202", size = 4657499, upload-time = "2026-02-11T04:22:09.613Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/6f/18/008d2ca0eb612e81968e8be0bbae5051efba24d52debf930126d7eaacbba/pillow-12.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:652a2c9ccfb556235b2b501a3a7cf3742148cd22e04b5625c5fe057ea3e3191f", size = 6232137, upload-time = "2026-02-11T04:22:11.434Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/70/f1/f14d5b8eeb4b2cd62b9f9f847eb6605f103df89ef619ac68f92f748614ea/pillow-12.1.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d6e4571eedf43af33d0fc233a382a76e849badbccdf1ac438841308652a08e1f", size = 8042721, upload-time = "2026-02-11T04:22:13.321Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/5a/d6/17824509146e4babbdabf04d8171491fa9d776f7061ff6e727522df9bd03/pillow-12.1.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b574c51cf7d5d62e9be37ba446224b59a2da26dc4c1bb2ecbe936a4fb1a7cb7f", size = 6347798, upload-time = "2026-02-11T04:22:15.449Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/d1/ee/c85a38a9ab92037a75615aba572c85ea51e605265036e00c5b67dfafbfe2/pillow-12.1.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a37691702ed687799de29a518d63d4682d9016932db66d4e90c345831b02fb4e", size = 7039315, upload-time = "2026-02-11T04:22:17.24Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/ec/f3/bc8ccc6e08a148290d7523bde4d9a0d6c981db34631390dc6e6ec34cacf6/pillow-12.1.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f95c00d5d6700b2b890479664a06e754974848afaae5e21beb4d83c106923fd0", size = 6462360, upload-time = "2026-02-11T04:22:19.111Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/f6/ab/69a42656adb1d0665ab051eec58a41f169ad295cf81ad45406963105408f/pillow-12.1.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:559b38da23606e68681337ad74622c4dbba02254fc9cb4488a305dd5975c7eeb", size = 7165438, upload-time = "2026-02-11T04:22:21.041Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/02/46/81f7aa8941873f0f01d4b55cc543b0a3d03ec2ee30d617a0448bf6bd6dec/pillow-12.1.1-cp314-cp314-win32.whl", hash = "sha256:03edcc34d688572014ff223c125a3f77fb08091e4607e7745002fc214070b35f", size = 6431503, upload-time = "2026-02-11T04:22:22.833Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/40/72/4c245f7d1044b67affc7f134a09ea619d4895333d35322b775b928180044/pillow-12.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:50480dcd74fa63b8e78235957d302d98d98d82ccbfac4c7e12108ba9ecbdba15", size = 7176748, upload-time = "2026-02-11T04:22:24.64Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/e4/ad/8a87bdbe038c5c698736e3348af5c2194ffb872ea52f11894c95f9305435/pillow-12.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:5cb1785d97b0c3d1d1a16bc1d710c4a0049daefc4935f3a8f31f827f4d3d2e7f", size = 2544314, upload-time = "2026-02-11T04:22:26.685Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/6c/9d/efd18493f9de13b87ede7c47e69184b9e859e4427225ea962e32e56a49bc/pillow-12.1.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:1f90cff8aa76835cba5769f0b3121a22bd4eb9e6884cfe338216e557a9a548b8", size = 5268612, upload-time = "2026-02-11T04:22:29.884Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/f8/f1/4f42eb2b388eb2ffc660dcb7f7b556c1015c53ebd5f7f754965ef997585b/pillow-12.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1f1be78ce9466a7ee64bfda57bdba0f7cc499d9794d518b854816c41bf0aa4e9", size = 4660567, upload-time = "2026-02-11T04:22:31.799Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/01/54/df6ef130fa43e4b82e32624a7b821a2be1c5653a5fdad8469687a7db4e00/pillow-12.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:42fc1f4677106188ad9a55562bbade416f8b55456f522430fadab3cef7cd4e60", size = 6269951, upload-time = "2026-02-11T04:22:33.921Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/a9/48/618752d06cc44bb4aae8ce0cd4e6426871929ed7b46215638088270d9b34/pillow-12.1.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:98edb152429ab62a1818039744d8fbb3ccab98a7c29fc3d5fcef158f3f1f68b7", size = 8074769, upload-time = "2026-02-11T04:22:35.877Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/c3/bd/f1d71eb39a72fa088d938655afba3e00b38018d052752f435838961127d8/pillow-12.1.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d470ab1178551dd17fdba0fef463359c41aaa613cdcd7ff8373f54be629f9f8f", size = 6381358, upload-time = "2026-02-11T04:22:37.698Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/64/ef/c784e20b96674ed36a5af839305f55616f8b4f8aa8eeccf8531a6e312243/pillow-12.1.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6408a7b064595afcab0a49393a413732a35788f2a5092fdc6266952ed67de586", size = 7068558, upload-time = "2026-02-11T04:22:39.597Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/73/cb/8059688b74422ae61278202c4e1ad992e8a2e7375227be0a21c6b87ca8d5/pillow-12.1.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5d8c41325b382c07799a3682c1c258469ea2ff97103c53717b7893862d0c98ce", size = 6493028, upload-time = "2026-02-11T04:22:42.73Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/c6/da/e3c008ed7d2dd1f905b15949325934510b9d1931e5df999bb15972756818/pillow-12.1.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c7697918b5be27424e9ce568193efd13d925c4481dd364e43f5dff72d33e10f8", size = 7191940, upload-time = "2026-02-11T04:22:44.543Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/01/4a/9202e8d11714c1fc5951f2e1ef362f2d7fbc595e1f6717971d5dd750e969/pillow-12.1.1-cp314-cp314t-win32.whl", hash = "sha256:d2912fd8114fc5545aa3a4b5576512f64c55a03f3ebcca4c10194d593d43ea36", size = 6438736, upload-time = "2026-02-11T04:22:46.347Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/f3/ca/cbce2327eb9885476b3957b2e82eb12c866a8b16ad77392864ad601022ce/pillow-12.1.1-cp314-cp314t-win_amd64.whl", hash = "sha256:4ceb838d4bd9dab43e06c363cab2eebf63846d6a4aeaea283bbdfd8f1a8ed58b", size = 7182894, upload-time = "2026-02-11T04:22:48.114Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/ec/d2/de599c95ba0a973b94410477f8bf0b6f0b5e67360eb89bcb1ad365258beb/pillow-12.1.1-cp314-cp314t-win_arm64.whl", hash = "sha256:7b03048319bfc6170e93bd60728a1af51d3dd7704935feb228c4d4faab35d334", size = 2546446, upload-time = "2026-02-11T04:22:50.342Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/56/11/5d43209aa4cb58e0cc80127956ff1796a68b928e6324bbf06ef4db34367b/pillow-12.1.1-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:600fd103672b925fe62ed08e0d874ea34d692474df6f4bf7ebe148b30f89f39f", size = 5228606, upload-time = "2026-02-11T04:22:52.106Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/5f/d5/3b005b4e4fda6698b371fa6c21b097d4707585d7db99e98d9b0b87ac612a/pillow-12.1.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:665e1b916b043cef294bc54d47bf02d87e13f769bc4bc5fa225a24b3a6c5aca9", size = 4622321, upload-time = "2026-02-11T04:22:53.827Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/df/36/ed3ea2d594356fd8037e5a01f6156c74bc8d92dbb0fa60746cc96cabb6e8/pillow-12.1.1-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:495c302af3aad1ca67420ddd5c7bd480c8867ad173528767d906428057a11f0e", size = 5247579, upload-time = "2026-02-11T04:22:56.094Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/54/9a/9cc3e029683cf6d20ae5085da0dafc63148e3252c2f13328e553aaa13cfb/pillow-12.1.1-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8fd420ef0c52c88b5a035a0886f367748c72147b2b8f384c9d12656678dfdfa9", size = 6989094, upload-time = "2026-02-11T04:22:58.288Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/00/98/fc53ab36da80b88df0967896b6c4b4cd948a0dc5aa40a754266aa3ae48b3/pillow-12.1.1-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f975aa7ef9684ce7e2c18a3aa8f8e2106ce1e46b94ab713d156b2898811651d3", size = 5313850, upload-time = "2026-02-11T04:23:00.554Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/30/02/00fa585abfd9fe9d73e5f6e554dc36cc2b842898cbfc46d70353dae227f8/pillow-12.1.1-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8089c852a56c2966cf18835db62d9b34fef7ba74c726ad943928d494fa7f4735", size = 5963343, upload-time = "2026-02-11T04:23:02.934Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/f2/26/c56ce33ca856e358d27fda9676c055395abddb82c35ac0f593877ed4562e/pillow-12.1.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:cb9bb857b2d057c6dfc72ac5f3b44836924ba15721882ef103cecb40d002d80e", size = 7029880, upload-time = "2026-02-11T04:23:04.783Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "platformdirs"
|
||||
version = "4.7.0"
|
||||
@ -151,6 +358,24 @@ wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "pyerfa"
|
||||
version = "2.0.1.5"
|
||||
source = { registry = "https://pypi.org/simple" }
|
||||
dependencies = [
|
||||
{ name = "numpy" },
|
||||
]
|
||||
sdist = { url = "https://files.pythonhosted.org/packages/71/39/63cc8291b0cf324ae710df41527faf7d331bce573899199d926b3e492260/pyerfa-2.0.1.5.tar.gz", hash = "sha256:17d6b24fe4846c65d5e7d8c362dcb08199dc63b30a236aedd73875cc83e1f6c0", size = 818430, upload-time = "2024-11-11T15:22:30.852Z" }
|
||||
wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/7d/d9/3448a57cb5bd19950de6d6ab08bd8fbb3df60baa71726de91d73d76c481b/pyerfa-2.0.1.5-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:b282d7c60c4c47cf629c484c17ac504fcb04abd7b3f4dfcf53ee042afc3a5944", size = 341818, upload-time = "2024-11-11T15:22:16.467Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/11/4a/31a363370478b63c6289a34743f2ba2d3ae1bd8223e004d18ab28fb92385/pyerfa-2.0.1.5-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:be1aeb70390dd03a34faf96749d5cabc58437410b4aab7213c512323932427df", size = 329370, upload-time = "2024-11-11T15:22:17.829Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/cb/96/b6210fc624123c8ae13e1eecb68fb75e3f3adff216d95eee1c7b05843e3e/pyerfa-2.0.1.5-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b0603e8e1b839327d586c8a627cdc634b795e18b007d84f0cda5500a0908254e", size = 692794, upload-time = "2024-11-11T15:22:19.429Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/e5/e0/050018d855d26d3c0b4a7d1b2ed692be758ce276d8289e2a2b44ba1014a5/pyerfa-2.0.1.5-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0e43c7194e3242083f2350b46c09fd4bf8ba1bcc0ebd1460b98fc47fe2389906", size = 738711, upload-time = "2024-11-11T15:22:20.661Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/b9/f5/ff91ee77308793ae32fa1e1de95e9edd4551456dd888b4e87c5938657ca5/pyerfa-2.0.1.5-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:07b80cd70701f5d066b1ac8cce406682cfcd667a1186ec7d7ade597239a6021d", size = 722966, upload-time = "2024-11-11T15:22:21.905Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/2c/56/b22b35c8551d2228ff8d445e63787112927ca13f6dc9e2c04f69d742c95b/pyerfa-2.0.1.5-cp39-abi3-win32.whl", hash = "sha256:d30b9b0df588ed5467e529d851ea324a67239096dd44703125072fd11b351ea2", size = 339955, upload-time = "2024-11-11T15:22:23.087Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/b4/11/97233cf23ad5411ac6f13b1d6ee3888f90ace4f974d9bf9db887aa428912/pyerfa-2.0.1.5-cp39-abi3-win_amd64.whl", hash = "sha256:66292d437dcf75925b694977aa06eb697126e7b86553e620371ed3e48b5e0ad0", size = 349410, upload-time = "2024-11-11T15:22:24.817Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "pygments"
|
||||
version = "2.19.2"
|
||||
@ -198,6 +423,61 @@ wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/e5/35/f8b19922b6a25bc0880171a2f1a003eaeb93657475193ab516fd87cac9da/pytest_asyncio-1.3.0-py3-none-any.whl", hash = "sha256:611e26147c7f77640e6d0a92a38ed17c3e9848063698d5c93d5aa7aa11cebff5", size = 15075, upload-time = "2025-11-10T16:07:45.537Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "pyyaml"
|
||||
version = "6.0.3"
|
||||
source = { registry = "https://pypi.org/simple" }
|
||||
sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
|
||||
wheels = [
|
||||
{ url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" },
|
||||
{ url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rich"
|
||||
version = "14.3.2"
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user