blog-package 0.1.0__tar.gz

blog_package-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 puzzllium
+
+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.

blog_package-0.1.0/PKG-INFO

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: blog-package
+Version: 0.1.0
+Summary: Blog site package for the Core boilerplate (posts with a gallery, comments, likes, saves, share tracking). Depends on core-package for auth, RBAC, and the shared User model — it does not define its own.
+Author-email: puzzllium <puzzllium@gmail.com>
+Maintainer-email: puzzllium <puzzllium@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/puzzelchannel/package-blog
+Project-URL: Issues, https://github.com/puzzelchannel/package-blog/issues
+Classifier: Framework :: Django
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: core-package
+Requires-Dist: django-ninja>=1.7.0
+Requires-Dist: django-unfold>=0.81.0
+Requires-Dist: Pillow>=10.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-django>=4.14; extra == "dev"
+Requires-Dist: pytest-asyncio>=1.4; extra == "dev"
+Dynamic: license-file
+
+# blog-package
+
+**Author:** puzzllium · [puzzllium@gmail.com](mailto:puzzllium@gmail.com) · [LinkedIn](https://www.linkedin.com/in/puzzllium)
+
+Blog site package built on [core-package](https://pypi.org/project/core-package/):
+posts with a cover picture and image gallery, comments, likes, saves (bookmarks)
+and share-count tracking. It never defines its own user model: every post,
+comment, like and save is owned by a core-package `User` via
+`settings.AUTH_USER_MODEL`.
+
+`Post.subject`/`description`/`text` are translatable through a single
+`translations` JSON field (`{"fa": {"subject": "..."}, "de": {...}}`), so adding a
+language needs no migration: `PUT /posts/{id}/translations/{language}`.
+
+## Install
+
+```bash
+pip install blog-package
+```
+
+Requires Python 3.10+ and Django 5.2 (via core-package).
+
+## What's inside
+
+The package ships the reusable `blog` Django app:
+
+| Module | Purpose |
+| --- | --- |
+| `blog.models` | Post, gallery image, comment, like, save |
+| `blog.api` | Django Ninja router (public reads, logged-in interactions, admin-only writes) |
+| `blog.schemas` / `blog.services` | Request/response schemas and business logic |
+| `blog.admin` | Django admin (Unfold) incl. cover and gallery image management |
+
+`testproject/` is dev-only scaffolding for this repo's own tests and is **not** part of the installable package.
+
+## Dependencies
+
+**Required**
+
+| Package | Used for |
+| --- | --- |
+| core-package | Auth, RBAC, the shared `User` model, base/translatable models, pagination, throttling |
+| django-ninja `>=1.7.0` | REST API layer |
+| django-unfold `>=0.81.0` | Admin theme |
+| Pillow `>=10.0` | Post cover and gallery images |
+
+core-package in turn brings in Django 5.2 and the rest of the stack; see its README.
+
+**Optional extras**
+
+| Extra | Installs |
+| --- | --- |
+| `dev` | `pytest>=8`, `pytest-django>=4.14`, `pytest-asyncio>=1.4` |
+
+## Local development
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -e /path/to/Core/Core   # core-package, editable
+pip install -e ".[dev]"
+pytest
+```
+
+## Installing into a Core-based project
+
+1. Install it editable into the host repo's venv:
+   ```bash
+   source .venv/bin/activate
+   pip install -e ../Packages/blog
+   ```
+2. Add it to `INSTALLED_APPS` in the host's `config/settings/base.py`, under
+   the `# site packages` comment:
+   ```python
+   # site packages
+   "blog",
+   ```
+3. Mount its router in the host's `config/api.py`:
+   ```python
+   from blog.api import router as blog_router
+   ...
+   api.add_router("/blog", blog_router)
+   ```
+4. Migrate:
+   ```bash
+   python manage.py migrate
+   ```
+
+**Installed automatically alongside `portfolio`**: `portfolio` declares
+`blog-package` as a pip dependency (its site includes a blog section), so
+`pip install -e ../Packages/portfolio` pulls this package in for you too —
+but per Core's "no auto-discovery, explicit wiring" convention (§10), step 2
+(`INSTALLED_APPS`) and step 3 (router mount) above still need doing by hand
+for `blog`, exactly like for `portfolio` itself. The pip dependency only
+saves you the `pip install` step, not the Django-level wiring.
+
+## Endpoints
+
+Mounted at whatever prefix the host chooses (`/blog` in the example above).
+Reads are public; interactions require login; content writes are admin-only.
+
+- `GET /posts` — paginated list of published posts (public), optional
+  `?user_id=` and `?lang=` (returns the post's translated `subject`/
+  `description`/`text` for that language if a translation exists, else the
+  original)
+- `GET /posts/by-slug/{slug}` — published post detail (public), optional
+  `?lang=`
+- `GET /posts/{post_id}/comments` — paginated comments on a post (public)
+- `POST /posts/{post_id}/comments` — add a comment (logged in)
+- `DELETE /comments/{comment_id}` — delete a comment (its author, or admin)
+- `POST /posts/{post_id}/like` — toggle like on/off (logged in), returns the
+  new state + like count
+- `POST /posts/{post_id}/save` — toggle save/bookmark on/off (logged in)
+- `POST /posts/{post_id}/share` — public, rate-limited by IP; increments and
+  returns the post's share count (no account needed to share)
+- `POST /posts`, `GET /posts/{post_id}`, `PATCH /posts/{post_id}`,
+  `DELETE /posts/{post_id}` — admin-only (`require_role("admin")`, from Core)
+- `PUT /posts/{post_id}/translations/{language}` — admin-only; sets/updates
+  the translated `subject`/`description`/`text` for that language
+
+Post pictures and gallery images are managed through the Django admin (same
+convention as the portfolio package's `Project.cover_image`/`ProjectImage` —
+no write API for images yet, deliberately, to avoid building endpoints
+nothing needs yet).
+
+## License
+
+MIT. See [LICENSE](LICENSE).

blog_package-0.1.0/README.md

@@ -0,0 +1,128 @@
+# blog-package
+
+**Author:** puzzllium · [puzzllium@gmail.com](mailto:puzzllium@gmail.com) · [LinkedIn](https://www.linkedin.com/in/puzzllium)
+
+Blog site package built on [core-package](https://pypi.org/project/core-package/):
+posts with a cover picture and image gallery, comments, likes, saves (bookmarks)
+and share-count tracking. It never defines its own user model: every post,
+comment, like and save is owned by a core-package `User` via
+`settings.AUTH_USER_MODEL`.
+
+`Post.subject`/`description`/`text` are translatable through a single
+`translations` JSON field (`{"fa": {"subject": "..."}, "de": {...}}`), so adding a
+language needs no migration: `PUT /posts/{id}/translations/{language}`.
+
+## Install
+
+```bash
+pip install blog-package
+```
+
+Requires Python 3.10+ and Django 5.2 (via core-package).
+
+## What's inside
+
+The package ships the reusable `blog` Django app:
+
+| Module | Purpose |
+| --- | --- |
+| `blog.models` | Post, gallery image, comment, like, save |
+| `blog.api` | Django Ninja router (public reads, logged-in interactions, admin-only writes) |
+| `blog.schemas` / `blog.services` | Request/response schemas and business logic |
+| `blog.admin` | Django admin (Unfold) incl. cover and gallery image management |
+
+`testproject/` is dev-only scaffolding for this repo's own tests and is **not** part of the installable package.
+
+## Dependencies
+
+**Required**
+
+| Package | Used for |
+| --- | --- |
+| core-package | Auth, RBAC, the shared `User` model, base/translatable models, pagination, throttling |
+| django-ninja `>=1.7.0` | REST API layer |
+| django-unfold `>=0.81.0` | Admin theme |
+| Pillow `>=10.0` | Post cover and gallery images |
+
+core-package in turn brings in Django 5.2 and the rest of the stack; see its README.
+
+**Optional extras**
+
+| Extra | Installs |
+| --- | --- |
+| `dev` | `pytest>=8`, `pytest-django>=4.14`, `pytest-asyncio>=1.4` |
+
+## Local development
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -e /path/to/Core/Core   # core-package, editable
+pip install -e ".[dev]"
+pytest
+```
+
+## Installing into a Core-based project
+
+1. Install it editable into the host repo's venv:
+   ```bash
+   source .venv/bin/activate
+   pip install -e ../Packages/blog
+   ```
+2. Add it to `INSTALLED_APPS` in the host's `config/settings/base.py`, under
+   the `# site packages` comment:
+   ```python
+   # site packages
+   "blog",
+   ```
+3. Mount its router in the host's `config/api.py`:
+   ```python
+   from blog.api import router as blog_router
+   ...
+   api.add_router("/blog", blog_router)
+   ```
+4. Migrate:
+   ```bash
+   python manage.py migrate
+   ```
+
+**Installed automatically alongside `portfolio`**: `portfolio` declares
+`blog-package` as a pip dependency (its site includes a blog section), so
+`pip install -e ../Packages/portfolio` pulls this package in for you too —
+but per Core's "no auto-discovery, explicit wiring" convention (§10), step 2
+(`INSTALLED_APPS`) and step 3 (router mount) above still need doing by hand
+for `blog`, exactly like for `portfolio` itself. The pip dependency only
+saves you the `pip install` step, not the Django-level wiring.
+
+## Endpoints
+
+Mounted at whatever prefix the host chooses (`/blog` in the example above).
+Reads are public; interactions require login; content writes are admin-only.
+
+- `GET /posts` — paginated list of published posts (public), optional
+  `?user_id=` and `?lang=` (returns the post's translated `subject`/
+  `description`/`text` for that language if a translation exists, else the
+  original)
+- `GET /posts/by-slug/{slug}` — published post detail (public), optional
+  `?lang=`
+- `GET /posts/{post_id}/comments` — paginated comments on a post (public)
+- `POST /posts/{post_id}/comments` — add a comment (logged in)
+- `DELETE /comments/{comment_id}` — delete a comment (its author, or admin)
+- `POST /posts/{post_id}/like` — toggle like on/off (logged in), returns the
+  new state + like count
+- `POST /posts/{post_id}/save` — toggle save/bookmark on/off (logged in)
+- `POST /posts/{post_id}/share` — public, rate-limited by IP; increments and
+  returns the post's share count (no account needed to share)
+- `POST /posts`, `GET /posts/{post_id}`, `PATCH /posts/{post_id}`,
+  `DELETE /posts/{post_id}` — admin-only (`require_role("admin")`, from Core)
+- `PUT /posts/{post_id}/translations/{language}` — admin-only; sets/updates
+  the translated `subject`/`description`/`text` for that language
+
+Post pictures and gallery images are managed through the Django admin (same
+convention as the portfolio package's `Project.cover_image`/`ProjectImage` —
+no write API for images yet, deliberately, to avoid building endpoints
+nothing needs yet).
+
+## License
+
+MIT. See [LICENSE](LICENSE).

blog_package-0.1.0/blog/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

blog_package-0.1.0/blog/admin.py

@@ -0,0 +1,47 @@
+from django.contrib import admin
+from unfold.admin import ModelAdmin, TabularInline
+
+from blog.models import Comment, Like, Post, PostImage, SavedPost
+
+
+class PostImageInline(TabularInline):
+    model = PostImage
+    extra = 1
+    fields = ("image", "caption", "order")
+
+
+@admin.register(Post)
+class PostAdmin(ModelAdmin):
+    list_display = ("subject", "user", "is_published", "like_count", "comment_count", "share_count", "created_at")
+    list_filter = ("is_published",)
+    search_fields = ("subject", "slug", "description")
+    prepopulated_fields = {"slug": ("subject",)}
+    readonly_fields = ("id", "share_count", "created_at", "updated_at")
+    inlines = [PostImageInline]
+
+    @admin.display(description="Likes")
+    def like_count(self, obj: Post) -> int:
+        return obj.likes.count()
+
+    @admin.display(description="Comments")
+    def comment_count(self, obj: Post) -> int:
+        return obj.comments.count()
+
+
+@admin.register(Comment)
+class CommentAdmin(ModelAdmin):
+    list_display = ("post", "user", "created_at")
+    search_fields = ("text",)
+    readonly_fields = ("id", "created_at", "updated_at")
+
+
+@admin.register(Like)
+class LikeAdmin(ModelAdmin):
+    list_display = ("post", "user", "created_at")
+    readonly_fields = ("id", "created_at", "updated_at")
+
+
+@admin.register(SavedPost)
+class SavedPostAdmin(ModelAdmin):
+    list_display = ("post", "user", "created_at")
+    readonly_fields = ("id", "created_at", "updated_at")

blog_package-0.1.0/blog/api.py

@@ -0,0 +1,130 @@
+import uuid
+
+from apps.core.pagination import PageParams, paginate_queryset
+from apps.core.permissions import require_role
+from apps.core.schemas import PagedResponse
+from apps.core.throttling import check_rate_limit
+from apps.core.utils import get_client_ip
+from ninja import Router, Status
+
+from blog import services
+from blog.schemas import (
+    CommentIn,
+    CommentOut,
+    LikeToggleOut,
+    PostIn,
+    PostOut,
+    PostTranslationIn,
+    PostUpdateIn,
+    SaveToggleOut,
+    ShareOut,
+    ViewerStateOut,
+)
+
+router = Router(tags=["blog"])
+
+# NOTE: literal-path routes ("/posts/by-slug/{slug}", "/posts/{post_id}/..."
+# sub-resources) are registered ahead of the bare "/posts/{post_id}" wildcard
+# below. They don't actually collide by URL shape (different segment counts/
+# literal positions — see blog's README), but keeping literal-before-wildcard
+# is Core's house style for every router (see Core's AGENT.md §9 point 5), so
+# this follows it even where the collision itself isn't possible.
+
+# --- Public read endpoints ----------------------------------------------------
+
+
+@router.get("/posts", response=PagedResponse[PostOut], auth=None)
+async def list_posts(request, page: PageParams = PageParams(), user_id: uuid.UUID | None = None, lang: str | None = None, search: str | None = None):  # noqa: B008 (ninja query-schema idiom)
+    items, meta = await paginate_queryset(services.published_post_queryset(user_id, search), page)
+    return {"items": await services.serialize_posts(items, lang, None), "meta": meta}
+
+
+@router.get("/posts/by-slug/{slug}", response=PostOut, auth=None)
+async def get_post_by_slug(request, slug: str, lang: str | None = None):
+    post = await services.get_published_post_or_404(slug)
+    return (await services.serialize_posts([post], lang, None))[0]
+
+
+@router.get("/posts/{post_id}/comments", response=PagedResponse[CommentOut], auth=None)
+async def list_comments(request, post_id: uuid.UUID, page: PageParams = PageParams()):  # noqa: B008
+    items, meta = await paginate_queryset(services.comment_queryset(post_id), page)
+    return {"items": items, "meta": meta}
+
+
+# --- Reader interactions: like / save / comment / share -----------------------
+# Inherit the API's default `auth=session_token_auth` (no `auth=` kwarg here)
+# except "/share", which stays public — sharing shouldn't require an account,
+# it's rate-limited by IP instead (same pattern as Core's contact-form POST).
+
+
+@router.get("/posts/{post_id}/viewer-state", response=ViewerStateOut)
+async def post_viewer_state(request, post_id: uuid.UUID):
+    return await services.viewer_state(request.auth, post_id)
+
+
+@router.post("/posts/{post_id}/like", response=LikeToggleOut)
+async def like_post(request, post_id: uuid.UUID):
+    liked, like_count = await services.toggle_like(request.auth, post_id)
+    return {"liked": liked, "like_count": like_count}
+
+
+@router.post("/posts/{post_id}/save", response=SaveToggleOut)
+async def save_post(request, post_id: uuid.UUID):
+    saved, save_count = await services.toggle_save(request.auth, post_id)
+    return {"saved": saved, "save_count": save_count}
+
+
+@router.post("/posts/{post_id}/comments", response={201: CommentOut})
+async def create_comment(request, post_id: uuid.UUID, payload: CommentIn):
+    comment = await services.add_comment(request.auth, post_id, payload.text)
+    return Status(201, comment)
+
+
+@router.post("/posts/{post_id}/share", response=ShareOut, auth=None)
+async def share_post(request, post_id: uuid.UUID):
+    await check_rate_limit(f"blog_share:{get_client_ip(request)}", limit=30, window_seconds=60)
+    return {"share_count": await services.record_share(post_id)}
+
+
+@router.delete("/comments/{comment_id}", response={204: None})
+async def delete_comment(request, comment_id: uuid.UUID):
+    await services.delete_comment(request.auth, comment_id)
+    return Status(204, None)
+
+
+# --- Admin-only writes (Post) --------------------------------------------------
+
+
+@router.post("/posts", response={201: PostOut})
+@require_role("admin")
+async def create_post(request, payload: PostIn):
+    post = await services.create_post(request.auth, request.auth.id, **payload.model_dump())
+    return Status(201, (await services.serialize_posts([post], None, None))[0])
+
+
+@router.get("/posts/{post_id}", response=PostOut)
+@require_role("admin")
+async def get_post(request, post_id: uuid.UUID):
+    post = await services.get_post_or_404(post_id)
+    return (await services.serialize_posts([post], None, None))[0]
+
+
+@router.patch("/posts/{post_id}", response=PostOut)
+@require_role("admin")
+async def update_post(request, post_id: uuid.UUID, payload: PostUpdateIn):
+    post = await services.update_post(request.auth, post_id, **payload.model_dump())
+    return (await services.serialize_posts([post], None, None))[0]
+
+
+@router.delete("/posts/{post_id}", response={204: None})
+@require_role("admin")
+async def delete_post(request, post_id: uuid.UUID):
+    await services.delete_post(request.auth, post_id)
+    return Status(204, None)
+
+
+@router.put("/posts/{post_id}/translations/{language}", response=PostOut)
+@require_role("admin")
+async def set_post_translation(request, post_id: uuid.UUID, language: str, payload: PostTranslationIn):
+    post = await services.set_post_translation(request.auth, post_id, language, **payload.model_dump())
+    return (await services.serialize_posts([post], language, None))[0]

blog_package-0.1.0/blog/apps.py

@@ -0,0 +1,8 @@
+from django.apps import AppConfig
+
+
+class BlogConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "blog"
+    label = "blog"
+    verbose_name = "Blog"

blog_package-0.1.0/blog/migrations/0001_initial.py

@@ -0,0 +1,113 @@
+# Generated by Django 5.2.17 on 2026-09-16 11:56
+
+import django.db.models.deletion
+import uuid
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Post',
+            fields=[
+                ('created_at', models.DateTimeField(auto_now_add=True, db_index=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('id', models.UUIDField(default=uuid.uuid4, editable=False, primary_key=True, serialize=False)),
+                ('translations', models.JSONField(blank=True, default=dict)),
+                ('subject', models.CharField(max_length=200)),
+                ('slug', models.SlugField(max_length=220, unique=True)),
+                ('picture', models.ImageField(blank=True, null=True, upload_to='blog/posts/pictures/')),
+                ('description', models.CharField(blank=True, default='', max_length=300)),
+                ('text', models.TextField(blank=True, default='')),
+                ('is_published', models.BooleanField(default=True)),
+                ('share_count', models.PositiveIntegerField(default=0)),
+                ('order', models.PositiveIntegerField(default=0)),
+                ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='blog_posts', to=settings.AUTH_USER_MODEL)),
+            ],
+            options={
+                'db_table': 'blog_posts',
+                'ordering': ['order', '-created_at'],
+            },
+        ),
+        migrations.CreateModel(
+            name='Like',
+            fields=[
+                ('created_at', models.DateTimeField(auto_now_add=True, db_index=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('id', models.UUIDField(default=uuid.uuid4, editable=False, primary_key=True, serialize=False)),
+                ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='blog_likes', to=settings.AUTH_USER_MODEL)),
+                ('post', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='likes', to='blog.post')),
+            ],
+            options={
+                'db_table': 'blog_likes',
+            },
+        ),
+        migrations.CreateModel(
+            name='Comment',
+            fields=[
+                ('created_at', models.DateTimeField(auto_now_add=True, db_index=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('id', models.UUIDField(default=uuid.uuid4, editable=False, primary_key=True, serialize=False)),
+                ('text', models.TextField()),
+                ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='blog_comments', to=settings.AUTH_USER_MODEL)),
+                ('post', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='comments', to='blog.post')),
+            ],
+            options={
+                'db_table': 'blog_comments',
+                'ordering': ['-created_at'],
+            },
+        ),
+        migrations.CreateModel(
+            name='PostImage',
+            fields=[
+                ('created_at', models.DateTimeField(auto_now_add=True, db_index=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('id', models.UUIDField(default=uuid.uuid4, editable=False, primary_key=True, serialize=False)),
+                ('image', models.ImageField(upload_to='blog/posts/gallery/')),
+                ('caption', models.CharField(blank=True, default='', max_length=200)),
+                ('order', models.PositiveIntegerField(default=0)),
+                ('post', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='images', to='blog.post')),
+            ],
+            options={
+                'db_table': 'blog_post_images',
+                'ordering': ['order'],
+            },
+        ),
+        migrations.CreateModel(
+            name='SavedPost',
+            fields=[
+                ('created_at', models.DateTimeField(auto_now_add=True, db_index=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('id', models.UUIDField(default=uuid.uuid4, editable=False, primary_key=True, serialize=False)),
+                ('post', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='saves', to='blog.post')),
+                ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='blog_saved_posts', to=settings.AUTH_USER_MODEL)),
+            ],
+            options={
+                'db_table': 'blog_saved_posts',
+            },
+        ),
+        migrations.AddIndex(
+            model_name='post',
+            index=models.Index(fields=['slug'], name='blog_posts_slug_b4ca25_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='post',
+            index=models.Index(fields=['is_published'], name='blog_posts_is_publ_b91838_idx'),
+        ),
+        migrations.AddConstraint(
+            model_name='like',
+            constraint=models.UniqueConstraint(fields=('post', 'user'), name='blog_unique_post_like'),
+        ),
+        migrations.AddConstraint(
+            model_name='savedpost',
+            constraint=models.UniqueConstraint(fields=('post', 'user'), name='blog_unique_post_save'),
+        ),
+    ]