python: Reformat with Black, except quotes.

Signed-off-by: Anders Kaseorg <anders@zulip.com>

zerver/openapi/python_examples.py

@@ -32,6 +32,7 @@ CALLED_TEST_FUNCTIONS: Set[str] = set()
 
 FuncT = TypeVar("FuncT", bound=Callable[..., object])
 
+
 def openapi_test_function(endpoint: str) -> Callable[[FuncT], FuncT]:
     """This decorator is used to register an OpenAPI test function with
     its endpoint. Example usage:
@@ -39,6 +40,7 @@ def openapi_test_function(endpoint: str) -> Callable[[FuncT], FuncT]:
     @openapi_test_function("/messages/render:post")
     def ...
     """
+
     def wrapper(test_func: FuncT) -> FuncT:
         @wraps(test_func)
         def _record_calls_wrapper(*args: object, **kwargs: object) -> object:
@@ -49,8 +51,10 @@ def openapi_test_function(endpoint: str) -> Callable[[FuncT], FuncT]:
         TEST_FUNCTIONS[endpoint] = _record_calls_wrapper
 
         return cast(FuncT, _record_calls_wrapper)  # https://github.com/python/mypy/issues/1927
+
     return wrapper
 
+
 def ensure_users(ids_list: List[int], user_names: List[str]) -> None:
     # Ensure that the list of user ids (ids_list)
     # matches the users we want to refer to (user_names).
@@ -59,6 +63,7 @@ def ensure_users(ids_list: List[int], user_names: List[str]) -> None:
 
     assert ids_list == user_ids
 
+
 @openapi_test_function("/users/me/subscriptions:post")
 def add_subscriptions(client: Client) -> None:
 
@@ -74,8 +79,7 @@ def add_subscriptions(client: Client) -> None:
     )
     # {code_example|end}
 
-    validate_against_openapi_schema(result, '/users/me/subscriptions', 'post',
-                                    '200_0')
+    validate_against_openapi_schema(result, '/users/me/subscriptions', 'post', '200_0')
 
     # {code_example|start}
     # To subscribe other users to a stream, you may pass
@@ -91,6 +95,7 @@ def add_subscriptions(client: Client) -> None:
     assert result['result'] == 'success'
     assert 'newbie@zulip.com' in result['subscribed']
 
+
 def test_add_subscriptions_already_subscribed(client: Client) -> None:
     result = client.add_subscriptions(
         streams=[
@@ -99,8 +104,8 @@ def test_add_subscriptions_already_subscribed(client: Client) -> None:
         principals=['newbie@zulip.com'],
     )
 
-    validate_against_openapi_schema(result, '/users/me/subscriptions', 'post',
-                                    '200_1')
+    validate_against_openapi_schema(result, '/users/me/subscriptions', 'post', '200_1')
+
 
 def test_authorization_errors_fatal(client: Client, nonadmin_client: Client) -> None:
     client.add_subscriptions(
@@ -123,8 +128,7 @@ def test_authorization_errors_fatal(client: Client, nonadmin_client: Client) ->
         authorization_errors_fatal=False,
     )
 
-    validate_against_openapi_schema(result, '/users/me/subscriptions', 'post',
-                                    '400_0')
+    validate_against_openapi_schema(result, '/users/me/subscriptions', 'post', '400_0')
 
     result = nonadmin_client.add_subscriptions(
         streams=[
@@ -133,8 +137,8 @@ def test_authorization_errors_fatal(client: Client, nonadmin_client: Client) ->
         authorization_errors_fatal=True,
     )
 
-    validate_against_openapi_schema(result, '/users/me/subscriptions', 'post',
-                                    '400_1')
+    validate_against_openapi_schema(result, '/users/me/subscriptions', 'post', '400_1')
+
 
 @openapi_test_function("/users/{email}/presence:get")
 def get_user_presence(client: Client) -> None:
@@ -146,6 +150,7 @@ def get_user_presence(client: Client) -> None:
 
     validate_against_openapi_schema(result, '/users/{email}/presence', 'get', '200')
 
+
 @openapi_test_function("/users/me/presence:post")
 def update_presence(client: Client) -> None:
     request = {
@@ -158,6 +163,7 @@ def update_presence(client: Client) -> None:
 
     assert result['result'] == 'success'
 
+
 @openapi_test_function("/users:post")
 def create_user(client: Client) -> None:
 
@@ -178,6 +184,7 @@ def create_user(client: Client) -> None:
 
     validate_against_openapi_schema(result, '/users', 'post', '400')
 
+
 @openapi_test_function("/users:get")
 def get_members(client: Client) -> None:
 
@@ -214,6 +221,7 @@ def get_members(client: Client) -> None:
         else:
             assert member.get('profile_data', None) is not None
 
+
 @openapi_test_function("/users/{user_id}:get")
 def get_single_user(client: Client) -> None:
 
@@ -230,6 +238,7 @@ def get_single_user(client: Client) -> None:
     # {code_example|end}
     validate_against_openapi_schema(result, '/users/{user_id}', 'get', '200')
 
+
 @openapi_test_function("/users/{user_id}:delete")
 def deactivate_user(client: Client) -> None:
 
@@ -240,6 +249,7 @@ def deactivate_user(client: Client) -> None:
     # {code_example|end}
     validate_against_openapi_schema(result, '/users/{user_id}', 'delete', '200')
 
+
 @openapi_test_function("/users/{user_id}/reactivate:post")
 def reactivate_user(client: Client) -> None:
     # {code_example|start}
@@ -249,23 +259,25 @@ def reactivate_user(client: Client) -> None:
     # {code_example|end}
     validate_against_openapi_schema(result, '/users/{user_id}/reactivate', 'post', '200')
 
+
 @openapi_test_function("/users/{user_id}:patch")
 def update_user(client: Client) -> None:
 
     # {code_example|start}
     # Change a user's full name.
     user_id = 10
-    result = client.update_user_by_id(user_id, full_name = "New Name")
+    result = client.update_user_by_id(user_id, full_name="New Name")
     # {code_example|end}
     validate_against_openapi_schema(result, '/users/{user_id}', 'patch', '200')
 
     # {code_example|start}
     # Change value of the custom profile field with ID 9.
     user_id = 8
-    result = client.update_user_by_id(user_id, profile_data = [{'id': 9, 'value': 'some data'}])
+    result = client.update_user_by_id(user_id, profile_data=[{'id': 9, 'value': 'some data'}])
     # {code_example|end}
     validate_against_openapi_schema(result, '/users/{user_id}', 'patch', '400')
 
+
 @openapi_test_function("/users/{user_id}/subscriptions/{stream_id}:get")
 def get_subscription_status(client: Client) -> None:
     # {code_example|start}
@@ -277,7 +289,10 @@ def get_subscription_status(client: Client) -> None:
         method='GET',
     )
     # {code_example|end}
-    validate_against_openapi_schema(result, '/users/{user_id}/subscriptions/{stream_id}', 'get', '200')
+    validate_against_openapi_schema(
+        result, '/users/{user_id}/subscriptions/{stream_id}', 'get', '200'
+    )
+
 
 @openapi_test_function("/realm/filters:get")
 def get_realm_filters(client: Client) -> None:
@@ -289,6 +304,7 @@ def get_realm_filters(client: Client) -> None:
 
     validate_against_openapi_schema(result, '/realm/filters', 'get', '200')
 
+
 @openapi_test_function("/realm/profile_fields:get")
 def get_realm_profile_fields(client: Client) -> None:
     # {code_example|start}
@@ -300,54 +316,45 @@ def get_realm_profile_fields(client: Client) -> None:
     # {code_example|end}
     validate_against_openapi_schema(result, '/realm/profile_fields', 'get', '200')
 
+
 @openapi_test_function("/realm/profile_fields:patch")
 def reorder_realm_profile_fields(client: Client) -> None:
     # {code_example|start}
     # Reorder the custom profile fields in the user's organization.
     order = [8, 7, 6, 5, 4, 3, 2, 1]
-    request = {
-        'order': json.dumps(order)
-    }
+    request = {'order': json.dumps(order)}
 
-    result = client.call_endpoint(
-        url='/realm/profile_fields',
-        method='PATCH',
-        request=request
-    )
+    result = client.call_endpoint(url='/realm/profile_fields', method='PATCH', request=request)
     # {code_example|end}
     validate_against_openapi_schema(result, '/realm/profile_fields', 'patch', '200')
 
+
 @openapi_test_function("/realm/profile_fields:post")
 def create_realm_profile_field(client: Client) -> None:
     # {code_example|start}
     # Create a custom profile field in the user's organization.
-    request = {
-        'name': 'Phone',
-        'hint': 'Contact No.',
-        'field_type': 1
-    }
+    request = {'name': 'Phone', 'hint': 'Contact No.', 'field_type': 1}
 
-    result = client.call_endpoint(
-        url='/realm/profile_fields',
-        method='POST',
-        request=request
-    )
+    result = client.call_endpoint(url='/realm/profile_fields', method='POST', request=request)
     # {code_example|end}
 
     validate_against_openapi_schema(result, '/realm/profile_fields', 'post', '200')
 
+
 @openapi_test_function("/realm/filters:post")
 def add_realm_filter(client: Client) -> None:
 
     # {code_example|start}
     # Add a filter to automatically linkify #<number> to the corresponding
     # issue in Zulip's server repo
-    result = client.add_realm_filter('#(?P<id>[0-9]+)',
-                                     'https://github.com/zulip/zulip/issues/%(id)s')
+    result = client.add_realm_filter(
+        '#(?P<id>[0-9]+)', 'https://github.com/zulip/zulip/issues/%(id)s'
+    )
     # {code_example|end}
 
     validate_against_openapi_schema(result, '/realm/filters', 'post', '200')
 
+
 @openapi_test_function("/realm/filters/{filter_id}:delete")
 def remove_realm_filter(client: Client) -> None:
 
@@ -358,6 +365,7 @@ def remove_realm_filter(client: Client) -> None:
 
     validate_against_openapi_schema(result, '/realm/filters/{filter_id}', 'delete', '200')
 
+
 @openapi_test_function("/users/me:get")
 def get_profile(client: Client) -> None:
 
@@ -369,6 +377,7 @@ def get_profile(client: Client) -> None:
 
     validate_against_openapi_schema(result, '/users/me', 'get', '200')
 
+
 @openapi_test_function("/get_stream_id:get")
 def get_stream_id(client: Client) -> int:
 
@@ -382,6 +391,7 @@ def get_stream_id(client: Client) -> int:
 
     return result['stream_id']
 
+
 @openapi_test_function("/streams/{stream_id}:delete")
 def delete_stream(client: Client, stream_id: int) -> None:
     result = client.add_subscriptions(
@@ -402,6 +412,7 @@ def delete_stream(client: Client, stream_id: int) -> None:
 
     assert result['result'] == 'success'
 
+
 @openapi_test_function("/streams:get")
 def get_streams(client: Client) -> None:
 
@@ -423,6 +434,7 @@ def get_streams(client: Client) -> None:
     validate_against_openapi_schema(result, '/streams', 'get', '200')
     assert len(result['streams']) == 4
 
+
 @openapi_test_function("/streams/{stream_id}:patch")
 def update_stream(client: Client, stream_id: int) -> None:
 
@@ -440,6 +452,7 @@ def update_stream(client: Client, stream_id: int) -> None:
     validate_against_openapi_schema(result, '/streams/{stream_id}', 'patch', '200')
     assert result['result'] == 'success'
 
+
 @openapi_test_function("/user_groups:get")
 def get_user_groups(client: Client) -> int:
 
@@ -449,29 +462,31 @@ def get_user_groups(client: Client) -> int:
     # {code_example|end}
 
     validate_against_openapi_schema(result, '/user_groups', 'get', '200')
-    hamlet_user_group = [u for u in result['user_groups']
-                         if u['name'] == "hamletcharacters"][0]
+    hamlet_user_group = [u for u in result['user_groups'] if u['name'] == "hamletcharacters"][0]
     assert hamlet_user_group['description'] == 'Characters of Hamlet'
 
-    marketing_user_group = [u for u in result['user_groups']
-                            if u['name'] == "marketing"][0]
+    marketing_user_group = [u for u in result['user_groups'] if u['name'] == "marketing"][0]
     return marketing_user_group['id']
 
+
 def test_user_not_authorized_error(nonadmin_client: Client) -> None:
     result = nonadmin_client.get_streams(include_all_active=True)
 
     validate_against_openapi_schema(result, '/rest-error-handling', 'post', '400_2')
 
+
 def get_subscribers(client: Client) -> None:
 
     result = client.get_subscribers(stream='new stream')
     assert result['subscribers'] == ['iago@zulip.com', 'newbie@zulip.com']
 
+
 def get_user_agent(client: Client) -> None:
 
     result = client.get_user_agent()
     assert result.startswith('ZulipPython/')
 
+
 @openapi_test_function("/users/me/subscriptions:get")
 def list_subscriptions(client: Client) -> None:
     # {code_example|start}
@@ -479,12 +494,12 @@ def list_subscriptions(client: Client) -> None:
     result = client.list_subscriptions()
     # {code_example|end}
 
-    validate_against_openapi_schema(result, '/users/me/subscriptions',
-                                    'get', '200')
+    validate_against_openapi_schema(result, '/users/me/subscriptions', 'get', '200')
 
     streams = [s for s in result['subscriptions'] if s['name'] == 'new stream']
     assert streams[0]['description'] == 'New stream for testing'
 
+
 @openapi_test_function("/users/me/subscriptions:delete")
 def remove_subscriptions(client: Client) -> None:
 
@@ -495,8 +510,7 @@ def remove_subscriptions(client: Client) -> None:
     )
     # {code_example|end}
 
-    validate_against_openapi_schema(result, '/users/me/subscriptions',
-                                    'delete', '200')
+    validate_against_openapi_schema(result, '/users/me/subscriptions', 'delete', '200')
 
     # test it was actually removed
     result = client.list_subscriptions()
@@ -512,8 +526,8 @@ def remove_subscriptions(client: Client) -> None:
     )
     # {code_example|end}
 
-    validate_against_openapi_schema(result, '/users/me/subscriptions',
-                                    'delete', '200')
+    validate_against_openapi_schema(result, '/users/me/subscriptions', 'delete', '200')
+
 
 @openapi_test_function("/users/me/subscriptions/muted_topics:patch")
 def toggle_mute_topic(client: Client) -> None:
@@ -540,9 +554,7 @@ def toggle_mute_topic(client: Client) -> None:
     result = client.mute_topic(request)
     # {code_example|end}
 
-    validate_against_openapi_schema(result,
-                                    '/users/me/subscriptions/muted_topics',
-                                    'patch', '200')
+    validate_against_openapi_schema(result, '/users/me/subscriptions/muted_topics', 'patch', '200')
 
     # {code_example|start}
     # Unmute the topic "boat party" in the stream "Denmark"
@@ -555,9 +567,8 @@ def toggle_mute_topic(client: Client) -> None:
     result = client.mute_topic(request)
     # {code_example|end}
 
-    validate_against_openapi_schema(result,
-                                    '/users/me/subscriptions/muted_topics',
-                                    'patch', '200')
+    validate_against_openapi_schema(result, '/users/me/subscriptions/muted_topics', 'patch', '200')
+
 
 @openapi_test_function("/mark_all_as_read:post")
 def mark_all_as_read(client: Client) -> None:
@@ -569,6 +580,7 @@ def mark_all_as_read(client: Client) -> None:
 
     validate_against_openapi_schema(result, '/mark_all_as_read', 'post', '200')
 
+
 @openapi_test_function("/mark_stream_as_read:post")
 def mark_stream_as_read(client: Client) -> None:
 
@@ -579,6 +591,7 @@ def mark_stream_as_read(client: Client) -> None:
 
     validate_against_openapi_schema(result, '/mark_stream_as_read', 'post', '200')
 
+
 @openapi_test_function("/mark_topic_as_read:post")
 def mark_topic_as_read(client: Client) -> None:
 
@@ -592,27 +605,30 @@ def mark_topic_as_read(client: Client) -> None:
 
     validate_against_openapi_schema(result, '/mark_stream_as_read', 'post', '200')
 
+
 @openapi_test_function("/users/me/subscriptions/properties:post")
 def update_subscription_settings(client: Client) -> None:
 
     # {code_example|start}
     # Update the user's subscription in stream #1 to pin it to the top of the
     # stream list; and in stream #3 to have the hex color "f00"
-    request = [{
-        'stream_id': 1,
-        'property': 'pin_to_top',
-        'value': True,
-    }, {
-        'stream_id': 3,
-        'property': 'color',
-        'value': '#f00f00',
-    }]
+    request = [
+        {
+            'stream_id': 1,
+            'property': 'pin_to_top',
+            'value': True,
+        },
+        {
+            'stream_id': 3,
+            'property': 'color',
+            'value': '#f00f00',
+        },
+    ]
     result = client.update_subscription_settings(request)
     # {code_example|end}
 
-    validate_against_openapi_schema(result,
-                                    '/users/me/subscriptions/properties',
-                                    'POST', '200')
+    validate_against_openapi_schema(result, '/users/me/subscriptions/properties', 'POST', '200')
+
 
 @openapi_test_function("/messages/render:post")
 def render_message(client: Client) -> None:
@@ -627,6 +643,7 @@ def render_message(client: Client) -> None:
 
     validate_against_openapi_schema(result, '/messages/render', 'post', '200')
 
+
 @openapi_test_function("/messages:get")
 def get_messages(client: Client) -> None:
 
@@ -636,8 +653,10 @@ def get_messages(client: Client) -> None:
         'anchor': 'newest',
         'num_before': 100,
         'num_after': 0,
-        'narrow': [{'operator': 'sender', 'operand': 'iago@zulip.com'},
-                   {'operator': 'stream', 'operand': 'Verona'}],
+        'narrow': [
+            {'operator': 'sender', 'operand': 'iago@zulip.com'},
+            {'operator': 'stream', 'operand': 'Verona'},
+        ],
     }
     result = client.get_messages(request)
     # {code_example|end}
@@ -645,14 +664,10 @@ def get_messages(client: Client) -> None:
     validate_against_openapi_schema(result, '/messages', 'get', '200')
     assert len(result['messages']) <= request['num_before']
 
+
 @openapi_test_function("/messages/matches_narrow:get")
 def check_messages_match_narrow(client: Client) -> None:
-    message = {
-        "type": "stream",
-        "to": "Verona",
-        "topic": "test_topic",
-        "content": "http://foo.com"
-    }
+    message = {"type": "stream", "to": "Verona", "topic": "test_topic", "content": "http://foo.com"}
     msg_ids = []
     response = client.send_message(message)
     msg_ids.append(response['id'])
@@ -667,15 +682,12 @@ def check_messages_match_narrow(client: Client) -> None:
         'narrow': [{'operator': 'has', 'operand': 'link'}],
     }
 
-    result = client.call_endpoint(
-        url='messages/matches_narrow',
-        method='GET',
-        request=request
-    )
+    result = client.call_endpoint(url='messages/matches_narrow', method='GET', request=request)
     # {code_example|end}
 
     validate_against_openapi_schema(result, '/messages/matches_narrow', 'get', '200')
 
+
 @openapi_test_function("/messages/{message_id}:get")
 def get_raw_message(client: Client, message_id: int) -> None:
 
@@ -686,8 +698,8 @@ def get_raw_message(client: Client, message_id: int) -> None:
     result = client.get_raw_message(message_id)
     # {code_example|end}
 
-    validate_against_openapi_schema(result, '/messages/{message_id}', 'get',
-                                    '200')
+    validate_against_openapi_schema(result, '/messages/{message_id}', 'get', '200')
+
 
 @openapi_test_function("/attachments:get")
 def get_attachments(client: Client) -> None:
@@ -698,6 +710,7 @@ def get_attachments(client: Client) -> None:
     # {code_example|end}
     validate_against_openapi_schema(result, '/attachments', 'get', '200')
 
+
 @openapi_test_function("/messages:post")
 def send_message(client: Client) -> int:
 
@@ -753,6 +766,7 @@ def send_message(client: Client) -> int:
 
     return message_id
 
+
 @openapi_test_function("/messages/{message_id}/reactions:post")
 def add_reaction(client: Client, message_id: int) -> None:
     # {code_example|start}
@@ -766,6 +780,7 @@ def add_reaction(client: Client, message_id: int) -> None:
     # {code_example|end}
     validate_against_openapi_schema(result, '/messages/{message_id}/reactions', 'post', '200')
 
+
 @openapi_test_function("/messages/{message_id}/reactions:delete")
 def remove_reaction(client: Client, message_id: int) -> None:
     # {code_example|start}
@@ -779,6 +794,7 @@ def remove_reaction(client: Client, message_id: int) -> None:
     # {code_example|end}
     validate_against_openapi_schema(result, '/messages/{message_id}/reactions', 'delete', '200')
 
+
 def test_nonexistent_stream_error(client: Client) -> None:
     request = {
         "type": "stream",
@@ -788,8 +804,8 @@ def test_nonexistent_stream_error(client: Client) -> None:
     }
     result = client.send_message(request)
 
-    validate_against_openapi_schema(result, '/messages', 'post',
-                                    '400_0')
+    validate_against_openapi_schema(result, '/messages', 'post', '400_0')
+
 
 def test_private_message_invalid_recipient(client: Client) -> None:
     request = {
@@ -799,8 +815,8 @@ def test_private_message_invalid_recipient(client: Client) -> None:
     }
     result = client.send_message(request)
 
-    validate_against_openapi_schema(result, '/messages', 'post',
-                                    '400_1')
+    validate_against_openapi_schema(result, '/messages', 'post', '400_1')
+
 
 @openapi_test_function("/messages/{message_id}:patch")
 def update_message(client: Client, message_id: int) -> None:
@@ -818,8 +834,7 @@ def update_message(client: Client, message_id: int) -> None:
     result = client.update_message(request)
     # {code_example|end}
 
-    validate_against_openapi_schema(result, '/messages/{message_id}', 'patch',
-                                    '200')
+    validate_against_openapi_schema(result, '/messages/{message_id}', 'patch', '200')
 
     # test it was actually updated
     url = 'messages/' + str(message_id)
@@ -830,6 +845,7 @@ def update_message(client: Client, message_id: int) -> None:
     assert result['result'] == 'success'
     assert result['raw_content'] == request['content']
 
+
 def test_update_message_edit_permission_error(client: Client, nonadmin_client: Client) -> None:
     request = {
         "type": "stream",
@@ -847,6 +863,7 @@ def test_update_message_edit_permission_error(client: Client, nonadmin_client: C
 
     validate_against_openapi_schema(result, '/messages/{message_id}', 'patch', '400')
 
+
 @openapi_test_function("/messages/{message_id}:delete")
 def delete_message(client: Client, message_id: int) -> None:
 
@@ -855,8 +872,8 @@ def delete_message(client: Client, message_id: int) -> None:
     result = client.delete_message(message_id)
     # {code_example|end}
 
-    validate_against_openapi_schema(result, '/messages/{message_id}', 'delete',
-                                    '200')
+    validate_against_openapi_schema(result, '/messages/{message_id}', 'delete', '200')
+
 
 def test_delete_message_edit_permission_error(client: Client, nonadmin_client: Client) -> None:
     request = {
@@ -869,8 +886,8 @@ def test_delete_message_edit_permission_error(client: Client, nonadmin_client: C
 
     result = nonadmin_client.delete_message(result['id'])
 
-    validate_against_openapi_schema(result, '/messages/{message_id}', 'delete',
-                                    '400_1')
+    validate_against_openapi_schema(result, '/messages/{message_id}', 'delete', '400_1')
+
 
 @openapi_test_function("/messages/{message_id}/history:get")
 def get_message_history(client: Client, message_id: int) -> None:
@@ -880,8 +897,8 @@ def get_message_history(client: Client, message_id: int) -> None:
     result = client.get_message_history(message_id)
     # {code_example|end}
 
-    validate_against_openapi_schema(result, '/messages/{message_id}/history',
-                                    'get', '200')
+    validate_against_openapi_schema(result, '/messages/{message_id}/history', 'get', '200')
+
 
 @openapi_test_function("/realm/emoji:get")
 def get_realm_emoji(client: Client) -> None:
@@ -892,6 +909,7 @@ def get_realm_emoji(client: Client) -> None:
 
     validate_against_openapi_schema(result, '/realm/emoji', 'GET', '200')
 
+
 @openapi_test_function("/messages/flags:post")
 def update_message_flags(client: Client) -> None:
 
@@ -916,8 +934,7 @@ def update_message_flags(client: Client) -> None:
     result = client.update_message_flags(request)
     # {code_example|end}
 
-    validate_against_openapi_schema(result, '/messages/flags', 'post',
-                                    '200')
+    validate_against_openapi_schema(result, '/messages/flags', 'post', '200')
 
     # {code_example|start}
     # Remove the "starred" flag from the messages with IDs in "message_ids"
@@ -929,8 +946,8 @@ def update_message_flags(client: Client) -> None:
     result = client.update_message_flags(request)
     # {code_example|end}
 
-    validate_against_openapi_schema(result, '/messages/flags', 'post',
-                                    '200')
+    validate_against_openapi_schema(result, '/messages/flags', 'post', '200')
+
 
 def register_queue_all_events(client: Client) -> str:
 
@@ -941,6 +958,7 @@ def register_queue_all_events(client: Client) -> str:
     validate_against_openapi_schema(result, '/register', 'post', '200')
     return result['queue_id']
 
+
 @openapi_test_function("/register:post")
 def register_queue(client: Client) -> str:
 
@@ -954,6 +972,7 @@ def register_queue(client: Client) -> str:
     validate_against_openapi_schema(result, '/register', 'post', '200')
     return result['queue_id']
 
+
 @openapi_test_function("/events:delete")
 def deregister_queue(client: Client, queue_id: str) -> None:
 
@@ -969,6 +988,7 @@ def deregister_queue(client: Client, queue_id: str) -> None:
     result = client.deregister(queue_id)
     validate_against_openapi_schema(result, '/events', 'delete', '400')
 
+
 @openapi_test_function("/server_settings:get")
 def get_server_settings(client: Client) -> None:
 
@@ -979,6 +999,7 @@ def get_server_settings(client: Client) -> None:
 
     validate_against_openapi_schema(result, '/server_settings', 'get', '200')
 
+
 @openapi_test_function("/settings/notifications:patch")
 def update_notification_settings(client: Client) -> None:
 
@@ -993,6 +1014,7 @@ def update_notification_settings(client: Client) -> None:
 
     validate_against_openapi_schema(result, '/settings/notifications', 'patch', '200')
 
+
 @openapi_test_function("/user_uploads:post")
 def upload_file(client: Client) -> None:
     path_to_file = os.path.join(ZULIP_DIR, 'zerver', 'tests', 'images', 'img.jpg')
@@ -1006,16 +1028,19 @@ def upload_file(client: Client) -> None:
             files=[fp],
         )
 
-    client.send_message({
-        "type": "stream",
-        "to": "Denmark",
-        "topic": "Castle",
-        "content": "Check out [this picture]({}) of my castle!".format(result['uri']),
-    })
+    client.send_message(
+        {
+            "type": "stream",
+            "to": "Denmark",
+            "topic": "Castle",
+            "content": "Check out [this picture]({}) of my castle!".format(result['uri']),
+        }
+    )
     # {code_example|end}
 
     validate_against_openapi_schema(result, '/user_uploads', 'post', '200')
 
+
 @openapi_test_function("/users/me/{stream_id}/topics:get")
 def get_stream_topics(client: Client, stream_id: int) -> None:
 
@@ -1023,8 +1048,8 @@ def get_stream_topics(client: Client, stream_id: int) -> None:
     result = client.get_stream_topics(stream_id)
     # {code_example|end}
 
-    validate_against_openapi_schema(result, '/users/me/{stream_id}/topics',
-                                    'get', '200')
+    validate_against_openapi_schema(result, '/users/me/{stream_id}/topics', 'get', '200')
+
 
 @openapi_test_function("/typing:post")
 def set_typing_status(client: Client) -> None:
@@ -1058,6 +1083,7 @@ def set_typing_status(client: Client) -> None:
 
     validate_against_openapi_schema(result, '/typing', 'post', '200')
 
+
 @openapi_test_function("/realm/emoji/{emoji_name}:post")
 def upload_custom_emoji(client: Client) -> None:
     emoji_path = os.path.join(ZULIP_DIR, 'zerver', 'tests', 'images', 'img.jpg')
@@ -1073,9 +1099,8 @@ def upload_custom_emoji(client: Client) -> None:
         )
     # {code_example|end}
 
-    validate_against_openapi_schema(result,
-                                    '/realm/emoji/{emoji_name}',
-                                    'post', '200')
+    validate_against_openapi_schema(result, '/realm/emoji/{emoji_name}', 'post', '200')
+
 
 @openapi_test_function("/users/me/alert_words:get")
 def get_alert_words(client: Client) -> None:
@@ -1083,6 +1108,7 @@ def get_alert_words(client: Client) -> None:
 
     assert result['result'] == 'success'
 
+
 @openapi_test_function("/users/me/alert_words:post")
 def add_alert_words(client: Client) -> None:
     word = ['foo', 'bar']
@@ -1091,6 +1117,7 @@ def add_alert_words(client: Client) -> None:
 
     assert result['result'] == 'success'
 
+
 @openapi_test_function("/users/me/alert_words:delete")
 def remove_alert_words(client: Client) -> None:
     word = ['foo']
@@ -1099,6 +1126,7 @@ def remove_alert_words(client: Client) -> None:
 
     assert result['result'] == 'success'
 
+
 @openapi_test_function("/user_groups/create:post")
 def create_user_group(client: Client) -> None:
     ensure_users([6, 7, 8, 10], ['aaron', 'zoe', 'cordelia', 'hamlet'])
@@ -1116,6 +1144,7 @@ def create_user_group(client: Client) -> None:
 
     assert result['result'] == 'success'
 
+
 @openapi_test_function("/user_groups/{user_group_id}:patch")
 def update_user_group(client: Client, user_group_id: int) -> None:
     # {code_example|start}
@@ -1129,6 +1158,7 @@ def update_user_group(client: Client, user_group_id: int) -> None:
     # {code_example|end}
     assert result['result'] == 'success'
 
+
 @openapi_test_function("/user_groups/{user_group_id}:delete")
 def remove_user_group(client: Client, user_group_id: int) -> None:
     # {code_example|start}
@@ -1138,6 +1168,7 @@ def remove_user_group(client: Client, user_group_id: int) -> None:
     validate_against_openapi_schema(result, '/user_groups/{user_group_id}', 'delete', '200')
     assert result['result'] == 'success'
 
+
 @openapi_test_function("/user_groups/{user_group_id}/members:post")
 def update_user_group_members(client: Client, user_group_id: int) -> None:
     ensure_users([8, 10, 11], ['cordelia', 'hamlet', 'iago'])
@@ -1152,10 +1183,12 @@ def update_user_group_members(client: Client, user_group_id: int) -> None:
     # {code_example|end}
     validate_against_openapi_schema(result, '/user_groups/{group_id}/members', 'post', '200')
 
+
 def test_invalid_api_key(client_with_invalid_key: Client) -> None:
     result = client_with_invalid_key.list_subscriptions()
     validate_against_openapi_schema(result, '/rest-error-handling', 'post', '400_0')
 
+
 def test_missing_request_argument(client: Client) -> None:
     result = client.render_message({})
 
@@ -1169,7 +1202,12 @@ def test_invalid_stream_error(client: Client) -> None:
 
 
 # SETUP METHODS FOLLOW
-def test_against_fixture(result: Dict[str, Any], fixture: Dict[str, Any], check_if_equal: Optional[Iterable[str]] = None, check_if_exists: Optional[Iterable[str]] = None) -> None:
+def test_against_fixture(
+    result: Dict[str, Any],
+    fixture: Dict[str, Any],
+    check_if_equal: Optional[Iterable[str]] = None,
+    check_if_exists: Optional[Iterable[str]] = None,
+) -> None:
     assertLength(result, fixture)
 
     if check_if_equal is None and check_if_exists is None:
@@ -1184,24 +1222,31 @@ def test_against_fixture(result: Dict[str, Any], fixture: Dict[str, Any], check_
         for key in check_if_exists:
             assertIn(key, result)
 
+
 def assertEqual(key: str, result: Dict[str, Any], fixture: Dict[str, Any]) -> None:
     if result[key] != fixture[key]:
         first = f"{key} = {result[key]}"
         second = f"{key} = {fixture[key]}"
-        raise AssertionError("Actual and expected outputs do not match; showing diff:\n" +
-                             mdiff.diff_strings(first, second))
+        raise AssertionError(
+            "Actual and expected outputs do not match; showing diff:\n"
+            + mdiff.diff_strings(first, second)
+        )
     else:
         assert result[key] == fixture[key]
 
+
 def assertLength(result: Dict[str, Any], fixture: Dict[str, Any]) -> None:
     if len(result) != len(fixture):
         result_string = json.dumps(result, indent=4, sort_keys=True)
         fixture_string = json.dumps(fixture, indent=4, sort_keys=True)
-        raise AssertionError("The lengths of the actual and expected outputs do not match; showing diff:\n" +
-                             mdiff.diff_strings(result_string, fixture_string))
+        raise AssertionError(
+            "The lengths of the actual and expected outputs do not match; showing diff:\n"
+            + mdiff.diff_strings(result_string, fixture_string)
+        )
     else:
         assert len(result) == len(fixture)
 
+
 def assertIn(key: str, result: Dict[str, Any]) -> None:
     if key not in result.keys():
         raise AssertionError(
@@ -1210,6 +1255,7 @@ def assertIn(key: str, result: Dict[str, Any]) -> None:
     else:
         assert key in result
 
+
 def test_messages(client: Client, nonadmin_client: Client) -> None:
 
     render_message(client)
@@ -1232,6 +1278,7 @@ def test_messages(client: Client, nonadmin_client: Client) -> None:
     test_update_message_edit_permission_error(client, nonadmin_client)
     test_delete_message_edit_permission_error(client, nonadmin_client)
 
+
 def test_users(client: Client) -> None:
 
     create_user(client)
@@ -1257,6 +1304,7 @@ def test_users(client: Client) -> None:
     add_alert_words(client)
     remove_alert_words(client)
 
+
 def test_streams(client: Client, nonadmin_client: Client) -> None:
 
     add_subscriptions(client)
@@ -1287,6 +1335,7 @@ def test_queues(client: Client) -> None:
     deregister_queue(client, queue_id)
     register_queue_all_events(client)
 
+
 def test_server_organizations(client: Client) -> None:
 
     get_realm_filters(client)
@@ -1299,10 +1348,12 @@ def test_server_organizations(client: Client) -> None:
     reorder_realm_profile_fields(client)
     create_realm_profile_field(client)
 
+
 def test_errors(client: Client) -> None:
     test_missing_request_argument(client)
     test_invalid_stream_error(client)
 
+
 def test_the_api(client: Client, nonadmin_client: Client) -> None:
 
     get_user_agent(client)