sandwitches 2.2.0__py3-none-any.whl

sandwitches/__init__.py

@@ -0,0 +1,6 @@
+"""Top-level package for sandwitches."""
+
+from importlib.metadata import version
+
+__version__ = version("sandwitches")  # Matches the 'name' in pyproject.toml
+__author__ = """Martyn van Dijke"""

sandwitches/admin.py

@@ -0,0 +1,69 @@
+from django.contrib import admin
+from django.contrib.auth import get_user_model
+from django.contrib.auth.admin import UserAdmin
+from .models import Recipe, Tag, Rating, Setting
+from django.utils.html import format_html
+from import_export import resources
+from import_export.admin import ImportExportModelAdmin
+from solo.admin import SingletonModelAdmin
+from .forms import SettingForm
+
+
+class RecipeResource(resources.ModelResource):
+    class Meta:
+        model = Recipe
+
+
+class TagResource(resources.ModelResource):
+    class Meta:
+        model = Tag
+
+
+class RatingResource(resources.ModelResource):
+    class Meta:
+        model = Rating
+
+
+User = get_user_model()
+
+
+@admin.register(Setting)
+class SettingAdmin(SingletonModelAdmin):
+    form = SettingForm
+
+
+@admin.register(User)
+class CustomUserAdmin(UserAdmin):
+    fieldsets = UserAdmin.fieldsets + (
+        (None, {"fields": ("avatar", "bio", "language", "favorites")}),
+    )
+
+
+@admin.register(Recipe)
+class RecipeAdmin(ImportExportModelAdmin):
+    resource_classes = [RecipeResource]
+    list_display = ("title", "uploaded_by", "created_at", "is_highlighted", "show_url")
+    list_editable = ("is_highlighted",)
+    readonly_fields = ("created_at", "updated_at")
+
+    def save_model(self, request, obj, form, change):
+        # set uploaded_by automatically when creating in admin
+        if not change and not obj.uploaded_by:
+            obj.uploaded_by = request.user
+        super().save_model(request, obj, form, change)
+
+    def show_url(self, obj):
+        url = obj.get_absolute_url()
+        return format_html("<a href='{url}'>{url}</a>", url=url)
+
+    show_url.short_description = "Recipe Link"  # ty:ignore[unresolved-attribute]
+
+
+@admin.register(Tag)
+class TagAdmin(ImportExportModelAdmin):
+    resource_classes = [TagResource]
+
+
+@admin.register(Rating)
+class RatingAdmin(ImportExportModelAdmin):
+    resource_classes = [RatingResource]

sandwitches/api.py

@@ -0,0 +1,207 @@
+import logging
+from ninja import NinjaAPI
+from .models import Recipe, Tag, Setting, Rating
+from django.contrib.auth import get_user_model
+from .utils import (
+    parse_ingredient_line,
+    scale_ingredient,
+    format_scaled_ingredient,
+)  # Import utility functions
+
+from ninja import ModelSchema
+from ninja import Schema
+from django.shortcuts import get_object_or_404
+from datetime import date
+import random
+from typing import List, Optional  # Import typing hints
+
+from ninja.security import django_auth
+
+from . import __version__
+
+# Get the custom User model
+User = get_user_model()
+
+api = NinjaAPI(version=__version__)
+
+
+class UserPublicSchema(ModelSchema):
+    class Meta:
+        model = User
+        fields = ["username", "first_name", "last_name", "avatar"]
+
+
+class RecipeSchema(ModelSchema):
+    favorited_by: List[UserPublicSchema] = []
+
+    class Meta:
+        model = Recipe
+        fields = "__all__"
+
+
+class TagSchema(ModelSchema):
+    class Meta:
+        model = Tag
+        fields = "__all__"
+
+
+class UserSchema(ModelSchema):
+    class Meta:
+        model = User
+        exclude = ["password", "last_login", "user_permissions"]
+
+
+class SettingSchema(ModelSchema):
+    class Meta:
+        model = Setting
+        fields = "__all__"
+
+
+class RatingSchema(ModelSchema):
+    user: UserPublicSchema
+
+    class Meta:
+        model = Rating
+        fields = "__all__"
+
+
+class Error(Schema):
+    message: str
+
+
+class RatingResponseSchema(Schema):
+    average: float
+    count: int
+
+
+class ScaledIngredient(Schema):  # New Schema for scaled ingredients
+    original_line: str
+    scaled_line: str
+    quantity: Optional[float]
+    unit: Optional[str]
+    name: Optional[str]
+
+
+@api.get("ping")
+def ping(request):
+    return {"status": "ok", "message": "pong"}
+
+
+@api.get("v1/settings", response=SettingSchema)
+def get_settings(request):
+    return Setting.objects.get()  # ty:ignore[unresolved-attribute]
+
+
+@api.post("v1/settings", auth=django_auth, response={200: SettingSchema, 403: Error})
+def update_settings(request, payload: SettingSchema):
+    if not request.user.is_staff:
+        return 403, {"message": "You are not authorized to perform this action"}
+    settings = Setting.objects.get()  # ty:ignore[unresolved-attribute]
+    for attr, value in payload.dict().items():
+        setattr(settings, attr, value)
+    settings.save()
+    return settings
+
+
+@api.get("v1/me", response={200: UserSchema, 403: Error})
+def me(request):
+    if not request.user.is_authenticated:
+        return 403, {"message": "Please sign in first"}
+    return request.user
+
+
+@api.get("v1/users", auth=django_auth, response=list[UserSchema])
+def users(request):
+    return User.objects.all()
+
+
+@api.get("v1/recipes", response=list[RecipeSchema])
+def get_recipes(request):
+    return Recipe.objects.all().prefetch_related("favorited_by")  # ty:ignore[unresolved-attribute]
+
+
+@api.get("v1/recipes/{recipe_id}", response=RecipeSchema)
+def get_recipe(request, recipe_id: int):
+    recipe = get_object_or_404(
+        Recipe.objects.prefetch_related("favorited_by"),  # ty:ignore[unresolved-attribute]
+        id=recipe_id,
+    )
+    return recipe
+
+
+@api.get("v1/recipes/{recipe_id}/scale-ingredients", response=List[ScaledIngredient])
+def scale_recipe_ingredients(request, recipe_id: int, target_servings: int):
+    recipe = get_object_or_404(Recipe, id=recipe_id)
+
+    # Ensure target_servings is at least 1
+    target_servings = max(1, target_servings)
+
+    current_servings = recipe.servings
+    if not current_servings or current_servings <= 0:
+        current_servings = 1
+
+    ingredient_lines = [
+        line.strip() for line in (recipe.ingredients or "").split("\n") if line.strip()
+    ]
+
+    scaled_ingredients_output = []
+    for line in ingredient_lines:
+        try:
+            parsed = parse_ingredient_line(line)
+            scaled = scale_ingredient(parsed, current_servings, target_servings)
+            formatted_line = format_scaled_ingredient(scaled)
+
+            scaled_ingredients_output.append(
+                ScaledIngredient(
+                    original_line=line,
+                    scaled_line=formatted_line,
+                    quantity=scaled.get("quantity"),
+                    unit=scaled.get("unit"),
+                    name=scaled.get("name"),
+                )
+            )
+        except Exception as e:
+            # Fallback for lines that fail to parse/scale
+            scaled_ingredients_output.append(
+                ScaledIngredient(
+                    original_line=line,
+                    scaled_line=line,
+                    quantity=None,
+                    unit=None,
+                    name=line,
+                )
+            )
+            logging.warning(f"Failed to scale ingredient line '{line}': {e}")
+
+    return scaled_ingredients_output
+
+
+@api.get("v1/recipe-of-the-day", response=RecipeSchema)
+def get_recipe_of_the_day(request):
+    recipes = list(Recipe.objects.all().prefetch_related("favorited_by"))  # ty:ignore[unresolved-attribute]
+    if not recipes:
+        return None
+    today = date.today()
+    random.seed(today.toordinal())
+    recipe = random.choice(recipes)
+    return recipe
+
+
+@api.get("v1/recipes/{recipe_id}/rating", response=RatingResponseSchema)
+def get_recipe_rating(request, recipe_id: int):
+    recipe = get_object_or_404(Recipe, id=recipe_id)
+    return {
+        "average": recipe.average_rating(),
+        "count": recipe.rating_count(),
+    }
+
+
+@api.get("v1/tags", response=list[TagSchema])
+def get_tags(request):
+    return Tag.objects.all()  # ty:ignore[unresolved-attribute]
+
+
+@api.get("v1/tags/{tag_id}", response=TagSchema)
+def get_tag(request, tag_id: int):
+    tag = get_object_or_404(Tag, id=tag_id)
+    return tag

sandwitches/asgi.py

@@ -0,0 +1,16 @@
+"""
+ASGI config for sandwitches project.
+
+It exposes the ASGI callable as a module-level variable named ``application``.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/5.2/howto/deployment/asgi/
+"""
+
+import os
+
+from django.core.asgi import get_asgi_application
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "sandwitches.settings")
+
+application = get_asgi_application()

sandwitches/feeds.py

@@ -0,0 +1,23 @@
+from django.contrib.syndication.views import Feed
+from django.urls import reverse_lazy
+from .models import Recipe
+
+
+class LatestRecipesFeed(Feed):
+    title = "Sandwitches - Latest Recipes"
+    link = reverse_lazy(
+        "index"
+    )  # This should point to the homepage or a list of recipes
+    description = "Updates on the newest recipes added to Sandwitches."
+
+    def items(self):
+        return Recipe.objects.order_by("-created_at")[:5]  # ty:ignore[unresolved-attribute]
+
+    def item_title(self, item):
+        return item.title
+
+    def item_description(self, item):
+        return item.description
+
+    def item_link(self, item):
+        return item.get_absolute_url()

sandwitches/forms.py

@@ -0,0 +1,196 @@
+from django import forms
+from django.conf import settings
+from django.contrib.auth import get_user_model
+from django.contrib.auth.forms import UserCreationForm
+from django.utils.translation import gettext_lazy as _
+from .models import Recipe, Tag, Setting
+
+User = get_user_model()
+
+
+class BaseUserFormMixin:
+    """Mixin to handle common password validation and user field processing."""
+
+    def clean_passwords(self, cleaned_data):
+        p1 = cleaned_data.get("password1")
+        p2 = cleaned_data.get("password2")
+        if p1 and p2 and p1 != p2:
+            raise forms.ValidationError(_("Passwords do not match."))
+        return cleaned_data
+
+    def _set_user_attributes(self, user, data):
+        """Helper to apply optional name fields."""
+        user.first_name = data.get("first_name", "")
+        user.last_name = data.get("last_name", "")
+        user.save()
+        return user
+
+
+class AdminSetupForm(forms.ModelForm, BaseUserFormMixin):
+    password1 = forms.CharField(widget=forms.PasswordInput, label=_("Password"))
+    password2 = forms.CharField(widget=forms.PasswordInput, label=_("Confirm Password"))
+
+    class Meta:
+        model = User
+        fields = ("username", "first_name", "last_name", "email")
+
+    def clean(self):
+        cleaned_data = super().clean()
+        return self.clean_passwords(cleaned_data)
+
+    def save(self, commit=True):
+        data = self.cleaned_data
+        user = User.objects.create_superuser(
+            username=data["username"], email=data["email"], password=data["password1"]
+        )
+        return self._set_user_attributes(user, data)
+
+
+class UserSignupForm(UserCreationForm, BaseUserFormMixin):
+    language = forms.ChoiceField(
+        choices=settings.LANGUAGES,
+        label=_("Preferred language"),
+        initial=settings.LANGUAGE_CODE,
+    )
+    avatar = forms.ImageField(label=_("Profile Image"), required=False)
+    bio = forms.CharField(
+        widget=forms.Textarea(attrs={"rows": 3}), label=_("Bio"), required=False
+    )
+
+    class Meta(UserCreationForm.Meta):
+        model = User
+        fields = (
+            "username",
+            "first_name",
+            "last_name",
+            "email",
+            "language",
+            "avatar",
+            "bio",
+        )
+
+    def clean(self):
+        return super().clean()
+
+    def save(self, commit=True):
+        user = super().save(commit=False)
+        user.is_superuser = False
+        user.is_staff = False
+        # Explicitly save the extra fields if they aren't automatically handled by ModelForm save (they should be if in Meta.fields)
+        user.language = self.cleaned_data["language"]
+        user.avatar = self.cleaned_data["avatar"]
+        user.bio = self.cleaned_data["bio"]
+        if commit:
+            user.save()
+        return user
+
+
+class UserEditForm(forms.ModelForm):
+    class Meta:
+        model = User
+        fields = (
+            "username",
+            "first_name",
+            "last_name",
+            "email",
+            "is_staff",
+            "is_active",
+            "language",
+            "avatar",
+            "bio",
+        )
+
+
+class TagForm(forms.ModelForm):
+    class Meta:
+        model = Tag
+        fields = ("name",)
+
+
+class RecipeForm(forms.ModelForm):
+    tags_string = forms.CharField(
+        required=False,
+        label=_("Tags (comma separated)"),
+        widget=forms.TextInput(attrs={"placeholder": _("e.g. spicy, vegan, quick")}),
+    )
+    rotation = forms.IntegerField(widget=forms.HiddenInput(), initial=0, required=False)
+
+    class Meta:
+        model = Recipe
+        fields = [
+            "title",
+            "image",
+            "uploaded_by",
+            "description",
+            "ingredients",
+            "instructions",
+        ]
+        widgets = {
+            "image": forms.FileInput(),
+        }
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if self.instance.pk:
+            self.fields["tags_string"].initial = ", ".join(
+                self.instance.tags.values_list("name", flat=True)
+            )
+
+    def save(self, commit=True):
+        recipe = super().save(commit=commit)
+
+        # Handle rotation if an image exists and rotation is requested
+        rotation = self.cleaned_data.get("rotation", 0)
+        if rotation != 0 and recipe.image:
+            try:
+                from PIL import Image as PILImage
+
+                img = PILImage.open(recipe.image.path)
+                # PIL rotates counter-clockwise by default, our 'rotation' is clockwise
+                img = img.rotate(-rotation, expand=True)
+                img.save(recipe.image.path)
+            except Exception as e:
+                print(f"Error rotating image: {e}")
+
+        if commit:
+            recipe.set_tags_from_string(self.cleaned_data.get("tags_string", ""))
+        else:
+            # We'll need to handle this in the view if commit=False
+            self.save_m2m = lambda: recipe.set_tags_from_string(
+                self.cleaned_data.get("tags_string", "")
+            )
+        return recipe
+
+
+class RatingForm(forms.Form):
+    """Form for rating recipes (0-10) with an optional comment."""
+
+    score = forms.FloatField(
+        min_value=0.0,
+        max_value=10.0,
+        widget=forms.NumberInput(
+            attrs={"step": "0.1", "min": "0", "max": "10", "class": "slider"}
+        ),
+        label=_("Your rating"),
+    )
+    comment = forms.CharField(
+        widget=forms.Textarea(attrs={"rows": 2}),
+        label=_("Comment (optional)"),
+        required=False,
+    )
+
+
+class SettingForm(forms.ModelForm):
+    class Meta:
+        model = Setting
+        fields = [
+            "site_name",
+            "site_description",
+            "email",
+            "ai_connection_point",
+            "ai_model",
+            "ai_api_key",
+        ]
+        widgets = {
+            "ai_api_key": forms.PasswordInput(render_value=True),
+        }