Files
media-batch-tools/unit_tests/test_photo_metadata_logic.py
T

342 lines
14 KiB
Python

from __future__ import annotations
import os
import unittest
from contextlib import contextmanager
from datetime import datetime, timedelta, timezone
from pathlib import Path
from tempfile import TemporaryDirectory
from unittest.mock import patch
from tools.console import read_key
from tools.filesystem import complete_path, path_completions, prompt_existing_paths, resolve_output_directory
from tools.photo_grouping import detect_photo_groups, infer_group_subseconds
from tools.photo_planning import (
UserChoices,
build_write_plan,
filename_timestamp_stem,
infer_missing_timestamps,
merge_record_groups,
prepare_plan,
)
from tools.photo_records import (
MediaRecord,
infer_video_timezone,
)
from tools.photo_settings import (
SettingsState,
TimezoneAnalysis,
default_artist,
prompt_choices,
reference_completions,
settings_lines,
)
class PhotoMetadataLogicTests(unittest.TestCase):
def choices(self, **values):
base = dict(
working_dir=Path("."),
time_offset=None,
fixed_timezone=None,
fill_timezone_gaps=False,
artist_action="leave",
artist_value=None,
rename_mode="adjust_replace",
organize_files=False,
group_min_size=2,
process_pto_files=False,
infer_missing_timestamps=True,
)
base.update(values)
return UserChoices(**base)
def test_interactive_paths_accept_quotes_and_file_urls(self) -> None:
with TemporaryDirectory() as temporary:
directory = Path(temporary)
photo = directory / "a photo.jpg"
photo.touch()
answers = ["missing", f'"{photo}"', directory.as_uri(), ""]
with (
patch("tools.filesystem.prompt_input", side_effect=answers),
patch("builtins.print"),
):
self.assertEqual(
prompt_existing_paths(),
[str(photo.resolve()), str(directory.resolve())],
)
def test_path_completion_supports_spaces_and_directories(self) -> None:
with TemporaryDirectory() as temporary:
directory = Path(temporary)
(directory / "a photo.jpg").touch()
(directory / "a folder").mkdir()
prefix = str(directory / "a")
self.assertEqual(
path_completions(prefix),
[str(directory / "a folder") + os.sep, str(directory / "a photo.jpg")],
)
self.assertEqual(complete_path("a ", directory), "a ")
self.assertEqual(complete_path("a f", directory), "a folder" + os.sep)
(directory / "a folder" / "nested.jpg").touch()
self.assertEqual(complete_path("a folder/", directory), str(Path("a folder") / "nested.jpg"))
def test_reference_completion_uses_only_selected_photo_names(self) -> None:
records = [
MediaRecord(Path("one/Clock photo.jpg"), {}, "image"),
MediaRecord(Path("two/Clock photo.jpg"), {}, "image"),
MediaRecord(Path("Clock video.mp4"), {}, "video"),
MediaRecord(Path("Other.jpg"), {}, "image"),
]
self.assertEqual(reference_completions("cl", records), ["Clock photo.jpg"])
self.assertEqual(reference_completions('"Cl', records), ['"Clock photo.jpg"'])
self.assertEqual(reference_completions("+1:00", records), [])
def test_reference_photo_can_be_selected_with_tab(self) -> None:
timestamp = datetime(2026, 6, 7, 14, 0, 0)
record = MediaRecord(Path("Clock photo.jpg"), {}, "image", original_time=timestamp)
keys = iter(["down", "right", "C", "l", "tab", "enter", *"14:03:25", "enter",
"down", "down", "down", "down", "enter"])
@contextmanager
def key_input():
yield lambda: next(keys)
with (
patch("tools.photo_settings.raw_key_input", key_input),
patch("tools.photo_settings.draw_screen"),
):
choices, _ = prompt_choices("exiftool", [record], Path("/photos"), False)
self.assertEqual(choices.time_offset, timedelta(minutes=3, seconds=25))
@unittest.skipIf(os.name == "nt", "Unix terminal sequence")
def test_arrow_sequence_is_read_as_one_key(self) -> None:
class Input:
def fileno(self) -> int:
return 7
terminal = Input()
with (
patch("tools.console.sys.stdin", terminal),
patch("tools.console.os.read", side_effect=[b"\x1b", b"[", b"A"]),
patch("tools.console.select.select", return_value=([7], [], [])),
):
self.assertEqual(read_key(), "up")
@unittest.skipIf(os.name == "nt", "Unix terminal input")
def test_raw_key_reader_keeps_unicode_characters(self) -> None:
terminal = type("Input", (), {"fileno": lambda self: 7})()
with (
patch("tools.console.sys.stdin", terminal),
patch("tools.console.os.read", side_effect=[b"\xc3", b"\xa4"]),
):
self.assertEqual(read_key(), "ä")
def test_output_directory_defaults_and_resolves_relative_paths(self) -> None:
with TemporaryDirectory() as temporary:
default = Path(temporary).resolve()
self.assertEqual(resolve_output_directory("", default), default)
self.assertEqual(resolve_output_directory("organized", default), default / "organized")
self.assertEqual(resolve_output_directory(default.as_uri(), Path.cwd()), default)
file_path = default / "photo.jpg"
file_path.touch()
with self.assertRaisesRegex(ValueError, "not a directory"):
resolve_output_directory(str(file_path), default)
def test_adjusted_filename_preserves_each_timestamp_interval(self) -> None:
stem = "20260516_130011-20260516_130102_fused"
result = filename_timestamp_stem(stem, datetime(2026, 6, 7, 14, 0, 0), "adjust_replace")
self.assertEqual(result, "20260607_140000-20260607_140051_fused")
def test_uses_one_existing_artist_as_the_disabled_default(self) -> None:
records = [
MediaRecord(Path("a.jpg"), {"EXIF:Artist": "Anton"}, "image"),
MediaRecord(Path("b.jpg"), {"XMP:Author": "Anton"}, "image"),
]
self.assertEqual(default_artist(records), "Anton")
def test_infers_missing_photo_time_from_filename_before_modify_date(self) -> None:
record = MediaRecord(
Path("20260607_140011.jpg"),
{"EXIF:ModifyDate": "2020:01:01 00:00:00"},
"image",
)
infer_missing_timestamps([record], True)
self.assertEqual(record.original_time, datetime(2026, 6, 7, 14, 0, 11))
self.assertEqual(record.inferred_timestamp_source, "filename")
def test_infers_missing_photo_time_from_modify_date(self) -> None:
record = MediaRecord(
Path("DSC0001.jpg"),
{"EXIF:ModifyDate": "2026:06:07 14:00:11"},
"image",
)
infer_missing_timestamps([record], True)
self.assertEqual(record.original_time, datetime(2026, 6, 7, 14, 0, 11))
self.assertEqual(record.inferred_timestamp_source, "ModifyDate")
def test_infers_video_timezone_from_filename_and_utc_end_time(self) -> None:
record = MediaRecord(
Path("20260704_161323.mp4"),
{},
"video",
original_time=datetime(2026, 7, 4, 14, 13, 36, tzinfo=timezone.utc),
duration_seconds=13,
)
self.assertEqual(infer_video_timezone(record), timezone(timedelta(hours=2)))
def test_existing_subseconds_prevent_burst_inference(self) -> None:
records = [
MediaRecord(Path("a.jpg"), {}, "image", adjusted_time=datetime(2026, 6, 7, 14, 0, 0), subsec=100),
MediaRecord(Path("b.jpg"), {}, "image", adjusted_time=datetime(2026, 6, 7, 14, 0, 0)),
]
infer_group_subseconds([records])
self.assertIsNone(records[1].inferred_subsec)
def test_infers_subseconds_for_a_single_second_burst(self) -> None:
records = [
MediaRecord(
Path(f"photo-{index}.jpg"),
{},
"image",
adjusted_time=datetime(2026, 6, 7, 14, 0, 0),
)
for index in range(3)
]
infer_group_subseconds([records])
self.assertEqual([record.inferred_subsec for record in records], [0, 333, 666])
def test_flat_organization_preserves_names_and_resolves_collisions(self) -> None:
with TemporaryDirectory() as temporary:
root = Path(temporary)
records = [
MediaRecord(
root / folder / "photo.jpg",
{},
"image",
adjusted_time=datetime(2026, 6, 7, 14, 0, 0),
)
for folder in ("one", "two")
]
choices = self.choices(
working_dir=root,
rename_mode="none",
organize_files=True,
group_files=False,
)
self.assertEqual(prepare_plan(records, choices, []), [])
self.assertEqual(
[record.target_path for record in records],
[root / "photo.jpg", root / "photo-1.jpg"],
)
self.assertTrue(all(record.inferred_subsec is None for record in records))
def test_confirm_selection_does_not_highlight_organization_controls(self) -> None:
state = SettingsState(
working_dir=Path("/photos"),
time_offset=None,
infer_missing_timestamps=True,
fixed_timezone=timezone.utc,
fixed_timezone_enabled=False,
fill_timezone_gaps=False,
organize_files=True,
group_files=True,
)
lines = settings_lines(
state,
TimezoneAnalysis([], 0, 0),
["organize", "confirm"],
1,
1,
)
organize_line = next(line for line in lines if line.startswith("Organize/group:"))
confirm_line = next(line for line in lines if "Confirm" in line and line.startswith(" "))
self.assertNotIn("\x1b[30;47m", organize_line)
self.assertIn("\x1b[30;47mExit", confirm_line)
def test_settings_can_disable_rename_and_select_flat_organization(self) -> None:
timestamp = datetime(2026, 6, 7, 14, 0, 0)
record = MediaRecord(
Path("photo.jpg"),
{},
"image",
original_time=timestamp,
adjusted_time=timestamp,
)
keys = iter(["down", "down", "down", "left", "down", "down", "space", "down", "enter"])
@contextmanager
def key_input():
yield lambda: next(keys)
with (
patch("tools.photo_settings.raw_key_input", key_input),
patch("tools.photo_settings.draw_screen"),
):
choices, _state = prompt_choices("exiftool", [record], Path("/photos"), False)
assert choices is not None
self.assertEqual(choices.rename_mode, "none")
self.assertTrue(choices.organize_files)
self.assertFalse(choices.group_files)
def test_burst_detection_stays_per_camera(self) -> None:
timestamp = datetime(2026, 6, 7, 14, 0, 0)
records = [
MediaRecord(Path("a.jpg"), {}, "image", adjusted_time=timestamp, camera_key="A"),
MediaRecord(Path("b.jpg"), {}, "image", adjusted_time=timestamp, camera_key="A"),
MediaRecord(Path("c.jpg"), {}, "image", adjusted_time=timestamp, camera_key="B"),
]
self.assertEqual([[record.path.name for record in group] for group in detect_photo_groups(records)], [["a.jpg", "b.jpg"]])
def test_single_file_pto_group_is_preserved(self) -> None:
record = MediaRecord(Path("a.jpg"), {}, "image")
self.assertEqual(merge_record_groups([record], [[record]]), [[record]])
def test_shift_keeps_later_modify_date_but_clamps_an_earlier_one(self) -> None:
original = datetime(2026, 6, 7, 14, 0, 0)
record = MediaRecord(
Path("photo.jpg"),
{
"EXIF:DateTimeOriginal": "2026:06:07 14:00:00",
"EXIF:CreateDate": "2026:06:07 14:00:00",
"EXIF:ModifyDate": "2026:06:07 13:00:00",
},
"image",
original_time=original,
adjusted_time=original + timedelta(hours=2),
)
writes = build_write_plan(record, self.choices(time_offset=timedelta(hours=2)))
changed = {write.label: write.new_value for write in writes if write.will_write}
self.assertEqual(changed["DateTimeOriginal"], "2026:06:07 16:00:00")
self.assertEqual(changed["CreateDate"], "2026:06:07 16:00:00")
self.assertEqual(changed["ModifyDate"], "2026:06:07 16:00:00")
self.assertTrue(any("ModifyDate" in warning for warning in record.warnings))
def test_timezone_only_follows_capture_related_dates(self) -> None:
captured = datetime(2026, 6, 7, 14, 0, 0)
record = MediaRecord(
Path("photo.jpg"),
{
"EXIF:DateTimeOriginal": "2026:06:07 14:00:00",
"EXIF:CreateDate": "2026:06:07 14:00:00",
"EXIF:ModifyDate": "2026:07:07 14:00:00",
"EXIF:OffsetTimeOriginal": "+00:00",
"EXIF:OffsetTimeDigitized": "+00:00",
"EXIF:OffsetTime": "+00:00",
},
"image",
original_time=captured,
adjusted_time=captured,
resolved_timezone=timezone(timedelta(hours=2)),
)
writes = build_write_plan(record, self.choices(fixed_timezone=record.resolved_timezone))
changed = {write.arg for write in writes if write.will_write}
self.assertIn("-EXIF:OffsetTimeOriginal=+02:00", changed)
self.assertIn("-EXIF:OffsetTimeDigitized=+02:00", changed)
self.assertNotIn("-EXIF:OffsetTime=+02:00", changed)
if __name__ == "__main__":
unittest.main()