sandwitches 1.4.2__py3-none-any.whl → 1.5.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

@@ -1,8 +1,12 @@
 from django.contrib import admin
-from .models import Recipe, Tag, Rating
+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):
@@ -20,6 +24,21 @@ class RatingResource(resources.ModelResource):
         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]
@@ -36,7 +55,7 @@ class RecipeAdmin(ImportExportModelAdmin):
         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, inconsistent-mro]
+    show_url.short_description = "Recipe Link"  # ty:ignore[unresolved-attribute]
 
 
 @admin.register(Tag)

sandwitches/api.py

@@ -1,21 +1,39 @@
+import logging
 from ninja import NinjaAPI
-from .models import Recipe, Tag
+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.contrib.auth.models import User
 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 __init__ import __version__
+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__"
@@ -33,6 +51,20 @@ class UserSchema(ModelSchema):
         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
 
@@ -42,11 +74,35 @@ class RatingResponseSchema(Schema):
     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:
@@ -61,18 +117,68 @@ def users(request):
 
 @api.get("v1/recipes", response=list[RecipeSchema])
 def get_recipes(request):
-    return Recipe.objects.all()  # ty:ignore[unresolved-attribute]
+    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, id=recipe_id)
+    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())  # ty:ignore[unresolved-attribute]
+    recipes = list(Recipe.objects.all().prefetch_related("favorited_by"))  # ty:ignore[unresolved-attribute]
     if not recipes:
         return None
     today = date.today()

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

@@ -1,8 +1,9 @@
 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
+from .models import Recipe, Tag, Setting
 
 User = get_user_model()
 
@@ -46,11 +47,27 @@ class AdminSetupForm(forms.ModelForm, BaseUserFormMixin):
 
 
 class UserSignupForm(UserCreationForm, BaseUserFormMixin):
-    """Refactored Regular User Form inheriting from Django's UserCreationForm"""
+    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")
+        fields = (
+            "username",
+            "first_name",
+            "last_name",
+            "email",
+            "language",
+            "avatar",
+            "bio",
+        )
 
     def clean(self):
         return super().clean()
@@ -59,29 +76,94 @@ class UserSignupForm(UserCreationForm, BaseUserFormMixin):
         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",
-            "image",
-            "tags",
         ]
         widgets = {
-            "tags": forms.TextInput(attrs={"placeholder": "tag1,tag2"}),
+            "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:
+                pass
+
+        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)."""
+    """Form for rating recipes (0-10) with an optional comment."""
 
     score = forms.FloatField(
         min_value=0.0,
@@ -91,3 +173,24 @@ class RatingForm(forms.Form):
         ),
         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),
+        }