django-drf-blog-api 0.0.1__tar.gz

django-drf-blog-api-0.0.1/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2024 Osiota Samuel Obrozie
+
+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.

django-drf-blog-api-0.0.1/MANIFEST.in

@@ -0,0 +1,2 @@
+  include LICENSE
+  include README.rst

django-drf-blog-api-0.0.1/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.1
+Name: django-drf-blog-api
+Version: 0.0.1
+Summary: A Django app blog API endpoints.
+Home-page: https://www.example.com/
+Author: Osiota Samuel Obrozie
+Author-email: osiotaobrozie@gmail.com
+License: BSD-3-Clause  # Example license
+Platform: UNKNOWN
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.0
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+
+# django-drf-blog-api
+
+
+django-drf-blog-api is a Django blog API app
+
+
+
+## Quick start
+
+
+1. Add "Blog" to your INSTALLED_APPS setting like this::
+
+    INSTALLED_APPS = [
+        ...,
+        "django-drf-blog-api",
+    ]
+```
+2. Include the polls URLconf in your project urls.py like this::
+
+    path("blog/", include("django-drf-blog-api.urls")),
+
+3. Run ``python manage.py migrate`` to create the models.
+
+4. Start the development server and visit the admin to create a poll.
+
+5. Visit the ``/blog/`` URL to participate in the poll.
+

django-drf-blog-api-0.0.1/README.rst

@@ -0,0 +1,27 @@
+
+# django-drf-blog-api
+
+
+django-drf-blog-api is a Django blog API app
+
+
+
+## Quick start
+
+
+1. Add "Blog" to your INSTALLED_APPS setting like this::
+
+    INSTALLED_APPS = [
+        ...,
+        "django-drf-blog-api",
+    ]
+```
+2. Include the polls URLconf in your project urls.py like this::
+
+    path("blog/", include("django-drf-blog-api.urls")),
+
+3. Run ``python manage.py migrate`` to create the models.
+
+4. Start the development server and visit the admin to create a poll.
+
+5. Visit the ``/blog/`` URL to participate in the poll.

django-drf-blog-api-0.0.1/django_drf_blog_api/admin.py

@@ -0,0 +1,38 @@
+from django.contrib import admin
+
+from . models import *
+from django.contrib.auth.admin import UserAdmin
+from .models import UserAccount
+from .forms import UserChangeForm, UserCreationForm
+
+
+class CustomUserAdmin(UserAdmin):
+    form = UserChangeForm
+    add_form = UserCreationForm
+    ordering = ('email',)
+    list_display = ('first_name', 'last_name', 'email',
+                    'is_featured', 'is_active', 'is_staff', 'is_superuser')
+    model = UserAccount
+    fieldsets = (
+        (None, {'fields': ('image', 'password',)}),
+        ('Personal info', {
+            'fields': ('first_name', 'last_name', 'email', 'gender', 'phone_number', 'date_of_birth',)}),
+        ('Featured Athlete', {
+            'fields': ('is_featured',)}),
+        ('Contact Address', {
+         'fields': ('home_address', 'local_govt', 'state_of_origin', 'nationality',)}),
+        ('Permissions', {
+         'fields': ('is_active', 'is_staff', 'is_superuser', 'groups', 'user_permissions')}),
+        ('Important dates', {
+            'fields': ('date_joined', 'last_login',)}),
+    )
+
+    add_fieldsets = (
+        (None, {
+            'classes': ('wide',),
+            'fields': ('first_name', 'last_name', 'email', 'phone_number', 'password1', 'password2')}
+         ),
+    )
+
+
+admin.site.register(UserAccount, CustomUserAdmin)

django-drf-blog-api-0.0.1/django_drf_blog_api/apps.py

@@ -0,0 +1,9 @@
+from django.apps import AppConfig
+
+
+class BlogConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'django_drf_blog_api'
+
+    def ready(self):
+        pass

django-drf-blog-api-0.0.1/django_drf_blog_api/forms.py

@@ -0,0 +1,39 @@
+from django import forms
+from django.contrib.auth.forms import ReadOnlyPasswordHashField
+
+from .models import UserAccount
+
+
+class UserCreationForm(forms.ModelForm):
+    password1 = forms.CharField(label='Password', widget=forms.PasswordInput)
+    password2 = forms.CharField(
+        label='Password confirmation', widget=forms.PasswordInput)
+
+    class Meta:
+        model = UserAccount
+        fields = ("first_name", "last_name", "phone_number", "email")
+
+    def clean_password2(self):
+        password1 = self.cleaned_data.get("password1")
+        password2 = self.cleaned_data.get("password2")
+        if password1 and password2 and password1 != password2:
+            raise forms.ValidationError("Passwords don't match")
+        return password2
+
+    def save(self, commit=True):
+        user = super().save(commit=False)
+        user.set_password(self.cleaned_data["password1"])
+        if commit:
+            user.save()
+        return user
+
+
+class UserChangeForm(forms.ModelForm):
+    password = ReadOnlyPasswordHashField()
+
+    class Meta:
+        model = UserAccount
+        fields = '__all__'
+
+    def clean_password(self):
+        return self.initial["password"]

django-drf-blog-api-0.0.1/django_drf_blog_api/models.py

@@ -0,0 +1,147 @@
+from django.db import models
+from django.contrib.auth.models import AbstractBaseUser, PermissionsMixin, BaseUserManager
+from django.core.validators import RegexValidator
+from django.conf import settings
+from cloudinary.models import CloudinaryField
+from django.contrib.contenttypes.fields import GenericForeignKey
+from django.contrib.contenttypes.models import ContentType
+
+
+class UserAccountManager(BaseUserManager):
+    use_in_migrations = True
+
+    def _create_user(self, email, password, **extra_fields):
+        """
+        Creates and saves a User with the given email and password.
+        """
+        if not email:
+            raise ValueError('Users must have an email address')
+
+        email = self.normalize_email(email)
+        user = self.model(email=email, **extra_fields)
+        user.set_password(password)
+        user.save(using=self._db)
+        return user
+
+    def create_user(self, email, password=None, **extra_fields):
+        return self._create_user(email, password, **extra_fields)
+
+    def create_superuser(self, email, password, **extra_fields):
+
+        extra_fields.setdefault('is_superuser', True)
+        extra_fields.setdefault('is_staff', True)
+
+        if extra_fields.get('is_superuser') is not True:
+            raise ValueError('Superuser must have is_superuser=True.')
+
+        return self._create_user(email, password, **extra_fields)
+
+
+class UserAccount(AbstractBaseUser, PermissionsMixin):
+    GENDER = [
+        ('Male', 'Male'),
+        ('Female', 'Female')
+    ]
+
+    USER_TYPE = [
+        ('Author', 'Author'),
+        ('Public', 'Public')
+    ]
+
+    email = models.EmailField(max_length=255, unique=True)
+    first_name = models.CharField(max_length=255)
+    last_name = models.CharField(max_length=255)
+    account_type = models.CharField(
+        max_length=255, blank=True, choices=USER_TYPE, default='Public')
+    phone_number = models.CharField(null=True, blank=True, max_length=11, validators=[
+                                    RegexValidator(r'^\d{11}$', 'Enter a valid phone number.')])
+    date_of_birth = models.DateField(null=True, blank=True)
+    is_active = models.BooleanField(default=True)
+    is_staff = models.BooleanField(default=False)
+    is_superuser = models.BooleanField(default=False)
+    date_joined = models.DateTimeField(null=True, blank=True)
+    image = CloudinaryField('image', null=True, blank=True)
+    gender = models.CharField(
+        max_length=255, null=True, blank=True, choices=GENDER)
+    home_address = models.TextField(null=True, blank=True)
+    local_govt = models.CharField(max_length=255, null=True, blank=True)
+    state_of_origin = models.CharField(max_length=255, null=True, blank=True)
+    nationality = models.CharField(max_length=255, null=True, blank=True)
+
+    objects = UserAccountManager()
+
+    USERNAME_FIELD = 'email'
+    REQUIRED_FIELDS = ['first_name', 'last_name', 'phone_number']
+    ordering = ('email',)
+
+    def get_full_name(self):
+        return f"{self.first_name} {self.last_name}"
+
+    def get_short_name(self):
+        return self.first_name
+
+    def get_image_url(self):
+        return (f"https://res.cloudinary.com/dkcjpdk1c/image/upload/{self.image}")
+
+    @property
+    def get_photo_url(self):
+        if self.image and hasattr(self.image, 'url'):
+            return self.image.url
+        else:
+            return "https://cdn-icons-png.flaticon.com/512/147/147142.png"
+
+    def __str__(self):
+        return self.email
+
+
+class Category(models.Model):
+    name = models.CharField(max_length=50)
+
+
+class Tag(models.Model):
+    name = models.CharField(max_length=50)
+
+
+class Keyword(models.Model):
+    name = models.CharField(max_length=50)
+
+
+class Post(models.Model):
+    title = models.CharField(max_length=200)
+    content = models.TextField()
+    pub_date = models.DateTimeField(auto_now_add=True)
+    author = models.ForeignKey(
+        settings.AUTH_USER_MODEL, related_name='post_author', on_delete=models.CASCADE)
+    category = models.ForeignKey(
+        Category, related_name='post_category', on_delete=models.SET_NULL, null=True)
+    tags = models.ManyToManyField(Tag, related_name='post_tag')
+    keywords = models.ManyToManyField(Keyword, related_name='post_keyword')
+    slug = models.SlugField(max_length=250, blank=True, null=True)
+
+    def __str__(self):
+        return self.title
+
+
+class Comment(models.Model):
+    post = models.ForeignKey(Post, on_delete=models.CASCADE)
+    user = models.ForeignKey(settings.AUTH_USER_MODEL, related_name='comment_user',
+                             on_delete=models.CASCADE)
+    comment = models.TextField()
+    parent = models.ForeignKey(
+        'self', null=True, blank=True, related_name='replies', on_delete=models.CASCADE)
+    created_at = models.DateTimeField(auto_now_add=True)
+
+    def __str__(self):
+        return f"Comment by {self.user} on {self.post} at {self.created_at}"
+
+
+class Like(models.Model):
+    user = models.ForeignKey(settings.AUTH_USER_MODEL,
+                             on_delete=models.CASCADE)
+    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
+    object_id = models.PositiveIntegerField()
+    content_object = GenericForeignKey('content_type', 'object_id')
+    created_at = models.DateTimeField(auto_now_add=True)
+
+    def __str__(self):
+        return f"Like by {self.user} on {self.content_object} at {self.created_at}"

django-drf-blog-api-0.0.1/django_drf_blog_api/serializer.py

@@ -0,0 +1,76 @@
+from rest_framework import serializers
+from .models import *
+from djoser.serializers import UserCreateSerializer, UserSerializer
+from django.contrib.auth import get_user_model
+
+user = get_user_model()
+
+
+class UserCreateSerializer(UserCreateSerializer):
+    class Meta(UserCreateSerializer.Meta):
+        model = user
+        fields = ('id', 'first_name', 'last_name',
+                  'phone_number', 'email', 'password')
+
+
+class UserInfoSerializer(UserSerializer):
+    class Meta(UserSerializer.Meta):
+        model = user
+        fields = ('id', 'first_name', 'last_name', 'phone_number', 'email', 'get_photo_url', 'date_of_birth',
+                  'gender', 'home_address', 'local_govt', 'state_of_origin', 'nationality', 'image',)
+
+
+class CategorySerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Category
+        fields = "__all__"
+
+
+class TagSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Tag
+        fields = "__all__"
+
+
+class KeywordSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Keyword
+        fields = "__all__"
+
+
+class CommentSerializer(serializers.ModelSerializer):
+    user = UserInfoSerializer()
+    replies = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Comment
+        fields = ('id', 'user', 'comment', 'created_at', 'replies')
+
+    def get_replies(self, obj):
+        replies = obj.replies.all()
+        return CommentSerializer(replies, many=True).data
+
+
+class PostSerializer(serializers.ModelSerializer):
+    category = CategorySerializer()
+    comments = CommentSerializer()
+    tags = TagSerializer(many=True)
+    Keywords = KeywordSerializer(many=True)
+    author = UserInfoSerializer()
+
+    class Meta:
+        model = Post
+        fields = ('id', 'content', 'pub_date', 'slug',
+                  'category', 'tags', 'keywords', 'comments', 'author')
+
+
+class LikeSerializer(serializers.ModelSerializer):
+    user = UserInfoSerializer()
+    content_object = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Like
+        fields = ('id', 'user', 'content_object', 'created_at')
+
+    def get_content_object(self, obj):
+        return str(obj.content_object)

django-drf-blog-api-0.0.1/django_drf_blog_api/signals.py

@@ -0,0 +1,11 @@
+from django.db.models.signals import pre_save
+from .utils import unique_slug_generator
+from .models import *
+
+
+def slug_generator(sender, instance, *args, **kwargs):
+    if not instance.slug:
+        instance.slug = unique_slug_generator(instance)
+
+
+pre_save.connect(slug_generator, sender=Post)

django-drf-blog-api-0.0.1/django_drf_blog_api/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

django-drf-blog-api-0.0.1/django_drf_blog_api/urls.py

@@ -0,0 +1,11 @@
+from django.urls import path
+from .views import *
+
+urlpatterns = [
+    path('category', CategoryView.as_view()),
+    path('post-list', PostListView.as_view()),  # Public users
+    path('post-list/<slug:slug>', PostDetailView.as_view()),  # Public users
+    path('post', PostView.as_view()),  # Authors
+    path('comment', CommentView.as_view()),
+    path('like', LikeView.as_view()),
+]

django-drf-blog-api-0.0.1/django_drf_blog_api/utils.py

@@ -0,0 +1,32 @@
+import random
+import string
+
+from django.utils.text import slugify
+
+
+def random_string_generator(size=10, chars=string.ascii_lowercase + string.digits):
+    return ''.join(random.choice(chars) for _ in range(size))
+
+
+def unique_slug_generator(instance, new_slug=None):
+    """
+    This is for a Django project and it assumes your instance
+    has a model with a slug field and a title character (char) field.
+    """
+    if new_slug is not None:
+        slug = new_slug
+    else:
+        try:
+            slug = slugify(instance.title)
+        except AttributeError:
+            slug = slugify(instance.name)
+
+    Klass = instance.__class__
+    qs_exists = Klass.objects.filter(slug=slug).exists()
+    if qs_exists:
+        new_slug = "{slug}-{randstr}".format(
+            slug=slug,
+            randstr=random_string_generator(size=4)
+        )
+        return unique_slug_generator(instance, new_slug=new_slug)
+    return slug

django-drf-blog-api-0.0.1/django_drf_blog_api/views.py

@@ -0,0 +1,157 @@
+from django.shortcuts import render
+from rest_framework import generics
+from .models import *
+from .serializer import *
+from rest_framework.decorators import api_view
+from rest_framework.response import Response
+from rest_framework.authtoken.serializers import AuthTokenSerializer
+from rest_framework.permissions import AllowAny, IsAuthenticated
+from rest_framework_simplejwt.authentication import JWTAuthentication
+from djoser.views import UserViewSet
+from rest_framework.views import APIView
+from rest_framework import status
+from django.contrib.contenttypes.models import ContentType
+
+
+class PostListView(generics.ListAPIView):  # Public users
+    serializer_class = PostSerializer
+    queryset = Post.objects.all()
+    permission_classes = [AllowAny,]
+
+
+class PostDetailView(generics.RetrieveAPIView):
+    lookup_field = 'slug'
+    queryset = Post.objects.all()
+    serializer_class = PostSerializer
+    permission_classes = [AllowAny,]
+
+
+class CategoryView(generics.ListAPIView):
+    queryset = Category.objects.all()
+    serializer_class = CategorySerializer
+    permission_classes = [AllowAny,]
+
+
+class PostView(APIView):  # Authors
+    permission_classes = [IsAuthenticated,]
+
+    def get(self, request, *args, **kwargs):
+        posts = Post.objects.filter(user=self.request.user)
+        serializer = PostSerializer(posts, many=True)
+        return Response(serializer.data)
+
+    def put(self, request, *args, **kwargs):
+        post_id = request.data.get('id')
+
+        try:
+            post = Post.objects.get(
+                id=post_id, user=self.request.user)
+        except Post.DoesNotExist:
+            return Response({'error': 'Post not found.'}, status=404)
+
+        serializer = PostSerializer(post, data=request.data)
+        if serializer.is_valid():
+            serializer.save()
+            return Response(serializer.data, status=200)
+
+        return Response(serializer.errors, status=400)
+
+    def post(self, request, *args, **kwargs):
+        title = request.data.get('title')
+        content = request.data.get('content')
+        category = request.data.get('category')
+        tags = request.data.get('tags')
+        keywords = request.data.get('keywords')
+
+        if not title or not content or not category:
+            return Response({'error': 'Title, Content and Category are required fields.'}, status=status.HTTP_400_BAD_REQUEST)
+
+        try:
+            post = Post.objects.create(
+                user=request.user, title=title, content=content, category=category, tags=tags, keywords=keywords)
+
+            serializer = PostSerializer(post)
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        except Exception as e:
+            return Response({'error': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    def delete(self, request, *args, **kwargs):
+        post_id = request.data.get('id')
+        try:
+            post = Post.objects.get(id=post_id)
+            post.delete()
+            return Response(status=status.HTTP_204_NO_CONTENT)
+        except Post.DoesNotExist:
+            return Response({'error': 'Post not found'}, status=status.HTTP_404_NOT_FOUND)
+
+
+class CommentView(APIView):
+    permission_classes = [IsAuthenticated,]
+
+    def get(self, request, *args, **kwargs):
+        # Get the post_id from query parameters
+        post_id = request.GET.get('post_id')
+        if post_id is None:
+            return Response({"error": "Missing 'post_id' query parameter."}, status=400)
+
+        comments = Comment.objects.filter(post_id=post_id)
+        serializer = PostSerializer(comments, many=True)
+        return Response(serializer.data)
+
+    def put(self, request, *args, **kwargs):
+        pass
+
+    def post(self, request, *args, **kwargs):
+        comment = request.data.get('comment')
+        post_id = request.data.get('post')
+        parent_comment_id = request.data.get('parent_comment')
+
+        if not comment or not parent_comment_id or not post_id:
+            return Response({'error': 'Comment and Post_ID are required fields.'}, status=status.HTTP_400_BAD_REQUEST)
+
+        try:
+            post = Post.objects.get(id=post_id)
+
+            if parent_comment_id:
+                parent_comment = Comment.objects.get(id=parent_comment_id)
+                comment = Comment.objects.create(
+                    user=request.user, comment=comment, post=post, parent=parent_comment)
+            else:
+                comment = Comment.objects.create(
+                    user=request.user, comment=comment, post=post)
+
+            serializer = CommentSerializer(comment)
+            return Response(serializer.data, status=status.HTTP_201_CREATED)
+        except Exception as e:
+            return Response({'error': str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    def delete(self, request, *args, **kwargs):
+        pass
+
+
+class LikeView(APIView):
+    permission_classes = [IsAuthenticated]
+
+    def post(self, request, *args, **kwargs):
+        content_type = request.data.get('content_type')
+        object_id = request.data.get('object_id')
+
+        if not content_type or not object_id:
+            return Response({'error': 'content_type and object_id are required fields.'}, status=status.HTTP_400_BAD_REQUEST)
+
+        try:
+            content_type = ContentType.objects.get(model=content_type)
+        except ContentType.DoesNotExist:
+            return Response({'error': 'Invalid content_type.'}, status=status.HTTP_400_BAD_REQUEST)
+
+        like, created = Like.objects.get_or_create(
+            user=request.user,
+            content_type=content_type,
+            object_id=object_id
+        )
+
+        if created:
+            return Response({'message': 'Liked successfully.'}, status=status.HTTP_201_CREATED)
+        else:
+            like.delete()
+            return Response({'message': 'Unliked successfully.'}, status=status.HTTP_200_OK)

django-drf-blog-api-0.0.1/django_drf_blog_api.egg-info/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.1
+Name: django-drf-blog-api
+Version: 0.0.1
+Summary: A Django app blog API endpoints.
+Home-page: https://www.example.com/
+Author: Osiota Samuel Obrozie
+Author-email: osiotaobrozie@gmail.com
+License: BSD-3-Clause  # Example license
+Platform: UNKNOWN
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.0
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+
+# django-drf-blog-api
+
+
+django-drf-blog-api is a Django blog API app
+
+
+
+## Quick start
+
+
+1. Add "Blog" to your INSTALLED_APPS setting like this::
+
+    INSTALLED_APPS = [
+        ...,
+        "django-drf-blog-api",
+    ]
+```
+2. Include the polls URLconf in your project urls.py like this::
+
+    path("blog/", include("django-drf-blog-api.urls")),
+
+3. Run ``python manage.py migrate`` to create the models.
+
+4. Start the development server and visit the admin to create a poll.
+
+5. Visit the ``/blog/`` URL to participate in the poll.
+

django-drf-blog-api-0.0.1/django_drf_blog_api.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+LICENSE
+MANIFEST.in
+README.rst
+pyproject.toml
+setup.cfg
+setup.py
+django_drf_blog_api/__init__.py
+django_drf_blog_api/admin.py
+django_drf_blog_api/apps.py
+django_drf_blog_api/forms.py
+django_drf_blog_api/models.py
+django_drf_blog_api/serializer.py
+django_drf_blog_api/signals.py
+django_drf_blog_api/tests.py
+django_drf_blog_api/urls.py
+django_drf_blog_api/utils.py
+django_drf_blog_api/views.py
+django_drf_blog_api.egg-info/PKG-INFO
+django_drf_blog_api.egg-info/SOURCES.txt
+django_drf_blog_api.egg-info/dependency_links.txt
+django_drf_blog_api.egg-info/requires.txt
+django_drf_blog_api.egg-info/top_level.txt
+django_drf_blog_api/migrations/__init__.py

django-drf-blog-api-0.0.1/django_drf_blog_api.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

django-drf-blog-api-0.0.1/django_drf_blog_api.egg-info/requires.txt

@@ -0,0 +1 @@
+Django>=5.0

django-drf-blog-api-0.0.1/django_drf_blog_api.egg-info/top_level.txt

@@ -0,0 +1 @@
+django_drf_blog_api

django-drf-blog-api-0.0.1/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ['setuptools>=40.8.0']
+build-backend = 'setuptools.build_meta'

django-drf-blog-api-0.0.1/setup.cfg

@@ -0,0 +1,36 @@
+[metadata]
+name = django-drf-blog-api
+version = 0.0.1
+description = A Django app blog API endpoints.
+long_description = file: README.rst
+url = https://www.example.com/
+author = Osiota Samuel Obrozie
+author_email = osiotaobrozie@gmail.com
+license = BSD-3-Clause  # Example license
+classifiers = 
+	Environment :: Web Environment
+	Framework :: Django
+	Framework :: Django :: 5.0
+	Intended Audience :: Developers
+	License :: OSI Approved :: BSD License
+	Operating System :: OS Independent
+	Programming Language :: Python
+	Programming Language :: Python :: 3
+	Programming Language :: Python :: 3 :: Only
+	Programming Language :: Python :: 3.10
+	Programming Language :: Python :: 3.11
+	Programming Language :: Python :: 3.12
+	Topic :: Internet :: WWW/HTTP
+	Topic :: Internet :: WWW/HTTP :: Dynamic Content
+
+[options]
+include_package_data = true
+packages = find:
+python_requires = >=3.10
+install_requires = 
+	Django >= 5.0
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

django-drf-blog-api-0.0.1/setup.py

@@ -0,0 +1,13 @@
+from setuptools import setup
+
+# read the contents of your README file
+from pathlib import Path
+this_directory = Path(__file__).parent
+long_description = (this_directory / "README.rst").read_text()
+
+setup(
+    name='django-drf-blog-api',
+    # other arguments omitted
+    long_description=long_description,
+    long_description_content_type='text/markdown'
+)