"add_identifier_to_resource_type",
     "external_request",
     "internal_patient_search",
     "new_resource_hook",
     "sync_bundle",
-    "restore_patient"
+    "restore_patient",
 ]

 
 @fixture
 def internal_patient_duplicate_inactive_match(datadir):
     return load_json(datadir, "internal_patient_duplicate_inactive_match.json")
 
+
 def test_new_upsert(
     client,
     mocker,
     faux_token,
     external_patient_search,
     internal_patient_miss,
     new_patient,
-    ):
+):
     """Without finding a matching patient, should insert new and return"""
 
     # Mock HAPI search failing to find a matching patient
     mocker.patch(
         "patientsearch.models.sync.requests.get",

     client,
     mocker,
     faux_token,
     external_patient_search_active,
     internal_patient_miss,
-    new_patient_active
-    ):
+    new_patient_active,
+):
     """Without finding a matching patient, should insert new and return"""
 
     # Mock HAPI search failing to find a matching patient
     mocker.patch(
         "patientsearch.models.sync.requests.get",

     client,
     mocker,
     faux_token,
     external_patient_search_active,
     internal_patient_miss,
-    new_patient_active
-    ):
+    new_patient_active,
+):
     """Finding a matching inactive patient, user chose to generate new patient"""
 
     # Mock HAPI search finding a matching inactive
     mocker.patch(
         "patientsearch.models.sync.requests.get",

         assert len(entry["identifier"]) == 1
         assert entry["identifier"][0] == ident
 
 
 def test_existing(
-    client, 
-    mocker, 
-    faux_token, 
-    external_patient_search, 
-    internal_patient_match, 
+    client,
+    mocker,
+    faux_token,
+    external_patient_search,
+    internal_patient_match,
 ):
     """Finding a matching patient, return existing"""
 
     # Mock HAPI search finding a matching patient
     mocker.patch(

     result = sync_bundle(faux_token, external_patient_search)
     assert result == internal_patient_match["entry"][0]["resource"]
 
 
 def test_existing_active(
-    client, 
-    mocker, 
-    faux_token, 
-    external_patient_search_active,
-    internal_patient_active_match, 
+    client,
+    mocker,
+    faux_token,
+    external_patient_search_active,
+    internal_patient_active_match,
 ):
     """Finding a matching active patient from active external search, return existing"""
 
     # Mock HAPI search finding a matching active patient
     mocker.patch(

     result = sync_bundle(faux_token, external_patient_search_active)
     assert result != internal_patient_active_match["entry"][0]["resource"]
 
 
 def test_existing_inactive(
-    client, 
-    mocker, 
-    faux_token, 
-    external_patient_search_active,
-    internal_patient_inactive_match
+    client,
+    mocker,
+    faux_token,
+    external_patient_search_active,
+    internal_patient_inactive_match,
 ):
     """Finding a matching inactive patient from active external search, return existing restored"""
 
-    # Mock HAPI search finding a matching inactive patient 
+    # Mock HAPI search finding a matching inactive patient
     # when the service is called for the patient to be restored
     mocker.patch(
         "patientsearch.models.sync.requests.get",
         return_value=mock_response(internal_patient_inactive_match),
     )

     result = sync_bundle(faux_token, external_patient_search_active)
     assert result == internal_patient_inactive_match["entry"][0]["resource"]
 
 
 def test_existing_modified(
-    client,
-    mocker, 
-    faux_token, 
-    external_patient_search, 
-    internal_patient_match
+    client, mocker, faux_token, external_patient_search, internal_patient_match
 ):
     """Confirm modified external details get synchronized"""
 
     # Mock HAPI search finding a matching patient (w/o the identifier)
     assert "identifier" not in internal_patient_match["entry"][0]["resource"]

     # Confirm we get back the identified/patched patient from the PUT
     result = sync_bundle(faux_token, external_patient_search_w_identifier)
     assert result == identified_internal
     assert result["identifier"] == [found_identifier]
 
+
 def test_duplicate(
     client,
     mocker,
     faux_token,
     external_patient_search,

     )
 
     # Shouldn't kill the process, but return the first
     result = sync_bundle(faux_token, external_patient_search_active)
     assert result == internal_patient_duplicate_inactive_match["entry"][0]["resource"]
-

 
     if not different(src_patient, internal_patient):
         # If patient is active, proceed. If not, re-activate
         if internal_patient.get("active") != True:
             return internal_patient
-        
+
         params = patient_as_search_params(internal_patient)
         # Ensure it is active
         internal_patient["active"] = True
         return HAPI_request(
             token=token,

             resource=internal_patient,
             resource_id=internal_patient["id"],
         )
 
 
-def patient_as_search_params(patient, active_only = False):
+def patient_as_search_params(patient, active_only=False):
     """Generate HAPI search params from patient resource"""
 
     # Use same parameters sent to external src looking for existing Patient
     # Note FHIR uses list for 'name' and 'given', common parameter use defines just one
     search_map = (

             ("name.given[0]", "given", ""),
             ("name[0].given[0]", "given", ""),
             ("birthDate", "birthdate", "eq"),
             ("active", True, "eq"),
         )
-        
+
     search_params = {}
 
     for path, queryterm, compstr in search_map:
         match = json_search(path, patient)
         if match and isinstance(match, str):
             search_params[queryterm] = compstr + match
     return search_params
 
 
-def internal_patient_search(token, patient, active_only = False):
+def internal_patient_search(token, patient, active_only=False):
     """Look up given patient from "internal" HAPI store, returns bundle"""
     params = patient_as_search_params(patient, active_only)
 
     return HAPI_request(
         token=token, method="GET", resource_type="Patient", params=params

             current_app.logger.warning(
                 f"expected ONE matching patient, found {match_count}"
             )
 
         internal_patient = internal_search["entry"][0]["resource"]
-        #TODO: ask whether they prefer to merge and update active value or to start a new Patient for each sync attempt toward a non-active patient. 
+        # TODO: ask whether they prefer to merge and update active value or to start a new Patient for each sync attempt toward a non-active patient.
         merged_patient = _merge_patient(
             src_patient=patient, internal_patient=internal_patient, token=token
         )
         return merged_patient
 
     # No match, insert and return
     patient = new_resource_hook(resource=patient)
     patient["active"] = True
     return HAPI_request(
-        token=token, method="POST", resource_type="Patient", resource=patient,
+        token=token,
+        method="POST",
+        resource_type="Patient",
+        resource=patient,
     )
 
 
 def restore_patient(token, patient):
     """Restore single internal patient resource"""

     add_identifier_to_resource_type,
     external_request,
     internal_patient_search,
     new_resource_hook,
     sync_bundle,
-    restore_patient
+    restore_patient,
 )
 from patientsearch.extensions import oidc
 from patientsearch.jsonify_abort import jsonify_abort
 
 api_blueprint = Blueprint("patientsearch-api", __name__)

             extra["patient"]["subject.id"] = local_fhir_patient["id"]
     else:
         # See if local match already exists
         patient = resource_from_args(resource_type, request.args)
         try:
-            internal_bundle = internal_patient_search(token, patient, not reinstate_patient)
+            internal_bundle = internal_patient_search(
+                token, patient, not reinstate_patient
+            )
         except (RuntimeError, ValueError) as error:
             return jsonify_abort(status_code=400, message=str(error))
         local_fhir_patient = None
         if internal_bundle["total"] > 0:
             local_fhir_patient = internal_bundle["entry"][0]["resource"]

                 resource_type=resource_type,
                 resource=patient,
             )
             patient["active"] = True
             local_fhir_patient = HAPI_request(
-                token=token, method=method, resource_type="Patient", resource=patient)
+                token=token, method=method, resource_type="Patient", resource=patient
+            )
         except (RuntimeError, ValueError) as error:
             return jsonify_abort(status_code=400, message=str(error))
         audit_entry(
             "PDMP search failed; create new patient from search params", extra=extra
         )