photo-objects 0.8.6__tar.gz → 0.9.1__tar.gz

{photo_objects-0.8.6 → photo_objects-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: photo-objects
-Version: 0.8.6
+Version: 0.9.1
 Summary: Application for storing photos in S3 compatible object-storage.
 Author: Toni Kangas
 License: MIT License

photo_objects-0.9.1/photo_objects/django/admin.py

@@ -0,0 +1,14 @@
+from django.contrib import admin
+
+from .models import Album, Backup, Photo, PhotoChangeRequest, SiteSettings
+
+
+class BackupAdmin(admin.ModelAdmin):
+    readonly_fields = ["status"]
+
+
+admin.site.register(Album)
+admin.site.register(Photo)
+admin.site.register(SiteSettings)
+admin.site.register(PhotoChangeRequest)
+admin.site.register(Backup, BackupAdmin)

{photo_objects-0.8.6 → photo_objects-0.9.1}/photo_objects/django/api/__init__.py

@@ -1,4 +1,5 @@
 from .album import *
 from .auth import *
+from .backup import *
 from .photo import *
 from .photo_change_request import *

photo_objects-0.9.1/photo_objects/django/api/backup.py

@@ -0,0 +1,215 @@
+from django.contrib.auth import get_user_model
+from django.contrib.auth.models import Group, Permission
+from django.contrib.sites.models import Site
+from django.db import transaction
+
+from photo_objects.django.models import Album, Backup, Photo, SiteSettings
+from photo_objects.django.objsto import (
+    backup_data_key,
+    backup_info_key,
+    delete_backup_objects,
+    get_backup_data,
+    get_backup_object,
+    get_backup_objects,
+    put_backup_json,
+)
+from photo_objects.utils import timestamp_str
+
+
+def _permission_dict(permission: Permission):
+    return {
+        "app_label": permission.content_type.app_label,
+        "codename": permission.codename,
+    }
+
+
+def _get_permissions(permissions=None):
+    for permission in (permissions or []):
+        yield Permission.objects.get(
+            content_type__app_label=permission.get("app_label"),
+            codename=permission.get("codename"))
+
+
+def _user_dict(user):
+    return {
+        "username": user.username,
+        "first_name": user.first_name,
+        "last_name": user.last_name,
+        "email": user.email,
+        "groups": [
+            i.name for i in user.groups.all()],
+        "user_permissions": [
+            _permission_dict(i) for i in user.user_permissions.all()],
+        "is_staff": user.is_staff,
+        "is_active": user.is_active,
+        "is_superuser": user.is_superuser,
+        "last_login": timestamp_str(
+            user.last_login),
+        "date_joined": timestamp_str(
+            user.date_joined)}
+
+
+def _group_dict(group: Group):
+    return {
+        "name": group.name,
+        "permissions": [_permission_dict(i) for i in group.permissions.all()],
+    }
+
+
+def create_backup(backup: Backup):
+    # Check if backup already exists
+    if get_backup_object(backup.id):
+        backup.status = "ready"
+        backup.save()
+        return
+
+    user_model = get_user_model()
+
+    backup.status = "pending"
+    backup.save()
+
+    try:
+        albums = Album.objects.all()
+        for album in albums:
+            album_dict = album.to_json()
+            photos = []
+            for photo in album.photo_set.all():
+                photos.append(photo.to_json())
+            album_dict["photos"] = photos
+
+            put_backup_json(
+                backup_data_key(
+                    backup.id,
+                    'album',
+                    album.key),
+                album_dict,
+            )
+
+        groups = Group.objects.all()
+        for group in groups:
+            put_backup_json(
+                backup_data_key(
+                    backup.id,
+                    'group',
+                    group.name),
+                _group_dict(group),
+            )
+
+        users = user_model.objects.all()
+        for user in users:
+            if user.username == "admin":
+                continue
+
+            put_backup_json(
+                backup_data_key(
+                    backup.id,
+                    'user',
+                    user.username),
+                _user_dict(user))
+
+        sites = Site.objects.all()
+        for site in sites:
+            put_backup_json(
+                backup_data_key(backup.id, 'site', site.id),
+                {
+                    "id": site.id,
+                    "domain": site.domain,
+                    "name": site.name,
+                }
+            )
+
+        site_settings = SiteSettings.objects.all()
+        for settings in site_settings:
+            put_backup_json(
+                backup_data_key(backup.id, 'settings', settings.site.id),
+                {
+                    "site_id": settings.site.id,
+                    "description": settings.description,
+                    "preview_image_key": settings.preview_image.key
+                    if settings.preview_image else None,
+                }
+            )
+
+        put_backup_json(backup_info_key(backup.id), backup.to_json())
+    except Exception:
+        backup.status = "create_failed"
+        backup.save()
+        raise
+
+    backup.status = "ready"
+    backup.save()
+
+
+def delete_backup(backup: Backup):
+    return delete_backup_objects(backup.id)
+
+
+def get_backups() -> list[dict]:
+    return get_backup_objects()
+
+
+@transaction.atomic
+def restore_backup(backup_id: int):
+    user_model = get_user_model()
+
+    for i in get_backups():
+        Backup.objects.create(**i)
+
+    for i in get_backup_data(backup_id, "group"):
+        group = Group.objects.create(name=i.get('name'))
+
+        for permission in _get_permissions(i.get('permissions')):
+            group.permissions.add(permission)
+
+        group.save()
+
+    for i in get_backup_data(backup_id, "user"):
+        permissions = i.pop("user_permissions")
+        groups = i.pop("groups")
+
+        user = user_model.objects.create(**i)
+
+        for group in groups:
+            user.groups.add(Group.objects.get(name=group))
+
+        for permission in _get_permissions(permissions):
+            user.user_permissions.add(permission)
+
+        user.save()
+
+    for i in get_backup_data(backup_id, "album"):
+        photos = i.pop("photos")
+        cover_photo = i.pop("cover_photo")
+
+        album = Album.objects.create(**i)
+
+        for photo in photos:
+            photo.pop("album", None)
+            filename = photo.pop("filename")
+
+            photo = Photo.objects.create(**photo, album=album)
+
+            if cover_photo == filename:
+                album.cover_photo = photo
+                album.save()
+
+    for i in get_backup_data(backup_id, "site"):
+        site, _ = Site.objects.get_or_create(id=i.get("id"))
+        site.domain = i.get("domain")
+        site.name = i.get("name")
+        site.save()
+
+    for i in get_backup_data(backup_id, "settings"):
+        site = Site.objects.get(id=i.get("site_id"))
+
+        preview_image = None
+        if key := i.get("preview_image_key"):
+            preview_image = Photo.objects.get(key=key)
+
+        settings = SiteSettings.objects.create(
+            site=site,
+            description=i.get("description"),
+            preview_image=preview_image
+            if i.get("preview_image_key") else None
+        )
+        settings.save()

{photo_objects-0.8.6 → photo_objects-0.9.1}/photo_objects/django/forms.py

@@ -1,6 +1,4 @@
 import random
-import re
-import unicodedata
 
 from django import forms
 from django.forms import (
@@ -16,6 +14,8 @@ from django.forms import (
 from django.utils.safestring import mark_safe
 from django.utils.translation import gettext_lazy as _
 
+from photo_objects.utils import slugify
+
 from .models import Album, Photo, PhotoChangeRequest
 
 
@@ -26,22 +26,6 @@ KEY_POSTFIX_LEN = 5
 ALT_TEXT_HELP = _('Alternative text content for the photo.')
 
 
-def slugify(title: str, lower=False, replace_leading_underscores=False) -> str:
-    key = unicodedata.normalize(
-        'NFKD', title).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():
     for _ in range(13):
         yield '-' + ''.join(

{photo_objects-0.8.6 → photo_objects-0.9.1}/photo_objects/django/management/commands/create-initial-admin-account.py

@@ -12,7 +12,9 @@ class Command(BaseCommand):
 
     def handle(self, *args, **options):
         user = get_user_model()
-        superuser_count = user.objects.filter(is_superuser=True).count()
+        superuser_count = user.objects.filter(
+            is_superuser=True).exclude(
+            password="").count()
 
         if superuser_count == 0:
             username = 'admin'

photo_objects-0.9.1/photo_objects/django/management/commands/restore-backup.py

@@ -0,0 +1,96 @@
+# pylint: disable=invalid-name
+from io import StringIO
+
+from django.core.management import call_command
+from django.core.management.base import BaseCommand
+from django.contrib.auth import get_user_model
+from django.contrib.auth.models import Group
+from django.db import connection
+
+from photo_objects.django.api.backup import get_backups, restore_backup
+from photo_objects.django.models import Album, Photo
+
+
+class DatabaseStatus:
+    def __init__(self):
+        user = get_user_model()
+
+        self._users = user.objects.count()
+        self._groups = Group.objects.count()
+        self._albums = Album.objects.count()
+        self._photos = Photo.objects.count()
+
+    def should_restore(self):
+        count = self._users + self._groups + self._albums + self._photos
+        return count == 0
+
+    def __str__(self):
+        return (
+            f"Database contains {self._users} users, "
+            f"{self._groups} groups, {self._albums} albums, and "
+            f"{self._photos} photos"
+        )
+
+
+def reset_sequences():
+    output = StringIO()
+    call_command(
+        'sqlsequencereset',
+        'photo_objects',
+        'auth',
+        'sites',
+        stdout=output,
+        no_color=True)
+
+    sql = output.getvalue()
+    with connection.cursor() as cursor:
+        cursor.execute(sql)
+
+    output.close()
+
+
+class Command(BaseCommand):
+    help = "Restore latest backup if database is empty."
+
+    def handle(self, *args, **options):
+        status = DatabaseStatus()
+        if not status.should_restore():
+            self.stdout.write(
+                self.style.NOTICE(
+                    f'Restoring backup skipped: {status}'
+                )
+            )
+            return
+
+        backups = get_backups()
+
+        if not backups:
+            self.stdout.write(
+                self.style.NOTICE(
+                    'Restoring backup skipped: No backups found.'
+                )
+            )
+            return
+
+        try:
+            id_ = backups[-1].get("id")
+            self.stdout.write(
+                self.style.NOTICE(
+                    f'Restoring backup with ID {id_}.'
+                )
+            )
+            restore_backup(id_)
+            reset_sequences()
+            status = DatabaseStatus()
+            self.stdout.write(
+                self.style.SUCCESS(
+                    f'Restored backup with ID {id_}: {status}'
+                )
+            )
+        except Exception as e:
+            self.stdout.write(
+                self.style.ERROR(
+                    f'Failed to restore backup: {e}'
+                )
+            )
+            raise

photo_objects-0.9.1/photo_objects/django/migrations/0007_backup.py

@@ -0,0 +1,22 @@
+# Generated by Django 5.2.6 on 2025-10-26 23:26
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('photo_objects', '0006_photo_alt_text'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Backup',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('comment', models.TextField(blank=True)),
+                ('status', models.TextField(blank=True)),
+            ],
+        ),
+    ]

{photo_objects-0.8.6 → photo_objects-0.9.1}/photo_objects/django/models.py

@@ -4,7 +4,7 @@ from django.contrib.sites.models import Site
 from django.core.validators import RegexValidator
 from django.utils.translation import gettext_lazy as _
 
-from photo_objects.utils import first_paragraph_textcontent
+from photo_objects.utils import first_paragraph_textcontent, timestamp_str
 
 
 album_key_validator = RegexValidator(
@@ -23,10 +23,6 @@ def _str(key, **kwargs):
     return f'{key} ({details})' if details else key
 
 
-def _timestamp_str(timestamp):
-    return timestamp.isoformat() if timestamp else None
-
-
 class BaseModel(models.Model):
     title = models.CharField(blank=True)
     description = models.TextField(blank=True)
@@ -41,8 +37,8 @@ class BaseModel(models.Model):
         return dict(
             title=self.title,
             description=self.description,
-            created_at=_timestamp_str(self.created_at),
-            updated_at=_timestamp_str(self.updated_at),
+            created_at=timestamp_str(self.created_at),
+            updated_at=timestamp_str(self.updated_at),
         )
 
 
@@ -82,8 +78,8 @@ class Album(BaseModel):
             visibility=self.visibility,
             cover_photo=(
                 self.cover_photo.filename if self.cover_photo else None),
-            first_timestamp=_timestamp_str(self.first_timestamp),
-            last_timestamp=_timestamp_str(self.last_timestamp),
+            first_timestamp=timestamp_str(self.first_timestamp),
+            last_timestamp=timestamp_str(self.last_timestamp),
         )
 
 
@@ -190,7 +186,7 @@ class PhotoChangeRequest(models.Model):
         return dict(
             id=self.id,
             photo=self.photo.key,
-            created_at=_timestamp_str(self.created_at),
+            created_at=timestamp_str(self.created_at),
             alt_text=self.alt_text,
         )
 
@@ -233,3 +229,23 @@ def clear_cached_settings(sender, **kwargs):
 
 pre_save.connect(clear_cached_settings, sender=SiteSettings)
 pre_delete.connect(clear_cached_settings, sender=SiteSettings)
+
+
+class Backup(models.Model):
+    created_at = models.DateTimeField(auto_now_add=True)
+    comment = models.TextField(blank=True)
+    status = models.TextField(blank=True)
+
+    def __str__(self):
+        return _str(
+            f'Backup {self.id}',
+            created_at=self.created_at,
+            comment=self.comment,
+        )
+
+    def to_json(self):
+        return dict(
+            id=self.id,
+            created_at=timestamp_str(self.created_at),
+            comment=self.comment,
+        )

{photo_objects-0.8.6 → photo_objects-0.9.1}/photo_objects/django/objsto.py

@@ -13,6 +13,7 @@ from photo_objects.django.conf import (
     objsto_settings,
     parse_photo_sizes,
 )
+from photo_objects.utils import slugify
 
 
 MEGABYTE = 1 << 20
@@ -33,20 +34,35 @@ def _anonymous_readonly_policy(bucket: str):
     return json.dumps(policy)
 
 
-def _objsto_access() -> tuple[Minio, str]:
+def _objsto_access() -> tuple[dict, Minio]:
     conf = objsto_settings()
     http = urllib3.PoolManager(
         retries=urllib3.util.Retry(connect=1),
         timeout=urllib3.util.Timeout(connect=2.5, read=20),
     )
 
-    client = Minio(
+    return (conf, Minio(
         conf.get('URL'),
         conf.get('ACCESS_KEY'),
         conf.get('SECRET_KEY'),
         http_client=http,
         secure=conf.get('SECURE', True),
-    )
+    ))
+
+
+def _backup_access() -> tuple[Minio, str]:
+    conf, client = _objsto_access()
+    bucket = conf.get('BACKUP_BUCKET', 'backups')
+
+    # TODO: move this to management command
+    if not client.bucket_exists(bucket):
+        client.make_bucket(bucket)
+
+    return client, bucket
+
+
+def _photos_access() -> tuple[Minio, str]:
+    conf, client = _objsto_access()
     bucket = conf.get('BUCKET', 'photos')
 
     # TODO: move this to management command
@@ -57,6 +73,96 @@ def _objsto_access() -> tuple[Minio, str]:
     return client, bucket
 
 
+def _put_json(key, data, access_fn):
+    data_str = json.dumps(data)
+    stream = BytesIO(data_str.encode('utf-8'))
+
+    client, bucket = access_fn()
+    client.put_object(
+        bucket,
+        key,
+        stream,
+        length=-1,
+        part_size=10 * MEGABYTE,
+        content_type="application/json",
+    )
+
+
+def _list_all(client: Minio, bucket: str, prefix: str):
+    start_after = None
+    while True:
+        objects = client.list_objects(
+            bucket,
+            prefix=prefix,
+            recursive=True,
+            start_after=start_after)
+
+        if not objects:
+            break
+
+        empty = True
+        for i in objects:
+            empty = False
+            yield i
+            start_after = i.object_name
+
+        if empty:
+            break
+
+
+def _get_all(client: Minio, bucket: str, prefix: str):
+    for i in _list_all(client, bucket, prefix):
+        yield client.get_object(bucket, i.object_name)
+
+
+def _delete_all(client: Minio, bucket: str, prefix: str):
+    for i in _list_all(client, bucket, prefix):
+        client.remove_object(bucket, i.object_name)
+        yield i.object_name
+
+
+def backup_info_key(id_):
+    return f'info_{id_}.json'
+
+
+def backup_data_key(id_, type_, key):
+    return f'data_{id_}/{type_}_{slugify(key)}.json'
+
+
+def backup_data_prefix(id_, type_=None):
+    return f'data_{id_}/{type_ or ""}'
+
+
+def put_backup_json(key: str, data: dict):
+    return _put_json(key, data, _backup_access)
+
+
+def get_backup_object(backup_id: int):
+    client, bucket = _backup_access()
+    return json.loads(
+        client.get_object(
+            bucket,
+            backup_info_key(backup_id)).read())
+
+
+def get_backup_objects():
+    client, bucket = _backup_access()
+    return [json.loads(i.read()) for i in _get_all(client, bucket, 'info_')]
+
+
+def get_backup_data(id_: int, type_=None):
+    client, bucket = _backup_access()
+    for i in _get_all(client, bucket, backup_data_prefix(id_, type_)):
+        yield json.loads(i.read())
+
+
+def delete_backup_objects(id_: int):
+    client, bucket = _backup_access()
+    client.remove_object(bucket, backup_info_key(id_))
+    for _ in _delete_all(client, bucket, backup_data_prefix(id_)):
+        continue
+
+
 def photo_path(album_key, photo_key, size_key):
     return f"{size_key}/{album_key}/{photo_key}"
 
@@ -86,7 +192,7 @@ def photo_content_headers(
 def put_photo(album_key, photo_key, size_key, photo_file, image_format=None):
     content_type, headers = photo_content_headers(photo_key, image_format)
 
-    client, bucket = _objsto_access()
+    client, bucket = _photos_access()
     return client.put_object(
         bucket,
         photo_path(album_key, photo_key, size_key),
@@ -99,7 +205,7 @@ def put_photo(album_key, photo_key, size_key, photo_file, image_format=None):
 
 
 def get_photo(album_key, photo_key, size_key):
-    client, bucket = _objsto_access()
+    client, bucket = _photos_access()
     return client.get_object(
         bucket,
         photo_path(album_key, photo_key, size_key)
@@ -107,33 +213,17 @@ def get_photo(album_key, photo_key, size_key):
 
 
 def delete_photo(album_key, photo_key):
-    client, bucket = _objsto_access()
+    client, bucket = _photos_access()
 
     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()
+    client, bucket = _photos_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
+        yield from _delete_all(client, bucket, f'{size}/')
 
 
 def get_error_code(e: Exception) -> str:
@@ -151,22 +241,11 @@ def with_error_code(msg: str, e: Exception) -> str:
 
 
 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",
-    )
+    return _put_json("photo_sizes.json", asdict(sizes), _photos_access)
 
 
 def get_photo_sizes() -> PhotoSizes:
-    client, bucket = _objsto_access()
+    client, bucket = _photos_access()
     try:
         data = client.get_object(bucket, "photo_sizes.json")
         return parse_photo_sizes(json.loads(data.read()))

{photo_objects-0.8.6 → photo_objects-0.9.1}/photo_objects/django/signals.py

@@ -1,7 +1,10 @@
-from django.db.models.signals import post_save, post_delete
+from django.db.models.signals import post_save, post_delete, pre_delete
 from django.dispatch import receiver
 
-from .models import Photo
+from photo_objects.django.api import create_backup
+from photo_objects.django.api.backup import delete_backup
+
+from .models import Backup, Photo
 
 
 @receiver(post_save, sender=Photo)
@@ -56,3 +59,19 @@ def update_album_on_photo_delete(sender, **kwargs):
 
     if needs_save:
         album.save()
+
+
+@receiver(post_save, sender=Backup)
+def create_backup_to_objsto(sender, **kwargs):
+    created = kwargs.get('created', False)
+    if not created:
+        return None
+
+    backup = kwargs.get('instance', None)
+    return create_backup(backup)
+
+
+@receiver(pre_delete, sender=Backup)
+def delete_backup_from_objsto(sender, **kwargs):
+    backup = kwargs.get('instance', None)
+    return delete_backup(backup)

{photo_objects-0.8.6 → photo_objects-0.9.1}/photo_objects/django/tests/test_utils.py

@@ -25,6 +25,9 @@ class TestUtils(TestCase):
     def test_slugify_lower(self):
         self.assertEqual(slugify("QwErTy!", True), "qwerty-")
 
+    def test_slugify_number(self):
+        self.assertEqual(slugify(123), "123")
+
     def test_slugify_replace_leading_underscores(self):
         self.assertEqual(
             slugify(

{photo_objects-0.8.6 → photo_objects-0.9.1}/photo_objects/django/tests/utils.py

@@ -14,7 +14,7 @@ from minio import S3Error
 
 from photo_objects.django import objsto
 from photo_objects.django.models import Album, Photo
-from photo_objects.django.objsto import _objsto_access
+from photo_objects.django.objsto import _photos_access
 
 
 def add_permissions(user, *permissions):
@@ -56,7 +56,7 @@ class TestCase(DjangoTestCase):
     # pylint: disable=invalid-name
     @classmethod
     def tearDownClass(cls):
-        client, bucket = _objsto_access()
+        client, bucket = _photos_access()
 
         for i in client.list_objects(bucket, recursive=True):
             client.remove_object(bucket, i.object_name)

photo_objects-0.9.1/photo_objects/utils.py

@@ -0,0 +1,50 @@
+from datetime import datetime
+import re
+import unicodedata
+from xml.etree import ElementTree as ET
+
+from django.utils.safestring import mark_safe
+from markdown import markdown
+
+
+def pretty_list(in_: list, conjunction: str):
+    return f' {conjunction} '.join(
+        i for i in (', '.join(in_[:-1]), in_[-1],) if i)
+
+
+def render_markdown(value: str):
+    return mark_safe(markdown(value))
+
+
+def first_paragraph_textcontent(raw: str) -> str | None:
+    html = render_markdown(raw)
+    root = ET.fromstring(f"<root>{html}</root>")
+
+    first = root.find("p")
+    if first is None:
+        return None
+
+    return ''.join(first.itertext())
+
+
+def timestamp_str(timestamp: datetime):
+    return timestamp.isoformat() if timestamp else None
+
+
+def slugify(
+        title: str | int,
+        lower=False,
+        replace_leading_underscores=False) -> str:
+    key = unicodedata.normalize(
+        'NFKD', str(title)).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

{photo_objects-0.8.6 → photo_objects-0.9.1}/photo_objects.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: photo-objects
-Version: 0.8.6
+Version: 0.9.1
 Summary: Application for storing photos in S3 compatible object-storage.
 Author: Toni Kangas
 License: MIT License

{photo_objects-0.8.6 → photo_objects-0.9.1}/photo_objects.egg-info/SOURCES.txt

@@ -24,6 +24,7 @@ photo_objects/django/urls.py
 photo_objects/django/api/__init__.py
 photo_objects/django/api/album.py
 photo_objects/django/api/auth.py
+photo_objects/django/api/backup.py
 photo_objects/django/api/photo.py
 photo_objects/django/api/photo_change_request.py
 photo_objects/django/api/utils.py
@@ -31,12 +32,14 @@ photo_objects/django/management/__init__.py
 photo_objects/django/management/commands/__init__.py
 photo_objects/django/management/commands/clean-scaled-photos.py
 photo_objects/django/management/commands/create-initial-admin-account.py
+photo_objects/django/management/commands/restore-backup.py
 photo_objects/django/migrations/0001_initial.py
 photo_objects/django/migrations/0002_created_at_updated_at.py
 photo_objects/django/migrations/0003_admin_visibility.py
 photo_objects/django/migrations/0004_camera_setup_and_settings.py
 photo_objects/django/migrations/0005_sitesettings.py
 photo_objects/django/migrations/0006_photo_alt_text.py
+photo_objects/django/migrations/0007_backup.py
 photo_objects/django/migrations/__init__.py
 photo_objects/django/templatetags/__init__.py
 photo_objects/django/templatetags/photo_objects_extras.py

{photo_objects-0.8.6 → photo_objects-0.9.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "photo-objects"
-version = "0.8.6"
+version = "0.9.1"
 dependencies = [
     "markdown~=3.7",
     "minio~=7.2",

photo_objects-0.8.6/photo_objects/django/admin.py

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

photo_objects-0.8.6/photo_objects/utils.py

@@ -1,24 +0,0 @@
-from xml.etree import ElementTree as ET
-
-from django.utils.safestring import mark_safe
-from markdown import markdown
-
-
-def pretty_list(in_: list, conjunction: str):
-    return f' {conjunction} '.join(
-        i for i in (', '.join(in_[:-1]), in_[-1],) if i)
-
-
-def render_markdown(value: str):
-    return mark_safe(markdown(value))
-
-
-def first_paragraph_textcontent(raw: str) -> str | None:
-    html = render_markdown(raw)
-    root = ET.fromstring(f"<root>{html}</root>")
-
-    first = root.find("p")
-    if first is None:
-        return None
-
-    return ''.join(first.itertext())