342 lines
14 KiB
Python
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()
|