{% trans "Published" %} {{ object.date_added }}
++ {% if object.date_taken %}{% trans "Taken" %} {{ object.date_taken }}{% if object.date_is_approximate %} ({% trans "approximate date" %}){% endif %} · {% endif %} + {% trans "Published" %} {{ object.date_added }} +
{{ object.caption }}
{% endif %} diff --git a/photologue/utils.py b/photologue/utils.py index d3ff68b..a697eb1 100644 --- a/photologue/utils.py +++ b/photologue/utils.py @@ -5,7 +5,12 @@ import logging import os +from datetime import datetime, timezone as dt_timezone + +from django.conf import settings from django.core.files.base import ContentFile +from django.utils import timezone +from django.utils.dateparse import parse_datetime from io import BytesIO from PIL import Image import av @@ -61,3 +66,89 @@ def generate_video_thumbnail(video): video.thumbnail.save(thumb_name, ContentFile(buffer.getvalue()), save=True) except Exception: logger.error("Failed to save video thumbnail", exc_info=True) + + +def capture_date_from_exif(exif_value): + """Turn an EXIF "YYYY:MM:DD HH:MM:SS" value into an aware datetime. + + EXIF dates carry no time zone: they are local time as read by the camera, so + they are interpreted in the site time zone. + """ + try: + day, hour = str(exif_value).split() + year, month, dayofmonth = (int(part) for part in day.split(":")) + hours, minutes, seconds = (int(part) for part in hour.split(":")) + naive = datetime(year, month, dayofmonth, hours, minutes, seconds) + except (AttributeError, TypeError, ValueError): + logger.error("Unreadable EXIF date %r", exif_value) + return None + return timezone.make_aware(naive) if settings.USE_TZ else naive + + +def capture_date_from_video(path): + """Read the capture date from a video container, or None.""" + try: + container = av.open(path) + raw = container.metadata.get("creation_time") + container.close() + except Exception: + logger.error("Failed to read video metadata from %s", path, exc_info=True) + return None + if not raw: + return None + parsed = parse_datetime(raw) + if parsed is None: + return None + if settings.USE_TZ and timezone.is_naive(parsed): + # Containers usually store UTC; a naive value is the camera's local time. + parsed = timezone.make_aware(parsed) + return parsed + + +def capture_date_from_upload(last_modified_ms): + """Turn a browser File.lastModified value (ms since epoch) into a datetime.""" + try: + stamp = int(last_modified_ms) / 1000 + except (TypeError, ValueError): + return None + if not stamp: + return None + return datetime.fromtimestamp(stamp, tz=dt_timezone.utc) + + +def order_media_by_capture(items): + """Sort media in capture order, and fill in the dates that are missing. + + A file name is a reliable chronological clue inside one photographer's batch + (most cameras number their files in order) and meaningless between two of + them. So media without a capture date borrow the date of the closest dated + file of the same owner, which puts them back in the middle of the sequence + instead of exiling them at the end of the gallery. Only media whose owner has + no dated file at all end up at the end, in file name order. + + Every item is annotated with `capture_date` and `capture_date_is_guessed`. + """ + by_owner = {} + for item in items: + item.capture_date = item.date_taken + item.capture_date_is_guessed = False + by_owner.setdefault(item.owner_id, []).append(item) + + dated, undated = [], [] + for batch in by_owner.values(): + batch.sort(key=lambda item: (item.title, item.pk)) + # Forwards, then backwards for the files that come before the first date. + for sequence in (batch, batch[::-1]): + known = None + for item in sequence: + if item.capture_date is not None: + known = item.capture_date + elif known is not None: + item.capture_date = known + item.capture_date_is_guessed = True + for item in batch: + (dated if item.capture_date is not None else undated).append(item) + + dated.sort(key=lambda item: (item.capture_date, item.owner_id, item.title, item.pk)) + undated.sort(key=lambda item: (item.owner_id, item.title, item.pk)) + return dated + undated diff --git a/photologue/views.py b/photologue/views.py index 93116d2..21b4643 100644 --- a/photologue/views.py +++ b/photologue/views.py @@ -26,8 +26,15 @@ from django.contrib.auth import get_user_model from django.db.models import F, Q from .forms import UploadForm -from .models import Gallery, Photo, Tag, Video -from .utils import generate_video_thumbnail, is_photo, is_video +from .models import DATE_FROM_FILE, DATE_FROM_VIDEO, Gallery, Photo, Tag, Video +from .utils import ( + capture_date_from_upload, + capture_date_from_video, + generate_video_thumbnail, + is_photo, + is_video, + order_media_by_capture, +) MEDIA_MODELS = {"photo": Photo, "video": Video} @@ -229,9 +236,9 @@ class GalleryDetailView(DetailView): context["photos"] = context["photos"].filter(owner__id=self.kwargs["owner"]) context["videos"] = context["videos"].filter(owner__id=self.kwargs["owner"]) - # Combine photos and videos into a single sorted list for the template - context["media_items"] = sorted( - [*context["photos"], *context["videos"]], key=lambda x: x.title + # Combine photos and videos into a single list, in capture order + context["media_items"] = order_media_by_capture( + [*context["photos"], *context["videos"]] ) # Increment the photo view count @@ -304,7 +311,25 @@ class GalleryUpload(PermissionRequiredMixin, FormView): kwargs["is_staff"] = self.request.user.is_staff return kwargs - def _upload_media(self, model, file_field, file_obj, gallery, gallery_dir, owner, post_save=None): + @staticmethod + def _complete_capture_date(obj, modified_ms): + """ + Fill in the capture date that the file itself did not carry: photos get + theirs from EXIF when saved, videos from their container, and anything + still undated falls back on the file date sent by the browser. + """ + taken = source = None + if obj.date_taken is None and obj.is_video: + taken, source = capture_date_from_video(obj.file_path), DATE_FROM_VIDEO + if taken is None and obj.date_taken is None and modified_ms: + taken, source = capture_date_from_upload(modified_ms), DATE_FROM_FILE + if taken is None: + return + obj.set_capture_date(taken, source) + obj.save(update_fields=["date_taken", "date_source"]) + + def _upload_media(self, model, file_field, file_obj, gallery, gallery_dir, owner, + post_save=None, modified_ms=None): """ Create a media object, save it to the DB, schedule file save on commit. Returns True if uploaded, False if already exists. @@ -317,11 +342,12 @@ class GalleryUpload(PermissionRequiredMixin, FormView): with transaction.atomic(): obj.save() obj.galleries.set([gallery]) - def _save(o=obj, fp=file_path, f=file_obj, ff=file_field, ps=post_save): + def _save(o=obj, fp=file_path, f=file_obj, ff=file_field, ps=post_save, ms=modified_ms): f.seek(0) getattr(o, ff).save(fp, f) if ps: ps(o) + self._complete_capture_date(o, ms) transaction.on_commit(_save) return True @@ -359,11 +385,14 @@ class GalleryUpload(PermissionRequiredMixin, FormView): uploaded_photo_name = [] already_exists = 0 files = form.cleaned_data["file_field"] + modified_ms = form.cleaned_data.get("file_modified") for photo_file in files: if is_photo(photo_file): - uploaded = self._upload_media(Photo, "image", photo_file, gallery, gallery_dir, owner) + uploaded = self._upload_media(Photo, "image", photo_file, gallery, gallery_dir, owner, + modified_ms=modified_ms) elif is_video(photo_file): - uploaded = self._upload_media(Video, "file", photo_file, gallery, gallery_dir, owner, post_save=generate_video_thumbnail) + uploaded = self._upload_media(Video, "file", photo_file, gallery, gallery_dir, owner, + post_save=generate_video_thumbnail, modified_ms=modified_ms) else: messages.error(self.request, f"{photo_file.name} is not a recognized image or video") jsondata["code"] = 400