photo-objects 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

photo_objects/__init__.py

@@ -0,0 +1,3 @@
+import logging
+
+logger = logging.getLogger("photo-objects")

photo_objects/config.py

@@ -0,0 +1,31 @@
+from os import getenv
+from pathlib import Path
+from secrets import token_urlsafe
+
+
+def get_home_directory() -> Path:
+    return Path(getenv("PHOTO_OBJECTS_HOME", Path.home() / ".photo_objects"))
+
+
+def write_to_home_directory(
+        filename: str,
+        content: str,
+        end: str = "\n") -> int:
+    home = get_home_directory()
+    home.mkdir(parents=True, exist_ok=True)
+
+    with open(home / filename, "w+") as f:
+        return f.write(content) + f.write(end)
+
+
+def get_secret_key() -> str:
+    try:
+        with open(get_home_directory() / "secret_key") as f:
+            return f.read().strip()
+    except FileNotFoundError:
+        pass
+
+    key = token_urlsafe(64)
+    write_to_home_directory("secret_key", key)
+
+    return key

photo_objects/django/api/album.py

@@ -16,15 +16,21 @@ from .utils import (
 def get_albums(request: HttpRequest):
     if not request.user.is_authenticated:
         return Album.objects.filter(visibility=Album.Visibility.PUBLIC)
-    else:
+    if request.user.is_staff:
         return Album.objects.all()
 
+    return Album.objects.filter(visibility__in=[
+        Album.Visibility.PUBLIC,
+        Album.Visibility.HIDDEN,
+        Album.Visibility.PRIVATE,
+    ])
+
 
 def create_album(request: HttpRequest):
     check_permissions(request, 'photo_objects.add_album')
     data = parse_input_data(request)
 
-    f = CreateAlbumForm(data)
+    f = CreateAlbumForm(data, user=request.user)
     if not f.is_valid():
         raise FormValidationFailed(f)
 
@@ -36,7 +42,8 @@ def modify_album(request: HttpRequest, album_key: str):
     album = check_album_access(request, album_key)
     data = parse_input_data(request)
 
-    f = ModifyAlbumForm({**album.to_json(), **data}, instance=album)
+    f = ModifyAlbumForm({**album.to_json(), **data},
+                        instance=album, user=request.user)
     if not f.is_valid():
         raise FormValidationFailed(f)
 
@@ -47,6 +54,13 @@ def delete_album(request: HttpRequest, album_key: str):
     check_permissions(request, 'photo_objects.delete_album')
     album = check_album_access(request, album_key)
 
+    if album.key.startswith('_'):
+        raise JsonProblem(
+            f"Album with {album_key} key is managed by the system and can not "
+            "be deleted.",
+            409,
+        )
+
     try:
         album.delete()
     except ProtectedError:

photo_objects/django/api/auth.py

@@ -19,7 +19,11 @@ def check_album_access(request: HttpRequest, album_key: str):
         raise AlbumNotFound(album_key)
 
     if not request.user.is_authenticated:
-        if album.visibility != Album.Visibility.PUBLIC:
+        if album.visibility == Album.Visibility.PRIVATE:
+            raise AlbumNotFound(album_key)
+
+    if not request.user.is_staff:
+        if album.visibility == Album.Visibility.ADMIN:
             raise AlbumNotFound(album_key)
 
     return album

photo_objects/django/api/photo.py

@@ -2,7 +2,9 @@ from django.core.files.uploadedfile import UploadedFile
 from django.http import HttpRequest
 from minio.error import S3Error
 from PIL import UnidentifiedImageError
+from urllib3.exceptions import HTTPError
 
+from photo_objects import logger
 from photo_objects.django import objsto
 from photo_objects.django.forms import (
     CreatePhotoForm,
@@ -51,15 +53,13 @@ def _upload_photo(album_key: str, photo_file: UploadedFile):
     photo_file.seek(0)
     try:
         objsto.put_photo(photo.album.key, photo.filename, "og", photo_file)
-    except S3Error:
-        # TODO: check that there is no photo entry in the database, if object
-        # storage upload fails.
+    except (S3Error, HTTPError) as e:
         photo.delete()
-        # TODO: logging
-        raise JsonProblem(
-            "Could not save photo to object storage.",
-            500,
-        )
+
+        msg = objsto.with_error_code(
+            "Could not save photo to object storage", e)
+        logger.error(f"{msg}: {str(e)}")
+        raise JsonProblem(f"{msg}.", 500)
 
     return photo
 
@@ -121,16 +121,15 @@ def delete_photo(request: HttpRequest, album_key: str, photo_key: str):
 
     try:
         objsto.delete_photo(album_key, photo_key)
-    except S3Error:
-        raise JsonProblem(
-            "Could not delete photo from object storage.",
-            500,
-        )
+    except (S3Error, HTTPError) as e:
+        msg = objsto.with_error_code(
+            "Could not delete photo from object storage", e)
+        logger.error(f"{msg}: {str(e)}")
+        raise JsonProblem("{msg}.", 500)
 
     try:
         photo.delete()
-    except Exception:
-        raise JsonProblem(
-            "Could not delete photo from database.",
-            500,
-        )
+    except Exception as e:
+        msg = "Could not delete photo from database"
+        logger.error(f"{msg}: {str(e)}")
+        raise JsonProblem(f"{msg}.", 500)

photo_objects/django/forms.py

@@ -9,8 +9,10 @@ from django.forms import (
     Form,
     HiddenInput,
     ModelForm,
-    ValidationError
+    RadioSelect,
+    ValidationError,
 )
+from django.utils.safestring import mark_safe
 from django.utils.translation import gettext_lazy as _
 
 from .models import Album, Photo
@@ -21,28 +23,64 @@ KEY_POSTFIX_CHARS = 'bcdfghjklmnpqrstvwxz2456789'
 KEY_POSTFIX_LEN = 5
 
 
-def slugify(input: str):
+def slugify(input: str, lower=False, replace_leading_underscores=False) -> str:
     key = unicodedata.normalize(
         'NFKD', input).encode(
         'ascii', 'ignore').decode('ascii')
+    if lower:
+        key = key.lower()
+
     key = re.sub(r'[^a-zA-Z0-9._-]', '-', key)
     key = re.sub(r'[-_]{2,}', '-', key)
+
+    if replace_leading_underscores:
+        key = re.sub(r'^_+', '-', key)
+
     return key
 
 
 def _postfix_generator():
-    yield ''
     for _ in range(13):
         yield '-' + ''.join(
             random.choices(KEY_POSTFIX_CHARS, k=KEY_POSTFIX_LEN))
 
 
+def description_help(resource):
+    return {'description': _(
+        f'Optional description for the {resource}. If defined, the '
+        f'description is visible on the {resource} details page. Use Markdown '
+        'syntax to format the description.'),
+    }
+
+
+def _check_admin_visibility(form):
+    if form.user and form.user.is_staff:
+        return
+
+    if form.data.get("visibility") == Album.Visibility.ADMIN:
+        form.add_error(
+            'visibility',
+            ValidationError(
+                _(
+                    'Can not set admin visibility as non-admin user. Select a '
+                    'different visibility setting.'),
+                code='invalid'))
+        return
+
+
 class CreateAlbumForm(ModelForm):
     key = CharField(min_length=1, widget=HiddenInput)
 
     class Meta:
         model = Album
         fields = ['key', 'title', 'description', 'visibility']
+        help_texts = {
+            **description_help('album'),
+        }
+
+    def __init__(self, *args, user=None, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.user = user
 
     def clean(self):
         super().clean()
@@ -50,8 +88,17 @@ class CreateAlbumForm(ModelForm):
         key = self.cleaned_data.get('key', '')
         title = self.cleaned_data.get('title', '')
 
+        _check_admin_visibility(self)
+
         # If key is set to _new, generate a key from the title.
         if key != '_new':
+            if key.startswith('_'):
+                self.add_error(
+                    'key',
+                    ValidationError(
+                        _('Keys starting with underscore are reserved for '
+                          'system albums.'),
+                        code='invalid'))
             return
 
         if title == '':
@@ -62,7 +109,7 @@ class CreateAlbumForm(ModelForm):
                     code='required'))
             return
 
-        key = slugify(title)
+        key = slugify(title, lower=True, replace_leading_underscores=True)
 
         postfix_iter = _postfix_generator()
         try:
@@ -81,15 +128,47 @@ class CreateAlbumForm(ModelForm):
         self.cleaned_data['key'] = key + postfix
 
 
+def photo_label(photo: Photo):
+    return mark_safe(
+        f'''
+<img
+  alt="{photo.title}"
+  src="/img/{photo.key}/sm"
+  style="
+    background: url(data:image/png;base64,{photo.tiny_base64});
+    background-size: 100% 100%;
+    font-size: 0;"
+  height="{photo.thumbnail_height}"
+  width="{photo.thumbnail_width}"
+/>''')
+
+
 class ModifyAlbumForm(ModelForm):
     class Meta:
         model = Album
         fields = ['title', 'description', 'cover_photo', 'visibility']
+        help_texts = {
+            **description_help('album'),
+            'cover_photo': _(
+                'Select a cover photo for the album. The cover photo is '
+                'visible on the albums list page and in album preview image.'),
+        }
+        widgets = {
+            'cover_photo': RadioSelect(attrs={'class': 'photo-select'}),
+        }
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, user=None, **kwargs):
         super().__init__(*args, **kwargs)
+        self.user = user
+
         self.fields['cover_photo'].queryset = Photo.objects.filter(
             album=self.instance)
+        self.fields['cover_photo'].empty_label = None
+        self.fields['cover_photo'].label_from_instance = photo_label
+
+    def clean(self):
+        super().clean()
+        _check_admin_visibility(self)
 
 
 class CreatePhotoForm(ModelForm):
@@ -103,7 +182,16 @@ class CreatePhotoForm(ModelForm):
             'timestamp',
             'height',
             'width',
-            'tiny_base64']
+            'tiny_base64',
+            'camera_make',
+            'camera_model',
+            'lens_make',
+            'lens_model',
+            'focal_length',
+            'f_number',
+            'exposure_time',
+            'iso_speed',
+        ]
         error_messages = {
             'album': {
                 'invalid_choice': _('Album with %(value)s key does not exist.')
@@ -115,6 +203,13 @@ class ModifyPhotoForm(ModelForm):
     class Meta:
         model = Photo
         fields = ['title', 'description']
+        help_texts = {
+            **description_help('photo'),
+            'title': _(
+                'Title for the photo. If not defined, the filename of the '
+                'photo is used as the title.'
+            ),
+        }
 
 
 class MultipleFileInput(ClearableFileInput):

photo_objects/django/management/commands/create-initial-admin-account.py

@@ -2,6 +2,8 @@ from django.core.management.base import BaseCommand
 from django.contrib.auth import get_user_model
 from secrets import token_urlsafe
 
+from photo_objects.config import write_to_home_directory
+
 
 class Command(BaseCommand):
     help = "Create initial admin user account."
@@ -15,13 +17,13 @@ class Command(BaseCommand):
             password = token_urlsafe(32)
             User.objects.create_superuser(username, password=password)
 
-            msg = (
+            write_to_home_directory("initial_admin_password", password)
+
+            self.stdout.write(
                 self.style.SUCCESS('Initial admin account created:') +
                 f'\n  Username: {username}'
                 f'\n  Password: {password}'
             )
-
-            self.stdout.write(msg)
         else:
             self.stdout.write(
                 self.style.NOTICE(

photo_objects/django/management/commands/create-site-albums.py

@@ -0,0 +1,32 @@
+from django.core.management.base import BaseCommand
+from django.contrib.sites.models import Site
+
+from photo_objects.django.models import Album
+
+
+class Command(BaseCommand):
+    help = "Create albums for configuring site metadata."
+
+    def handle(self, *args, **options):
+        sites = Site.objects.all()
+
+        for site in sites:
+            album_key = f'_site_{site.id}'
+            _, created = Album.objects.get_or_create(
+                key=album_key,
+                defaults={
+                    'visibility': Album.Visibility.ADMIN,
+                })
+
+            if created:
+                self.stdout.write(
+                    self.style.SUCCESS(
+                        f'Album for site {site.domain} created:') +
+                    f'\n  Key: {album_key}')
+            else:
+                self.stdout.write(
+                    self.style.NOTICE(
+                        f'Album creation for site {site.domain} skipped: '
+                        'Album already exists.'
+                    )
+                )

photo_objects/django/migrations/0002_created_at_updated_at.py

@@ -0,0 +1,36 @@
+# Generated by Django 5.0.7 on 2025-03-02 22:31
+
+import django.utils.timezone
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('photo_objects', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='album',
+            name='created_at',
+            field=models.DateTimeField(auto_now_add=True, default=django.utils.timezone.now),
+            preserve_default=False,
+        ),
+        migrations.AddField(
+            model_name='album',
+            name='updated_at',
+            field=models.DateTimeField(auto_now=True),
+        ),
+        migrations.AddField(
+            model_name='photo',
+            name='created_at',
+            field=models.DateTimeField(auto_now_add=True, default=django.utils.timezone.now),
+            preserve_default=False,
+        ),
+        migrations.AddField(
+            model_name='photo',
+            name='updated_at',
+            field=models.DateTimeField(auto_now=True),
+        ),
+    ]

photo_objects/django/migrations/0003_admin_visibility.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.0.7 on 2025-03-09 21:48
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('photo_objects', '0002_created_at_updated_at'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='album',
+            name='visibility',
+            field=models.CharField(blank=True, choices=[('public', 'Public'), ('hidden', 'Hidden'), ('private', 'Private'), ('', 'Admin')], db_default='private', default='private'),
+        ),
+    ]

photo_objects/django/migrations/0004_camera_setup_and_settings.py

@@ -0,0 +1,63 @@
+# Generated by Django 5.0.7 on 2025-04-05 21:45
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('photo_objects', '0003_admin_visibility'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='photo',
+            name='camera_make',
+            field=models.CharField(blank=True),
+        ),
+        migrations.AddField(
+            model_name='photo',
+            name='camera_model',
+            field=models.CharField(blank=True),
+        ),
+        migrations.AddField(
+            model_name='photo',
+            name='exposure_time',
+            field=models.FloatField(blank=True, null=True),
+        ),
+        migrations.AddField(
+            model_name='photo',
+            name='f_number',
+            field=models.FloatField(blank=True, null=True),
+        ),
+        migrations.AddField(
+            model_name='photo',
+            name='focal_length',
+            field=models.FloatField(blank=True, null=True),
+        ),
+        migrations.AddField(
+            model_name='photo',
+            name='iso_speed',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+        migrations.AddField(
+            model_name='photo',
+            name='lens_make',
+            field=models.CharField(blank=True),
+        ),
+        migrations.AddField(
+            model_name='photo',
+            name='lens_model',
+            field=models.CharField(blank=True),
+        ),
+        migrations.AlterField(
+            model_name='album',
+            name='first_timestamp',
+            field=models.DateTimeField(blank=True, null=True),
+        ),
+        migrations.AlterField(
+            model_name='album',
+            name='last_timestamp',
+            field=models.DateTimeField(blank=True, null=True),
+        ),
+    ]

photo_objects/django/models.py

@@ -23,7 +23,26 @@ def _timestamp_str(timestamp):
     return timestamp.isoformat() if timestamp else None
 
 
-class Album(models.Model):
+class BaseModel(models.Model):
+    title = models.CharField(blank=True)
+    description = models.TextField(blank=True)
+
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    class Meta:
+        abstract = True
+
+    def to_json(self):
+        return dict(
+            title=self.title,
+            description=self.description,
+            created_at=_timestamp_str(self.created_at),
+            updated_at=_timestamp_str(self.updated_at),
+        )
+
+
+class Album(BaseModel):
     class Meta:
         ordering = ["-first_timestamp", "-last_timestamp", "key"]
 
@@ -31,6 +50,7 @@ class Album(models.Model):
         PUBLIC = "public", _("Public")
         HIDDEN = "hidden", _("Hidden")
         PRIVATE = "private", _("Private")
+        ADMIN = "", _("Admin")
 
     key = models.CharField(primary_key=True, validators=[album_key_validator])
     visibility = models.CharField(
@@ -39,27 +59,23 @@ class Album(models.Model):
         default=Visibility.PRIVATE,
         choices=Visibility)
 
-    title = models.CharField(blank=True)
-    description = models.TextField(blank=True)
-
     cover_photo = models.ForeignKey(
         "Photo",
         blank=True,
         null=True,
         on_delete=models.SET_NULL,
         related_name="+")
-    first_timestamp = models.DateTimeField(null=True)
-    last_timestamp = models.DateTimeField(null=True)
+    first_timestamp = models.DateTimeField(blank=True, null=True)
+    last_timestamp = models.DateTimeField(blank=True, null=True)
 
     def __str__(self):
         return _str(self.key, title=self.title, visibility=self.visibility)
 
     def to_json(self):
         return dict(
+            **super().to_json(),
             key=self.key,
             visibility=self.visibility,
-            title=self.title,
-            description=self.description,
             cover_photo=(
                 self.cover_photo.filename if self.cover_photo else None),
             first_timestamp=_timestamp_str(self.first_timestamp),
@@ -67,7 +83,7 @@ class Album(models.Model):
         )
 
 
-class Photo(models.Model):
+class Photo(BaseModel):
     class Meta:
         ordering = ["timestamp"]
 
@@ -75,13 +91,21 @@ class Photo(models.Model):
     album = models.ForeignKey("Album", null=True, on_delete=models.PROTECT)
 
     timestamp = models.DateTimeField()
-    title = models.CharField(blank=True)
-    description = models.TextField(blank=True)
 
     height = models.PositiveIntegerField()
     width = models.PositiveIntegerField()
     tiny_base64 = models.TextField(blank=True)
 
+    camera_make = models.CharField(blank=True)
+    camera_model = models.CharField(blank=True)
+    lens_make = models.CharField(blank=True)
+    lens_model = models.CharField(blank=True)
+
+    focal_length = models.FloatField(blank=True, null=True)
+    f_number = models.FloatField(blank=True, null=True)
+    exposure_time = models.FloatField(blank=True, null=True)
+    iso_speed = models.IntegerField(blank=True, null=True)
+
     def __str__(self):
         return _str(
             self.key,
@@ -105,6 +129,7 @@ class Photo(models.Model):
         album_key = self.album.key if self.album else None
 
         return dict(
+            **super().to_json(),
             key=self.key,
             filename=self.filename,
             album=album_key,
@@ -112,6 +137,12 @@ class Photo(models.Model):
             height=self.height,
             width=self.width,
             tiny_base64=self.tiny_base64,
-            title=self.title,
-            description=self.description,
+            camera_make=self.camera_make,
+            camera_model=self.camera_model,
+            lens_make=self.lens_make,
+            lens_model=self.lens_model,
+            focal_length=self.focal_length,
+            f_number=self.f_number,
+            exposure_time=self.exposure_time,
+            iso_speed=self.iso_speed,
         )

photo_objects/django/objsto.py

@@ -1,5 +1,6 @@
 import json
 import mimetypes
+import urllib3
 
 from django.conf import settings
 
@@ -27,10 +28,16 @@ def _anonymous_readonly_policy(bucket: str):
 def _objsto_access() -> tuple[Minio, str]:
     conf = settings.PHOTO_OBJECTS_OBJSTO
 
+    http = urllib3.PoolManager(
+        retries=urllib3.util.Retry(connect=1),
+        timeout=urllib3.util.Timeout(connect=2.5, read=20),
+    )
+
     client = Minio(
         conf.get('URL'),
         conf.get('ACCESS_KEY'),
         conf.get('SECRET_KEY'),
+        http_client=http,
         secure=conf.get('SECURE', True),
     )
     bucket = conf.get('BUCKET', 'photos')
@@ -80,3 +87,17 @@ def delete_photo(album_key, photo_key):
                 ""),
             recursive=True):
         client.remove_object(bucket, i.object_name)
+
+
+def get_error_code(e: Exception) -> str:
+    try:
+        return e.code
+    except AttributeError:
+        return None
+
+
+def with_error_code(msg: str, e: Exception) -> str:
+    code = get_error_code(e)
+    if code:
+        return f'{msg} ({code})'
+    return msg