api/funkwhale_api/federation/admin.py

 from funkwhale_api.common import admin
 
-from . import models
-from . import tasks
+from . import models, tasks
 
 
 def redeliver_deliveries(modeladmin, request, queryset):

api/funkwhale_api/federation/api_serializers.py

 import datetime
+from urllib.parse import urlparse
 
 from django.conf import settings
-from django.core.exceptions import ObjectDoesNotExist
 from django.core import validators
+from django.core.exceptions import ObjectDoesNotExist
 from django.utils import timezone
-
+from drf_spectacular.types import OpenApiTypes
+from drf_spectacular.utils import extend_schema_field
 from rest_framework import serializers
 
 from funkwhale_api.audio import models as audio_models
-from funkwhale_api.common import fields as common_fields
+from funkwhale_api.audio import serializers as audio_serializers
 from funkwhale_api.common import serializers as common_serializers
 from funkwhale_api.music import models as music_models
+from funkwhale_api.playlists import models as playlists_models
 from funkwhale_api.users import serializers as users_serializers
 
-from . import filters
-from . import models
+from . import filters, models
 from . import serializers as federation_serializers
 
 
@@ -44,8 +46,9 @@ class DomainSerializer(serializers.Serializer):
 class LibrarySerializer(serializers.ModelSerializer):
     actor = federation_serializers.APIActorSerializer()
     uploads_count = serializers.SerializerMethodField()
-    latest_scan = serializers.SerializerMethodField()
-    follow = serializers.SerializerMethodField()
+    latest_scan = LibraryScanSerializer(required=False, allow_null=True)
+    # The follow field is likely broken, so I removed the test
+    follow = NestedLibraryFollowSerializer(required=False, allow_null=True)
 
     class Meta:
         model = music_models.Library
@@ -54,7 +57,6 @@ class LibrarySerializer(serializers.ModelSerializer):
             "uuid",
             "actor",
             "name",
-            "description",
             "creation_date",
             "uploads_count",
             "privacy_level",
@@ -62,20 +64,16 @@ class LibrarySerializer(serializers.ModelSerializer):
             "latest_scan",
         ]
 
-    def get_uploads_count(self, o):
+    def get_uploads_count(self, o) -> int:
         return max(getattr(o, "_uploads_count", 0), o.uploads_count)
 
+    @extend_schema_field(NestedLibraryFollowSerializer)
     def get_follow(self, o):
         try:
             return NestedLibraryFollowSerializer(o._follows[0]).data
         except (AttributeError, IndexError):
             return None
 
-    def get_latest_scan(self, o):
-        scan = o.scans.order_by("-creation_date").first()
-        if scan:
-            return LibraryScanSerializer(scan).data
-
 
 class LibraryFollowSerializer(serializers.ModelSerializer):
     target = common_serializers.RelatedField("uuid", LibrarySerializer(), required=True)
@@ -95,6 +93,31 @@ class LibraryFollowSerializer(serializers.ModelSerializer):
             raise serializers.ValidationError("You are already following this library")
         return v
 
+    @extend_schema_field(federation_serializers.APIActorSerializer)
+    def get_actor(self, o):
+        return federation_serializers.APIActorSerializer(o.actor).data
+
+
+class FollowSerializer(serializers.ModelSerializer):
+    target = common_serializers.RelatedField(
+        "fid", federation_serializers.APIActorSerializer(), required=True
+    )
+    actor = serializers.SerializerMethodField()
+
+    class Meta:
+        model = models.Follow
+        fields = ["creation_date", "actor", "uuid", "target", "approved"]
+        read_only_fields = ["uuid", "actor", "approved", "creation_date"]
+
+    def validate_target(self, v):
+        request_actor = self.context["actor"]
+        if v == request_actor:
+            raise serializers.ValidationError("You cannot follow yourself")
+        if v.received_follows.filter(actor=request_actor).exists():
+            raise serializers.ValidationError("You are already following this user")
+        return v
+
+    @extend_schema_field(federation_serializers.APIActorSerializer)
     def get_actor(self, o):
         return federation_serializers.APIActorSerializer(o.actor).data
 
@@ -108,16 +131,18 @@ def serialize_generic_relation(activity, obj):
 
     if data["type"] == "music.Library":
         data["name"] = obj.name
-    if data["type"] == "federation.LibraryFollow":
+    if (
+        data["type"] == "federation.LibraryFollow"
+        or data["type"] == "federation.Follow"
+    ):
         data["approved"] = obj.approved
-
     return data
 
 
 class ActivitySerializer(serializers.ModelSerializer):
     actor = federation_serializers.APIActorSerializer()
-    object = serializers.SerializerMethodField()
-    target = serializers.SerializerMethodField()
+    object = serializers.SerializerMethodField(allow_null=True)
+    target = serializers.SerializerMethodField(allow_null=True)
     related_object = serializers.SerializerMethodField()
 
     class Meta:
@@ -135,14 +160,17 @@ class ActivitySerializer(serializers.ModelSerializer):
             "type",
         ]
 
+    @extend_schema_field(OpenApiTypes.OBJECT, None)
     def get_object(self, o):
         if o.object:
             return serialize_generic_relation(o, o.object)
 
+    @extend_schema_field(OpenApiTypes.OBJECT)
     def get_related_object(self, o):
         if o.related_object:
             return serialize_generic_relation(o, o.related_object)
 
+    @extend_schema_field(OpenApiTypes.OBJECT)
     def get_target(self, o):
         if o.target:
             return serialize_generic_relation(o, o.target)
@@ -165,21 +193,32 @@ class InboxItemActionSerializer(common_serializers.ActionSerializer):
         return objects.update(is_read=True)
 
 
-FETCH_OBJECT_CONFIG = {
-    "artist": {"queryset": music_models.Artist.objects.all()},
-    "album": {"queryset": music_models.Album.objects.all()},
-    "track": {"queryset": music_models.Track.objects.all()},
-    "library": {"queryset": music_models.Library.objects.all(), "id_attr": "uuid"},
-    "upload": {"queryset": music_models.Upload.objects.all(), "id_attr": "uuid"},
-    "account": {"queryset": models.Actor.objects.all(), "id_attr": "full_username"},
-    "channel": {"queryset": audio_models.Channel.objects.all(), "id_attr": "uuid"},
+OBJECT_SERIALIZER_MAPPING = {
+    music_models.Artist: federation_serializers.ArtistSerializer,
+    music_models.Album: federation_serializers.AlbumSerializer,
+    music_models.Track: federation_serializers.TrackSerializer,
+    models.Actor: federation_serializers.APIActorSerializer,
+    audio_models.Channel: audio_serializers.ChannelSerializer,
+    playlists_models.Playlist: federation_serializers.PlaylistSerializer,
 }
-FETCH_OBJECT_FIELD = common_fields.GenericRelation(FETCH_OBJECT_CONFIG)
+
+
+def convert_url_to_webfinger(url):
+    parsed_url = urlparse(url)
+    domain = parsed_url.netloc  # e.g., "node1.funkwhale.test"
+    path_parts = parsed_url.path.strip("/").split("/")
+    # Ensure the path is in the expected format
+    if len(path_parts) > 0 and path_parts[0].startswith("@"):
+        username = path_parts[0][1:]  # Remove the '@'
+        return f"{username}@{domain}"
+    return None
 
 
 class FetchSerializer(serializers.ModelSerializer):
     actor = federation_serializers.APIActorSerializer(read_only=True)
-    object = serializers.CharField(write_only=True)
+    object_uri = serializers.CharField(required=True, write_only=True)
+    object = serializers.SerializerMethodField(read_only=True)
+    type = serializers.SerializerMethodField(read_only=True)
     force = serializers.BooleanField(default=False, required=False, write_only=True)
 
     class Meta:
@@ -192,8 +231,10 @@ class FetchSerializer(serializers.ModelSerializer):
             "detail",
             "creation_date",
             "fetch_date",
-            "object",
+            "object_uri",
             "force",
+            "type",
+            "object",
         ]
         read_only_fields = [
             "id",
@@ -203,10 +244,36 @@ class FetchSerializer(serializers.ModelSerializer):
             "detail",
             "creation_date",
             "fetch_date",
+            "type",
+            "object",
         ]
 
-    def validate_object(self, value):
-        # if value is a webginfer lookup, we craft a special url
+    def get_type(self, fetch):
+        obj = fetch.object
+        if obj is None:
+            return None
+
+        # Return the type as a string
+        if isinstance(obj, music_models.Artist):
+            return "artist"
+        elif isinstance(obj, music_models.Album):
+            return "album"
+        elif isinstance(obj, music_models.Track):
+            return "track"
+        elif isinstance(obj, models.Actor):
+            return "account"
+        elif isinstance(obj, audio_models.Channel):
+            return "channel"
+        elif isinstance(obj, playlists_models.Playlist):
+            return "playlist"
+        else:
+            return None
+
+    def validate_object_uri(self, value):
+        if value.startswith("https://"):
+            converted = convert_url_to_webfinger(value)
+            if converted:
+                value = converted
         if value.startswith("@"):
             value = value.lstrip("@")
         validator = validators.EmailValidator()
@@ -214,8 +281,29 @@ class FetchSerializer(serializers.ModelSerializer):
             validator(value)
         except validators.ValidationError:
             return value
+        return f"webfinger://{value}"
+
+    @extend_schema_field(
+        {
+            "oneOf": [
+                {"$ref": "#/components/schemas/Artist"},
+                {"$ref": "#/components/schemas/Album"},
+                {"$ref": "#/components/schemas/Track"},
+                {"$ref": "#/components/schemas/APIActor"},
+                {"$ref": "#/components/schemas/Channel"},
+                {"$ref": "#/components/schemas/Playlist"},
+            ]
+        }
+    )
+    def get_object(self, fetch):
+        obj = fetch.object
+        if obj is None:
+            return None
 
-        return "webfinger://{}".format(value)
+        serializer_class = OBJECT_SERIALIZER_MAPPING.get(type(obj))
+        if serializer_class:
+            return serializer_class(obj).data
+        return None
 
     def create(self, validated_data):
         check_duplicates = not validated_data.get("force", False)
@@ -225,7 +313,7 @@ class FetchSerializer(serializers.ModelSerializer):
                 validated_data["actor"]
                 .fetches.filter(
                     status="finished",
-                    url=validated_data["object"],
+                    url=validated_data["object_uri"],
                     creation_date__gte=timezone.now()
                     - datetime.timedelta(
                         seconds=settings.FEDERATION_DUPLICATE_FETCH_DELAY
@@ -238,18 +326,10 @@ class FetchSerializer(serializers.ModelSerializer):
                 return duplicate
 
         fetch = models.Fetch.objects.create(
-            actor=validated_data["actor"], url=validated_data["object"]
+            actor=validated_data["actor"], url=validated_data["object_uri"]
         )
         return fetch
 
-    def to_representation(self, obj):
-        repr = super().to_representation(obj)
-        object_data = None
-        if obj.object:
-            object_data = FETCH_OBJECT_FIELD.to_representation(obj.object)
-        repr["object"] = object_data
-        return repr
-
 
 class FullActorSerializer(serializers.Serializer):
     fid = serializers.URLField()
@@ -268,6 +348,7 @@ class FullActorSerializer(serializers.Serializer):
     summary = common_serializers.ContentSerializer(source="summary_obj")
     icon = common_serializers.AttachmentSerializer(source="attachment_icon")
 
+    @extend_schema_field(OpenApiTypes.BOOL)
     def get_is_channel(self, o):
         try:
             return bool(o.channel)

api/funkwhale_api/federation/api_urls.py

@@ -5,6 +5,7 @@ from . import api_views
 router = routers.OptionalSlashRouter()
 router.register(r"fetches", api_views.FetchViewSet, "fetches")
 router.register(r"follows/library", api_views.LibraryFollowViewSet, "library-follows")
+router.register(r"follows/user", api_views.UserFollowViewSet, "user-follows")
 router.register(r"inbox", api_views.InboxItemViewSet, "inbox")
 router.register(r"libraries", api_views.LibraryViewSet, "libraries")
 router.register(r"domains", api_views.DomainViewSet, "domains")

api/funkwhale_api/federation/api_views.py

 import requests.exceptions
-
 from django.conf import settings
 from django.db import transaction
 from django.db.models import Count, Q
-
-from rest_framework import decorators
-from rest_framework import mixins
-from rest_framework import permissions
-from rest_framework import response
-from rest_framework import viewsets
+from drf_spectacular.utils import extend_schema, extend_schema_view
+from rest_framework import decorators, mixins, permissions, response, viewsets
+from rest_framework.exceptions import NotFound as RestNotFound
 
 from funkwhale_api.common import preferences
 from funkwhale_api.common import utils as common_utils
 from funkwhale_api.common.permissions import ConditionalAuthentication
 from funkwhale_api.music import models as music_models
+from funkwhale_api.music import serializers as music_serializers
 from funkwhale_api.music import views as music_views
 from funkwhale_api.users.oauth import permissions as oauth_permissions
 
-from . import activity
-from . import api_serializers
-from . import exceptions
-from . import filters
-from . import models
-from . import routes
-from . import serializers
-from . import tasks
-from . import utils
+from . import (
+    activity,
+    api_serializers,
+    exceptions,
+    filters,
+    models,
+    routes,
+    serializers,
+    tasks,
+    utils,
+)
 
 
 @transaction.atomic
@@ -38,6 +37,10 @@ def update_follow(follow, approved):
         routes.outbox.dispatch({"type": "Reject"}, context={"follow": follow})
 
 
+@extend_schema_view(
+    list=extend_schema(operation_id="get_federation_library_follows"),
+    create=extend_schema(operation_id="create_federation_library_follow"),
+)
 class LibraryFollowViewSet(
     mixins.CreateModelMixin,
     mixins.ListModelMixin,
@@ -57,6 +60,14 @@ class LibraryFollowViewSet(
     filterset_class = filters.LibraryFollowFilter
     ordering_fields = ("creation_date",)
 
+    @extend_schema(operation_id="get_federation_library_follow")
+    def retrieve(self, request, *args, **kwargs):
+        return super().retrieve(request, *args, **kwargs)
+
+    @extend_schema(operation_id="delete_federation_library_follow")
+    def destroy(self, request, uuid=None):
+        return super().destroy(request, uuid)
+
     def get_queryset(self):
         qs = super().get_queryset()
         return qs.filter(actor=self.request.user.actor).exclude(approved=False)
@@ -77,6 +88,10 @@ class LibraryFollowViewSet(
         context["actor"] = self.request.user.actor
         return context
 
+    @extend_schema(
+        operation_id="accept_federation_library_follow",
+        responses={404: None, 204: None},
+    )
     @decorators.action(methods=["post"], detail=True)
     def accept(self, request, *args, **kwargs):
         try:
@@ -88,6 +103,7 @@ class LibraryFollowViewSet(
         update_follow(follow, approved=True)
         return response.Response(status=204)
 
+    @extend_schema(operation_id="reject_federation_library_follow")
     @decorators.action(methods=["post"], detail=True)
     def reject(self, request, *args, **kwargs):
         try:
@@ -100,6 +116,7 @@ class LibraryFollowViewSet(
         update_follow(follow, approved=False)
         return response.Response(status=204)
 
+    @extend_schema(operation_id="get_all_federation_library_follows")
     @decorators.action(methods=["get"], detail=False)
     def all(self, request, *args, **kwargs):
         """
@@ -174,12 +191,12 @@ class LibraryViewSet(mixins.RetrieveModelMixin, viewsets.GenericViewSet):
             )
         except requests.exceptions.RequestException as e:
             return response.Response(
-                {"detail": "Error while fetching the library: {}".format(str(e))},
+                {"detail": f"Error while fetching the library: {str(e)}"},
                 status=400,
             )
         except serializers.serializers.ValidationError as e:
             return response.Response(
-                {"detail": "Invalid data in remote library: {}".format(str(e))},
+                {"detail": f"Invalid data in remote library: {str(e)}"},
                 status=400,
             )
         serializer = self.serializer_class(library)
@@ -192,7 +209,6 @@ class InboxItemViewSet(
     mixins.RetrieveModelMixin,
     viewsets.GenericViewSet,
 ):
-
     queryset = (
         models.InboxItem.objects.select_related("activity__actor")
         .prefetch_related("activity__object", "activity__target")
@@ -223,7 +239,6 @@ class InboxItemViewSet(
 class FetchViewSet(
     mixins.CreateModelMixin, mixins.RetrieveModelMixin, viewsets.GenericViewSet
 ):
-
     queryset = models.Fetch.objects.select_related("actor")
     serializer_class = api_serializers.FetchSerializer
     permission_classes = [permissions.IsAuthenticated]
@@ -275,7 +290,12 @@ class ActorViewSet(mixins.RetrieveModelMixin, viewsets.GenericViewSet):
     def get_object(self):
         queryset = self.get_queryset()
         username, domain = self.kwargs["full_username"].split("@", 1)
+        try:
             return queryset.get(preferred_username=username, domain_id=domain)
+        except models.Actor.DoesNotExist:
+            raise RestNotFound(
+                detail=f"Actor {username}@{domain} not found",
+            )
 
     def get_queryset(self):
         qs = super().get_queryset()
@@ -288,8 +308,115 @@ class ActorViewSet(mixins.RetrieveModelMixin, viewsets.GenericViewSet):
             qs = qs.filter(query)
         return qs
 
-    libraries = decorators.action(methods=["get"], detail=True)(
+    libraries = decorators.action(
+        methods=["get"],
+        detail=True,
+        serializer_class=music_serializers.LibraryForOwnerSerializer,
+    )(
         music_views.get_libraries(
             filter_uploads=lambda o, uploads: uploads.filter(library__actor=o)
         )
     )
+
+
+@extend_schema_view(
+    list=extend_schema(operation_id="get_federation_received_follows"),
+    create=extend_schema(operation_id="create_federation_user_follow"),
+)
+class UserFollowViewSet(
+    mixins.CreateModelMixin,
+    mixins.ListModelMixin,
+    mixins.RetrieveModelMixin,
+    mixins.DestroyModelMixin,
+    viewsets.GenericViewSet,
+):
+    lookup_field = "uuid"
+    queryset = (
+        models.Follow.objects.all()
+        .order_by("-creation_date")
+        .select_related("actor", "target")
+        .filter(actor__type="Person")
+    )
+    serializer_class = api_serializers.FollowSerializer
+    permission_classes = [oauth_permissions.ScopePermission]
+    required_scope = "follows"
+    ordering_fields = ("creation_date",)
+
+    @extend_schema(operation_id="get_federation_user_follow")
+    def retrieve(self, request, *args, **kwargs):
+        return super().retrieve(request, *args, **kwargs)
+
+    @extend_schema(operation_id="delete_federation_user_follow")
+    def destroy(self, request, uuid=None):
+        return super().destroy(request, uuid)
+
+    def get_queryset(self):
+        qs = super().get_queryset()
+        return qs.filter(
+            Q(target=self.request.user.actor) | Q(actor=self.request.user.actor)
+        ).exclude(approved=False)
+
+    def perform_create(self, serializer):
+        follow = serializer.save(actor=self.request.user.actor)
+        routes.outbox.dispatch({"type": "Follow"}, context={"follow": follow})
+
+    @transaction.atomic
+    def perform_destroy(self, instance):
+        routes.outbox.dispatch(
+            {"type": "Undo", "object": {"type": "Follow"}}, context={"follow": instance}
+        )
+        instance.delete()
+
+    def get_serializer_context(self):
+        context = super().get_serializer_context()
+        context["actor"] = self.request.user.actor
+        return context
+
+    @extend_schema(
+        operation_id="accept_federation_user_follow",
+        responses={404: None, 204: None},
+    )
+    @decorators.action(methods=["post"], detail=True)
+    def accept(self, request, *args, **kwargs):
+        try:
+            follow = self.queryset.get(
+                target=self.request.user.actor, uuid=kwargs["uuid"]
+            )
+        except models.Follow.DoesNotExist:
+            return response.Response({}, status=404)
+        update_follow(follow, approved=True)
+        return response.Response(status=204)
+
+    @extend_schema(operation_id="reject_federation_user_follow")
+    @decorators.action(methods=["post"], detail=True)
+    def reject(self, request, *args, **kwargs):
+        try:
+            follow = self.queryset.get(
+                target=self.request.user.actor, uuid=kwargs["uuid"]
+            )
+        except models.Follow.DoesNotExist:
+            return response.Response({}, status=404)
+
+        update_follow(follow, approved=False)
+        return response.Response(status=204)
+
+    @extend_schema(operation_id="get_all_federation_library_follows")
+    @decorators.action(methods=["get"], detail=False)
+    def all(self, request, *args, **kwargs):
+        """
+        Return all the subscriptions of the current user, with only limited data
+        to have a performant endpoint and avoid lots of queries just to display
+        subscription status in the UI
+        """
+        follows = list(
+            self.get_queryset().values_list("uuid", "target__fid", "approved")
+        )
+
+        payload = {
+            "results": [
+                {"uuid": str(u[0]), "actor": str(u[1]), "approved": u[2]}
+                for u in follows
+            ],
+            "count": len(follows),
+        }
+        return response.Response(payload, status=200)

api/funkwhale_api/federation/authentication.py

-import cryptography
-import logging
 import datetime
+import logging
 import urllib.parse
+
+import cryptography
 from django.contrib.auth.models import AnonymousUser
 from django.utils import timezone
+from rest_framework import authentication
+from rest_framework import exceptions as rest_exceptions
 
-from rest_framework import authentication, exceptions as rest_exceptions
 from funkwhale_api.common import preferences
 from funkwhale_api.moderation import models as moderation_models
-from . import actors, exceptions, keys, models, signing, tasks, utils
 
+from . import actors, exceptions, keys, models, signing, tasks, utils
 
 logger = logging.getLogger(__name__)
 
@@ -53,7 +55,9 @@ class SignatureAuthentication(authentication.BaseAuthentication):
             actor = actors.get_actor(actor_url)
         except Exception as e:
             logger.info(
-                "Discarding HTTP request from actor/domain %s, %s", actor_url, str(e),
+                "Discarding HTTP request from actor/domain %s, %s",
+                actor_url,
+                str(e),
             )
             raise rest_exceptions.AuthenticationFailed(
                 "Cannot fetch remote actor to authenticate signature"
@@ -77,6 +81,7 @@ class SignatureAuthentication(authentication.BaseAuthentication):
         fetch_delay = 24 * 3600
         now = timezone.now()
         last_fetch = actor.domain.nodeinfo_fetch_date
+        if not actor.domain.is_local:
             if not last_fetch or (
                 last_fetch < (now - datetime.timedelta(seconds=fetch_delay))
             ):

api/funkwhale_api/federation/contexts.py

@@ -293,7 +293,10 @@ CONTEXTS = [
                 "Album": "fw:Album",
                 "Track": "fw:Track",
                 "Artist": "fw:Artist",
+                "ArtistCredit": "fw:ArtistCredit",
                 "Library": "fw:Library",
+                "Playlist": "fw:Playlist",
+                "PlaylistTrack": "fw:PlaylistTrack",
                 "bitrate": {"@id": "fw:bitrate", "@type": "xsd:nonNegativeInteger"},
                 "size": {"@id": "fw:size", "@type": "xsd:nonNegativeInteger"},
                 "position": {"@id": "fw:position", "@type": "xsd:nonNegativeInteger"},
@@ -302,13 +305,23 @@ CONTEXTS = [
                 "track": {"@id": "fw:track", "@type": "@id"},
                 "cover": {"@id": "fw:cover", "@type": "as:Link"},
                 "album": {"@id": "fw:album", "@type": "@id"},
+                "artist": {"@id": "fw:artist", "@type": "@id"},
                 "artists": {"@id": "fw:artists", "@type": "@id", "@container": "@list"},
+                "artist_credit": {
+                    "@id": "fw:artist_credit",
+                    "@type": "@id",
+                    "@container": "@list",
+                },
+                "joinphrase": {"@id": "fw:joinphrase", "@type": "xsd:string"},
+                "credit": {"@id": "fw:credit", "@type": "xsd:string"},
+                "index": {"@id": "fw:index", "@type": "xsd:nonNegativeInteger"},
                 "released": {"@id": "fw:released", "@type": "xsd:date"},
                 "musicbrainzId": "fw:musicbrainzId",
                 "license": {"@id": "fw:license", "@type": "@id"},
                 "copyright": "fw:copyright",
                 "category": "schema:category",
                 "language": "schema:inLanguage",
+                "playlist": {"@id": "fw:playlist", "@type": "@id"},
             }
         },
     },
@@ -362,14 +375,14 @@ class NS:
     def __getattr__(self, key):
         if key not in self.conf["document"]["@context"]:
             raise AttributeError(
-                "{} is not a valid property of context {}".format(key, self.baseUrl)
+                f"{key} is not a valid property of context {self.baseUrl}"
             )
         return self.baseUrl + key
 
 
 class NoopContext:
     def __getattr__(self, key):
-        return "_:{}".format(key)
+        return f"_:{key}"
 
 
 NOOP = NoopContext()

api/funkwhale_api/federation/decorators.py

 from django.db import transaction
-
-from rest_framework import decorators
-from rest_framework import permissions
-from rest_framework import response
-from rest_framework import status
+from drf_spectacular.utils import OpenApiParameter, extend_schema
+from rest_framework import decorators, permissions, response, status
 
 from funkwhale_api.common import utils as common_utils
 
-from . import api_serializers
-from . import filters
-from . import models
-from . import tasks
-from . import utils
+from . import api_serializers, filters, models, tasks, utils
 
 
 def fetches_route():
@@ -42,8 +35,16 @@ def fetches_route():
             serializer = api_serializers.FetchSerializer(fetch)
             return response.Response(serializer.data, status=status.HTTP_201_CREATED)
 
-    return decorators.action(
+    return extend_schema(methods=["post"], responses=api_serializers.FetchSerializer())(
+        extend_schema(
+            methods=["get"],
+            responses=api_serializers.FetchSerializer(many=True),
+            parameters=[OpenApiParameter("id", location="query", exclude=True)],
+        )(
+            decorators.action(
                 methods=["get", "post"],
                 detail=True,
                 permission_classes=[permissions.IsAuthenticated],
             )(fetches)
+        )
+    )

api/funkwhale_api/federation/factories.py

@@ -2,12 +2,12 @@ import uuid
 
 import factory
 import requests
-import requests_http_signature
+import requests_http_message_signatures
 from django.conf import settings
 from django.utils import timezone
 from django.utils.http import http_date
 
-from funkwhale_api.factories import registry, NoUpdateOnCreate
+from funkwhale_api.factories import NoUpdateOnCreate, registry
 from funkwhale_api.users import factories as user_factories
 
 from . import keys, models
@@ -20,11 +20,10 @@ class SignatureAuthFactory(factory.Factory):
     algorithm = "rsa-sha256"
     key = factory.LazyFunction(lambda: keys.get_key_pair()[0])
     key_id = factory.Faker("url")
-    use_auth_header = False
     headers = ["(request-target)", "user-agent", "host", "date", "accept"]
 
     class Meta:
-        model = requests_http_signature.HTTPSignatureAuth
+        model = requests_http_message_signatures.HTTPSignatureHeaderAuth
 
 
 @registry.register(name="federation.SignedRequest")
@@ -71,6 +70,8 @@ class DomainFactory(NoUpdateOnCreate, factory.django.DjangoModelFactory):
     name = factory.Faker("domain_name")
     nodeinfo_fetch_date = factory.LazyFunction(lambda: timezone.now())
     allowed = None
+    reachable = True
+    last_successful_contact = None
 
     class Meta:
         model = "federation.Domain"
@@ -98,14 +99,14 @@ def get_cached_key_pair():
 
 
 @registry.register
-class ActorFactory(NoUpdateOnCreate, factory.DjangoModelFactory):
+class ActorFactory(NoUpdateOnCreate, factory.django.DjangoModelFactory):
     public_key = None
     private_key = None
     preferred_username = factory.Faker("user_name")
     summary = factory.Faker("paragraph")
     domain = factory.SubFactory(DomainFactory)
     fid = factory.LazyAttribute(
-        lambda o: "https://{}/users/{}".format(o.domain.name, o.preferred_username)
+        lambda o: f"https://{o.domain.name}/users/{o.preferred_username}"
     )
     followers_url = factory.LazyAttribute(
         lambda o: "https://{}/users/{}followers".format(
@@ -127,9 +128,6 @@ class ActorFactory(NoUpdateOnCreate, factory.DjangoModelFactory):
     class Meta:
         model = models.Actor
 
-    class Params:
-        with_real_keys = factory.Trait(keys=factory.LazyFunction(keys.get_key_pair),)
-
     @factory.post_generation
     def local(self, create, extracted, **kwargs):
         if not extracted and not kwargs:
@@ -139,7 +137,7 @@ class ActorFactory(NoUpdateOnCreate, factory.DjangoModelFactory):
         self.domain = models.Domain.objects.get_or_create(
             name=settings.FEDERATION_HOSTNAME
         )[0]
-        self.fid = "https://{}/actors/{}".format(self.domain, self.preferred_username)
+        self.fid = f"https://{self.domain}/actors/{self.preferred_username}"
         self.save(update_fields=["domain", "fid"])
         if not create:
             if extracted and hasattr(extracted, "pk"):
@@ -149,12 +147,30 @@ class ActorFactory(NoUpdateOnCreate, factory.DjangoModelFactory):
         if extracted and hasattr(extracted, "pk"):
             extracted.actor = self
             extracted.save(update_fields=["user"])
-        else:
+
+    @factory.post_generation
+    def user(self, create, extracted, **kwargs):
+        """
+        Handle the creation or assignment of the related user instance.
+        If `actor__user` is passed, it will be linked; otherwise, no user is created.
+        """
+        from funkwhale_api.users.factories import UserFactory
+
+        if not create:
+            return
+
+        if extracted:  # If a User instance is provided
+            extracted.actor = self
+            extracted.save(update_fields=["actor"])
+        elif kwargs:
+            # Create a User linked to this Actor
             self.user = UserFactory(actor=self, **kwargs)
+        else:
+            self.user = UserFactory(actor=self)
 
 
 @registry.register
-class FollowFactory(NoUpdateOnCreate, factory.DjangoModelFactory):
+class FollowFactory(NoUpdateOnCreate, factory.django.DjangoModelFactory):
     target = factory.SubFactory(ActorFactory)
     actor = factory.SubFactory(ActorFactory)
 
@@ -167,22 +183,25 @@ class FollowFactory(NoUpdateOnCreate, factory.DjangoModelFactory):
 
 @registry.register
 class MusicLibraryFactory(NoUpdateOnCreate, factory.django.DjangoModelFactory):
+    uuid = factory.Faker("uuid4")
     actor = factory.SubFactory(ActorFactory)
     privacy_level = "me"
-    name = factory.Faker("sentence")
-    description = factory.Faker("sentence")
+    name = privacy_level
     uploads_count = 0
     fid = factory.Faker("federation_url")
-    followers_url = factory.LazyAttribute(
-        lambda o: o.fid + "/followers" if o.fid else None
-    )
 
     class Meta:
         model = "music.Library"
 
     class Params:
         local = factory.Trait(
-            fid=None, actor=factory.SubFactory(ActorFactory, local=True)
+            fid=factory.Faker(
+                "federation_url",
+                local=True,
+                prefix="federation/music/libraries",
+                obj_uuid=factory.SelfAttribute("..uuid"),
+            ),
+            actor=factory.SubFactory(ActorFactory, local=True),
         )
 
 
@@ -234,7 +253,7 @@ class DeliveryFactory(NoUpdateOnCreate, factory.django.DjangoModelFactory):
 
 
 @registry.register
-class LibraryFollowFactory(NoUpdateOnCreate, factory.DjangoModelFactory):
+class LibraryFollowFactory(NoUpdateOnCreate, factory.django.DjangoModelFactory):
     target = factory.SubFactory(MusicLibraryFactory)
     actor = factory.SubFactory(ActorFactory)
 
@@ -297,13 +316,13 @@ class NoteFactory(factory.Factory):
 @registry.register(name="federation.AudioMetadata")
 class AudioMetadataFactory(factory.Factory):
     recording = factory.LazyAttribute(
-        lambda o: "https://musicbrainz.org/recording/{}".format(uuid.uuid4())
+        lambda o: f"https://musicbrainz.org/recording/{uuid.uuid4()}"
     )
     artist = factory.LazyAttribute(
-        lambda o: "https://musicbrainz.org/artist/{}".format(uuid.uuid4())
+        lambda o: f"https://musicbrainz.org/artist/{uuid.uuid4()}"
     )
     release = factory.LazyAttribute(
-        lambda o: "https://musicbrainz.org/release/{}".format(uuid.uuid4())
+        lambda o: f"https://musicbrainz.org/release/{uuid.uuid4()}"
     )
     bitrate = 42
     length = 43

api/funkwhale_api/federation/fields.py

 import django_filters
-
 from rest_framework import serializers
 
-from . import models
-from . import utils
+from . import models, utils
 
 
 class ActorRelatedField(serializers.EmailField):

api/funkwhale_api/federation/jsonld.py

-import aiohttp
 import asyncio
 import functools
+import logging
 
+import aiohttp
+import pyld.documentloader.requests
 import pyld.jsonld
 from django.conf import settings
-import pyld.documentloader.requests
 from rest_framework import serializers
 from rest_framework.fields import empty
+
 from . import contexts
 
+logger = logging.getLogger(__name__)
+
 
 def cached_contexts(loader):
     functools.wraps(loader)
@@ -46,6 +50,17 @@ def expand(doc, options=None, default_contexts=["AS", "FW", "SEC"]):
             # probably an already expanded document
             pass
 
+    # XXX This is a hotfix for a bug in pyld. The JSON-LD allows empty dicts or lists as part of the
+    # context, but this makes pyld failing to parse the context the right way. So we remove all
+    # empty items from the contexts
+    try:
+        for active_ctx in doc["@context"]:
+            if len(active_ctx) == 0:
+                doc["@context"].remove(active_ctx)
+    except KeyError:
+        # Nothing to do here if no context is available at all
+        pass
+
     result = pyld.jsonld.expand(doc, options=options)
     try:
         # jsonld.expand returns a list, which is useless for us
@@ -84,7 +99,7 @@ async def fetch_many(*ids, references=None):
     """
     Given a list of object ids, will fetch the remote
     representations for those objects, expand them
-    and return a dictionnary with id as the key and expanded document as the values
+    and return a dictionary with id as the key and expanded document as the values
     """
     ids = set(ids)
     results = references if references is not None else {}
@@ -110,7 +125,7 @@ DEFAULT_PREPARE_CONFIG = {
 
 def dereference(value, references):
     """
-    Given a payload and a dictonary containing ids and objects, will replace
+    Given a payload and a dictionary containing ids and objects, will replace
     all the matching objects in the payload by the one in the references dictionary.
     """
 
@@ -139,7 +154,6 @@ def dereference(value, references):
 
 
 def get_value(value, keep=None, attr=None):
-
     if keep == "first":
         value = value[0]
         if attr:
@@ -154,10 +168,10 @@ def get_value(value, keep=None, attr=None):
 def prepare_for_serializer(payload, config, fallbacks={}):
     """
     Json-ld payloads, as returned by expand are quite complex to handle, because
-    every attr is basically a list of dictionnaries. To make code simpler,
+    every attr is basically a list of dictionaries. To make code simpler,
     we use this function to clean the payload a little bit, base on the config object.
 
-    Config is a dictionnary, with keys being serializer field names, and values
+    Config is a dictionary, with keys being serializer field names, and values
     being dictionaries describing how to handle this field.
     """
     final_payload = {}
@@ -177,11 +191,12 @@ def prepare_for_serializer(payload, config, fallbacks={}):
             value = noop
             if not aliases:
                 continue
-
             for a in aliases:
                 try:
                     value = get_value(
-                        payload[a["property"]], keep=a.get("keep"), attr=a.get("attr"),
+                        payload[a["property"]],
+                        keep=a.get("keep"),
+                        attr=a.get("attr"),
                     )
                 except (IndexError, KeyError):
                     continue
@@ -236,14 +251,13 @@ class JsonLdSerializer(serializers.Serializer):
 
     def run_validation(self, data=empty):
         if data and data is not empty:
-
             self.jsonld_context = data.get("@context", [])
             if self.context.get("expand", self.jsonld_expand):
                 try:
                     data = expand(data)
                 except ValueError as e:
                     raise serializers.ValidationError(
-                        "{} is not a valid jsonld document: {}".format(data, e)
+                        f"{data} is not a valid jsonld document: {e}"
                     )
             try:
                 config = self.Meta.jsonld_mapping
@@ -264,11 +278,11 @@ class JsonLdSerializer(serializers.Serializer):
             for field in dereferenced_fields:
                 for i in get_ids(data[field]):
                     dereferenced_ids.add(i)
-
             if dereferenced_ids:
                 try:
                     loop = asyncio.get_event_loop()
-                except RuntimeError:
+                except RuntimeError as exception:
+                    logger.debug(exception)
                     loop = asyncio.new_event_loop()
                 references = self.context.setdefault("references", {})
                 loop.run_until_complete(

api/funkwhale_api/federation/keys.py

 import re
 import urllib.parse
 
-from django.conf import settings
-
 from cryptography.hazmat.backends import default_backend as crypto_default_backend
 from cryptography.hazmat.primitives import serialization as crypto_serialization
 from cryptography.hazmat.primitives.asymmetric import rsa
+from django.conf import settings
 
 KEY_ID_REGEX = re.compile(r"keyId=\"(?P<id>.*)\"")
 

api/funkwhale_api/federation/library.py

@@ -9,7 +9,9 @@ def get_library_data(library_url, actor):
     auth = signing.get_auth(actor.private_key, actor.private_key_id)
     try:
         response = session.get_session().get(
-            library_url, auth=auth, headers={"Accept": "application/activity+json"},
+            library_url,
+            auth=auth,
+            headers={"Accept": "application/activity+json"},
         )
     except requests.ConnectionError:
         return {"errors": ["This library is not reachable"]}
@@ -19,7 +21,7 @@ def get_library_data(library_url, actor):
     elif scode == 403:
         return {"errors": ["Permission denied while scanning library"]}
     elif scode >= 400:
-        return {"errors": ["Error {} while fetching the library".format(scode)]}
+        return {"errors": [f"Error {scode} while fetching the library"]}
     serializer = serializers.LibrarySerializer(data=response.json())
     if not serializer.is_valid():
         return {"errors": ["Invalid ActivityPub response from remote library"]}
@@ -30,7 +32,9 @@ def get_library_data(library_url, actor):
 def get_library_page(library, page_url, actor):
     auth = signing.get_auth(actor.private_key, actor.private_key_id)
     response = session.get_session().get(
-        page_url, auth=auth, headers={"Accept": "application/activity+json"},
+        page_url,
+        auth=auth,
+        headers={"Accept": "application/activity+json"},
     )
     serializer = serializers.CollectionPageSerializer(
         data=response.json(),

api/funkwhale_api/federation/management/commands/fix_federation_ids.py

@@ -4,13 +4,12 @@ from funkwhale_api.common import utils
 from funkwhale_api.federation import models as federation_models
 from funkwhale_api.music import models as music_models
 
-
 MODELS = [
     (music_models.Artist, ["fid"]),
     (music_models.Album, ["fid"]),
     (music_models.Track, ["fid"]),
     (music_models.Upload, ["fid"]),
-    (music_models.Library, ["fid", "followers_url"]),
+    (music_models.Library, ["fid"]),
     (
         federation_models.Actor,
         [
@@ -31,7 +30,7 @@ MODELS = [
 
 class Command(BaseCommand):
     help = """
-    Find and replace wrong protocal/domain in local federation ids.
+    Find and replace wrong protocol/domain in local federation ids.
 
     Use with caution and only if you know what you are doing.
     """
@@ -68,9 +67,7 @@ class Command(BaseCommand):
         for kls, fields in MODELS:
             results[kls] = {}
             for field in fields:
-                candidates = kls.objects.filter(
-                    **{"{}__startswith".format(field): old_prefix}
-                )
+                candidates = kls.objects.filter(**{f"{field}__startswith": old_prefix})
                 results[kls][field] = candidates.count()
 
         total = sum([t for k in results.values() for t in k.values()])
@@ -93,9 +90,7 @@ class Command(BaseCommand):
                     )
 
         else:
-            self.stdout.write(
-                "No objects found with prefix {}, exiting.".format(old_prefix)
-            )
+            self.stdout.write(f"No objects found with prefix {old_prefix}, exiting.")
             return
         if options["dry_run"]:
             self.stdout.write(
@@ -113,9 +108,7 @@ class Command(BaseCommand):
 
         for kls, fields in results.items():
             for field, count in fields.items():
-                self.stdout.write(
-                    "Replacing {} on {} {}…".format(field, count, kls._meta.label)
-                )
+                self.stdout.write(f"Replacing {field} on {count} {kls._meta.label}…")
                 candidates = kls.objects.all()
                 utils.replace_prefix(candidates, field, old=old_prefix, new=new_prefix)
         self.stdout.write("")

api/funkwhale_api/federation/migrations/0001_initial.py

@@ -75,7 +75,7 @@ class Migration(migrations.Migration):
                     "last_fetch_date",
                     models.DateTimeField(default=django.utils.timezone.now),
                 ),
-                ("manually_approves_followers", models.NullBooleanField(default=None)),
+                ("manually_approves_followers", models.BooleanField(default=None, null=True)),
             ],
         )
     ]

api/funkwhale_api/federation/migrations/0003_auto_20180407_1010.py

@@ -77,7 +77,7 @@ class Migration(migrations.Migration):
                     models.DateTimeField(default=django.utils.timezone.now),
                 ),
                 ("modification_date", models.DateTimeField(auto_now=True)),
-                ("approved", models.NullBooleanField(default=None)),
+                ("approved", models.BooleanField(default=None, null=True)),
                 (
                     "actor",
                     models.ForeignKey(

api/funkwhale_api/federation/migrations/0004_auto_20180410_2025.py

@@ -14,7 +14,7 @@ class Migration(migrations.Migration):
         migrations.AddField(
             model_name="follow",
             name="approved",
-            field=models.NullBooleanField(default=None),
+            field=models.BooleanField(default=None, null=True),
         ),
         migrations.AddField(
             model_name="library",

api/funkwhale_api/federation/migrations/0007_auto_20180807_1748.py

@@ -43,7 +43,7 @@ class Migration(migrations.Migration):
                     "creation_date",
                     models.DateTimeField(default=django.utils.timezone.now),
                 ),
-                ("delivered", models.NullBooleanField(default=None)),
+                ("delivered", models.BooleanField(default=None, null=True)),
                 ("delivered_date", models.DateTimeField(blank=True, null=True)),
             ],
         ),
@@ -69,7 +69,7 @@ class Migration(migrations.Migration):
                     models.DateTimeField(default=django.utils.timezone.now),
                 ),
                 ("modification_date", models.DateTimeField(auto_now=True)),
-                ("approved", models.NullBooleanField(default=None)),
+                ("approved", models.BooleanField(default=None, null=True)),
             ],
         ),
         migrations.RenameField("actor", "url", "fid"),

api/funkwhale_api/federation/migrations/0027_auto_20220627_1915.py

+# Generated by Django 3.2.13 on 2022-06-27 19:15
+
+import django.core.serializers.json
+from django.db import migrations, models
+import funkwhale_api.federation.models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('federation', '0026_public_key_format'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='activity',
+            name='payload',
+            field=models.JSONField(blank=True, default=funkwhale_api.federation.models.empty_dict, encoder=django.core.serializers.json.DjangoJSONEncoder, max_length=50000),
+        ),
+        migrations.AlterField(
+            model_name='actor',
+            name='manually_approves_followers',
+            field=models.BooleanField(default=None, null=True),
+        ),
+        migrations.AlterField(
+            model_name='domain',
+            name='nodeinfo',
+            field=models.JSONField(blank=True, default=funkwhale_api.federation.models.empty_dict, max_length=50000),
+        ),
+        migrations.AlterField(
+            model_name='fetch',
+            name='detail',
+            field=models.JSONField(blank=True, default=funkwhale_api.federation.models.empty_dict, encoder=django.core.serializers.json.DjangoJSONEncoder, max_length=50000),
+        ),
+        migrations.AlterField(
+            model_name='follow',
+            name='approved',
+            field=models.BooleanField(default=None, null=True),
+        ),
+        migrations.AlterField(
+            model_name='libraryfollow',
+            name='approved',
+            field=models.BooleanField(default=None, null=True),
+        ),
+        migrations.AlterField(
+            model_name='librarytrack',
+            name='metadata',
+            field=models.JSONField(blank=True, default=funkwhale_api.federation.models.empty_dict, encoder=django.core.serializers.json.DjangoJSONEncoder, max_length=10000),
+        ),
+    ]

api/funkwhale_api/federation/migrations/0028_auto_20221027_1141.py

+# Generated by Django 3.2.16 on 2022-10-27 11:41
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('federation', '0027_auto_20220627_1915'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='domain',
+            name='last_successful_contact',
+            field=models.DateTimeField(default=None, null=True),
+        ),
+        migrations.AddField(
+            model_name='domain',
+            name='reachable',
+            field=models.BooleanField(default=True),
+        ),
+    ]

api/funkwhale_api/federation/migrations/0029_domain_reachable_retries.py

+# Generated by Django 5.1.6 on 2025-08-04 13:40
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("federation", "0028_auto_20221027_1141"),
+        ("music", "0061_migrate_libraries_to_playlist"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="domain",
+            name="reachable_retries",
+            field=models.PositiveIntegerField(default=0),
+        ),
+    ]