Fix formatting of test files

tests/unit/test_model_license.py

-import json
 from funkwhale_api_client.models.license_ import License
 
+
 def test_License(load_data):
     response = load_data("license")
     license: License = License.from_dict(response)

tests/unit/test_model_listening.py

-import json
 from funkwhale_api_client.models.listening import Listening
 
+
 def test_Listening(load_data):
     response = load_data("listening")
     listening: Listening = Listening.from_dict(response)

tests/unit/test_model_listening_write.py

-import json
 from funkwhale_api_client.models.listening_write import ListeningWrite
 
+
 def test_ListeningWrite(load_data):
     response = load_data("listening_write")
     listening: ListeningWrite = ListeningWrite.from_dict(response)

tests/unit/test_model_listening_write_request.py

-import json
 from funkwhale_api_client.models.listening_write_request import ListeningWriteRequest
 
+
 def test_ListeningWriteRequest(load_data):
     response = load_data("listening_write_request")
     listening: ListeningWriteRequest = ListeningWriteRequest.from_dict(response)

tests/unit/test_model_manage_album.py

-import json
 from funkwhale_api_client.models.manage_album import ManageAlbum
 
+
 def test_ManageAlbum(load_data):
     response = load_data("manage_album")
     album: ManageAlbum = ManageAlbum.from_dict(response)
 
     assert isinstance(album, ManageAlbum)
 
+
 def test_ManageAlbumStats(load_data):
     response = load_data("manage_album_stats")
     album_stats: ManageAlbum = ManageAlbum.from_dict(response)

tests/unit/test_model_manage_artist.py

-import json
 from funkwhale_api_client.models.manage_artist import ManageArtist
 
+
 def test_ManageArtist(load_data):
     response = load_data("manage_artist")
     artist: ManageArtist = ManageArtist.from_dict(response)

tests/unit/test_model_manage_channel.py

-import json
 from funkwhale_api_client.models.manage_channel import ManageChannel
 
+
 def test_ManageChannel(load_data):
     response = load_data("manage_channel")
     channel: ManageChannel = ManageChannel.from_dict(response)
 
     assert isinstance(channel, ManageChannel)
 
+
 def test_ManageChannelStats(load_data):
     response = load_data("manage_channel_stats")
     channel_stats: ManageChannel = ManageChannel.from_dict(response)

tests/unit/test_model_manage_domain.py

-import json
 from funkwhale_api_client.models.manage_domain import ManageDomain
 
+
 def test_ManageDomain(load_data):
     response = load_data("manage_domain")
     domain: ManageDomain = ManageDomain.from_dict(response)

tests/unit/test_model_manage_instance_policy.py

-import json
 from funkwhale_api_client.models.manage_instance_policy import ManageInstancePolicy
 
+
 def test_ManageInstancePolicy(load_data):
     response = load_data("manage_instance_policy")
     policy: ManageInstancePolicy = ManageInstancePolicy.from_dict(response)

tests/unit/test_model_manage_invitation.py

-import json
 from funkwhale_api_client.models.manage_invitation import ManageInvitation
 
+
 def test_ManageInvitation(load_data):
     response = load_data("manage_invitation")
     invitation: ManageInvitation = ManageInvitation.from_dict(response)

tests/unit/test_model_manage_invitation_request.py

-import json
 from funkwhale_api_client.models.manage_invitation_request import ManageInvitationRequest
 
+
 def test_ManageInvitationRequest(load_data):
     response = load_data("manage_invitation_request")
     request: ManageInvitationRequest = ManageInvitationRequest.from_dict(response)

tests/unit/test_model_manage_library.py

-import json
 from funkwhale_api_client.models.manage_library import ManageLibrary
 
+
 def test_ManageLibrary(load_data):
     response = load_data("manage_library")
     library: ManageLibrary = ManageLibrary.from_dict(response)
 
     assert isinstance(library, ManageLibrary)
 
+
 def test_ManageLibraryStats(load_data):
     response = load_data("manage_library_stats")
     library_stats: ManageLibrary = ManageLibrary.from_dict(response)

tests/unit/test_model_manage_note.py

-import json
-from re import A
 from funkwhale_api_client.models.manage_note import ManageNote
 
+
 def test_ManageNote(load_data):
     response = load_data("manage_note")
     note: ManageNote = ManageNote.from_dict(response)

tests/unit/test_model_manage_note_request.py

-import json
 from funkwhale_api_client.models.manage_note_request import ManageNoteRequest
 
+
 def test_ManageNoteRequest(load_data):
     response = load_data("manage_note_request")
     note: ManageNoteRequest = ManageNoteRequest.from_dict(response)

tests/unit/test_model_manage_report.py

-import json
 from funkwhale_api_client.models.manage_report import ManageReport
 
+
 def test_ManageReport(load_data):
     response = load_data("manage_report")
     report: ManageReport = ManageReport.from_dict(response)

tests/unit/test_model_manage_report_request.py

-import json
 from funkwhale_api_client.models.manage_report_request import ManageReportRequest
 
+
 def test_ManageReportRequest(load_data):
     response = load_data("manage_report_request")
     request: ManageReportRequest = ManageReportRequest.from_dict(response)

tests/unit/test_model_manage_track.py

-import json
 from funkwhale_api_client.models.manage_track import ManageTrack
 
+
 def test_ManageTrack(load_data):
     response = load_data("manage_track")
     track: ManageTrack = ManageTrack.from_dict(response)

tests/unit/test_model_manage_upload.py

-import json
 from funkwhale_api_client.models.manage_upload import ManageUpload
 
+
 def test_ManageUpload(load_data):
     response = load_data("manage_upload")
     upload: ManageUpload = ManageUpload.from_dict(response)

tests/unit/test_model_manage_user.py

-import json
 from funkwhale_api_client.models.manage_user import ManageUser
 
+
 def test_ManageUser(load_data):
     response = load_data("manage_user")
     user: ManageUser = ManageUser.from_dict(response)

tests/unit/test_model_manage_user_request.py

-import json
 from funkwhale_api_client.models.manage_user_request import ManageUserRequest
 
+
 def test_ManageUserRequest(load_data):
     response = load_data("manage_user_request")
     user_request: ManageUserRequest = ManageUserRequest.from_dict(response)