photo-objects 0.0.1__tar.gz

photo_objects-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Toni Kangas
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

photo_objects-0.0.1/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.1
+Name: photo-objects
+Version: 0.0.1
+Summary: Application for storing photos in S3 compatible object-storage.
+Author: Toni Kangas
+License: MIT License
+        
+        Copyright (c) 2024 Toni Kangas
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/kangasta/photo-objects
+Project-URL: Repository, https://github.com/kangasta/photo-objects.git
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.0
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: minio~=7.2
+Requires-Dist: pillow~=10.4
+
+# Photo Objects
+
+[![CI](https://github.com/kangasta/photo-objects/actions/workflows/ci.yml/badge.svg)](https://github.com/kangasta/photo-objects/actions/workflows/ci.yml)
+
+Application for storing photos in S3 compatible object-storage.
+
+## Testing
+
+Check and automatically fix formatting with:
+
+```bash
+pycodestyle --exclude back/api/settings.py,*/migrations/*.py back photo_objects
+autopep8 -aaar --in-place --exclude back/api/settings.py,*/migrations/*.py back photo_objects
+```
+
+Run static analysis with:
+
+```bash
+pylint -E --enable=invalid-name,unused-import,useless-object-inheritance back/api photo_objects
+```
+
+Run integration tests (in the `api` directory) with:
+
+```bash
+python3 runtests.py
+```
+
+Get test coverage with:
+
+```bash
+coverage run  --branch --source photo_objects runtests.py
+coverage report -m
+```

photo_objects-0.0.1/README.md

@@ -0,0 +1,33 @@
+# Photo Objects
+
+[![CI](https://github.com/kangasta/photo-objects/actions/workflows/ci.yml/badge.svg)](https://github.com/kangasta/photo-objects/actions/workflows/ci.yml)
+
+Application for storing photos in S3 compatible object-storage.
+
+## Testing
+
+Check and automatically fix formatting with:
+
+```bash
+pycodestyle --exclude back/api/settings.py,*/migrations/*.py back photo_objects
+autopep8 -aaar --in-place --exclude back/api/settings.py,*/migrations/*.py back photo_objects
+```
+
+Run static analysis with:
+
+```bash
+pylint -E --enable=invalid-name,unused-import,useless-object-inheritance back/api photo_objects
+```
+
+Run integration tests (in the `api` directory) with:
+
+```bash
+python3 runtests.py
+```
+
+Get test coverage with:
+
+```bash
+coverage run  --branch --source photo_objects runtests.py
+coverage report -m
+```

photo_objects-0.0.1/photo_objects/django/__init__.py

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

photo_objects-0.0.1/photo_objects/django/admin.py

@@ -0,0 +1,6 @@
+from django.contrib import admin
+
+from .models import Album, Photo
+
+admin.site.register(Album)
+admin.site.register(Photo)

photo_objects-0.0.1/photo_objects/django/api/__init__.py

@@ -0,0 +1,3 @@
+from .album import *
+from .auth import *
+from .photo import *

photo_objects-0.0.1/photo_objects/django/api/album.py

@@ -0,0 +1,57 @@
+from django.db.models.deletion import ProtectedError
+from django.http import HttpRequest
+
+from photo_objects.django.forms import CreateAlbumForm, ModifyAlbumForm
+from photo_objects.django.models import Album
+
+from .auth import check_album_access
+from .utils import (
+    FormValidationFailed,
+    JsonProblem,
+    check_permissions,
+    parse_input_data,
+)
+
+
+def get_albums(request: HttpRequest):
+    if not request.user.is_authenticated:
+        return Album.objects.filter(visibility=Album.Visibility.PUBLIC)
+    else:
+        return Album.objects.all()
+
+
+def create_album(request: HttpRequest):
+    check_permissions(request, 'photo_objects.add_album')
+    data = parse_input_data(request)
+
+    f = CreateAlbumForm(data)
+    if not f.is_valid():
+        raise FormValidationFailed(f)
+
+    return f.save()
+
+
+def modify_album(request: HttpRequest, album_key: str):
+    check_permissions(request, 'photo_objects.change_album')
+    album = check_album_access(request, album_key)
+    data = parse_input_data(request)
+
+    f = ModifyAlbumForm({**album.to_json(), **data}, instance=album)
+    if not f.is_valid():
+        raise FormValidationFailed(f)
+
+    return f.save()
+
+
+def delete_album(request: HttpRequest, album_key: str):
+    check_permissions(request, 'photo_objects.delete_album')
+    album = check_album_access(request, album_key)
+
+    try:
+        album.delete()
+    except ProtectedError:
+        raise JsonProblem(
+            f"Album with {album_key} key can not be deleted because it "
+            "contains photos.",
+            409,
+        )

photo_objects-0.0.1/photo_objects/django/api/auth.py

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

photo_objects-0.0.1/photo_objects/django/api/photo.py

@@ -0,0 +1,136 @@
+from django.core.files.uploadedfile import UploadedFile
+from django.http import HttpRequest
+from minio.error import S3Error
+from PIL import UnidentifiedImageError
+
+from photo_objects.django import objsto
+from photo_objects.django.forms import (
+    CreatePhotoForm,
+    ModifyPhotoForm,
+    UploadPhotosForm,
+    slugify,
+)
+from photo_objects.img import photo_details
+
+from .auth import check_album_access, check_photo_access
+from .utils import (
+    FormValidationFailed,
+    JsonProblem,
+    check_permissions,
+    parse_input_data,
+    parse_single_file,
+)
+
+
+def get_photos(request: HttpRequest, album_key: str):
+    album = check_album_access(request, album_key)
+    return album.photo_set.all()
+
+
+def _upload_photo(album_key: str, photo_file: UploadedFile):
+    try:
+        details = photo_details(photo_file)
+    except UnidentifiedImageError:
+        raise JsonProblem(
+            "Could not open photo file.",
+            400,
+        )
+
+    f = CreatePhotoForm(dict(
+        key=f"{album_key}/{slugify(photo_file.name)}",
+        album=album_key,
+        title="",
+        description="",
+        **details,
+    ))
+
+    if not f.is_valid():
+        raise FormValidationFailed(f)
+    photo = f.save()
+
+    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.
+        photo.delete()
+        # TODO: logging
+        raise JsonProblem(
+            "Could not save photo to object storage.",
+            500,
+        )
+
+    return photo
+
+
+def upload_photo(request: HttpRequest, album_key: str):
+    check_permissions(
+        request,
+        'photo_objects.add_photo',
+        'photo_objects.change_album')
+    photo_file = parse_single_file(request)
+    return _upload_photo(album_key, photo_file)
+
+
+def upload_photos(request: HttpRequest, album_key: str):
+    check_permissions(
+        request,
+        'photo_objects.add_photo',
+        'photo_objects.change_album')
+
+    f = UploadPhotosForm(request.POST, request.FILES)
+    if not f.is_valid():
+        raise FormValidationFailed(f)
+
+    photo_files = f.cleaned_data["photos"]
+    if len(photo_files) < 1:
+        f.add_error("photos", "Expected at least one file, got 0.")
+        raise FormValidationFailed(f)
+
+    photos = []
+    for photo_file in f.cleaned_data["photos"]:
+        try:
+            photos.append(_upload_photo(album_key, photo_file))
+        except JsonProblem:
+            # TODO: include error type in the message
+            f.add_error("photos", f"Failed to upload {photo_file.name}.")
+
+    if not f.is_valid():
+        raise FormValidationFailed(f)
+
+    return photos
+
+
+def modify_photo(request: HttpRequest, album_key: str, photo_key: str):
+    check_permissions(request, 'photo_objects.change_photo')
+    photo = check_photo_access(request, album_key, photo_key, 'xs')
+    data = parse_input_data(request)
+
+    f = ModifyPhotoForm({**photo.to_json(), **data}, instance=photo)
+
+    if not f.is_valid():
+        raise FormValidationFailed(f)
+
+    return f.save()
+
+
+def delete_photo(request: HttpRequest, album_key: str, photo_key: str):
+    check_permissions(request, 'photo_objects.delete_photo')
+    photo = check_photo_access(request, album_key, photo_key, 'xs')
+
+    try:
+        objsto.delete_photo(album_key, photo_key)
+    except S3Error:
+        raise JsonProblem(
+            "Could not delete photo from object storage.",
+            500,
+        )
+
+    try:
+        photo.delete()
+    except Exception:
+        raise JsonProblem(
+            "Could not delete photo from database.",
+            500,
+        )

photo_objects-0.0.1/photo_objects/django/api/utils.py

@@ -0,0 +1,191 @@
+import json
+
+from django.forms import ModelForm
+from django.http import HttpRequest, JsonResponse
+from django.core.files.uploadedfile import UploadedFile
+from django.shortcuts import render
+from django.urls import reverse_lazy
+
+from photo_objects.error import PhotoObjectsError
+from photo_objects.django.views.utils import BackLink
+from photo_objects.django import Size
+
+
+APPLICATION_JSON = "application/json"
+APPLICATION_X_WWW_FORM = "application/x-www-form-urlencoded"
+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)
+
+        self.title = title
+        self.status = status
+        self.payload = payload or {}
+        self.headers = headers
+        self.errors = errors
+
+    @property
+    def json_response(self):
+        payload = {
+            'title': self.title,
+            'status': self.status,
+            **self.payload
+        }
+
+        if self.errors:
+            payload['errors'] = self.errors
+
+        return JsonResponse(
+            payload,
+            content_type=APPLICATION_PROBLEM,
+            status=self.status,
+            headers=self.headers
+        )
+
+    def html_response(self, request: HttpRequest):
+        return render(request, "photo_objects/problem.html", {
+            "title": "Error",
+            "back": BackLink(
+                f'Back to albums',
+                reverse_lazy('photo_objects:list_albums')),
+            "problem_title": self.title,
+            "status": self.status
+        }, status=self.status)
+
+
+class MethodNotAllowed(JsonProblem):
+    def __init__(self, expected: list[str], actual: str):
+        expected_human = _pretty_list(expected, "or")
+
+        super().__init__(
+            f"Expected {expected_human} method, got {actual}.",
+            405,
+            headers=dict(Allow=', '.join(expected))
+        )
+
+
+class UnsupportedMediaType(JsonProblem):
+    def __init__(self, expected: list[str], actual: str):
+        expected_human = _pretty_list(expected, "or")
+
+        super().__init__(
+            f"Expected {expected_human} content-type, got {actual}.",
+            415,
+            headers={'Accept-Post': ', '.join(expected)}
+        )
+
+
+class Unauthorized(JsonProblem):
+    def __init__(self):
+        super().__init__(
+            "Not authenticated.",
+            401,
+        )
+
+
+class InvalidSize(JsonProblem):
+    def __init__(self, actual: str):
+        expected = _pretty_list([i.value for i in Size], "or")
+
+        super().__init__(
+            f"Expected {expected} size, got {actual or 'none'}.",
+            400,
+        )
+
+
+class AlbumNotFound(JsonProblem):
+    def __init__(self, album_key: str):
+        super().__init__(
+            f"Album with {album_key} key does not exist.",
+            404,
+        )
+
+
+class PhotoNotFound(JsonProblem):
+    def __init__(self, album_key: str, photo_key: str):
+        super().__init__(
+            f"Photo with {photo_key} key does not exist in {album_key} album.",
+            404,
+        )
+
+
+class FormValidationFailed(JsonProblem):
+    def __init__(self, form: ModelForm):
+        try:
+            resource = form.instance.__class__.__name__
+        except AttributeError:
+            resource = "Form"
+
+        super().__init__(
+            f"{resource} validation failed.",
+            400,
+            errors=form.errors.get_json_data(),
+        )
+
+        self.form = form
+
+
+def check_permissions(request: HttpRequest, *permissions: str):
+    if not request.user.is_authenticated:
+        raise Unauthorized()
+    if not request.user.has_perms(permissions):
+        raise JsonProblem(
+            f"Expected {_pretty_list(permissions, 'and')} permissions",
+            403,
+            headers=dict(Allow="GET, POST")
+        )
+
+
+def parse_json_body(request: HttpRequest):
+    if request.content_type != APPLICATION_JSON:
+        raise UnsupportedMediaType(
+            [APPLICATION_JSON],
+            request.content_type
+        )
+
+    try:
+        return json.loads(request.body)
+    except BaseException:
+        raise JsonProblem(
+            "Could not parse JSON data from request body.",
+            400,
+        )
+
+
+def parse_input_data(request: HttpRequest):
+    if request.content_type == APPLICATION_JSON:
+        return parse_json_body(request)
+    elif request.content_type == APPLICATION_X_WWW_FORM:
+        return request.POST.dict()
+    else:
+        raise UnsupportedMediaType(
+            [APPLICATION_JSON, APPLICATION_X_WWW_FORM], request.content_type)
+
+
+def parse_single_file(request: HttpRequest) -> UploadedFile:
+    if request.content_type != MULTIPART_FORMDATA:
+        raise UnsupportedMediaType(
+            [MULTIPART_FORMDATA],
+            request.content_type
+        )
+
+    if len(request.FILES) != 1:
+        raise JsonProblem(
+            f"Expected exactly one file, got {len(request.FILES)}.",
+            400,
+        )
+
+    for _, f in request.FILES.items():
+        return f
+
+
+def join_key(*args):
+    return '/'.join(args)

photo_objects-0.0.1/photo_objects/django/apps.py

@@ -0,0 +1,41 @@
+from django.apps import AppConfig
+from django.core.checks import Error, register
+from django.conf import settings
+
+
+class PhotoObjects(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'photo_objects.django'
+    label = 'photo_objects'
+
+    def ready(self):
+        from . import signals
+
+
+@register()
+def photo_objects_check(app_configs, **kwargs):
+    errors = []
+
+    try:
+        conf = settings.PHOTO_OBJECTS_OBJSTO
+    except AttributeError:
+        errors.append(
+            Error(
+                'The PHOTO_OBJECTS_OBJSTO setting must be defined.',
+                id='UNDEFINED_SETTING',
+                obj='photo_objects',
+            )
+        )
+        return errors
+
+    for key in ('URL', 'ACCESS_KEY', 'SECRET_KEY',):
+        if not conf.get(key):
+            errors.append(
+                Error(
+                    f'The PHOTO_OBJECTS_OBJSTO setting must define {key} '
+                    'field.',
+                    id='UNDEFINED_FIELD',
+                    obj='photo_objects',
+                ))
+
+    return errors

photo_objects-0.0.1/photo_objects/django/context_processors.py

@@ -0,0 +1,9 @@
+from importlib.metadata import version
+
+
+class Metadata:
+    version = version('photo_objects')
+
+
+def metadata(_):
+    return {"photo_objects_metadata": Metadata()}