code formatting for readability

src/registrar/config/urls.py

@@ -195,8 +195,8 @@ urlpatterns = [
         views.DomainDeleteUserView.as_view(http_method_names=["post"]),
         name="domain-user-delete",
     ),
-    path('get-domains-json/', get_domains_json, name='get_domains_json'),
+    path("get-domains-json/", get_domains_json, name="get_domains_json"),
-    path('get-domain-requests-json/', get_domain_requests_json, name='get_domain_requests_json'),
+    path("get-domain-requests-json/", get_domain_requests_json, name="get_domain_requests_json"),
 ]
 
 # Djangooidc strips out context data from that context, so we define a custom error

src/registrar/models/domain.py

@@ -1024,7 +1024,6 @@ class Domain(TimeStampedModel, DomainHelper):
         verbose_name="domain state",
     )
 
-
     expiration_date = DateField(
         null=True,
         help_text=("Date the domain expires in the registry"),
@@ -1066,9 +1065,9 @@ class Domain(TimeStampedModel, DomainHelper):
     def state_display(self):
         """Return the display status of the domain."""
         if self.is_expired() and self.state != self.State.UNKNOWN:
-            return 'Expired'
+            return "Expired"
         elif self.state == self.State.UNKNOWN or self.state == self.State.DNS_NEEDED:
-            return 'DNS needed'
+            return "DNS needed"
         else:
             return self.state.capitalize()
 

src/registrar/tests/test_views.py

@@ -164,9 +164,7 @@ class HomeTests(TestWithUser):
         deleted_text = "This domain has been removed and " "is no longer registered to your organization."
         dns_needed_text = "Before this domain can be used, "
         ready_text = "This domain has name servers and is ready for use."
-        on_hold_text = (
+        on_hold_text = "This domain is administratively paused, "
-            "This domain is administratively paused, "
-        )
         deleted_text = "This domain has been removed and " "is no longer registered to your organization."
         # Generate a mapping of domain names, the state, and expected messages for the subtest
         test_cases = [

src/registrar/tests/test_views_domain.py

@@ -239,7 +239,7 @@ class TestDomainDetail(TestDomainOverview):
 
             igorville = Domain.objects.get(name="igorville.gov")
             self.assertEquals(igorville.state, Domain.State.UNKNOWN)
-            detail_page = self.app.get(f'/domain/{igorville.id}')
+            detail_page = self.app.get(f"/domain/{igorville.id}")
             self.assertContains(detail_page, "Expired")
 
             self.assertNotContains(detail_page, "DNS needed")

src/registrar/tests/test_views_domains_json.py

@@ -3,27 +3,16 @@ from django.urls import reverse
 from .test_views import TestWithUser
 from django_webtest import WebTest  # type: ignore
 
+
 class GetDomainsJsonTest(TestWithUser, WebTest):
     def setUp(self):
         super().setUp()
         self.app.set_user(self.user.username)
 
         # Create test domains
-        self.domain1 = Domain.objects.create(
+        self.domain1 = Domain.objects.create(name="example1.com", expiration_date="2024-01-01", state="active")
-            name='example1.com',
+        self.domain2 = Domain.objects.create(name="example2.com", expiration_date="2024-02-01", state="inactive")
-            expiration_date='2024-01-01',
+        self.domain3 = Domain.objects.create(name="example3.com", expiration_date="2024-03-01", state="active")
-            state='active'
-        )
-        self.domain2 = Domain.objects.create(
-            name='example2.com',
-            expiration_date='2024-02-01',
-            state='inactive'
-        )
-        self.domain3 = Domain.objects.create(
-            name='example3.com',
-            expiration_date='2024-03-01',
-            state='active'
-        )
 
         # Create UserDomainRoles
         UserDomainRole.objects.create(user=self.user, domain=self.domain1)
@@ -34,68 +23,68 @@ class GetDomainsJsonTest(TestWithUser, WebTest):
         # Logout the user
         self.app.reset()
 
-        response = self.client.get(reverse('get_domains_json'))
+        response = self.client.get(reverse("get_domains_json"))
         self.assertEqual(response.status_code, 302)
 
     def test_get_domains_json_authenticated(self):
-        response = self.app.get(reverse('get_domains_json'))
+        response = self.app.get(reverse("get_domains_json"))
         self.assertEqual(response.status_code, 200)
         data = response.json
 
         # Check pagination info
-        self.assertEqual(data['page'], 1)
+        self.assertEqual(data["page"], 1)
-        self.assertFalse(data['has_next'])
+        self.assertFalse(data["has_next"])
-        self.assertFalse(data['has_previous'])
+        self.assertFalse(data["has_previous"])
-        self.assertEqual(data['num_pages'], 1)
+        self.assertEqual(data["num_pages"], 1)
 
         # Check domains
-        self.assertEqual(len(data['domains']), 3)
+        self.assertEqual(len(data["domains"]), 3)
-        domain_ids = [domain['id'] for domain in data['domains']]
+        domain_ids = [domain["id"] for domain in data["domains"]]
         self.assertIn(self.domain1.id, domain_ids)
         self.assertIn(self.domain2.id, domain_ids)
         self.assertIn(self.domain3.id, domain_ids)
 
     def test_pagination(self):
-        response = self.app.get(reverse('get_domains_json'), {'page': 1})
+        response = self.app.get(reverse("get_domains_json"), {"page": 1})
         self.assertEqual(response.status_code, 200)
         data = response.json
 
         # Check pagination info
-        self.assertEqual(data['page'], 1)
+        self.assertEqual(data["page"], 1)
-        self.assertFalse(data['has_next'])
+        self.assertFalse(data["has_next"])
-        self.assertFalse(data['has_previous'])
+        self.assertFalse(data["has_previous"])
-        self.assertEqual(data['num_pages'], 1)
+        self.assertEqual(data["num_pages"], 1)
 
     def test_sorting(self):
-        response = self.app.get(reverse('get_domains_json'), {'sort_by': 'expiration_date', 'order': 'desc'})
+        response = self.app.get(reverse("get_domains_json"), {"sort_by": "expiration_date", "order": "desc"})
         self.assertEqual(response.status_code, 200)
         data = response.json
 
         # Check if sorted by expiration_date in descending order
-        expiration_dates = [domain['expiration_date'] for domain in data['domains']]
+        expiration_dates = [domain["expiration_date"] for domain in data["domains"]]
         self.assertEqual(expiration_dates, sorted(expiration_dates, reverse=True))
 
-        response = self.app.get(reverse('get_domains_json'), {'sort_by': 'expiration_date', 'order': 'asc'})
+        response = self.app.get(reverse("get_domains_json"), {"sort_by": "expiration_date", "order": "asc"})
         self.assertEqual(response.status_code, 200)
         data = response.json
 
         # Check if sorted by expiration_date in ascending order
-        expiration_dates = [domain['expiration_date'] for domain in data['domains']]
+        expiration_dates = [domain["expiration_date"] for domain in data["domains"]]
         self.assertEqual(expiration_dates, sorted(expiration_dates))
 
     def test_sorting_by_state_display(self):
-        response = self.app.get(reverse('get_domains_json'), {'sort_by': 'state_display', 'order': 'asc'})
+        response = self.app.get(reverse("get_domains_json"), {"sort_by": "state_display", "order": "asc"})
         self.assertEqual(response.status_code, 200)
         data = response.json
 
         # Check if sorted by state_display in ascending order
-        states = [domain['state_display'] for domain in data['domains']]
+        states = [domain["state_display"] for domain in data["domains"]]
         self.assertEqual(states, sorted(states))
 
-        response = self.app.get(reverse('get_domains_json'), {'sort_by': 'state_display', 'order': 'desc'})
+        response = self.app.get(reverse("get_domains_json"), {"sort_by": "state_display", "order": "desc"})
         self.assertEqual(response.status_code, 200)
         data = response.json
 
         # Check if sorted by state_display in descending order
-        states = [domain['state_display'] for domain in data['domains']]
+        states = [domain["state_display"] for domain in data["domains"]]
         self.assertEqual(states, sorted(states, reverse=True))

src/registrar/tests/test_views_request.py

@@ -48,7 +48,7 @@ class DomainRequestTests(TestWithUser, WebTest):
     def test_domain_request_form_intro_is_skipped_when_edit_access(self):
         """Tests that user is NOT presented with intro acknowledgement page when accessed through 'edit'"""
         domain_request = completed_domain_request(status=DomainRequest.DomainRequestStatus.STARTED, user=self.user)
-        detail_page = self.app.get(f'/domain-request/{domain_request.id}/edit/')
+        detail_page = self.app.get(f"/domain-request/{domain_request.id}/edit/")
         # Check that the response is a redirect
         self.assertEqual(detail_page.status_code, 302)
         # You can access the 'Location' header to get the redirect URL
@@ -2399,7 +2399,7 @@ class DomainRequestTestDifferentStatuses(TestWithUser, WebTest):
         domain_request = completed_domain_request(status=DomainRequest.DomainRequestStatus.SUBMITTED, user=self.user)
         domain_request.save()
 
-        detail_page = self.app.get(f'/domain-request/{domain_request.id}')
+        detail_page = self.app.get(f"/domain-request/{domain_request.id}")
         self.assertContains(detail_page, "city.gov")
         self.assertContains(detail_page, "city1.gov")
         self.assertContains(detail_page, "Chief Tester")
@@ -2416,7 +2416,7 @@ class DomainRequestTestDifferentStatuses(TestWithUser, WebTest):
         domain_request = completed_domain_request(status=DomainRequest.DomainRequestStatus.SUBMITTED, user=self.user)
         domain_request.save()
 
-        detail_page = self.app.get(f'/domain-request/{domain_request.id}')
+        detail_page = self.app.get(f"/domain-request/{domain_request.id}")
         self.assertContains(detail_page, "city.gov")
         self.assertContains(detail_page, "Chief Tester")
         self.assertContains(detail_page, "testy@town.com")
@@ -2428,7 +2428,7 @@ class DomainRequestTestDifferentStatuses(TestWithUser, WebTest):
         domain_request = completed_domain_request(status=DomainRequest.DomainRequestStatus.SUBMITTED, user=self.user)
         domain_request.save()
 
-        detail_page = self.app.get(f'/domain-request/{domain_request.id}')
+        detail_page = self.app.get(f"/domain-request/{domain_request.id}")
         self.assertContains(detail_page, "city.gov")
         self.assertContains(detail_page, "city1.gov")
         self.assertContains(detail_page, "Chief Tester")
@@ -2450,7 +2450,7 @@ class DomainRequestTestDifferentStatuses(TestWithUser, WebTest):
             target_status_code=200,
             fetch_redirect_response=True,
         )
-        response = self.client.get('/get-domain-requests-json/')
+        response = self.client.get("/get-domain-requests-json/")
         self.assertContains(response, "Withdrawn")
 
     def test_domain_request_withdraw_no_permissions(self):
@@ -2460,7 +2460,7 @@ class DomainRequestTestDifferentStatuses(TestWithUser, WebTest):
         domain_request = completed_domain_request(status=DomainRequest.DomainRequestStatus.SUBMITTED, user=self.user)
         domain_request.save()
 
-        detail_page = self.app.get(f'/domain-request/{domain_request.id}')
+        detail_page = self.app.get(f"/domain-request/{domain_request.id}")
         self.assertContains(detail_page, "city.gov")
         self.assertContains(detail_page, "city1.gov")
         self.assertContains(detail_page, "Chief Tester")
@@ -2532,8 +2532,8 @@ class TestWizardUnlockingSteps(TestWithUser, WebTest):
 
         domain_request = completed_domain_request(status=DomainRequest.DomainRequestStatus.STARTED, user=self.user)
 
-        response = self.app.get(f'/domain-request/{domain_request.id}/edit/')
+        response = self.app.get(f"/domain-request/{domain_request.id}/edit/")
-         # django-webtest does not handle cookie-based sessions well because it keeps
+        # django-webtest does not handle cookie-based sessions well because it keeps
         # resetting the session key on each new request, thus destroying the concept
         # of a "session". We are going to do it manually, saving the session ID here
         # and then setting the cookie on each request.
@@ -2590,7 +2590,7 @@ class TestWizardUnlockingSteps(TestWithUser, WebTest):
         )
         domain_request.other_contacts.set([contact_2])
 
-        response = self.app.get(f'/domain-request/{domain_request.id}/edit/')
+        response = self.app.get(f"/domain-request/{domain_request.id}/edit/")
         # django-webtest does not handle cookie-based sessions well because it keeps
         # resetting the session key on each new request, thus destroying the concept
         # of a "session". We are going to do it manually, saving the session ID here

src/registrar/tests/test_views_requests_json.py

@@ -1,10 +1,9 @@
-from django.test import Client
-from django.contrib.auth.models import User
 from registrar.models import DomainRequest
 from django.urls import reverse
 from .test_views import TestWithUser
 from django_webtest import WebTest  # type: ignore
 
+
 class DomainRequestViewTest(TestWithUser, WebTest):
     def setUp(self):
         super().setUp()
@@ -17,146 +16,146 @@ class DomainRequestViewTest(TestWithUser, WebTest):
                 requested_domain=None,  # Assuming requested_domain is an optional field
                 submission_date="2024-01-01",
                 status=DomainRequest.DomainRequestStatus.STARTED,
-                created_at="2024-01-01"
+                created_at="2024-01-01",
             ),
             DomainRequest.objects.create(
                 creator=self.user,
                 requested_domain=None,
                 submission_date="2024-02-01",
                 status=DomainRequest.DomainRequestStatus.WITHDRAWN,
-                created_at="2024-02-01"
+                created_at="2024-02-01",
             ),
             DomainRequest.objects.create(
                 creator=self.user,
                 requested_domain=None,
                 submission_date="2024-03-01",
                 status=DomainRequest.DomainRequestStatus.REJECTED,
-                created_at="2024-03-01"
+                created_at="2024-03-01",
             ),
             DomainRequest.objects.create(
                 creator=self.user,
                 requested_domain=None,
                 submission_date="2024-04-01",
                 status=DomainRequest.DomainRequestStatus.STARTED,
-                created_at="2024-04-01"
+                created_at="2024-04-01",
             ),
             DomainRequest.objects.create(
                 creator=self.user,
                 requested_domain=None,  # Assuming requested_domain is an optional field
                 submission_date="2024-05-01",
                 status=DomainRequest.DomainRequestStatus.STARTED,
-                created_at="2024-05-01"
+                created_at="2024-05-01",
             ),
             DomainRequest.objects.create(
                 creator=self.user,
                 requested_domain=None,
                 submission_date="2024-06-01",
                 status=DomainRequest.DomainRequestStatus.WITHDRAWN,
-                created_at="2024-06-01"
+                created_at="2024-06-01",
             ),
             DomainRequest.objects.create(
                 creator=self.user,
                 requested_domain=None,
                 submission_date="2024-07-01",
                 status=DomainRequest.DomainRequestStatus.REJECTED,
-                created_at="2024-07-01"
+                created_at="2024-07-01",
             ),
             DomainRequest.objects.create(
                 creator=self.user,
                 requested_domain=None,
                 submission_date="2024-08-01",
                 status=DomainRequest.DomainRequestStatus.STARTED,
-                created_at="2024-08-01"
+                created_at="2024-08-01",
             ),
             DomainRequest.objects.create(
                 creator=self.user,
                 requested_domain=None,  # Assuming requested_domain is an optional field
                 submission_date="2024-09-01",
                 status=DomainRequest.DomainRequestStatus.STARTED,
-                created_at="2024-09-01"
+                created_at="2024-09-01",
             ),
             DomainRequest.objects.create(
                 creator=self.user,
                 requested_domain=None,
                 submission_date="2024-10-01",
                 status=DomainRequest.DomainRequestStatus.WITHDRAWN,
-                created_at="2024-10-01"
+                created_at="2024-10-01",
             ),
             DomainRequest.objects.create(
                 creator=self.user,
                 requested_domain=None,
                 submission_date="2024-11-01",
                 status=DomainRequest.DomainRequestStatus.REJECTED,
-                created_at="2024-11-01"
+                created_at="2024-11-01",
             ),
             DomainRequest.objects.create(
                 creator=self.user,
                 requested_domain=None,
                 submission_date="2024-12-01",
                 status=DomainRequest.DomainRequestStatus.APPROVED,
-                created_at="2024-12-01"
+                created_at="2024-12-01",
-            )
+            ),
         ]
 
     def test_get_domain_requests_json_authenticated(self):
-        response = self.app.get(reverse('get_domain_requests_json'))
+        response = self.app.get(reverse("get_domain_requests_json"))
         self.assertEqual(response.status_code, 200)
         data = response.json
 
         # Check pagination info
-        self.assertEqual(data['page'], 1)
+        self.assertEqual(data["page"], 1)
-        self.assertTrue(data['has_next'])
+        self.assertTrue(data["has_next"])
-        self.assertFalse(data['has_previous'])
+        self.assertFalse(data["has_previous"])
-        self.assertEqual(data['num_pages'], 2)
+        self.assertEqual(data["num_pages"], 2)
 
         # Check domain requests
-        self.assertEqual(len(data['domain_requests']), 10)
+        self.assertEqual(len(data["domain_requests"]), 10)
-        for domain_request in data['domain_requests']:
+        for domain_request in data["domain_requests"]:
-            self.assertNotEqual(domain_request['status'], 'Approved')
+            self.assertNotEqual(domain_request["status"], "Approved")
 
     def test_pagination(self):
-        response = self.app.get(reverse('get_domain_requests_json'), {'page': 1})
+        response = self.app.get(reverse("get_domain_requests_json"), {"page": 1})
         self.assertEqual(response.status_code, 200)
         data = response.json
 
         # Check pagination info
-        self.assertEqual(data['page'], 1)
+        self.assertEqual(data["page"], 1)
-        self.assertTrue(data['has_next'])
+        self.assertTrue(data["has_next"])
-        self.assertFalse(data['has_previous'])
+        self.assertFalse(data["has_previous"])
-        self.assertEqual(data['num_pages'], 2)
+        self.assertEqual(data["num_pages"], 2)
 
-        response = self.app.get(reverse('get_domain_requests_json'), {'page': 2})
+        response = self.app.get(reverse("get_domain_requests_json"), {"page": 2})
         self.assertEqual(response.status_code, 200)
         data = response.json
 
         # Check pagination info
-        self.assertEqual(data['page'], 2)
+        self.assertEqual(data["page"], 2)
-        self.assertFalse(data['has_next'])
+        self.assertFalse(data["has_next"])
-        self.assertTrue(data['has_previous'])
+        self.assertTrue(data["has_previous"])
-        self.assertEqual(data['num_pages'], 2)
+        self.assertEqual(data["num_pages"], 2)
 
     def test_sorting(self):
-        response = self.app.get(reverse('get_domain_requests_json'), {'sort_by': 'submission_date', 'order': 'desc'})
+        response = self.app.get(reverse("get_domain_requests_json"), {"sort_by": "submission_date", "order": "desc"})
         self.assertEqual(response.status_code, 200)
         data = response.json
 
         # Check if sorted by submission_date in descending order
-        submission_dates = [req['submission_date'] for req in data['domain_requests']]
+        submission_dates = [req["submission_date"] for req in data["domain_requests"]]
         self.assertEqual(submission_dates, sorted(submission_dates, reverse=True))
 
-        response = self.app.get(reverse('get_domain_requests_json'), {'sort_by': 'submission_date', 'order': 'asc'})
+        response = self.app.get(reverse("get_domain_requests_json"), {"sort_by": "submission_date", "order": "asc"})
         self.assertEqual(response.status_code, 200)
         data = response.json
 
         # Check if sorted by submission_date in ascending order
-        submission_dates = [req['submission_date'] for req in data['domain_requests']]
+        submission_dates = [req["submission_date"] for req in data["domain_requests"]]
         self.assertEqual(submission_dates, sorted(submission_dates))
 
     def test_filter_approved_excluded(self):
-        response = self.app.get(reverse('get_domain_requests_json'))
+        response = self.app.get(reverse("get_domain_requests_json"))
         self.assertEqual(response.status_code, 200)
         data = response.json
 
         # Ensure no approved requests are included
-        for domain_request in data['domain_requests']:
+        for domain_request in data["domain_requests"]:
-            self.assertNotEqual(domain_request['status'], DomainRequest.DomainRequestStatus.APPROVED)
+            self.assertNotEqual(domain_request["status"], DomainRequest.DomainRequestStatus.APPROVED)

src/registrar/views/domain_requests_json.py

@@ -2,42 +2,46 @@ from django.http import JsonResponse
 from django.core.paginator import Paginator
 from registrar.models import DomainRequest
 
+
 def get_domain_requests_json(request):
     """Given the current request,
     get all domain requests that are associated with the request user and exclude the APPROVED ones"""
 
     if not request.user.is_authenticated:
-        return JsonResponse({'error': 'User not authenticated'}, status=401)
+        return JsonResponse({"error": "User not authenticated"}, status=401)
 
     domain_requests = DomainRequest.objects.filter(creator=request.user).exclude(
         status=DomainRequest.DomainRequestStatus.APPROVED
     )
     # Handle sorting
-    sort_by = request.GET.get('sort_by', 'id')  # Default to 'id'
+    sort_by = request.GET.get("sort_by", "id")  # Default to 'id'
-    order = request.GET.get('order', 'asc')  # Default to 'asc'
+    order = request.GET.get("order", "asc")  # Default to 'asc'
-    if order == 'desc':
+    if order == "desc":
-        sort_by = f'-{sort_by}'
+        sort_by = f"-{sort_by}"
     domain_requests = domain_requests.order_by(sort_by)
-    page_number = request.GET.get('page', 1)
+    page_number = request.GET.get("page", 1)
     paginator = Paginator(domain_requests, 10)  # Adjust the number of items per page as needed
     page_obj = paginator.get_page(page_number)
 
     domain_requests_data = [
         {
-            'requested_domain': domain_request.requested_domain.name if domain_request.requested_domain else None,
+            "requested_domain": domain_request.requested_domain.name if domain_request.requested_domain else None,
-            'submission_date': domain_request.submission_date,
+            "submission_date": domain_request.submission_date,
-            'status': domain_request.get_status_display(),
+            "status": domain_request.get_status_display(),
-            'created_at': domain_request.created_at,
+            "created_at": domain_request.created_at,
-            'id': domain_request.id,
+            "id": domain_request.id,
-            'is_deletable': domain_request.status in [DomainRequest.DomainRequestStatus.STARTED, DomainRequest.DomainRequestStatus.WITHDRAWN],
+            "is_deletable": domain_request.status
+            in [DomainRequest.DomainRequestStatus.STARTED, DomainRequest.DomainRequestStatus.WITHDRAWN],
         }
         for domain_request in page_obj
     ]
 
-    return JsonResponse({
+    return JsonResponse(
-        'domain_requests': domain_requests_data,
+        {
-        'has_next': page_obj.has_next(),
+            "domain_requests": domain_requests_data,
-        'has_previous': page_obj.has_previous(),
+            "has_next": page_obj.has_next(),
-        'page': page_obj.number,
+            "has_previous": page_obj.has_previous(),
-        'num_pages': paginator.num_pages,
+            "page": page_obj.number,
-    })
+            "num_pages": paginator.num_pages,
+        }
+    )

src/registrar/views/domains_json.py

@@ -2,12 +2,13 @@ from django.http import JsonResponse
 from django.core.paginator import Paginator
 from registrar.models import UserDomainRole, Domain
 
+
 def get_domains_json(request):
     """Given the current request,
     get all domains that are associated with the UserDomainRole object"""
 
     if not request.user.is_authenticated:
-        return JsonResponse({'error': 'User not authenticated'}, status=401)
+        return JsonResponse({"error": "User not authenticated"}, status=401)
 
     user_domain_roles = UserDomainRole.objects.filter(user=request.user)
     domain_ids = user_domain_roles.values_list("domain_id", flat=True)
@@ -15,40 +16,42 @@ def get_domains_json(request):
     objects = Domain.objects.filter(id__in=domain_ids)
 
     # Handle sorting
-    sort_by = request.GET.get('sort_by', 'id')  # Default to 'id'
+    sort_by = request.GET.get("sort_by", "id")  # Default to 'id'
-    order = request.GET.get('order', 'asc')  # Default to 'asc'
+    order = request.GET.get("order", "asc")  # Default to 'asc'
 
-    if sort_by == 'state_display':
+    if sort_by == "state_display":
         # Fetch the objects and sort them in Python
         objects = list(objects)  # Evaluate queryset to a list
-        objects.sort(key=lambda domain: domain.state_display(), reverse=(order == 'desc'))
+        objects.sort(key=lambda domain: domain.state_display(), reverse=(order == "desc"))
     else:
-        if order == 'desc':
+        if order == "desc":
-            sort_by = f'-{sort_by}'
+            sort_by = f"-{sort_by}"
         objects = objects.order_by(sort_by)
 
     paginator = Paginator(objects, 10)
-    page_number = request.GET.get('page')
+    page_number = request.GET.get("page")
     page_obj = paginator.get_page(page_number)
 
     # Convert objects to JSON-serializable format
     domains = [
         {
-            'id': domain.id,
+            "id": domain.id,
-            'name': domain.name,
+            "name": domain.name,
-            'expiration_date': domain.expiration_date,
+            "expiration_date": domain.expiration_date,
-            'state': domain.state,
+            "state": domain.state,
-            'state_display': domain.state_display(),
+            "state_display": domain.state_display(),
-            'get_state_help_text': domain.get_state_help_text(),
+            "get_state_help_text": domain.get_state_help_text(),
             # Add other fields as necessary
         }
         for domain in page_obj.object_list
     ]
 
-    return JsonResponse({
+    return JsonResponse(
-        'domains': domains,
+        {
-        'page': page_obj.number,
+            "domains": domains,
-        'num_pages': paginator.num_pages,
+            "page": page_obj.number,
-        'has_previous': page_obj.has_previous(),
+            "num_pages": paginator.num_pages,
-        'has_next': page_obj.has_next(),
+            "has_previous": page_obj.has_previous(),
-    })
+            "has_next": page_obj.has_next(),
+        }
+    )

src/registrar/views/index.py

@@ -13,7 +13,6 @@ def index(request):
 
         context["domain_requests"] = domain_requests
 
-
         # Determine if the user will see domain requests that they can delete
         has_deletable_domain_requests = deletable_domain_requests.exists()
         context["has_deletable_domain_requests"] = has_deletable_domain_requests
@@ -52,4 +51,3 @@ def _get_domain_requests(request):
     deletable_domain_requests = domain_requests.filter(status__in=valid_statuses)
 
     return (domain_requests, deletable_domain_requests)
-