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()