ai-first-cli 1.3.1 → 1.3.6

package/test-projects/django-app/blog/models.py

@@ -1,55 +0,0 @@
-"""Blog application models."""
-
-from django.db import models
-from django.contrib.auth.models import User
-
-
-class Post(models.Model):
-    """Blog post model."""
-
-    title = models.CharField(max_length=200)
-    content = models.TextField()
-    author = models.ForeignKey(User, on_delete=models.CASCADE, related_name="posts")
-    created_at = models.DateTimeField(auto_now_add=True)
-    updated_at = models.DateTimeField(auto_now=True)
-    published = models.BooleanField(default=False)
-
-    class Meta:
-        ordering = ["-created_at"]
-
-    def __str__(self):
-        return self.title
-
-    def publish(self):
-        """Publish the post."""
-        self.published = True
-        self.save()
-
-
-class Comment(models.Model):
-    """Comment model for blog posts."""
-
-    post = models.ForeignKey(Post, on_delete=models.CASCADE, related_name="comments")
-    author = models.ForeignKey(User, on_delete=models.CASCADE, related_name="comments")
-    content = models.TextField()
-    created_at = models.DateTimeField(auto_now_add=True)
-
-    class Meta:
-        ordering = ["-created_at"]
-
-    def __str__(self):
-        return f"Comment by {self.author.username} on {self.post.title}"
-
-
-class Category(models.Model):
-    """Category model for organizing posts."""
-
-    name = models.CharField(max_length=100, unique=True)
-    description = models.TextField(blank=True)
-    posts = models.ManyToManyField(Post, related_name="categories", blank=True)
-
-    class Meta:
-        verbose_name_plural = "categories"
-
-    def __str__(self):
-        return self.name

package/test-projects/django-app/blog/serializers.py

@@ -1,69 +0,0 @@
-"""Blog application serializers."""
-
-from rest_framework import serializers
-from django.contrib.auth.models import User
-from .models import Post, Comment, Category
-
-
-class CategorySerializer(serializers.ModelSerializer):
-    """Serializer for Category model."""
-
-    class Meta:
-        model = Category
-        fields = ["id", "name", "description"]
-
-
-class CommentSerializer(serializers.ModelSerializer):
-    """Serializer for Comment model."""
-
-    author_username = serializers.CharField(source="author.username", read_only=True)
-
-    class Meta:
-        model = Comment
-        fields = ["id", "post", "author", "author_username", "content", "created_at"]
-        read_only_fields = ["author"]
-
-
-class PostSerializer(serializers.ModelSerializer):
-    """Serializer for Post model."""
-
-    author_username = serializers.CharField(source="author.username", read_only=True)
-    comments_count = serializers.IntegerField(source="comments.count", read_only=True)
-    categories = CategorySerializer(many=True, read_only=True)
-
-    class Meta:
-        model = Post
-        fields = [
-            "id",
-            "title",
-            "content",
-            "author",
-            "author_username",
-            "created_at",
-            "updated_at",
-            "published",
-            "comments_count",
-            "categories",
-        ]
-        read_only_fields = ["author"]
-
-
-class PostCreateUpdateSerializer(serializers.ModelSerializer):
-    """Serializer for creating and updating posts."""
-
-    category_ids = serializers.ListField(
-        child=serializers.IntegerField(), write_only=True, required=False
-    )
-
-    class Meta:
-        model = Post
-        fields = ["id", "title", "content", "published", "category_ids"]
-
-    def create(self, validated_data):
-        """Create a new post with categories."""
-        category_ids = validated_data.pop("category_ids", [])
-        post = Post.objects.create(**validated_data)
-        if category_ids:
-            categories = Category.objects.filter(id__in=category_ids)
-            post.categories.set(categories)
-        return post

package/test-projects/django-app/blog/urls.py

@@ -1,14 +0,0 @@
-"""Blog application URL configuration."""
-
-from django.urls import path, include
-from rest_framework.routers import DefaultRouter
-from .views import PostViewSet, CommentViewSet, CategoryViewSet
-
-router = DefaultRouter()
-router.register(r"posts", PostViewSet)
-router.register(r"comments", CommentViewSet)
-router.register(r"categories", CategoryViewSet)
-
-urlpatterns = [
-    path("", include(router.urls)),
-]

package/test-projects/django-app/blog/views.py

@@ -1,96 +0,0 @@
-"""Blog application views."""
-
-from rest_framework import viewsets, status
-from rest_framework.decorators import action
-from rest_framework.response import Response
-from rest_framework.permissions import IsAuthenticated, AllowAny
-from django.contrib.auth.models import User
-from .models import Post, Comment, Category
-from .serializers import (
-    PostSerializer,
-    PostCreateUpdateSerializer,
-    CommentSerializer,
-    CategorySerializer,
-)
-
-
-class PostViewSet(viewsets.ModelViewSet):
-    """ViewSet for blog posts."""
-
-    queryset = Post.objects.all()
-    permission_classes = [IsAuthenticated]
-
-    def get_serializer_class(self):
-        """Return appropriate serializer class."""
-        if self.action in ["create", "update", "partial_update"]:
-            return PostCreateUpdateSerializer
-        return PostSerializer
-
-    def get_permissions(self):
-        """Allow anyone to view published posts."""
-        if self.action in ["list", "retrieve"]:
-            return [AllowAny()]
-        return [IsAuthenticated()]
-
-    def perform_create(self, serializer):
-        """Set the author to the current user."""
-        serializer.save(author=self.request.user)
-
-    @action(detail=True, methods=["post"])
-    def publish(self, request, pk=None):
-        """Publish a blog post."""
-        post = self.get_object()
-        post.publish()
-        return Response({"status": "post published"})
-
-    @action(detail=False, methods=["get"])
-    def my_posts(self, request):
-        """Get posts by current user."""
-        posts = Post.objects.filter(author=request.user)
-        serializer = PostSerializer(posts, many=True)
-        return Response(serializer.data)
-
-    @action(detail=False, methods=["get"])
-    def published(self, request):
-        """Get all published posts."""
-        posts = Post.objects.filter(published=True)
-        serializer = PostSerializer(posts, many=True)
-        return Response(serializer.data)
-
-
-class CommentViewSet(viewsets.ModelViewSet):
-    """ViewSet for comments."""
-
-    queryset = Comment.objects.all()
-    serializer_class = CommentSerializer
-    permission_classes = [IsAuthenticated]
-
-    def perform_create(self, serializer):
-        """Set the author to the current user."""
-        serializer.save(author=self.request.user)
-
-    def get_queryset(self):
-        """Filter comments by post if provided."""
-        queryset = Comment.objects.all()
-        post_id = self.request.query_params.get("post", None)
-        if post_id:
-            queryset = queryset.filter(post_id=post_id)
-        return queryset
-
-
-class CategoryViewSet(viewsets.ModelViewSet):
-    """ViewSet for categories."""
-
-    queryset = Category.objects.all()
-    serializer_class = CategorySerializer
-    permission_classes = [AllowAny]
-
-    @action(detail=True, methods=["get"])
-    def posts(self, request, pk=None):
-        """Get posts in this category."""
-        category = self.get_object()
-        posts = category.posts.filter(published=True)
-        from .serializers import PostSerializer
-
-        serializer = PostSerializer(posts, many=True)
-        return Response(serializer.data)

package/test-projects/django-app/django_app/settings.py

@@ -1,90 +0,0 @@
-"""
-Django settings for django_app project.
-"""
-
-from pathlib import Path
-
-BASE_DIR = Path(__file__).resolve().parent.parent
-
-SECRET_KEY = "django-insecure-test-key-not-for-production"
-
-DEBUG = True
-
-ALLOWED_HOSTS = ["localhost", "127.0.0.1"]
-
-INSTALLED_APPS = [
-    "django.contrib.admin",
-    "django.contrib.auth",
-    "django.contrib.contenttypes",
-    "django.contrib.sessions",
-    "django.contrib.messages",
-    "django.contrib.staticfiles",
-    "rest_framework",
-    "blog",
-    "users",
-]
-
-MIDDLEWARE = [
-    "django.middleware.security.SecurityMiddleware",
-    "django.contrib.sessions.middleware.SessionMiddleware",
-    "django.middleware.common.CommonMiddleware",
-    "django.middleware.csrf.CsrfViewMiddleware",
-    "django.contrib.auth.middleware.AuthenticationMiddleware",
-    "django.contrib.messages.middleware.MessageMiddleware",
-    "django.middleware.clickjacking.XFrameOptionsMiddleware",
-]
-
-ROOT_URLCONF = "django_app.urls"
-
-TEMPLATES = [
-    {
-        "BACKEND": "django.template.backends.django.DjangoTemplates",
-        "DIRS": [],
-        "APP_DIRS": True,
-        "OPTIONS": {
-            "context_processors": [
-                "django.template.context_processors.debug",
-                "django.template.context_processors.request",
-                "django.contrib.auth.context_processors.auth",
-                "django.contrib.messages.context_processors.messages",
-            ],
-        },
-    },
-]
-
-WSGI_APPLICATION = "django_app.wsgi.application"
-
-DATABASES = {
-    "default": {
-        "ENGINE": "django.db.backends.sqlite3",
-        "NAME": BASE_DIR / "db.sqlite3",
-    }
-}
-
-AUTH_PASSWORD_VALIDATORS = [
-    {
-        "NAME": "django.contrib.auth.password_validation.UserAttributeSimilarityValidator",
-    },
-    {
-        "NAME": "django.contrib.auth.password_validation.MinimumLengthValidator",
-    },
-]
-
-LANGUAGE_CODE = "en-us"
-TIME_ZONE = "UTC"
-USE_I18N = True
-USE_TZ = True
-
-STATIC_URL = "static/"
-
-DEFAULT_AUTO_FIELD = "django.db.models.BigAutoField"
-
-REST_FRAMEWORK = {
-    "DEFAULT_AUTHENTICATION_CLASSES": [
-        "rest_framework.authentication.SessionAuthentication",
-        "rest_framework.authentication.TokenAuthentication",
-    ],
-    "DEFAULT_PERMISSION_CLASSES": [
-        "rest_framework.permissions.IsAuthenticated",
-    ],
-}

package/test-projects/django-app/django_app/urls.py

@@ -1,11 +0,0 @@
-"""django_app URL configuration."""
-
-from django.contrib import admin
-from django.urls import path, include
-
-urlpatterns = [
-    path("admin/", admin.site.urls),
-    path("api/blog/", include("blog.urls")),
-    path("api/users/", include("users.urls")),
-    path("api-auth/", include("rest_framework.urls")),
-]

package/test-projects/django-app/django_app/wsgi.py

@@ -1,9 +0,0 @@
-"""WSGI config for django_app project."""
-
-import os
-
-from django.core.wsgi import get_wsgi_application
-
-os.environ.setdefault("DJANGO_SETTINGS_MODULE", "django_app.settings")
-
-application = get_wsgi_application()

package/test-projects/django-app/manage.py

@@ -1,23 +0,0 @@
-#!/usr/bin/env python
-"""Django's command-line utility for administrative tasks."""
-
-import os
-import sys
-
-
-def main():
-    """Run administrative tasks."""
-    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "django_app.settings")
-    try:
-        from django.core.management import execute_from_command_line
-    except ImportError as exc:
-        raise ImportError(
-            "Couldn't import Django. Are you sure it's installed and "
-            "available on your PYTHONPATH environment variable? Did you "
-            "forget to activate a virtual environment?"
-        ) from exc
-    execute_from_command_line(sys.argv)
-
-
-if __name__ == "__main__":
-    main()

package/test-projects/django-app/requirements.txt

@@ -1,3 +0,0 @@
-Django>=4.2.0,<5.0
-djangorestframework>=3.14.0
-Pillow>=10.0.0

package/test-projects/django-app/users/admin.py

@@ -1,42 +0,0 @@
-"""Users application admin configuration."""
-
-from django.contrib import admin
-from django.contrib.auth.admin import UserAdmin as BaseUserAdmin
-from django.contrib.auth.models import User
-from .models import UserProfile, Follow
-
-
-class UserProfileInline(admin.StackedInline):
-    """Inline admin for UserProfile."""
-
-    model = UserProfile
-    can_delete = False
-    verbose_name_plural = "Profile"
-
-
-class UserAdmin(BaseUserAdmin):
-    """Extended User admin with profile."""
-
-    inlines = [UserProfileInline]
-    list_display = [
-        "username",
-        "email",
-        "first_name",
-        "last_name",
-        "is_staff",
-        "date_joined",
-    ]
-
-
-# Re-register UserAdmin
-admin.site.unregister(User)
-admin.site.register(User, UserAdmin)
-
-
-@admin.register(Follow)
-class FollowAdmin(admin.ModelAdmin):
-    """Admin configuration for Follow model."""
-
-    list_display = ["follower", "following", "created_at"]
-    list_filter = ["created_at"]
-    search_fields = ["follower__username", "following__username"]

package/test-projects/django-app/users/models.py

@@ -1,54 +0,0 @@
-"""Users application models."""
-
-from django.db import models
-from django.contrib.auth.models import User
-from django.db.models.signals import post_save
-from django.dispatch import receiver
-
-
-class UserProfile(models.Model):
-    """Extended user profile model."""
-
-    user = models.OneToOneField(User, on_delete=models.CASCADE, related_name="profile")
-    bio = models.TextField(max_length=500, blank=True)
-    location = models.CharField(max_length=100, blank=True)
-    birth_date = models.DateField(null=True, blank=True)
-    avatar = models.ImageField(upload_to="avatars/", blank=True)
-    website = models.URLField(blank=True)
-    twitter = models.CharField(max_length=100, blank=True)
-    github = models.CharField(max_length=100, blank=True)
-
-    def __str__(self):
-        return f"{self.user.username} Profile"
-
-
-@receiver(post_save, sender=User)
-def create_user_profile(sender, instance, created, **kwargs):
-    """Create a user profile when a new user is created."""
-    if created:
-        UserProfile.objects.create(user=instance)
-
-
-@receiver(post_save, sender=User)
-def save_user_profile(sender, instance, **kwargs):
-    """Save user profile when user is saved."""
-    instance.profile.save()
-
-
-class Follow(models.Model):
-    """Follow relationship model."""
-
-    follower = models.ForeignKey(
-        User, on_delete=models.CASCADE, related_name="following"
-    )
-    following = models.ForeignKey(
-        User, on_delete=models.CASCADE, related_name="followers"
-    )
-    created_at = models.DateTimeField(auto_now_add=True)
-
-    class Meta:
-        unique_together = ["follower", "following"]
-        ordering = ["-created_at"]
-
-    def __str__(self):
-        return f"{self.follower.username} follows {self.following.username}"

package/test-projects/django-app/users/serializers.py

@@ -1,113 +0,0 @@
-"""Users application serializers."""
-
-from rest_framework import serializers
-from django.contrib.auth.models import User
-from .models import UserProfile, Follow
-
-
-class UserProfileSerializer(serializers.ModelSerializer):
-    """Serializer for UserProfile model."""
-
-    class Meta:
-        model = UserProfile
-        fields = [
-            "bio",
-            "location",
-            "birth_date",
-            "avatar",
-            "website",
-            "twitter",
-            "github",
-        ]
-
-
-class UserSerializer(serializers.ModelSerializer):
-    """Serializer for User model."""
-
-    profile = UserProfileSerializer()
-    posts_count = serializers.IntegerField(source="posts.count", read_only=True)
-    followers_count = serializers.IntegerField(source="followers.count", read_only=True)
-    following_count = serializers.IntegerField(source="following.count", read_only=True)
-
-    class Meta:
-        model = User
-        fields = [
-            "id",
-            "username",
-            "email",
-            "first_name",
-            "last_name",
-            "profile",
-            "posts_count",
-            "followers_count",
-            "following_count",
-            "date_joined",
-        ]
-        read_only_fields = ["date_joined"]
-
-
-class UserCreateSerializer(serializers.ModelSerializer):
-    """Serializer for creating new users."""
-
-    password = serializers.CharField(write_only=True)
-    password_confirm = serializers.CharField(write_only=True)
-
-    class Meta:
-        model = User
-        fields = [
-            "username",
-            "email",
-            "password",
-            "password_confirm",
-            "first_name",
-            "last_name",
-        ]
-
-    def validate(self, data):
-        """Validate that passwords match."""
-        if data["password"] != data["password_confirm"]:
-            raise serializers.ValidationError("Passwords don't match")
-        return data
-
-    def create(self, validated_data):
-        """Create a new user."""
-        validated_data.pop("password_confirm")
-        user = User.objects.create_user(**validated_data)
-        return user
-
-
-class FollowSerializer(serializers.ModelSerializer):
-    """Serializer for Follow model."""
-
-    follower_username = serializers.CharField(
-        source="follower.username", read_only=True
-    )
-    following_username = serializers.CharField(
-        source="following.username", read_only=True
-    )
-
-    class Meta:
-        model = Follow
-        fields = [
-            "id",
-            "follower",
-            "follower_username",
-            "following",
-            "following_username",
-            "created_at",
-        ]
-        read_only_fields = ["follower"]
-
-
-class ChangePasswordSerializer(serializers.Serializer):
-    """Serializer for password change."""
-
-    old_password = serializers.CharField(required=True)
-    new_password = serializers.CharField(required=True)
-    new_password_confirm = serializers.CharField(required=True)
-
-    def validate(self, data):
-        """Validate new passwords match."""
-        if data["new_password"] != data["new_password_confirm"]:
-            raise serializers.ValidationError("New passwords don't match")
-        return data

package/test-projects/django-app/users/urls.py

@@ -1,13 +0,0 @@
-"""Users application URL configuration."""
-
-from django.urls import path, include
-from rest_framework.routers import DefaultRouter
-from .views import UserViewSet, UserProfileViewSet
-
-router = DefaultRouter()
-router.register(r"users", UserViewSet)
-router.register(r"profiles", UserProfileViewSet)
-
-urlpatterns = [
-    path("", include(router.urls)),
-]