photo-objects 0.3.1__py3-none-any.whl → 0.4.1__py3-none-any.whl

photo_objects/config.py

@@ -29,3 +29,9 @@ def get_secret_key() -> str:
     write_to_home_directory("secret_key", key)
 
     return key
+
+
+def add_port_to_host(url: str, port: str | None) -> str:
+    if port:
+        return f"{url}:{port}"
+    return url

photo_objects/django/__init__.py

@@ -1,10 +0,0 @@
-from enum import Enum
-
-
-class Size(Enum):
-    TINY = "xs"
-    SMALL = "sm"
-    MEDIUM = "md"
-    LARGE = "lg"
-    HUGE = "xl"
-    ORIGINAL = "og"

photo_objects/django/api/album.py

@@ -16,7 +16,7 @@ from .utils import (
 )
 
 
-def get_site_album(site: Site) -> Album:
+def get_site_album(site: Site) -> tuple[Album, bool]:
     album_key = f'_site_{site.id}'
     return Album.objects.get_or_create(
         key=album_key,
@@ -89,4 +89,4 @@ def delete_album(request: HttpRequest, album_key: str):
             f"Album with {album_key} key can not be deleted because it "
             "contains photos.",
             409,
-        )
+        ) from None

photo_objects/django/api/auth.py

@@ -1,6 +1,6 @@
 from django.http import HttpRequest
 
-from photo_objects.django import Size
+from photo_objects.django.conf import PhotoSize
 from photo_objects.django.models import Album, Photo
 
 from photo_objects.django.api.utils import (
@@ -16,7 +16,7 @@ def check_album_access(request: HttpRequest, album_key: str):
     try:
         album = Album.objects.get(key=album_key)
     except Album.DoesNotExist:
-        raise AlbumNotFound(album_key)
+        raise AlbumNotFound(album_key) from None
 
     if not request.user.is_authenticated:
         if album.visibility == Album.Visibility.PRIVATE:
@@ -35,19 +35,19 @@ def check_photo_access(
         photo_key: str,
         size_key: str):
     try:
-        size = Size(size_key)
+        size = PhotoSize(size_key)
     except ValueError:
-        raise InvalidSize(size_key)
+        raise InvalidSize(size_key) from None
 
     try:
         photo = Photo.objects.get(key=join_key(album_key, photo_key))
     except Photo.DoesNotExist:
-        raise PhotoNotFound(album_key, photo_key)
+        raise PhotoNotFound(album_key, photo_key) from None
 
     if not request.user.is_authenticated:
         if photo.album.visibility == Album.Visibility.PRIVATE:
             raise AlbumNotFound(album_key)
-        if size == Size.ORIGINAL:
+        if size == PhotoSize.ORIGINAL:
             raise Unauthorized()
 
     return photo

photo_objects/django/api/photo.py

@@ -36,7 +36,7 @@ def _upload_photo(album_key: str, photo_file: UploadedFile):
         raise JsonProblem(
             "Could not open photo file.",
             400,
-        )
+        ) from None
 
     f = CreatePhotoForm(dict(
         key=f"{album_key}/{slugify(photo_file.name)}",
@@ -59,7 +59,7 @@ def _upload_photo(album_key: str, photo_file: UploadedFile):
         msg = objsto.with_error_code(
             "Could not save photo to object storage", e)
         logger.error(f"{msg}: {str(e)}")
-        raise JsonProblem(f"{msg}.", 500)
+        raise JsonProblem(f"{msg}.", 500) from e
 
     return photo
 
@@ -125,11 +125,11 @@ def delete_photo(request: HttpRequest, album_key: str, photo_key: str):
         msg = objsto.with_error_code(
             "Could not delete photo from object storage", e)
         logger.error(f"{msg}: {str(e)}")
-        raise JsonProblem("{msg}.", 500)
+        raise JsonProblem(f"{msg}.", 500) from e
 
     try:
         photo.delete()
     except Exception as e:
         msg = "Could not delete photo from database"
         logger.error(f"{msg}: {str(e)}")
-        raise JsonProblem(f"{msg}.", 500)
+        raise JsonProblem(f"{msg}.", 500) from e

photo_objects/django/api/utils.py

@@ -7,8 +7,9 @@ from django.shortcuts import render
 from django.urls import reverse_lazy
 
 from photo_objects.error import PhotoObjectsError
+from photo_objects.utils import pretty_list
 from photo_objects.django.views.utils import BackLink
-from photo_objects.django import Size
+from photo_objects.django.conf import PhotoSize
 
 
 APPLICATION_JSON = "application/json"
@@ -17,11 +18,6 @@ MULTIPART_FORMDATA = "multipart/form-data"
 APPLICATION_PROBLEM = "application/problem+json"
 
 
-def _pretty_list(in_: list, conjunction: str):
-    return f' {conjunction} '.join(
-        i for i in (', '.join(in_[:-1]), in_[-1],) if i)
-
-
 class JsonProblem(PhotoObjectsError):
     def __init__(self, title, status, payload=None, headers=None, errors=None):
         super().__init__(title)
@@ -54,7 +50,7 @@ class JsonProblem(PhotoObjectsError):
         return render(request, "photo_objects/problem.html", {
             "title": "Error",
             "back": BackLink(
-                f'Back to albums',
+                'Back to albums',
                 reverse_lazy('photo_objects:list_albums')),
             "problem_title": self.title,
             "status": self.status
@@ -63,7 +59,7 @@ class JsonProblem(PhotoObjectsError):
 
 class MethodNotAllowed(JsonProblem):
     def __init__(self, expected: list[str], actual: str):
-        expected_human = _pretty_list(expected, "or")
+        expected_human = pretty_list(expected, "or")
 
         super().__init__(
             f"Expected {expected_human} method, got {actual}.",
@@ -74,7 +70,7 @@ class MethodNotAllowed(JsonProblem):
 
 class UnsupportedMediaType(JsonProblem):
     def __init__(self, expected: list[str], actual: str):
-        expected_human = _pretty_list(expected, "or")
+        expected_human = pretty_list(expected, "or")
 
         super().__init__(
             f"Expected {expected_human} content-type, got {actual}.",
@@ -93,7 +89,7 @@ class Unauthorized(JsonProblem):
 
 class InvalidSize(JsonProblem):
     def __init__(self, actual: str):
-        expected = _pretty_list([i.value for i in Size], "or")
+        expected = pretty_list([i.value for i in PhotoSize], "or")
 
         super().__init__(
             f"Expected {expected} size, got {actual or 'none'}.",
@@ -138,7 +134,7 @@ def check_permissions(request: HttpRequest, *permissions: str):
         raise Unauthorized()
     if not request.user.has_perms(permissions):
         raise JsonProblem(
-            f"Expected {_pretty_list(permissions, 'and')} permissions",
+            f"Expected {pretty_list(permissions, 'and')} permissions",
             403,
             headers=dict(Allow="GET, POST")
         )
@@ -157,7 +153,7 @@ def parse_json_body(request: HttpRequest):
         raise JsonProblem(
             "Could not parse JSON data from request body.",
             400,
-        )
+        ) from None
 
 
 def parse_input_data(request: HttpRequest):

photo_objects/django/apps.py

@@ -2,6 +2,8 @@ from django.apps import AppConfig
 from django.core.checks import Error, register
 from django.conf import settings
 
+from photo_objects.django.conf import validate_photo_sizes
+
 
 class PhotoObjects(AppConfig):
     default_auto_field = 'django.db.models.BigAutoField'
@@ -17,7 +19,7 @@ def photo_objects_check(app_configs, **kwargs):
     errors = []
 
     try:
-        conf = settings.PHOTO_OBJECTS_OBJSTO
+        objsto_conf = settings.PHOTO_OBJECTS_OBJSTO
     except AttributeError:
         errors.append(
             Error(
@@ -29,7 +31,7 @@ def photo_objects_check(app_configs, **kwargs):
         return errors
 
     for key in ('URL', 'ACCESS_KEY', 'SECRET_KEY',):
-        if not conf.get(key):
+        if not objsto_conf.get(key):
             errors.append(
                 Error(
                     f'The PHOTO_OBJECTS_OBJSTO setting must define {key} '
@@ -38,4 +40,14 @@ def photo_objects_check(app_configs, **kwargs):
                     obj='photo_objects',
                 ))
 
+    try:
+        sizes_conf = settings.PHOTO_OBJECTS_PHOTO_SIZES
+        errors.extend(
+            validate_photo_sizes(
+                sizes_conf,
+                'The PHOTO_OBJECTS_PHOTO_SIZES'))
+    except AttributeError:
+        # Use default values if sizes are not configured
+        pass
+
     return errors

photo_objects/django/conf.py

@@ -0,0 +1,105 @@
+from dataclasses import dataclass
+from enum import Enum
+
+from django.conf import settings
+
+from photo_objects.utils import pretty_list
+
+
+def objsto_settings() -> dict:
+    return settings.PHOTO_OBJECTS_OBJSTO
+
+
+class PhotoSize(Enum):
+    TINY = "xs"
+    SMALL = "sm"
+    MEDIUM = "md"
+    LARGE = "lg"
+    ORIGINAL = "og"
+
+
+CONFIGURABLE_PHOTO_SIZES = [
+    PhotoSize.SMALL.value,
+    PhotoSize.MEDIUM.value,
+    PhotoSize.LARGE.value
+]
+
+
+@dataclass()
+class PhotoSizeDimensions:
+    max_width: int = None
+    max_height: int = None
+    max_aspect_ratio: float = None
+
+
+DEFAULT_SM = dict(
+    max_width=512,
+    max_height=512,
+    max_aspect_ratio=1.5
+)
+DEFAULT_MD = dict(
+    max_width=2048,
+    max_height=2048
+)
+DEFAULT_LG = dict(
+    max_width=4096,
+    max_height=4096
+)
+
+
+@dataclass
+class PhotoSizes:
+    sm: PhotoSizeDimensions = None
+    md: PhotoSizeDimensions = None
+    lg: PhotoSizeDimensions = None
+
+
+def validate_photo_sizes(data: dict, prefix=None) -> list[str]:
+    prefix = prefix or "Photo size"
+    errors = []
+
+    for key, value in data.items():
+        if key not in CONFIGURABLE_PHOTO_SIZES:
+            expected = pretty_list(CONFIGURABLE_PHOTO_SIZES, 'or')
+            errors.append(
+                f"{prefix} key '{key}' is invalid, expected one of {expected}")
+
+        if not isinstance(value, dict):
+            errors.append(f"{prefix} '{key}' must be a dict.")
+
+        if 'max_width' not in value and 'max_height' not in value:
+            errors.append(
+                f"{prefix} '{key}' must define at least one dimension.")
+
+        if (
+            'max_aspect_ratio' in value and
+            value['max_aspect_ratio'] is not None and
+            not isinstance(value['max_aspect_ratio'], (float, int))
+        ):
+            errors.append(
+                f"{prefix} '{key}' max_aspect_ratio must be a number.")
+
+    return errors
+
+
+def parse_photo_sizes(data: dict) -> PhotoSizes:
+    errors = validate_photo_sizes(data)
+
+    if errors:
+        raise ValueError(
+            f"Invalid photo sizes configuration: {' '.join(errors)}")
+
+    return PhotoSizes(
+        sm=PhotoSizeDimensions(**data.get('sm', DEFAULT_SM)),
+        md=PhotoSizeDimensions(**data.get('md', DEFAULT_MD)),
+        lg=PhotoSizeDimensions(**data.get('lg', DEFAULT_LG)),
+    )
+
+
+def photo_sizes() -> PhotoSizes:
+    try:
+        data = settings.PHOTO_OBJECTS_PHOTO_SIZES
+    except AttributeError:
+        data = {}
+
+    return parse_photo_sizes(data)

photo_objects/django/forms.py

@@ -23,9 +23,9 @@ KEY_POSTFIX_CHARS = 'bcdfghjklmnpqrstvwxz2456789'
 KEY_POSTFIX_LEN = 5
 
 
-def slugify(input: str, lower=False, replace_leading_underscores=False) -> str:
+def slugify(title: str, lower=False, replace_leading_underscores=False) -> str:
     key = unicodedata.normalize(
-        'NFKD', input).encode(
+        'NFKD', title).encode(
         'ascii', 'ignore').decode('ascii')
     if lower:
         key = key.lower()

photo_objects/django/management/commands/clean-scaled-photos.py

@@ -0,0 +1,64 @@
+# pylint: disable=invalid-name
+from django.core.management.base import BaseCommand
+
+from photo_objects.utils import pretty_list
+from photo_objects.django.conf import photo_sizes, CONFIGURABLE_PHOTO_SIZES
+from photo_objects.django.objsto import (
+    delete_scaled_photos,
+    get_photo_sizes,
+    put_photo_sizes,
+)
+
+
+class Command(BaseCommand):
+    help = "Remove scaled photos when scaling settings have changed."
+
+    def handle(self, *args, **options):
+        current = photo_sizes()
+        previous = get_photo_sizes()
+
+        if current == previous:
+            self.stdout.write(
+                self.style.SUCCESS(
+                    "No changes in photo sizes configuration."
+                )
+            )
+            return
+
+        if previous is None:
+            self.stdout.write(
+                self.style.WARNING(
+                    "No previous photo sizes configuration found. "
+                    "Removing all scaled photos:"
+                )
+            )
+            to_delete = CONFIGURABLE_PHOTO_SIZES
+        else:
+            to_delete = []
+            for size in CONFIGURABLE_PHOTO_SIZES:
+                if getattr(previous, size) != getattr(current, size):
+                    to_delete.append(size)
+
+            changed = pretty_list(to_delete, 'and')
+            self.stdout.write(
+                self.style.NOTICE(
+                    "Found changes in photo sizes configuration for "
+                    f"{changed} sizes. Deleting scaled photos:"
+                )
+            )
+
+        try:
+            total = 0
+            for key in delete_scaled_photos(to_delete):
+                self.stdout.write(f"  {key}")
+                total += 1
+            self.stdout.write(f"Total deleted photos: {total}")
+        except Exception as e:
+            self.stdout.write(
+                self.style.ERROR(
+                    f"Error occurred while deleting scaled photos: {e}"
+                )
+            )
+            exit(1)
+
+        put_photo_sizes(current)

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

@@ -1,6 +1,8 @@
+# pylint: disable=invalid-name
+from secrets import token_urlsafe
+
 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
 
@@ -9,13 +11,13 @@ class Command(BaseCommand):
     help = "Create initial admin user account."
 
     def handle(self, *args, **options):
-        User = get_user_model()
-        superuser_count = User.objects.filter(is_superuser=True).count()
+        user = get_user_model()
+        superuser_count = user.objects.filter(is_superuser=True).count()
 
         if superuser_count == 0:
             username = 'admin'
             password = token_urlsafe(32)
-            User.objects.create_superuser(username, password=password)
+            user.objects.create_superuser(username, password=password)
 
             write_to_home_directory("initial_admin_password", password)
 

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

@@ -1,8 +1,8 @@
+# pylint: disable=invalid-name
 from django.core.management.base import BaseCommand
 from django.contrib.sites.models import Site
 
 from photo_objects.django.api.album import get_site_album
-from photo_objects.django.models import Album
 
 
 class Command(BaseCommand):

photo_objects/django/objsto.py

@@ -1,10 +1,17 @@
+from dataclasses import asdict
+from io import BytesIO
 import json
 import mimetypes
 import urllib3
 
-from django.conf import settings
+from minio import Minio, S3Error
 
-from minio import Minio
+from photo_objects.django.conf import (
+    PhotoSize,
+    PhotoSizes,
+    objsto_settings,
+    parse_photo_sizes,
+)
 
 
 MEGABYTE = 1 << 20
@@ -26,8 +33,7 @@ def _anonymous_readonly_policy(bucket: str):
 
 
 def _objsto_access() -> tuple[Minio, str]:
-    conf = settings.PHOTO_OBJECTS_OBJSTO
-
+    conf = objsto_settings()
     http = urllib3.PoolManager(
         retries=urllib3.util.Retry(connect=1),
         timeout=urllib3.util.Timeout(connect=2.5, read=20),
@@ -51,7 +57,7 @@ def _objsto_access() -> tuple[Minio, str]:
 
 
 def photo_path(album_key, photo_key, size_key):
-    return f"{album_key}/{photo_key}/{size_key}"
+    return f"{size_key}/{album_key}/{photo_key}"
 
 
 def put_photo(album_key, photo_key, size_key, photo_file):
@@ -79,14 +85,31 @@ def get_photo(album_key, photo_key, size_key):
 def delete_photo(album_key, photo_key):
     client, bucket = _objsto_access()
 
-    for i in client.list_objects(
-            bucket,
-            prefix=photo_path(
-                album_key,
-                photo_key,
-                ""),
-            recursive=True):
-        client.remove_object(bucket, i.object_name)
+    for i in PhotoSize:
+        client.remove_object(bucket, photo_path(album_key, photo_key, i.value))
+
+
+def delete_scaled_photos(sizes):
+    client, bucket = _objsto_access()
+
+    for size in sizes:
+        while True:
+            objects = client.list_objects(
+                bucket,
+                prefix=f"{size}/",
+                recursive=True)
+
+            if not objects:
+                break
+
+            empty = True
+            for i in objects:
+                empty = False
+                client.remove_object(bucket, i.object_name)
+                yield i.object_name
+
+            if empty:
+                break
 
 
 def get_error_code(e: Exception) -> str:
@@ -101,3 +124,29 @@ def with_error_code(msg: str, e: Exception) -> str:
     if code:
         return f'{msg} ({code})'
     return msg
+
+
+def put_photo_sizes(sizes: PhotoSizes):
+    data = json.dumps(asdict(sizes))
+    stream = BytesIO(data.encode('utf-8'))
+
+    client, bucket = _objsto_access()
+    client.put_object(
+        bucket,
+        "photo_sizes.json",
+        stream,
+        length=-1,
+        part_size=10 * MEGABYTE,
+        content_type="application/json",
+    )
+
+
+def get_photo_sizes() -> PhotoSizes:
+    client, bucket = _objsto_access()
+    try:
+        data = client.get_object(bucket, "photo_sizes.json")
+        return parse_photo_sizes(json.loads(data.read()))
+    except S3Error as e:
+        if e.code == "NoSuchKey":
+            return None
+        raise

photo_objects/django/signals.py

@@ -1,5 +1,3 @@
-import re
-
 from django.contrib.sites.models import Site
 from django.db.models.signals import post_save, post_delete
 from django.dispatch import receiver

photo_objects/django/templatetags/photo_objects_extras.py

@@ -2,6 +2,7 @@ from datetime import datetime
 from django import template
 
 from photo_objects.django.api.album import get_site_album
+from photo_objects.django.views.utils import meta_description
 
 
 register = template.Library()
@@ -47,12 +48,12 @@ def meta_og(context):
     try:
         request = context.get("request")
         site = request.site
-        album = get_site_album(site.id)
+        album, _ = get_site_album(site)
 
         return {
             'request': request,
             "title": album.title or site.name,
-            "description": album.description,
+            "description": meta_description(request, album.description),
             "photo": album.cover_photo,
         }
     except Exception:

photo_objects/django/tests/test_album.py

@@ -22,9 +22,9 @@ PHOTOS_DIRECTORY = "photos"
 class ViewVisibilityTests(TestCase):
     @classmethod
     def setUpTestData(cls):
-        User = get_user_model()
-        User.objects.create_user(username='test-visibility', password='test')
-        User.objects.create_user(
+        user = get_user_model()
+        user.objects.create_user(username='test-visibility', password='test')
+        user.objects.create_user(
             username='test-staff-visibility',
             password='test',
             is_staff=True)
@@ -91,16 +91,16 @@ class ViewVisibilityTests(TestCase):
 
 class AlbumViewTests(TestCase):
     def setUp(self):
-        User = get_user_model()
-        User.objects.create_user(username='no_permission', password='test')
+        user = get_user_model()
+        user.objects.create_user(username='no_permission', password='test')
 
-        has_permission = User.objects.create_user(
+        user.objects.create_user(
             username='superuser',
             password='test',
             is_staff=True,
             is_superuser=True)
 
-        has_permission = User.objects.create_user(
+        has_permission = user.objects.create_user(
             username='has_permission', password='test')
         permissions = [
             'add_album',

photo_objects/django/tests/test_auth.py

@@ -6,14 +6,14 @@ from .utils import TestCase, create_dummy_photo
 
 
 def _path_fn(album, photo):
-    return lambda size: f"{album}/{photo}/{size}"
+    return lambda size: f"{size}/{album}/{photo}"
 
 
 class AuthViewTests(TestCase):
     @classmethod
     def setUpTestData(cls):
-        User = get_user_model()
-        User.objects.create_user(username='test-auth', password='test')
+        user = get_user_model()
+        user.objects.create_user(username='test-auth', password='test')
 
         public_album = Album.objects.create(
             key="test-auth-public", visibility=Album.Visibility.PUBLIC)