python: Reformat with Black, except quotes.

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

zerver/lib/cache.py

@@ -42,6 +42,7 @@ FuncT = TypeVar('FuncT', bound=Callable[..., object])
 
 logger = logging.getLogger()
 
+
 class NotFoundInCache(Exception):
     pass
 
@@ -50,22 +51,27 @@ remote_cache_time_start = 0.0
 remote_cache_total_time = 0.0
 remote_cache_total_requests = 0
 
+
 def get_remote_cache_time() -> float:
     return remote_cache_total_time
 
+
 def get_remote_cache_requests() -> int:
     return remote_cache_total_requests
 
+
 def remote_cache_stats_start() -> None:
     global remote_cache_time_start
     remote_cache_time_start = time.time()
 
+
 def remote_cache_stats_finish() -> None:
     global remote_cache_total_time
     global remote_cache_total_requests
     global remote_cache_time_start
     remote_cache_total_requests += 1
-    remote_cache_total_time += (time.time() - remote_cache_time_start)
+    remote_cache_total_time += time.time() - remote_cache_time_start
+
 
 def get_or_create_key_prefix() -> str:
     if settings.PUPPETEER_TESTS:
@@ -105,8 +111,10 @@ def get_or_create_key_prefix() -> str:
 
     return prefix
 
+
 KEY_PREFIX: str = get_or_create_key_prefix()
 
+
 def bounce_key_prefix_for_testing(test_name: str) -> None:
     global KEY_PREFIX
     KEY_PREFIX = test_name + ':' + str(os.getpid()) + ':'
@@ -114,20 +122,23 @@ def bounce_key_prefix_for_testing(test_name: str) -> None:
     # Memcached keys should have a length of less than 250.
     KEY_PREFIX = hashlib.sha1(KEY_PREFIX.encode('utf-8')).hexdigest() + ":"
 
+
 def get_cache_backend(cache_name: Optional[str]) -> BaseCache:
     if cache_name is None:
         return djcache
     return caches[cache_name]
 
+
 def get_cache_with_key(
-        keyfunc: Callable[..., str],
-        cache_name: Optional[str]=None,
+    keyfunc: Callable[..., str],
+    cache_name: Optional[str] = None,
 ) -> Callable[[FuncT], FuncT]:
     """
     The main goal of this function getting value from the cache like in the "cache_with_key".
     A cache value can contain any data including the "None", so
     here used exception for case if value isn't found in the cache.
     """
+
     def decorator(func: FuncT) -> FuncT:
         @wraps(func)
         def func_with_caching(*args: object, **kwargs: object) -> object:
@@ -147,16 +158,19 @@ def get_cache_with_key(
 
     return decorator
 
+
 def cache_with_key(
-        keyfunc: Callable[..., str], cache_name: Optional[str]=None,
-        timeout: Optional[int]=None, with_statsd_key: Optional[str]=None,
+    keyfunc: Callable[..., str],
+    cache_name: Optional[str] = None,
+    timeout: Optional[int] = None,
+    with_statsd_key: Optional[str] = None,
 ) -> Callable[[FuncT], FuncT]:
     """Decorator which applies Django caching to a function.
 
-       Decorator argument is a function which computes a cache key
-       from the original function's arguments.  You are responsible
-       for avoiding collisions with other uses of this decorator or
-       other uses of caching."""
+    Decorator argument is a function which computes a cache key
+    from the original function's arguments.  You are responsible
+    for avoiding collisions with other uses of this decorator or
+    other uses of caching."""
 
     def decorator(func: FuncT) -> FuncT:
         @wraps(func)
@@ -197,14 +211,19 @@ def cache_with_key(
 
     return decorator
 
+
 class InvalidCacheKeyException(Exception):
     pass
 
+
 def log_invalid_cache_keys(stack_trace: str, key: List[str]) -> None:
     logger.warning(
-        "Invalid cache key used: %s\nStack trace: %s\n", key, stack_trace,
+        "Invalid cache key used: %s\nStack trace: %s\n",
+        key,
+        stack_trace,
     )
 
+
 def validate_cache_key(key: str) -> None:
     if not key.startswith(KEY_PREFIX):
         key = KEY_PREFIX + key
@@ -222,7 +241,10 @@ def validate_cache_key(key: str) -> None:
     if len(key) > MEMCACHED_MAX_KEY_LENGTH:
         raise InvalidCacheKeyException(f"Cache key too long: {key} Length: {len(key)}")
 
-def cache_set(key: str, val: Any, cache_name: Optional[str]=None, timeout: Optional[int]=None) -> None:
+
+def cache_set(
+    key: str, val: Any, cache_name: Optional[str] = None, timeout: Optional[int] = None
+) -> None:
     final_key = KEY_PREFIX + key
     validate_cache_key(final_key)
 
@@ -231,7 +253,8 @@ def cache_set(key: str, val: Any, cache_name: Optional[str]=None, timeout: Optio
     cache_backend.set(final_key, (val,), timeout=timeout)
     remote_cache_stats_finish()
 
-def cache_get(key: str, cache_name: Optional[str]=None) -> Any:
+
+def cache_get(key: str, cache_name: Optional[str] = None) -> Any:
     final_key = KEY_PREFIX + key
     validate_cache_key(final_key)
 
@@ -241,16 +264,18 @@ def cache_get(key: str, cache_name: Optional[str]=None) -> Any:
     remote_cache_stats_finish()
     return ret
 
-def cache_get_many(keys: List[str], cache_name: Optional[str]=None) -> Dict[str, Any]:
+
+def cache_get_many(keys: List[str], cache_name: Optional[str] = None) -> Dict[str, Any]:
     keys = [KEY_PREFIX + key for key in keys]
     for key in keys:
         validate_cache_key(key)
     remote_cache_stats_start()
     ret = get_cache_backend(cache_name).get_many(keys)
     remote_cache_stats_finish()
-    return {key[len(KEY_PREFIX):]: value for key, value in ret.items()}
+    return {key[len(KEY_PREFIX) :]: value for key, value in ret.items()}
 
-def safe_cache_get_many(keys: List[str], cache_name: Optional[str]=None) -> Dict[str, Any]:
+
+def safe_cache_get_many(keys: List[str], cache_name: Optional[str] = None) -> Dict[str, Any]:
     """Variant of cache_get_many that drops any keys that fail
     validation, rather than throwing an exception visible to the
     caller."""
@@ -266,8 +291,10 @@ def safe_cache_get_many(keys: List[str], cache_name: Optional[str]=None) -> Dict
         log_invalid_cache_keys(stack_trace, bad_keys)
         return cache_get_many(good_keys, cache_name)
 
-def cache_set_many(items: Dict[str, Any], cache_name: Optional[str]=None,
-                   timeout: Optional[int]=None) -> None:
+
+def cache_set_many(
+    items: Dict[str, Any], cache_name: Optional[str] = None, timeout: Optional[int] = None
+) -> None:
     new_items = {}
     for key in items:
         new_key = KEY_PREFIX + key
@@ -278,8 +305,10 @@ def cache_set_many(items: Dict[str, Any], cache_name: Optional[str]=None,
     get_cache_backend(cache_name).set_many(items, timeout=timeout)
     remote_cache_stats_finish()
 
-def safe_cache_set_many(items: Dict[str, Any], cache_name: Optional[str]=None,
-                        timeout: Optional[int]=None) -> None:
+
+def safe_cache_set_many(
+    items: Dict[str, Any], cache_name: Optional[str] = None, timeout: Optional[int] = None
+) -> None:
     """Variant of cache_set_many that drops saving any keys that fail
     validation, rather than throwing an exception visible to the
     caller."""
@@ -297,7 +326,8 @@ def safe_cache_set_many(items: Dict[str, Any], cache_name: Optional[str]=None,
         good_items = {key: items[key] for key in good_keys}
         return cache_set_many(good_items, cache_name, timeout)
 
-def cache_delete(key: str, cache_name: Optional[str]=None) -> None:
+
+def cache_delete(key: str, cache_name: Optional[str] = None) -> None:
     final_key = KEY_PREFIX + key
     validate_cache_key(final_key)
 
@@ -305,7 +335,8 @@ def cache_delete(key: str, cache_name: Optional[str]=None) -> None:
     get_cache_backend(cache_name).delete(final_key)
     remote_cache_stats_finish()
 
-def cache_delete_many(items: Iterable[str], cache_name: Optional[str]=None) -> None:
+
+def cache_delete_many(items: Iterable[str], cache_name: Optional[str] = None) -> None:
     keys = [KEY_PREFIX + item for item in items]
     for key in keys:
         validate_cache_key(key)
@@ -313,6 +344,7 @@ def cache_delete_many(items: Iterable[str], cache_name: Optional[str]=None) -> N
     get_cache_backend(cache_name).delete_many(keys)
     remote_cache_stats_finish()
 
+
 def filter_good_and_bad_keys(keys: List[str]) -> Tuple[List[str], List[str]]:
     good_keys = []
     bad_keys = []
@@ -325,6 +357,7 @@ def filter_good_and_bad_keys(keys: List[str]) -> Tuple[List[str], List[str]]:
 
     return good_keys, bad_keys
 
+
 # Generic_bulk_cached fetch and its helpers.  We start with declaring
 # a few type variables that help define its interface.
 
@@ -356,14 +389,14 @@ CompressedItemT = TypeVar('CompressedItemT')
 #   value for cache (in case the values that we're caching are some
 #   function of the objects, not the objects themselves)
 def generic_bulk_cached_fetch(
-        cache_key_function: Callable[[ObjKT], str],
-        query_function: Callable[[List[ObjKT]], Iterable[ItemT]],
-        object_ids: Sequence[ObjKT],
-        *,
-        extractor: Callable[[CompressedItemT], CacheItemT],
-        setter: Callable[[CacheItemT], CompressedItemT],
-        id_fetcher: Callable[[ItemT], ObjKT],
-        cache_transformer: Callable[[ItemT], CacheItemT],
+    cache_key_function: Callable[[ObjKT], str],
+    query_function: Callable[[List[ObjKT]], Iterable[ItemT]],
+    object_ids: Sequence[ObjKT],
+    *,
+    extractor: Callable[[CompressedItemT], CacheItemT],
+    setter: Callable[[CacheItemT], CompressedItemT],
+    id_fetcher: Callable[[ItemT], ObjKT],
+    cache_transformer: Callable[[ItemT], CacheItemT],
 ) -> Dict[ObjKT, CacheItemT]:
     if len(object_ids) == 0:
         # Nothing to fetch.
@@ -380,8 +413,9 @@ def generic_bulk_cached_fetch(
     cached_objects: Dict[str, CacheItemT] = {}
     for (key, val) in cached_objects_compressed.items():
         cached_objects[key] = extractor(cached_objects_compressed[key][0])
-    needed_ids = [object_id for object_id in object_ids if
-                  cache_keys[object_id] not in cached_objects]
+    needed_ids = [
+        object_id for object_id in object_ids if cache_keys[object_id] not in cached_objects
+    ]
 
     # Only call query_function if there are some ids to fetch from the database:
     if len(needed_ids) > 0:
@@ -397,8 +431,12 @@ def generic_bulk_cached_fetch(
         cached_objects[key] = item
     if len(items_for_remote_cache) > 0:
         safe_cache_set_many(items_for_remote_cache)
-    return {object_id: cached_objects[cache_keys[object_id]] for object_id in object_ids
-            if cache_keys[object_id] in cached_objects}
+    return {
+        object_id: cached_objects[cache_keys[object_id]]
+        for object_id in object_ids
+        if cache_keys[object_id] in cached_objects
+    }
+
 
 def transformed_bulk_cached_fetch(
     cache_key_function: Callable[[ObjKT], str],
@@ -418,6 +456,7 @@ def transformed_bulk_cached_fetch(
         cache_transformer=cache_transformer,
     )
 
+
 def bulk_cached_fetch(
     cache_key_function: Callable[[ObjKT], str],
     query_function: Callable[[List[ObjKT]], Iterable[ItemT]],
@@ -433,58 +472,83 @@ def bulk_cached_fetch(
         cache_transformer=lambda obj: obj,
     )
 
+
 def preview_url_cache_key(url: str) -> str:
     return f"preview_url:{make_safe_digest(url)}"
 
+
 def display_recipient_cache_key(recipient_id: int) -> str:
     return f"display_recipient_dict:{recipient_id}"
 
+
 def display_recipient_bulk_get_users_by_id_cache_key(user_id: int) -> str:
     # Cache key function for a function for bulk fetching users, used internally
     # by display_recipient code.
     return 'bulk_fetch_display_recipients:' + user_profile_by_id_cache_key(user_id)
 
+
 def user_profile_by_email_cache_key(email: str) -> str:
     # See the comment in zerver/lib/avatar_hash.py:gravatar_hash for why we
     # are proactively encoding email addresses even though they will
     # with high likelihood be ASCII-only for the foreseeable future.
     return f'user_profile_by_email:{make_safe_digest(email.strip())}'
 
+
 def user_profile_cache_key_id(email: str, realm_id: int) -> str:
     return f"user_profile:{make_safe_digest(email.strip())}:{realm_id}"
 
+
 def user_profile_cache_key(email: str, realm: 'Realm') -> str:
     return user_profile_cache_key_id(email, realm.id)
 
+
 def bot_profile_cache_key(email: str) -> str:
     return f"bot_profile:{make_safe_digest(email.strip())}"
 
+
 def user_profile_by_id_cache_key(user_profile_id: int) -> str:
     return f"user_profile_by_id:{user_profile_id}"
 
+
 def user_profile_by_api_key_cache_key(api_key: str) -> str:
     return f"user_profile_by_api_key:{api_key}"
 
+
 realm_user_dict_fields: List[str] = [
-    'id', 'full_name', 'email',
-    'avatar_source', 'avatar_version', 'is_active',
-    'role', 'is_bot', 'realm_id', 'timezone',
-    'date_joined', 'bot_owner_id', 'delivery_email',
-    'bot_type', 'long_term_idle'
+    'id',
+    'full_name',
+    'email',
+    'avatar_source',
+    'avatar_version',
+    'is_active',
+    'role',
+    'is_bot',
+    'realm_id',
+    'timezone',
+    'date_joined',
+    'bot_owner_id',
+    'delivery_email',
+    'bot_type',
+    'long_term_idle',
 ]
 
+
 def realm_user_dicts_cache_key(realm_id: int) -> str:
     return f"realm_user_dicts:{realm_id}"
 
+
 def get_realm_used_upload_space_cache_key(realm: 'Realm') -> str:
     return f'realm_used_upload_space:{realm.id}'
 
+
 def active_user_ids_cache_key(realm_id: int) -> str:
     return f"active_user_ids:{realm_id}"
 
+
 def active_non_guest_user_ids_cache_key(realm_id: int) -> str:
     return f"active_non_guest_user_ids:{realm_id}"
 
+
 bot_dict_fields: List[str] = [
     'api_key',
     'avatar_source',
@@ -501,16 +565,20 @@ bot_dict_fields: List[str] = [
     'realm_id',
 ]
 
+
 def bot_dicts_in_realm_cache_key(realm: 'Realm') -> str:
     return f"bot_dicts_in_realm:{realm.id}"
 
+
 def get_stream_cache_key(stream_name: str, realm_id: int) -> str:
     return f"stream_by_realm_and_name:{realm_id}:{make_safe_digest(stream_name.strip().lower())}"
 
+
 def delete_user_profile_caches(user_profiles: Iterable['UserProfile']) -> None:
     # Imported here to avoid cyclic dependency.
     from zerver.lib.users import get_all_api_keys
     from zerver.models import is_cross_realm_bot_email
+
     keys = []
     for user_profile in user_profiles:
         keys.append(user_profile_by_email_cache_key(user_profile.delivery_email))
@@ -524,14 +592,17 @@ def delete_user_profile_caches(user_profiles: Iterable['UserProfile']) -> None:
 
     cache_delete_many(keys)
 
+
 def delete_display_recipient_cache(user_profile: 'UserProfile') -> None:
     from zerver.models import Subscription  # We need to import here to avoid cyclic dependency.
+
     recipient_ids = Subscription.objects.filter(user_profile=user_profile)
     recipient_ids = recipient_ids.values_list('recipient_id', flat=True)
     keys = [display_recipient_cache_key(rid) for rid in recipient_ids]
     keys.append(display_recipient_bulk_get_users_by_id_cache_key(user_profile.id))
     cache_delete_many(keys)
 
+
 def changed(kwargs: Any, fields: List[str]) -> bool:
     if kwargs.get('update_fields') is None:
         # adds/deletes should invalidate the cache
@@ -544,6 +615,7 @@ def changed(kwargs: Any, fields: List[str]) -> bool:
 
     return False
 
+
 # Called by models.py to flush the user_profile cache whenever we save
 # a user_profile object
 def flush_user_profile(sender: Any, **kwargs: Any) -> None:
@@ -570,16 +642,20 @@ def flush_user_profile(sender: Any, **kwargs: Any) -> None:
     if user_profile.is_bot and changed(kwargs, bot_dict_fields):
         cache_delete(bot_dicts_in_realm_cache_key(user_profile.realm))
 
+
 # Called by models.py to flush various caches whenever we save
 # a Realm object.  The main tricky thing here is that Realm info is
 # generally cached indirectly through user_profile objects.
-def flush_realm(sender: Any, from_deletion: bool=False, **kwargs: Any) -> None:
+def flush_realm(sender: Any, from_deletion: bool = False, **kwargs: Any) -> None:
     realm = kwargs['instance']
     users = realm.get_active_users()
     delete_user_profile_caches(users)
 
-    if from_deletion or realm.deactivated or (kwargs["update_fields"] is not None and
-                                              "string_id" in kwargs['update_fields']):
+    if (
+        from_deletion
+        or realm.deactivated
+        or (kwargs["update_fields"] is not None and "string_id" in kwargs['update_fields'])
+    ):
         cache_delete(realm_user_dicts_cache_key(realm.id))
         cache_delete(active_user_ids_cache_key(realm.id))
         cache_delete(bot_dicts_in_realm_cache_key(realm))
@@ -592,52 +668,67 @@ def flush_realm(sender: Any, from_deletion: bool=False, **kwargs: Any) -> None:
         cache_delete(realm_rendered_description_cache_key(realm))
         cache_delete(realm_text_description_cache_key(realm))
 
+
 def realm_alert_words_cache_key(realm: 'Realm') -> str:
     return f"realm_alert_words:{realm.string_id}"
 
+
 def realm_alert_words_automaton_cache_key(realm: 'Realm') -> str:
     return f"realm_alert_words_automaton:{realm.string_id}"
 
+
 def realm_rendered_description_cache_key(realm: 'Realm') -> str:
     return f"realm_rendered_description:{realm.string_id}"
 
+
 def realm_text_description_cache_key(realm: 'Realm') -> str:
     return f"realm_text_description:{realm.string_id}"
 
+
 # Called by models.py to flush the stream cache whenever we save a stream
 # object.
 def flush_stream(sender: Any, **kwargs: Any) -> None:
     from zerver.models import UserProfile
+
     stream = kwargs['instance']
     items_for_remote_cache = {}
     items_for_remote_cache[get_stream_cache_key(stream.name, stream.realm_id)] = (stream,)
     cache_set_many(items_for_remote_cache)
 
-    if kwargs.get('update_fields') is None or 'name' in kwargs['update_fields'] and \
-       UserProfile.objects.filter(
-           Q(default_sending_stream=stream) |
-           Q(default_events_register_stream=stream)).exists():
+    if (
+        kwargs.get('update_fields') is None
+        or 'name' in kwargs['update_fields']
+        and UserProfile.objects.filter(
+            Q(default_sending_stream=stream) | Q(default_events_register_stream=stream)
+        ).exists()
+    ):
         cache_delete(bot_dicts_in_realm_cache_key(stream.realm))
 
+
 def flush_used_upload_space_cache(sender: Any, **kwargs: Any) -> None:
     attachment = kwargs['instance']
 
     if kwargs.get("created") is None or kwargs.get("created") is True:
         cache_delete(get_realm_used_upload_space_cache_key(attachment.owner.realm))
 
+
 def to_dict_cache_key_id(message_id: int) -> str:
     return f'message_dict:{message_id}'
 
-def to_dict_cache_key(message: 'Message', realm_id: Optional[int]=None) -> str:
+
+def to_dict_cache_key(message: 'Message', realm_id: Optional[int] = None) -> str:
     return to_dict_cache_key_id(message.id)
 
+
 def open_graph_description_cache_key(content: bytes, request: HttpRequest) -> str:
     return 'open_graph_description_path:{}'.format(make_safe_digest(request.META['PATH_INFO']))
 
+
 def flush_message(sender: Any, **kwargs: Any) -> None:
     message = kwargs['instance']
     cache_delete(to_dict_cache_key_id(message.id))
 
+
 def flush_submessage(sender: Any, **kwargs: Any) -> None:
     submessage = kwargs['instance']
     # submessages are not cached directly, they are part of their
@@ -645,9 +736,11 @@ def flush_submessage(sender: Any, **kwargs: Any) -> None:
     message_id = submessage.message_id
     cache_delete(to_dict_cache_key_id(message_id))
 
+
 DECORATOR = Callable[[Callable[..., Any]], Callable[..., Any]]
 
-def ignore_unhashable_lru_cache(maxsize: int=128, typed: bool=False) -> DECORATOR:
+
+def ignore_unhashable_lru_cache(maxsize: int = 128, typed: bool = False) -> DECORATOR:
     """
     This is a wrapper over lru_cache function. It adds following features on
     top of lru_cache:
@@ -695,8 +788,10 @@ def ignore_unhashable_lru_cache(maxsize: int=128, typed: bool=False) -> DECORATO
 
     return decorator
 
+
 def dict_to_items_tuple(user_function: Callable[..., Any]) -> Callable[..., Any]:
     """Wrapper that converts any dict args to dict item tuples."""
+
     def dict_to_tuple(arg: Any) -> Any:
         if isinstance(arg, dict):
             return tuple(sorted(arg.items()))
@@ -708,8 +803,10 @@ def dict_to_items_tuple(user_function: Callable[..., Any]) -> Callable[..., Any]
 
     return wrapper
 
+
 def items_tuple_to_dict(user_function: Callable[..., Any]) -> Callable[..., Any]:
     """Wrapper that converts any dict items tuple args to dicts."""
+
     def dict_items_to_dict(arg: Any) -> Any:
         if isinstance(arg, tuple):
             try: