ruff: Fix N818 exception name should be named with an Error suffix.

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

analytics/management/commands/check_analytics_state.py

@@ -8,7 +8,7 @@ from django.utils.timezone import now as timezone_now
 
 from analytics.lib.counts import COUNT_STATS, CountStat
 from analytics.models import installation_epoch
-from zerver.lib.timestamp import TimeZoneNotUTCException, floor_to_day, floor_to_hour, verify_UTC
+from zerver.lib.timestamp import TimeZoneNotUTCError, floor_to_day, floor_to_hour, verify_UTC
 from zerver.models import Realm
 
 states = {
@@ -48,7 +48,7 @@ class Command(BaseCommand):
                 last_fill = installation_epoch()
             try:
                 verify_UTC(last_fill)
-            except TimeZoneNotUTCException:
+            except TimeZoneNotUTCError:
                 return {"status": 2, "message": f"FillState not in UTC for {property}"}
 
             if stat.frequency == CountStat.DAY:

analytics/tests/test_counts.py

@@ -53,7 +53,7 @@ from zerver.actions.users import do_deactivate_user
 from zerver.lib.create_user import create_user
 from zerver.lib.exceptions import InvitationError
 from zerver.lib.test_classes import ZulipTestCase
-from zerver.lib.timestamp import TimeZoneNotUTCException, floor_to_day
+from zerver.lib.timestamp import TimeZoneNotUTCError, floor_to_day
 from zerver.lib.topic import DB_TOPIC_NAME
 from zerver.lib.utils import assert_is_not_none
 from zerver.models import (
@@ -290,7 +290,7 @@ class TestProcessCountStat(AnalyticsTestCase):
         stat = self.make_dummy_count_stat("test stat")
         with self.assertRaises(ValueError):
             process_count_stat(stat, installation_epoch() + 65 * self.MINUTE)
-        with self.assertRaises(TimeZoneNotUTCException):
+        with self.assertRaises(TimeZoneNotUTCError):
             process_count_stat(stat, installation_epoch().replace(tzinfo=None))
 
     # This tests the LoggingCountStat branch of the code in do_delete_counts_at_hour.

confirmation/models.py

@@ -29,7 +29,7 @@ from zerver.models import (
 )
 
 
-class ConfirmationKeyException(Exception):
+class ConfirmationKeyError(Exception):
     WRONG_LENGTH = 1
     EXPIRED = 2
     DOES_NOT_EXIST = 3
@@ -40,11 +40,11 @@ class ConfirmationKeyException(Exception):
 
 
 def render_confirmation_key_error(
-    request: HttpRequest, exception: ConfirmationKeyException
+    request: HttpRequest, exception: ConfirmationKeyError
 ) -> HttpResponse:
-    if exception.error_type == ConfirmationKeyException.WRONG_LENGTH:
+    if exception.error_type == ConfirmationKeyError.WRONG_LENGTH:
         return render(request, "confirmation/link_malformed.html", status=404)
-    if exception.error_type == ConfirmationKeyException.EXPIRED:
+    if exception.error_type == ConfirmationKeyError.EXPIRED:
         return render(request, "confirmation/link_expired.html", status=404)
     return render(request, "confirmation/link_does_not_exist.html", status=404)
 
@@ -77,16 +77,16 @@ def get_object_from_key(
 
     # Confirmation keys used to be 40 characters
     if len(confirmation_key) not in (24, 40):
-        raise ConfirmationKeyException(ConfirmationKeyException.WRONG_LENGTH)
+        raise ConfirmationKeyError(ConfirmationKeyError.WRONG_LENGTH)
     try:
         confirmation = Confirmation.objects.get(
             confirmation_key=confirmation_key, type__in=confirmation_types
         )
     except Confirmation.DoesNotExist:
-        raise ConfirmationKeyException(ConfirmationKeyException.DOES_NOT_EXIST)
+        raise ConfirmationKeyError(ConfirmationKeyError.DOES_NOT_EXIST)
 
     if confirmation.expiry_date is not None and timezone_now() > confirmation.expiry_date:
-        raise ConfirmationKeyException(ConfirmationKeyException.EXPIRED)
+        raise ConfirmationKeyError(ConfirmationKeyError.EXPIRED)
 
     obj = confirmation.content_object
     assert obj is not None
@@ -96,7 +96,7 @@ def get_object_from_key(
     if hasattr(obj, "status") and obj.status in [used_value, revoked_value]:
         # Confirmations where the object has the status attribute are one-time use
         # and are marked after being used (or revoked).
-        raise ConfirmationKeyException(ConfirmationKeyException.EXPIRED)
+        raise ConfirmationKeyError(ConfirmationKeyError.EXPIRED)
 
     if mark_object_used:
         # MultiuseInvite objects do not use the STATUS_USED status, since they are
@@ -240,10 +240,10 @@ def validate_key(creation_key: Optional[str]) -> Optional["RealmCreationKey"]:
     try:
         key_record = RealmCreationKey.objects.get(creation_key=creation_key)
     except RealmCreationKey.DoesNotExist:
-        raise RealmCreationKey.Invalid()
+        raise RealmCreationKey.InvalidError()
     time_elapsed = timezone_now() - key_record.date_created
     if time_elapsed.total_seconds() > settings.REALM_CREATION_LINK_VALIDITY_DAYS * 24 * 3600:
-        raise RealmCreationKey.Invalid()
+        raise RealmCreationKey.InvalidError()
     return key_record
 
 
@@ -266,5 +266,5 @@ class RealmCreationKey(models.Model):
     # is theirs, and skip sending mail to it to confirm that.
     presume_email_valid = models.BooleanField(default=False)
 
-    class Invalid(Exception):
+    class InvalidError(Exception):
         pass

corporate/lib/stripe.py

@@ -248,13 +248,13 @@ class UpgradeWithExistingPlanError(BillingError):
         )
 
 
-class InvalidBillingSchedule(Exception):
+class InvalidBillingScheduleError(Exception):
     def __init__(self, billing_schedule: int) -> None:
         self.message = f"Unknown billing_schedule: {billing_schedule}"
         super().__init__(self.message)
 
 
-class InvalidTier(Exception):
+class InvalidTierError(Exception):
     def __init__(self, tier: int) -> None:
         self.message = f"Unknown tier: {tier}"
         super().__init__(self.message)
@@ -570,16 +570,16 @@ def get_price_per_license(
         elif billing_schedule == CustomerPlan.MONTHLY:
             price_per_license = 800
         else:  # nocoverage
-            raise InvalidBillingSchedule(billing_schedule)
+            raise InvalidBillingScheduleError(billing_schedule)
     elif tier == CustomerPlan.PLUS:
         if billing_schedule == CustomerPlan.ANNUAL:
             price_per_license = 16000
         elif billing_schedule == CustomerPlan.MONTHLY:
             price_per_license = 1600
         else:  # nocoverage
-            raise InvalidBillingSchedule(billing_schedule)
+            raise InvalidBillingScheduleError(billing_schedule)
     else:
-        raise InvalidTier(tier)
+        raise InvalidTierError(tier)
 
     if discount is not None:
         price_per_license = calculate_discounted_price_per_license(price_per_license, discount)
@@ -602,7 +602,7 @@ def compute_plan_parameters(
     elif billing_schedule == CustomerPlan.MONTHLY:
         period_end = add_months(billing_cycle_anchor, 1)
     else:  # nocoverage
-        raise InvalidBillingSchedule(billing_schedule)
+        raise InvalidBillingScheduleError(billing_schedule)
 
     price_per_license = get_price_per_license(tier, billing_schedule, discount)
 

corporate/tests/test_stripe.py

@@ -40,8 +40,8 @@ from corporate.lib.stripe import (
     MIN_INVOICED_LICENSES,
     STRIPE_API_VERSION,
     BillingError,
-    InvalidBillingSchedule,
+    InvalidBillingScheduleError,
-    InvalidTier,
+    InvalidTierError,
     StripeCardError,
     add_months,
     approve_sponsorship,
@@ -4302,10 +4302,10 @@ class BillingHelpersTest(ZulipTestCase):
             800,
         )
 
-        with self.assertRaisesRegex(InvalidBillingSchedule, "Unknown billing_schedule: 1000"):
+        with self.assertRaisesRegex(InvalidBillingScheduleError, "Unknown billing_schedule: 1000"):
             get_price_per_license(CustomerPlan.STANDARD, 1000)
 
-        with self.assertRaisesRegex(InvalidTier, "Unknown tier: 10"):
+        with self.assertRaisesRegex(InvalidTierError, "Unknown tier: 10"):
             get_price_per_license(CustomerPlan.ENTERPRISE, CustomerPlan.ANNUAL)
 
     def test_get_plan_renewal_or_end_date(self) -> None:

corporate/views/portico.py

@@ -9,7 +9,10 @@ from django.template.response import TemplateResponse
 
 from zerver.context_processors import get_realm_from_request, latest_info_context
 from zerver.decorator import add_google_analytics
-from zerver.lib.github import InvalidPlatform, get_latest_github_release_download_link_for_platform
+from zerver.lib.github import (
+    InvalidPlatformError,
+    get_latest_github_release_download_link_for_platform,
+)
 from zerver.lib.realm_description import get_realm_text_description
 from zerver.lib.realm_icon import get_realm_icon_url
 from zerver.lib.subdomains import is_subdomain_root_or_alias
@@ -30,7 +33,7 @@ def app_download_link_redirect(request: HttpRequest, platform: str) -> HttpRespo
     try:
         download_link = get_latest_github_release_download_link_for_platform(platform)
         return HttpResponseRedirect(download_link, status=302)
-    except InvalidPlatform:
+    except InvalidPlatformError:
         return TemplateResponse(request, "404.html", status=404)
 
 

pyproject.toml

@@ -125,7 +125,6 @@ ignore = [
     "E731", # Do not assign a lambda expression, use a def
     "N802", # Function name should be lowercase
     "N806", # Variable in function should be lowercase
-    "N818", # Exception name should be named with an Error suffix
 ]
 line-length = 100
 src = [".", "tools", "tools/setup/emoji"]

templates/zerver/api/incoming-webhooks-walkthrough.md

@@ -628,9 +628,9 @@ Many third-party services have dozens of different event types. In
 some cases, we may choose to explicitly ignore specific events. In
 other cases, there may be events that are new or events that we don't
 know about. In such cases, we recommend raising
-`UnsupportedWebhookEventType` (found in `zerver/lib/exceptions.py`),
+`UnsupportedWebhookEventTypeError` (found in `zerver/lib/exceptions.py`),
 with a string describing the unsupported event type, like so:
 
 ```
-raise UnsupportedWebhookEventType(event_type)
+raise UnsupportedWebhookEventTypeError(event_type)
 ```

tools/coveragerc

@@ -12,7 +12,7 @@ exclude_lines =
     # Don't require coverage for __str__ statements just used for printing
     def __str__[(]self[)] -> .*:
     # Don't require coverage for errors about unsupported webhook event types
-    raise UnsupportedWebhookEventType
+    raise UnsupportedWebhookEventTypeError
     # Don't require coverage for blocks only run when type-checking
     if TYPE_CHECKING:
     # Don't require coverage for abstract methods; they're never called.

tools/lib/html_branches.py

@@ -2,7 +2,7 @@ import re
 from collections import defaultdict
 from typing import Dict, List
 
-from .template_parser import FormattedException, Token, tokenize
+from .template_parser import FormattedError, Token, tokenize
 
 
 class TagInfo:
@@ -83,7 +83,7 @@ def build_id_dict(templates: List[str]) -> (Dict[str, List[str]]):
 
         try:
             list_tags = tokenize(text)
-        except FormattedException as e:
+        except FormattedError as e:
             raise Exception(
                 f"""
                 fn: {fn}

tools/lib/template_parser.py

@@ -1,11 +1,11 @@
 from typing import Callable, List, Optional
 
 
-class FormattedException(Exception):
+class FormattedError(Exception):
     pass
 
 
-class TemplateParserException(Exception):
+class TemplateParserError(Exception):
     def __init__(self, message: str) -> None:
         self.message = message
 
@@ -13,7 +13,7 @@ class TemplateParserException(Exception):
         return self.message
 
 
-class TokenizationException(Exception):
+class TokenizationError(Exception):
     def __init__(self, message: str, line_content: Optional[str] = None) -> None:
         self.message = message
         self.line_content = line_content
@@ -149,7 +149,7 @@ def tokenize(text: str) -> List[Token]:
                 tag_parts = s[1:end_offset].split()
 
                 if not tag_parts:
-                    raise TemplateParserException("Tag name missing")
+                    raise TemplateParserError("Tag name missing")
 
                 tag = tag_parts[0]
 
@@ -228,8 +228,8 @@ def tokenize(text: str) -> List[Token]:
                     continue
                 tag = ""
                 kind = "text"
-        except TokenizationException as e:
+        except TokenizationError as e:
-            raise FormattedException(
+            raise FormattedError(
                 f'''{e.message} at line {state.line} col {state.col}:"{e.line_content}"''',
             )
 
@@ -350,8 +350,8 @@ def validate(fn: Optional[str] = None, text: Optional[str] = None) -> List[Token
 
     try:
         tokens = tokenize(text)
-    except FormattedException as e:
+    except FormattedError as e:
-        raise TemplateParserException(
+        raise TemplateParserError(
             f"""
             fn: {fn}
             {e}"""
@@ -367,7 +367,7 @@ def validate(fn: Optional[str] = None, text: Optional[str] = None) -> List[Token
 
     def no_start_tag(token: Optional[Token]) -> None:
         assert token
-        raise TemplateParserException(
+        raise TemplateParserError(
             f"""
             No start tag
             fn: {fn}
@@ -393,7 +393,7 @@ def validate(fn: Optional[str] = None, text: Optional[str] = None) -> List[Token
 
         def f(end_token: Optional[Token]) -> None:
             if end_token is None:
-                raise TemplateParserException(
+                raise TemplateParserError(
                     f"""
 
     Problem with {fn}
@@ -429,7 +429,7 @@ def validate(fn: Optional[str] = None, text: Optional[str] = None) -> List[Token
 
             problem = report_problem()
             if problem:
-                raise TemplateParserException(
+                raise TemplateParserError(
                     f"""
                     fn: {fn}
                    {problem}
@@ -460,12 +460,12 @@ def validate(fn: Optional[str] = None, text: Optional[str] = None) -> List[Token
         if not state.foreign:
             if kind == "html_start":
                 if tag in HTML_VOID_TAGS:
-                    raise TemplateParserException(
+                    raise TemplateParserError(
                         f"Tag must be self-closing: {tag} at {fn} line {token.line}, col {token.col}"
                     )
             elif kind == "html_singleton":
                 if tag not in HTML_VOID_TAGS:
-                    raise TemplateParserException(
+                    raise TemplateParserError(
                         f"Tag must not be self-closing: {tag} at {fn} line {token.line}, col {token.col}"
                     )
 
@@ -514,7 +514,7 @@ def ensure_matching_indentation(fn: str, tokens: List[Token], lines: List[str])
             return False
 
         if has_bad_indentation():
-            raise TemplateParserException(
+            raise TemplateParserError(
                 f"""
                 fn: {fn}
                 Indentation for start/end tags does not match.
@@ -539,14 +539,14 @@ def prevent_extra_newlines(fn: str, tokens: List[Token]) -> None:
 
         count += 1
         if count >= 4:
-            raise TemplateParserException(
+            raise TemplateParserError(
                 f"""Please avoid so many blank lines near row {token.line} in {fn}."""
             )
 
 
 def prevent_whitespace_violations(fn: str, tokens: List[Token]) -> None:
     if tokens[0].kind in ("indent", "whitespace"):
-        raise TemplateParserException(f" Please remove the whitespace at the beginning of {fn}.")
+        raise TemplateParserError(f" Please remove the whitespace at the beginning of {fn}.")
 
     prevent_extra_newlines(fn, tokens)
 
@@ -559,12 +559,12 @@ def prevent_whitespace_violations(fn: str, tokens: List[Token]) -> None:
                 raise AssertionError("programming error parsing indents")
 
             if next_token.kind == "newline":
-                raise TemplateParserException(
+                raise TemplateParserError(
                     f"""Please just make row {token.line} in {fn} a truly blank line (no spaces)."""
                 )
 
             if len(token.s) % 4 != 0:
-                raise TemplateParserException(
+                raise TemplateParserError(
                     f"""
                         Please use 4-space indents for template files. Most of our
                         codebase (including Python and JavaScript) uses 4-space indents,
@@ -578,13 +578,13 @@ def prevent_whitespace_violations(fn: str, tokens: List[Token]) -> None:
 
         if token.kind == "whitespace":
             if len(token.s) > 1:
-                raise TemplateParserException(
+                raise TemplateParserError(
                     f"""
                         We did not expect this much whitespace at row {token.line} column {token.col} in {fn}.
                     """
                 )
             if next_token.kind == "newline":
-                raise TemplateParserException(
+                raise TemplateParserError(
                     f"""
                         Unexpected trailing whitespace at row {token.line} column {token.col} in {fn}.
                     """
@@ -613,7 +613,7 @@ def get_handlebars_tag(text: str, i: int) -> str:
     while end < len(text) - 1 and text[end] != "}":
         end += 1
     if text[end] != "}" or text[end + 1] != "}":
-        raise TokenizationException('Tag missing "}}"', text[i : end + 2])
+        raise TokenizationError('Tag missing "}}"', text[i : end + 2])
     s = text[i : end + 2]
     return s
 
@@ -649,7 +649,7 @@ def get_django_tag(text: str, i: int, stripped: bool = False) -> str:
     while end < len(text) - 1 and text[end] != "%":
         end += 1
     if text[end] != "%" or text[end + 1] != "}":
-        raise TokenizationException('Tag missing "%}"', text[i : end + 2])
+        raise TokenizationError('Tag missing "%}"', text[i : end + 2])
     s = text[i : end + 2]
     return s
 
@@ -666,11 +666,11 @@ def get_html_tag(text: str, i: int) -> str:
         end += 1
     if quote_count % 2 != 0:
         if unclosed_end:
-            raise TokenizationException("Unbalanced quotes", text[i:unclosed_end])
+            raise TokenizationError("Unbalanced quotes", text[i:unclosed_end])
         else:
-            raise TokenizationException("Unbalanced quotes", text[i : end + 1])
+            raise TokenizationError("Unbalanced quotes", text[i : end + 1])
     if end == len(text) or text[end] != ">":
-        raise TokenizationException('Tag missing ">"', text[i : end + 1])
+        raise TokenizationError('Tag missing ">"', text[i : end + 1])
     s = text[i : end + 1]
     return s
 
@@ -684,7 +684,7 @@ def get_html_comment(text: str, i: int) -> str:
         if not unclosed_end and text[end] == "<":
             unclosed_end = end
         end += 1
-    raise TokenizationException("Unclosed comment", text[i:unclosed_end])
+    raise TokenizationError("Unclosed comment", text[i:unclosed_end])
 
 
 def get_handlebars_comment(text: str, i: int) -> str:
@@ -696,7 +696,7 @@ def get_handlebars_comment(text: str, i: int) -> str:
         if not unclosed_end and text[end] == "<":
             unclosed_end = end
         end += 1
-    raise TokenizationException("Unclosed comment", text[i:unclosed_end])
+    raise TokenizationError("Unclosed comment", text[i:unclosed_end])
 
 
 def get_template_var(text: str, i: int) -> str:
@@ -710,7 +710,7 @@ def get_template_var(text: str, i: int) -> str:
         if not unclosed_end and text[end] == "<":
             unclosed_end = end
         end += 1
-    raise TokenizationException("Unclosed var", text[i:unclosed_end])
+    raise TokenizationError("Unclosed var", text[i:unclosed_end])
 
 
 def get_django_comment(text: str, i: int) -> str:
@@ -722,7 +722,7 @@ def get_django_comment(text: str, i: int) -> str:
         if not unclosed_end and text[end] == "<":
             unclosed_end = end
         end += 1
-    raise TokenizationException("Unclosed comment", text[i:unclosed_end])
+    raise TokenizationError("Unclosed comment", text[i:unclosed_end])
 
 
 def get_handlebars_partial(text: str, i: int) -> str:
@@ -734,4 +734,4 @@ def get_handlebars_partial(text: str, i: int) -> str:
         if not unclosed_end and text[end] == "<":
             unclosed_end = end
         end += 1
-    raise TokenizationException("Unclosed partial", text[i:unclosed_end])
+    raise TokenizationError("Unclosed partial", text[i:unclosed_end])

tools/tests/test_template_parser.py

@@ -4,7 +4,7 @@ from typing import Optional
 
 try:
     from tools.lib.template_parser import (
-        TemplateParserException,
+        TemplateParserError,
         is_django_block_tag,
         tokenize,
         validate,
@@ -21,7 +21,7 @@ class ParserTest(unittest.TestCase):
         fn: Optional[str] = None,
         text: Optional[str] = None,
     ) -> None:
-        with self.assertRaisesRegex(TemplateParserException, error):
+        with self.assertRaisesRegex(TemplateParserError, error):
             validate(fn=fn, text=text)
 
     def test_is_django_block_tag(self) -> None:

zerver/actions/message_send.py

@@ -35,10 +35,10 @@ from zerver.lib.cache import cache_with_key, user_profile_delivery_email_cache_k
 from zerver.lib.create_user import create_user
 from zerver.lib.exceptions import (
     JsonableError,
-    MarkdownRenderingException,
+    MarkdownRenderingError,
     StreamDoesNotExistError,
     StreamWithIDDoesNotExistError,
-    ZephyrMessageAlreadySentException,
+    ZephyrMessageAlreadySentError,
 )
 from zerver.lib.markdown import MessageRenderingResult
 from zerver.lib.markdown import version as markdown_version
@@ -148,7 +148,7 @@ def render_incoming_message(
             url_embed_data=url_embed_data,
             email_gateway=email_gateway,
         )
-    except MarkdownRenderingException:
+    except MarkdownRenderingError:
         raise JsonableError(_("Unable to render message"))
     return rendering_result
 
@@ -1173,7 +1173,7 @@ def check_send_message(
             widget_content,
             skip_stream_access_check=skip_stream_access_check,
         )
-    except ZephyrMessageAlreadySentException as e:
+    except ZephyrMessageAlreadySentError as e:
         return e.message_id
     return do_send_messages([message])[0]
 
@@ -1460,7 +1460,7 @@ def check_message(
     if client.name == "zephyr_mirror":
         id = already_sent_mirrored_message_id(message)
         if id is not None:
-            raise ZephyrMessageAlreadySentException(id)
+            raise ZephyrMessageAlreadySentError(id)
 
     widget_content_dict = None
     if widget_content is not None:

zerver/decorator.py

@@ -38,17 +38,17 @@ from typing_extensions import Concatenate, ParamSpec
 
 from zerver.lib.exceptions import (
     AccessDeniedError,
-    AnomalousWebhookPayload,
+    AnomalousWebhookPayloadError,
     InvalidAPIKeyError,
     InvalidAPIKeyFormatError,
     InvalidJSONError,
     JsonableError,
-    OrganizationAdministratorRequired,
+    OrganizationAdministratorRequiredError,
-    OrganizationMemberRequired,
+    OrganizationMemberRequiredError,
-    OrganizationOwnerRequired,
+    OrganizationOwnerRequiredError,
     RealmDeactivatedError,
     UnauthorizedError,
-    UnsupportedWebhookEventType,
+    UnsupportedWebhookEventTypeError,
     UserDeactivatedError,
     WebhookError,
 )
@@ -139,7 +139,7 @@ def require_realm_owner(
         **kwargs: ParamT.kwargs,
     ) -> HttpResponse:
         if not user_profile.is_realm_owner:
-            raise OrganizationOwnerRequired()
+            raise OrganizationOwnerRequiredError()
         return func(request, user_profile, *args, **kwargs)
 
     return wrapper
@@ -157,7 +157,7 @@ def require_realm_admin(
         **kwargs: ParamT.kwargs,
     ) -> HttpResponse:
         if not user_profile.is_realm_admin:
-            raise OrganizationAdministratorRequired()
+            raise OrganizationAdministratorRequiredError()
         return func(request, user_profile, *args, **kwargs)
 
     return wrapper
@@ -175,7 +175,7 @@ def require_organization_member(
         **kwargs: ParamT.kwargs,
     ) -> HttpResponse:
         if user_profile.role > UserProfile.ROLE_MEMBER:
-            raise OrganizationMemberRequired()
+            raise OrganizationMemberRequiredError()
         return func(request, user_profile, *args, **kwargs)
 
     return wrapper
@@ -303,15 +303,15 @@ def log_unsupported_webhook_event(summary: str) -> None:
     # webhook integrations (e.g. GitHub) that need to log an unsupported
     # event based on attributes nested deep within a complicated JSON
     # payload. In such cases, the error message we want to log may not
-    # really fit what a regular UnsupportedWebhookEventType exception
+    # really fit what a regular UnsupportedWebhookEventTypeError exception
     # represents.
     webhook_unsupported_events_logger.exception(summary, stack_info=True)
 
 
 def log_exception_to_webhook_logger(err: Exception) -> None:
-    if isinstance(err, AnomalousWebhookPayload):
+    if isinstance(err, AnomalousWebhookPayloadError):
         webhook_anomalous_payloads_logger.exception(str(err), stack_info=True)
-    elif isinstance(err, UnsupportedWebhookEventType):
+    elif isinstance(err, UnsupportedWebhookEventTypeError):
         webhook_unsupported_events_logger.exception(str(err), stack_info=True)
     else:
         webhook_logger.exception(str(err), stack_info=True)

zerver/forms.py

@@ -26,7 +26,7 @@ from zerver.lib.email_validation import (
     email_allowed_for_realm,
     email_reserved_for_system_bots_error,
 )
-from zerver.lib.exceptions import JsonableError, RateLimited
+from zerver.lib.exceptions import JsonableError, RateLimitedError
 from zerver.lib.name_restrictions import is_disposable_domain, is_reserved_subdomain
 from zerver.lib.rate_limiter import RateLimitedObject, rate_limit_request_by_ip
 from zerver.lib.send_email import FromAddress, send_email
@@ -344,7 +344,7 @@ class ZulipPasswordResetForm(PasswordResetForm):
             try:
                 rate_limit_password_reset_form_by_email(email)
                 rate_limit_request_by_ip(request, domain="sends_email_by_ip")
-            except RateLimited:
+            except RateLimitedError:
                 logging.info(
                     "Too many password reset attempts for email %s from %s",
                     email,
@@ -418,7 +418,7 @@ class RateLimitedPasswordResetByEmail(RateLimitedObject):
 def rate_limit_password_reset_form_by_email(email: str) -> None:
     ratelimited, secs_to_freedom = RateLimitedPasswordResetByEmail(email).rate_limit()
     if ratelimited:
-        raise RateLimited(secs_to_freedom)
+        raise RateLimitedError(secs_to_freedom)
 
 
 class CreateUserForm(forms.Form):
@@ -447,7 +447,7 @@ class OurAuthenticationForm(AuthenticationForm):
                     realm=realm,
                     return_data=return_data,
                 )
-            except RateLimited as e:
+            except RateLimitedError as e:
                 assert e.secs_to_freedom is not None
                 secs_to_freedom = int(e.secs_to_freedom)
                 error_message = _(

zerver/lib/bot_lib.py

@@ -58,11 +58,11 @@ class StateHandler:
         return is_key_in_bot_storage(self.user_profile, key)
 
 
-class EmbeddedBotQuitException(Exception):
+class EmbeddedBotQuitError(Exception):
     pass
 
 
-class EmbeddedBotEmptyRecipientsList(Exception):
+class EmbeddedBotEmptyRecipientsListError(Exception):
     pass
 
 
@@ -102,7 +102,7 @@ class EmbeddedBotHandler:
         recipients = ",".join(message["to"]).split(",")
 
         if len(message["to"]) == 0:
-            raise EmbeddedBotEmptyRecipientsList(_("Message must have recipients!"))
+            raise EmbeddedBotEmptyRecipientsListError(_("Message must have recipients!"))
         elif len(message["to"]) == 1:
             recipient_user = get_active_user(recipients[0], self.user_profile.realm)
             message_id = internal_send_private_message(
@@ -151,4 +151,4 @@ class EmbeddedBotHandler:
             raise
 
     def quit(self, message: str = "") -> None:
-        raise EmbeddedBotQuitException(message)
+        raise EmbeddedBotQuitError(message)

zerver/lib/cache.py

@@ -44,11 +44,6 @@ ReturnT = TypeVar("ReturnT")
 
 logger = logging.getLogger()
 
-
-class NotFoundInCache(Exception):
-    pass
-
-
 remote_cache_time_start = 0.0
 remote_cache_total_time = 0.0
 remote_cache_total_requests = 0
@@ -151,7 +146,7 @@ def cache_with_key(
 
             try:
                 val = cache_get(key, cache_name=cache_name)
-            except InvalidCacheKeyException:
+            except InvalidCacheKeyError:
                 stack_trace = traceback.format_exc()
                 log_invalid_cache_keys(stack_trace, [key])
                 return func(*args, **kwargs)
@@ -190,7 +185,7 @@ def cache_with_key(
     return decorator
 
 
-class InvalidCacheKeyException(Exception):
+class InvalidCacheKeyError(Exception):
     pass
 
 
@@ -215,9 +210,9 @@ def validate_cache_key(key: str) -> None:
     # The regex checks "all characters between ! and ~ in the ascii table",
     # which happens to be the set of all "nice" ascii characters.
     if not bool(re.fullmatch(r"([!-~])+", key)):
-        raise InvalidCacheKeyException("Invalid characters in the cache key: " + key)
+        raise InvalidCacheKeyError("Invalid characters in the cache key: " + key)
     if len(key) > MEMCACHED_MAX_KEY_LENGTH:
-        raise InvalidCacheKeyException(f"Cache key too long: {key} Length: {len(key)}")
+        raise InvalidCacheKeyError(f"Cache key too long: {key} Length: {len(key)}")
 
 
 def cache_set(
@@ -262,7 +257,7 @@ def safe_cache_get_many(keys: List[str], cache_name: Optional[str] = None) -> Di
         # to do normal cache_get_many to avoid the overhead of
         # validating all the keys here.
         return cache_get_many(keys, cache_name)
-    except InvalidCacheKeyException:
+    except InvalidCacheKeyError:
         stack_trace = traceback.format_exc()
         good_keys, bad_keys = filter_good_and_bad_keys(keys)
 
@@ -295,7 +290,7 @@ def safe_cache_set_many(
         # to do normal cache_set_many to avoid the overhead of
         # validating all the keys here.
         return cache_set_many(items, cache_name, timeout)
-    except InvalidCacheKeyException:
+    except InvalidCacheKeyError:
         stack_trace = traceback.format_exc()
 
         good_keys, bad_keys = filter_good_and_bad_keys(list(items.keys()))
@@ -330,7 +325,7 @@ def filter_good_and_bad_keys(keys: List[str]) -> Tuple[List[str], List[str]]:
         try:
             validate_cache_key(key)
             good_keys.append(key)
-        except InvalidCacheKeyException:
+        except InvalidCacheKeyError:
             bad_keys.append(key)
 
     return good_keys, bad_keys

zerver/lib/email_mirror.py

@@ -20,7 +20,7 @@ from zerver.lib.email_mirror_helpers import (
     get_email_gateway_message_string_from_address,
 )
 from zerver.lib.email_notifications import convert_html_to_markdown
-from zerver.lib.exceptions import JsonableError, RateLimited
+from zerver.lib.exceptions import JsonableError, RateLimitedError
 from zerver.lib.message import normalize_body, truncate_topic
 from zerver.lib.queue import queue_json_publish
 from zerver.lib.rate_limiter import RateLimitedObject
@@ -534,4 +534,4 @@ def rate_limit_mirror_by_realm(recipient_realm: Realm) -> None:
     ratelimited, secs_to_freedom = RateLimitedRealmMirror(recipient_realm).rate_limit()
 
     if ratelimited:
-        raise RateLimited(secs_to_freedom)
+        raise RateLimitedError(secs_to_freedom)

zerver/lib/events.py

@@ -76,7 +76,7 @@ from zerver.tornado.django_api import get_user_events, request_event_queue
 from zproject.backends import email_auth_enabled, password_auth_enabled
 
 
-class RestartEventException(Exception):
+class RestartEventError(Exception):
     """
     Special error for handling restart events in apply_events.
     """
@@ -646,7 +646,7 @@ def apply_events(
 ) -> None:
     for event in events:
         if event["type"] == "restart":
-            raise RestartEventException()
+            raise RestartEventError()
         if fetch_event_types is not None and event["type"] not in fetch_event_types:
             # TODO: continuing here is not, most precisely, correct.
             # In theory, an event of one type, e.g. `realm_user`,
@@ -1483,7 +1483,7 @@ def do_events_register(
                 slim_presence=slim_presence,
                 include_subscribers=include_subscribers,
             )
-        except RestartEventException:
+        except RestartEventError:
             # This represents a rare race condition, where Tornado
             # restarted (and sent `restart` events) while we were waiting
             # for fetch_initial_state_data to return. To avoid the client

zerver/lib/exceptions.py

@@ -185,7 +185,7 @@ class CannotDeactivateLastUserError(JsonableError):
         return _("Cannot deactivate the only {entity}.")
 
 
-class InvalidMarkdownIncludeStatement(JsonableError):
+class InvalidMarkdownIncludeStatementError(JsonableError):
     code = ErrorCode.INVALID_MARKDOWN_INCLUDE_STATEMENT
     data_fields = ["include_statement"]
 
@@ -197,7 +197,7 @@ class InvalidMarkdownIncludeStatement(JsonableError):
         return _("Invalid Markdown include statement: {include_statement}")
 
 
-class RateLimited(JsonableError):
+class RateLimitedError(JsonableError):
     code = ErrorCode.RATE_LIMIT_HIT
     http_status_code = 429
 
@@ -232,7 +232,7 @@ class InvalidJSONError(JsonableError):
         return _("Malformed JSON")
 
 
-class OrganizationMemberRequired(JsonableError):
+class OrganizationMemberRequiredError(JsonableError):
     code: ErrorCode = ErrorCode.UNAUTHORIZED_PRINCIPAL
 
     def __init__(self) -> None:
@@ -243,7 +243,7 @@ class OrganizationMemberRequired(JsonableError):
         return _("Must be an organization member")
 
 
-class OrganizationAdministratorRequired(JsonableError):
+class OrganizationAdministratorRequiredError(JsonableError):
     code: ErrorCode = ErrorCode.UNAUTHORIZED_PRINCIPAL
 
     def __init__(self) -> None:
@@ -254,7 +254,7 @@ class OrganizationAdministratorRequired(JsonableError):
         return _("Must be an organization administrator")
 
 
-class OrganizationOwnerRequired(JsonableError):
+class OrganizationOwnerRequiredError(JsonableError):
     code: ErrorCode = ErrorCode.UNAUTHORIZED_PRINCIPAL
 
     def __init__(self) -> None:
@@ -320,7 +320,7 @@ class PasswordResetRequiredError(AuthenticationFailedError):
         return _("Your password has been disabled and needs to be reset")
 
 
-class MarkdownRenderingException(Exception):
+class MarkdownRenderingError(Exception):
     pass
 
 
@@ -346,7 +346,7 @@ class WebhookError(JsonableError):
     """
     Intended as a generic exception raised by specific webhook
     integrations. This class is subclassed by more specific exceptions
-    such as UnsupportedWebhookEventType and AnomalousWebhookPayload.
+    such as UnsupportedWebhookEventTypeError and AnomalousWebhookPayloadError.
     """
 
     data_fields = ["webhook_name"]
@@ -357,14 +357,14 @@ class WebhookError(JsonableError):
         self.webhook_name = "(unknown)"
 
 
-class UnsupportedWebhookEventType(WebhookError):
+class UnsupportedWebhookEventTypeError(WebhookError):
     """Intended as an exception for event formats that we know the
     third-party service generates but which Zulip doesn't support /
     generate a message for.
 
     Exceptions where we cannot parse the event type, possibly because
     the event isn't actually from the service in question, should
-    raise AnomalousWebhookPayload.
+    raise AnomalousWebhookPayloadError.
     """
 
     code = ErrorCode.UNSUPPORTED_WEBHOOK_EVENT_TYPE
@@ -379,14 +379,14 @@ class UnsupportedWebhookEventType(WebhookError):
         return _("The '{event_type}' event isn't currently supported by the {webhook_name} webhook")
 
 
-class AnomalousWebhookPayload(WebhookError):
+class AnomalousWebhookPayloadError(WebhookError):
     """Intended as an exception for incoming webhook requests that we
     cannot recognize as having been generated by the service in
     question. (E.g. because someone pointed a Jira server at the
     GitHub integration URL).
 
     If we can parse the event but don't support it, use
-    UnsupportedWebhookEventType.
+    UnsupportedWebhookEventTypeError.
 
     """
 
@@ -420,7 +420,7 @@ class InvalidSubdomainError(JsonableError):
         return _("Invalid subdomain")
 
 
-class ZephyrMessageAlreadySentException(Exception):
+class ZephyrMessageAlreadySentError(Exception):
     def __init__(self, message_id: int) -> None:
         self.message_id = message_id
 

zerver/lib/github.py

@@ -43,14 +43,14 @@ PLATFORM_TO_SETUP_FILE = {
 }
 
 
-class InvalidPlatform(Exception):
+class InvalidPlatformError(Exception):
     pass
 
 
 @cache_with_key(lambda platform: f"download_link:{platform}", timeout=60 * 30)
 def get_latest_github_release_download_link_for_platform(platform: str) -> str:
     if platform not in PLATFORM_TO_SETUP_FILE:
-        raise InvalidPlatform()
+        raise InvalidPlatformError()
 
     latest_version = get_latest_github_release_version_for_repo("zulip-desktop")
     if latest_version:

zerver/lib/markdown/__init__.py

@@ -50,7 +50,7 @@ from zerver.lib import mention as mention
 from zerver.lib.cache import cache_with_key
 from zerver.lib.camo import get_camo_url
 from zerver.lib.emoji import EMOTICON_RE, codepoint_to_name, name_to_codepoint, translate_emoticons
-from zerver.lib.exceptions import MarkdownRenderingException
+from zerver.lib.exceptions import MarkdownRenderingError
 from zerver.lib.markdown import fenced_code
 from zerver.lib.markdown.fenced_code import FENCE_RE
 from zerver.lib.mention import (
@@ -63,7 +63,7 @@ from zerver.lib.outgoing_http import OutgoingSession
 from zerver.lib.subdomains import is_static_or_current_realm_url
 from zerver.lib.tex import render_tex
 from zerver.lib.thumbnail import user_uploads_or_external
-from zerver.lib.timeout import TimeoutExpired, timeout
+from zerver.lib.timeout import TimeoutExpiredError, timeout
 from zerver.lib.timezone import common_timezones
 from zerver.lib.types import LinkifierDict
 from zerver.lib.url_encoding import encode_stream, hash_util_encode
@@ -474,7 +474,7 @@ def fetch_tweet_data(tweet_id: str) -> Optional[Dict[str, Any]]:
             # formatting timeout.
             tweet = timeout(3, lambda: api.GetStatus(tweet_id))
             res = tweet.AsDict()
-        except TimeoutExpired:
+        except TimeoutExpiredError:
             # We'd like to try again later and not cache the bad result,
             # so we need to re-raise the exception (just as though
             # we were being rate-limited)
@@ -2581,7 +2581,7 @@ def do_convert(
         # something huge.
         MAX_MESSAGE_LENGTH = settings.MAX_MESSAGE_LENGTH
         if len(rendering_result.rendered_content) > MAX_MESSAGE_LENGTH * 100:
-            raise MarkdownRenderingException(
+            raise MarkdownRenderingError(
                 f"Rendered content exceeds {MAX_MESSAGE_LENGTH * 100} characters (message {logging_message_id})"
             )
         return rendering_result
@@ -2596,7 +2596,7 @@ def do_convert(
             logging_message_id,
         )
 
-        raise MarkdownRenderingException()
+        raise MarkdownRenderingError()
     finally:
         # These next three lines are slightly paranoid, since
         # we always set these right before actually using the

zerver/lib/markdown/fenced_code.py

@@ -87,7 +87,7 @@ from markdown.preprocessors import Preprocessor
 from pygments.lexers import find_lexer_class_by_name
 from pygments.util import ClassNotFound
 
-from zerver.lib.exceptions import MarkdownRenderingException
+from zerver.lib.exceptions import MarkdownRenderingError
 from zerver.lib.markdown.priorities import PREPROCESSOR_PRIORITES
 from zerver.lib.tex import render_tex
 
@@ -137,7 +137,7 @@ Missing required -X argument in curl command:
         regex = r'curl [-](sS)?X "?(GET|DELETE|PATCH|POST)"?'
         if line.startswith("curl"):
             if re.search(regex, line) is None:
-                raise MarkdownRenderingException(error_msg.format(command=line.strip()))
+                raise MarkdownRenderingError(error_msg.format(command=line.strip()))
 
 
 CODE_VALIDATORS: Dict[Optional[str], Callable[[List[str]], None]] = {

zerver/lib/markdown/include.py

@@ -7,7 +7,7 @@ from markdown import Extension, Markdown
 from markdown.blockparser import BlockParser
 from markdown.blockprocessors import BlockProcessor
 
-from zerver.lib.exceptions import InvalidMarkdownIncludeStatement
+from zerver.lib.exceptions import InvalidMarkdownIncludeStatementError
 from zerver.lib.markdown.priorities import BLOCK_PROCESSOR_PRIORITIES
 
 
@@ -39,7 +39,7 @@ class IncludeBlockProcessor(BlockProcessor):
             with open(os.path.normpath(os.path.join(self.base_path, m[1]))) as f:
                 lines = f.read().splitlines()
         except OSError as e:
-            raise InvalidMarkdownIncludeStatement(m[0].strip()) from e
+            raise InvalidMarkdownIncludeStatementError(m[0].strip()) from e
 
         for prep in self.parser.md.preprocessors:
             lines = prep.run(lines)

zerver/lib/mdiff.py

@@ -3,7 +3,7 @@ import os
 import subprocess
 
 
-class DiffException(Exception):
+class DiffError(Exception):
     pass
 
 
@@ -13,7 +13,7 @@ def diff_strings(output: str, expected_output: str) -> str:
     if not os.path.isfile(mdiff_path):  # nocoverage
         msg = "Cannot find mdiff for Markdown diff rendering"
         logging.error(msg)
-        raise DiffException(msg)
+        raise DiffError(msg)
 
     command = ["node", mdiff_path, output, expected_output]
     diff = subprocess.check_output(command, text=True)

zerver/lib/narrow.py

@@ -186,7 +186,7 @@ def build_narrow_filter(narrow: Collection[Sequence[str]]) -> Callable[[Mapping[
 LARGER_THAN_MAX_MESSAGE_ID = 10000000000000000
 
 
-class BadNarrowOperator(JsonableError):
+class BadNarrowOperatorError(JsonableError):
     code = ErrorCode.BAD_NARROW
     data_fields = ["desc"]
 
@@ -284,7 +284,7 @@ class NarrowBuilder:
         method_name = "by_" + operator.replace("-", "_")
         method = getattr(self, method_name, None)
         if method is None:
-            raise BadNarrowOperator("unknown operator " + operator)
+            raise BadNarrowOperatorError("unknown operator " + operator)
 
         if negated:
             maybe_negate = not_
@@ -295,7 +295,7 @@ class NarrowBuilder:
 
     def by_has(self, query: Select, operand: str, maybe_negate: ConditionTransform) -> Select:
         if operand not in ["attachment", "image", "link"]:
-            raise BadNarrowOperator("unknown 'has' operand " + operand)
+            raise BadNarrowOperatorError("unknown 'has' operand " + operand)
         col_name = "has_" + operand
         cond = column(col_name, Boolean)
         return query.where(maybe_negate(cond))
@@ -311,7 +311,7 @@ class NarrowBuilder:
         elif operand == "all":
             return query
 
-        raise BadNarrowOperator("unknown 'in' operand " + operand)
+        raise BadNarrowOperatorError("unknown 'in' operand " + operand)
 
     def by_is(self, query: Select, operand: str, maybe_negate: ConditionTransform) -> Select:
         # This operator class does not support is_web_public_query.
@@ -338,7 +338,7 @@ class NarrowBuilder:
         elif operand == "resolved":
             cond = get_resolved_topic_condition_sa()
             return query.where(maybe_negate(cond))
-        raise BadNarrowOperator("unknown 'is' operand " + operand)
+        raise BadNarrowOperatorError("unknown 'is' operand " + operand)
 
     _alphanum = frozenset("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
 
@@ -371,9 +371,9 @@ class NarrowBuilder:
             stream = get_stream_by_narrow_operand_access_unchecked(operand, self.realm)
 
             if self.is_web_public_query and not stream.is_web_public:
-                raise BadNarrowOperator("unknown web-public stream " + str(operand))
+                raise BadNarrowOperatorError("unknown web-public stream " + str(operand))
         except Stream.DoesNotExist:
-            raise BadNarrowOperator("unknown stream " + str(operand))
+            raise BadNarrowOperatorError("unknown stream " + str(operand))
 
         if self.realm.is_zephyr_mirror_realm:
             # MIT users expect narrowing to "social" to also show messages to
@@ -412,7 +412,7 @@ class NarrowBuilder:
         elif operand == "web-public":
             recipient_queryset = get_web_public_streams_queryset(self.realm)
         else:
-            raise BadNarrowOperator("unknown streams operand " + operand)
+            raise BadNarrowOperatorError("unknown streams operand " + operand)
 
         recipient_ids = recipient_queryset.values_list("recipient_id", flat=True).order_by("id")
         cond = column("recipient_id", Integer).in_(recipient_ids)
@@ -472,7 +472,7 @@ class NarrowBuilder:
             else:
                 sender = get_user_by_id_in_realm_including_cross_realm(operand, self.realm)
         except UserProfile.DoesNotExist:
-            raise BadNarrowOperator("unknown user " + str(operand))
+            raise BadNarrowOperatorError("unknown user " + str(operand))
 
         cond = column("sender_id", Integer) == literal(sender.id)
         return query.where(maybe_negate(cond))
@@ -484,7 +484,7 @@ class NarrowBuilder:
         self, query: Select, operand: Union[int, str], maybe_negate: ConditionTransform
     ) -> Select:
         if not str(operand).isdigit():
-            raise BadNarrowOperator("Invalid message ID")
+            raise BadNarrowOperatorError("Invalid message ID")
         cond = self.msg_id_column == literal(operand)
         return query.where(maybe_negate(cond))
 
@@ -520,7 +520,7 @@ class NarrowBuilder:
                 allow_deactivated=True,
             )
         except (JsonableError, ValidationError):
-            raise BadNarrowOperator("unknown user in " + str(operand))
+            raise BadNarrowOperatorError("unknown user in " + str(operand))
 
         # Group DM
         if recipient.type == Recipient.HUDDLE:
@@ -576,7 +576,7 @@ class NarrowBuilder:
             else:
                 narrow_profile = get_user_by_id_in_realm_including_cross_realm(operand, self.realm)
         except UserProfile.DoesNotExist:
-            raise BadNarrowOperator("unknown user " + str(operand))
+            raise BadNarrowOperatorError("unknown user " + str(operand))
 
         self_recipient_ids = [
             recipient_tuple["recipient_id"]

zerver/lib/rate_limiter.py

@@ -11,7 +11,7 @@ from django.conf import settings
 from django.http import HttpRequest
 
 from zerver.lib.cache import cache_with_key
-from zerver.lib.exceptions import RateLimited
+from zerver.lib.exceptions import RateLimitedError
 from zerver.lib.redis_utils import get_redis_client
 from zerver.lib.utils import statsd
 from zerver.models import UserProfile
@@ -27,7 +27,7 @@ KEY_PREFIX = ""
 logger = logging.getLogger(__name__)
 
 
-class RateLimiterLockingException(Exception):
+class RateLimiterLockingError(Exception):
     pass
 
 
@@ -61,7 +61,7 @@ class RateLimitedObject(ABC):
         # Abort this request if the user is over their rate limits
         if ratelimited:
             # Pass information about what kind of entity got limited in the exception:
-            raise RateLimited(time)
+            raise RateLimitedError(time)
 
         calls_remaining, seconds_until_reset = self.api_calls_left()
 
@@ -483,7 +483,7 @@ class RedisRateLimiterBackend(RateLimiterBackend):
                     break
                 except redis.WatchError:  # nocoverage # Ideally we'd have a test for this.
                     if count > 10:
-                        raise RateLimiterLockingException()
+                        raise RateLimiterLockingError()
                     count += 1
 
                     continue
@@ -500,7 +500,7 @@ class RedisRateLimiterBackend(RateLimiterBackend):
         else:
             try:
                 cls.incr_ratelimit(entity_key, max_api_calls, max_api_window)
-            except RateLimiterLockingException:
+            except RateLimiterLockingError:
                 logger.warning("Deadlock trying to incr_ratelimit for %s", entity_key)
                 # rate-limit users who are hitting the API so hard we can't update our stats.
                 ratelimited = True
@@ -536,7 +536,7 @@ class RateLimitedSpectatorAttachmentAccessByFile(RateLimitedObject):
 def rate_limit_spectator_attachment_access_by_file(path_id: str) -> None:
     ratelimited, _ = RateLimitedSpectatorAttachmentAccessByFile(path_id).rate_limit()
     if ratelimited:
-        raise RateLimited
+        raise RateLimitedError
 
 
 def is_local_addr(addr: str) -> bool:
@@ -579,7 +579,7 @@ def client_is_exempt_from_rate_limiting(request: HttpRequest) -> bool:
 
 
 def rate_limit_user(request: HttpRequest, user: UserProfile, domain: str) -> None:
-    """Returns whether or not a user was rate limited. Will raise a RateLimited exception
+    """Returns whether or not a user was rate limited. Will raise a RateLimitedError exception
     if the user has been rate limited, otherwise returns and modifies request to contain
     the rate limit information"""
     if not should_rate_limit(request):

zerver/lib/remote_server.py

@@ -21,7 +21,7 @@ class PushBouncerSession(OutgoingSession):
         super().__init__(role="push_bouncer", timeout=30)
 
 
-class PushNotificationBouncerException(Exception):
+class PushNotificationBouncerError(Exception):
     pass
 
 
@@ -87,7 +87,7 @@ def send_to_push_bouncer(
         msg = result_dict["msg"]
         if "code" in result_dict and result_dict["code"] == "INVALID_ZULIP_SERVER":
             # Invalid Zulip server credentials should email this server's admins
-            raise PushNotificationBouncerException(
+            raise PushNotificationBouncerError(
                 _("Push notifications bouncer error: {}").format(msg)
             )
         else:
@@ -99,7 +99,7 @@ def send_to_push_bouncer(
         # Anything else is unexpected and likely suggests a bug in
         # this version of Zulip, so we throw an exception that will
         # email the server admins.
-        raise PushNotificationBouncerException(
+        raise PushNotificationBouncerError(
             f"Push notification bouncer returned unexpected status code {res.status_code}"
         )
 

zerver/lib/send_email.py

@@ -206,11 +206,11 @@ def build_email(
     return mail
 
 
-class EmailNotDeliveredException(Exception):
+class EmailNotDeliveredError(Exception):
     pass
 
 
-class DoubledEmailArgumentException(CommandError):
+class DoubledEmailArgumentError(CommandError):
     def __init__(self, argument_name: str) -> None:
         msg = (
             f"Argument '{argument_name}' is ambiguously present in both options and email template."
@@ -218,7 +218,7 @@ class DoubledEmailArgumentException(CommandError):
         super().__init__(msg)
 
 
-class NoEmailArgumentException(CommandError):
+class NoEmailArgumentError(CommandError):
     def __init__(self, argument_name: str) -> None:
         msg = f"Argument '{argument_name}' is required in either options or email template."
         super().__init__(msg)
@@ -277,7 +277,7 @@ def send_email(
         # it will only call .close() if it was not open to begin with
         if connection.send_messages([mail]) == 0:
             logger.error("Unknown error sending %s email to %s", template, mail.to)
-            raise EmailNotDeliveredException
+            raise EmailNotDeliveredError
     except smtplib.SMTPResponseException as e:
         logger.exception(
             "Error sending %s email to %s with error code %s: %s",
@@ -287,10 +287,10 @@ def send_email(
             e.smtp_error,
             stack_info=True,
         )
-        raise EmailNotDeliveredException
+        raise EmailNotDeliveredError
     except smtplib.SMTPException as e:
         logger.exception("Error sending %s email to %s: %s", template, mail.to, e, stack_info=True)
-        raise EmailNotDeliveredException
+        raise EmailNotDeliveredError
 
 
 @backoff.on_exception(backoff.expo, OSError, max_tries=MAX_CONNECTION_TRIES, logger=None)
@@ -488,9 +488,9 @@ def deliver_scheduled_emails(email: ScheduledEmail) -> None:
 
 def get_header(option: Optional[str], header: Optional[str], name: str) -> str:
     if option and header:
-        raise DoubledEmailArgumentException(name)
+        raise DoubledEmailArgumentError(name)
     if not option and not header:
-        raise NoEmailArgumentException(name)
+        raise NoEmailArgumentError(name)
     return str(option or header)
 
 
@@ -564,7 +564,7 @@ def send_custom_email(
                 context=context,
                 dry_run=options["dry_run"],
             )
-        except EmailNotDeliveredException:
+        except EmailNotDeliveredError:
             pass
 
         if options["dry_run"]:

zerver/lib/streams.py

@@ -9,8 +9,8 @@ from django.utils.translation import gettext as _
 from zerver.actions.default_streams import get_default_streams_for_realm
 from zerver.lib.exceptions import (
     JsonableError,
-    OrganizationAdministratorRequired,
+    OrganizationAdministratorRequiredError,
-    OrganizationOwnerRequired,
+    OrganizationOwnerRequiredError,
 )
 from zerver.lib.markdown import markdown_convert
 from zerver.lib.stream_subscription import (
@@ -318,7 +318,7 @@ def check_stream_access_for_delete_or_update(
     if sub is None and stream.invite_only:
         raise JsonableError(error)
 
-    raise OrganizationAdministratorRequired()
+    raise OrganizationAdministratorRequiredError()
 
 
 def access_stream_for_delete_or_update(
@@ -739,7 +739,7 @@ def list_to_streams(
 
         if message_retention_days_not_none:
             if not user_profile.is_realm_owner:
-                raise OrganizationOwnerRequired()
+                raise OrganizationOwnerRequiredError()
 
             user_profile.realm.ensure_not_on_limited_plan()
 

zerver/lib/test_classes.py

@@ -66,7 +66,7 @@ from zerver.lib.streams import (
 from zerver.lib.subscription_info import gather_subscriptions
 from zerver.lib.test_console_output import (
     ExtraConsoleOutputFinder,
-    ExtraConsoleOutputInTestException,
+    ExtraConsoleOutputInTestError,
     tee_stderr_and_find_extra_console_output,
     tee_stdout_and_find_extra_console_output,
 )
@@ -192,7 +192,7 @@ Output:
 {extra_output_finder.full_extra_output.decode(errors="replace")}
 --------------------------------------------
 """
-            raise ExtraConsoleOutputInTestException(exception_message)
+            raise ExtraConsoleOutputInTestError(exception_message)
         return test_result
 
     """

zerver/lib/test_console_output.py

@@ -7,7 +7,7 @@ from types import TracebackType
 from typing import IO, Iterable, Iterator, List, Optional, Type
 
 
-class ExtraConsoleOutputInTestException(Exception):
+class ExtraConsoleOutputInTestError(Exception):
     pass
 
 

zerver/lib/timeout.py

@@ -9,7 +9,7 @@ from typing import Callable, Optional, Tuple, Type, TypeVar
 # Based on https://code.activestate.com/recipes/483752/
 
 
-class TimeoutExpired(Exception):
+class TimeoutExpiredError(Exception):
     """Exception raised when a function times out."""
 
     def __str__(self) -> str:
@@ -24,7 +24,7 @@ def timeout(timeout: float, func: Callable[[], ResultT]) -> ResultT:
     Return its return value, or raise an exception,
     within approximately 'timeout' seconds.
 
-    The function may receive a TimeoutExpired exception
+    The function may receive a TimeoutExpiredError exception
     anywhere in its code, which could have arbitrary
     unsafe effects (resources not released, etc.).
     It might also fail to receive the exception and
@@ -57,11 +57,11 @@ def timeout(timeout: float, func: Callable[[], ResultT]) -> ResultT:
 
         def raise_async_timeout(self) -> None:
             # This function is called from another thread; we attempt
-            # to raise a TimeoutExpired in _this_ thread.
+            # to raise a TimeoutExpiredError in _this_ thread.
             assert self.ident is not None
             ctypes.pythonapi.PyThreadState_SetAsyncExc(
                 ctypes.c_ulong(self.ident),
-                ctypes.py_object(TimeoutExpired),
+                ctypes.py_object(TimeoutExpiredError),
             )
 
     thread = TimeoutThread()
@@ -86,7 +86,7 @@ def timeout(timeout: float, func: Callable[[], ResultT]) -> ResultT:
         # we just ignore it.
         if thread.is_alive():
             logging.warning("Failed to time out backend thread")
-        raise TimeoutExpired
+        raise TimeoutExpiredError
 
     if thread.exc_info[1] is not None:
         # Died with some other exception; re-raise it

zerver/lib/timestamp.py

@@ -2,13 +2,13 @@ import calendar
 import datetime
 
 
-class TimeZoneNotUTCException(Exception):
+class TimeZoneNotUTCError(Exception):
     pass
 
 
 def verify_UTC(dt: datetime.datetime) -> None:
     if dt.tzinfo is None or dt.tzinfo.utcoffset(dt) != datetime.timezone.utc.utcoffset(dt):
-        raise TimeZoneNotUTCException(f"Datetime {dt} does not have a UTC time zone.")
+        raise TimeZoneNotUTCError(f"Datetime {dt} does not have a UTC time zone.")
 
 
 def convert_to_UTC(dt: datetime.datetime) -> datetime.datetime:

zerver/lib/users.py

@@ -21,8 +21,8 @@ from zerver.lib.cache import (
 )
 from zerver.lib.exceptions import (
     JsonableError,
-    OrganizationAdministratorRequired,
+    OrganizationAdministratorRequiredError,
-    OrganizationOwnerRequired,
+    OrganizationOwnerRequiredError,
 )
 from zerver.lib.timezone import canonicalize_timezone
 from zerver.lib.types import ProfileDataElementUpdateDict, ProfileDataElementValue
@@ -145,12 +145,12 @@ def check_bot_creation_policy(user_profile: UserProfile, bot_type: int) -> None:
     if user_profile.realm.bot_creation_policy == Realm.BOT_CREATION_EVERYONE:
         return
     if user_profile.realm.bot_creation_policy == Realm.BOT_CREATION_ADMINS_ONLY:
-        raise OrganizationAdministratorRequired()
+        raise OrganizationAdministratorRequiredError()
     if (
         user_profile.realm.bot_creation_policy == Realm.BOT_CREATION_LIMIT_GENERIC_BOTS
         and bot_type == UserProfile.DEFAULT_BOT
     ):
-        raise OrganizationAdministratorRequired()
+        raise OrganizationAdministratorRequiredError()
 
 
 def check_valid_bot_type(user_profile: UserProfile, bot_type: int) -> None:
@@ -255,7 +255,7 @@ def access_bot_by_id(user_profile: UserProfile, user_id: int) -> UserProfile:
         # default, because it can be abused to send spam. Requiring an
         # owner is intended to ensure organizational responsibility
         # for use of this permission.
-        raise OrganizationOwnerRequired()
+        raise OrganizationOwnerRequiredError()
 
     return target
 

zerver/lib/webhooks/common.py

@@ -57,7 +57,7 @@ def notify_bot_owner_about_invalid_json(
     )
 
 
-class MissingHTTPEventHeader(JsonableError):
+class MissingHTTPEventHeaderError(JsonableError):
     code = ErrorCode.MISSING_HTTP_EVENT_HEADER
     data_fields = ["header"]
 
@@ -176,7 +176,7 @@ def validate_extract_webhook_http_header(
             request.user, request.user.realm, message_body
         )
 
-        raise MissingHTTPEventHeader(header)
+        raise MissingHTTPEventHeaderError(header)
 
     return extracted_header
 

zerver/management/commands/deliver_scheduled_emails.py

@@ -15,7 +15,7 @@ from django.db import transaction
 from django.utils.timezone import now as timezone_now
 
 from zerver.lib.logging_util import log_to_file
-from zerver.lib.send_email import EmailNotDeliveredException, deliver_scheduled_emails
+from zerver.lib.send_email import EmailNotDeliveredError, deliver_scheduled_emails
 from zerver.models import ScheduledEmail
 
 ## Setup ##
@@ -46,7 +46,7 @@ Usage: ./manage.py deliver_scheduled_emails
                     if job:
                         try:
                             deliver_scheduled_emails(job)
-                        except EmailNotDeliveredException:
+                        except EmailNotDeliveredError:
                             logger.warning("%r not delivered", job)
                     else:
                         time.sleep(10)

zerver/management/commands/sync_ldap_user_data.py

@@ -9,7 +9,7 @@ from django.db import transaction
 from zerver.lib.logging_util import log_to_file
 from zerver.lib.management import ZulipBaseCommand
 from zerver.models import UserProfile
-from zproject.backends import ZulipLDAPException, sync_user_from_ldap
+from zproject.backends import ZulipLDAPError, sync_user_from_ldap
 
 ## Setup ##
 logger = logging.getLogger("zulip.sync_ldap_user_data")
@@ -29,7 +29,7 @@ def sync_ldap_user_data(
             # does not exist.
             try:
                 sync_user_from_ldap(u, logger)
-            except ZulipLDAPException as e:
+            except ZulipLDAPError as e:
                 logger.error("Error attempting to update user %s:", u.delivery_email)
                 logger.error(e.args[0])
 

zerver/models.py

@@ -81,7 +81,7 @@ from zerver.lib.cache import (
     user_profile_by_id_cache_key,
     user_profile_cache_key,
 )
-from zerver.lib.exceptions import JsonableError, RateLimited
+from zerver.lib.exceptions import JsonableError, RateLimitedError
 from zerver.lib.pysa import mark_sanitized
 from zerver.lib.timestamp import datetime_to_timestamp
 from zerver.lib.types import (
@@ -3506,7 +3506,7 @@ def validate_attachment_request_for_spectator_access(
             from zerver.lib.rate_limiter import rate_limit_spectator_attachment_access_by_file
 
             rate_limit_spectator_attachment_access_by_file(attachment.path_id)
-        except RateLimited:
+        except RateLimitedError:
             return False
 
     return True
@@ -4672,7 +4672,7 @@ class BotConfigData(models.Model):
         unique_together = ("bot_profile", "key")
 
 
-class InvalidFakeEmailDomain(Exception):
+class InvalidFakeEmailDomainError(Exception):
     pass
 
 
@@ -4688,7 +4688,7 @@ def get_fake_email_domain(realm: Realm) -> str:
         # Check that the fake email domain can be used to form valid email addresses.
         validate_email(Address(username="bot", domain=settings.FAKE_EMAIL_DOMAIN).addr_spec)
     except ValidationError:
-        raise InvalidFakeEmailDomain(
+        raise InvalidFakeEmailDomainError(
             settings.FAKE_EMAIL_DOMAIN + " is not a valid domain. "
             "Consider setting the FAKE_EMAIL_DOMAIN setting."
         )

zerver/tests/test_auth_backends.py

@@ -71,7 +71,7 @@ from zerver.lib.email_validation import (
     get_realm_email_validator,
     validate_email_is_valid,
 )
-from zerver.lib.exceptions import JsonableError, RateLimited
+from zerver.lib.exceptions import JsonableError, RateLimitedError
 from zerver.lib.initial_password import initial_password
 from zerver.lib.mobile_auth_otp import otp_decrypt_api_key
 from zerver.lib.rate_limiter import add_ratelimit_rule, remove_ratelimit_rule
@@ -127,6 +127,8 @@ from zproject.backends import (
     GitHubAuthBackend,
     GitLabAuthBackend,
     GoogleAuthBackend,
+    NoMatchingLDAPUserError,
+    OutsideLDAPDomainError,
     PopulateUserLDAPError,
     RateLimitedAuthenticationByUsername,
     SAMLAuthBackend,
@@ -136,9 +138,7 @@ from zproject.backends import (
     ZulipDummyBackend,
     ZulipLDAPAuthBackend,
     ZulipLDAPConfigurationError,
-    ZulipLDAPException,
+    ZulipLDAPError,
-    ZulipLDAPExceptionNoMatchingLDAPUser,
-    ZulipLDAPExceptionOutsideDomain,
     ZulipLDAPUser,
     ZulipLDAPUserPopulator,
     ZulipRemoteUserBackend,
@@ -672,9 +672,9 @@ class RateLimitAuthenticationTests(ZulipTestCase):
                     self.assertIsNone(attempt_authentication(username, wrong_password))
                     # 2 failed attempts is the limit, so the next ones should get blocked,
                     # even with the correct password.
-                    with self.assertRaises(RateLimited):
+                    with self.assertRaises(RateLimitedError):
                         attempt_authentication(username, correct_password)
-                    with self.assertRaises(RateLimited):
+                    with self.assertRaises(RateLimitedError):
                         attempt_authentication(username, wrong_password)
 
                 # After enough time passes, more authentication attempts can be made:
@@ -690,7 +690,7 @@ class RateLimitAuthenticationTests(ZulipTestCase):
                     self.assertIsNone(attempt_authentication(username, wrong_password))
                     self.assertIsNone(attempt_authentication(username, wrong_password))
                     # But the third attempt goes over the limit:
-                    with self.assertRaises(RateLimited):
+                    with self.assertRaises(RateLimitedError):
                         attempt_authentication(username, wrong_password)
 
                     # Resetting the password also clears the rate-limit
@@ -5529,7 +5529,7 @@ class DjangoToLDAPUsernameTests(ZulipTestCase):
             self.assertEqual(self.backend.django_to_ldap_username("hamlet"), "hamlet")
             self.assertEqual(self.backend.django_to_ldap_username("hamlet@zulip.com"), "hamlet")
             with self.assertRaisesRegex(
-                ZulipLDAPExceptionOutsideDomain,
+                OutsideLDAPDomainError,
                 "Email hamlet@example.com does not match LDAP domain zulip.com.",
             ):
                 self.backend.django_to_ldap_username("hamlet@example.com")
@@ -5556,7 +5556,7 @@ class DjangoToLDAPUsernameTests(ZulipTestCase):
             self.backend.django_to_ldap_username("hamlet@zulip.com"), self.ldap_username("hamlet")
         )
         # If there are no matches through the email search, raise exception:
-        with self.assertRaises(ZulipLDAPExceptionNoMatchingLDAPUser):
+        with self.assertRaises(NoMatchingLDAPUserError):
             self.backend.django_to_ldap_username("no_such_email@example.com")
 
         self.assertEqual(
@@ -5564,7 +5564,7 @@ class DjangoToLDAPUsernameTests(ZulipTestCase):
         )
 
         with self.assertLogs(level="WARNING") as m:
-            with self.assertRaises(ZulipLDAPExceptionNoMatchingLDAPUser):
+            with self.assertRaises(NoMatchingLDAPUserError):
                 self.backend.django_to_ldap_username("shared_email@zulip.com")
         self.assertEqual(
             m.output,
@@ -5938,19 +5938,19 @@ class TestLDAP(ZulipLDAPTestCase):
             realm.save()
 
             email = "spam@mailnator.com"
-            with self.assertRaisesRegex(ZulipLDAPException, "Email validation failed."):
+            with self.assertRaisesRegex(ZulipLDAPError, "Email validation failed."):
                 self.backend.get_or_build_user(email, _LDAPUser())
 
             realm.emails_restricted_to_domains = True
             realm.save(update_fields=["emails_restricted_to_domains"])
 
             email = "spam+spam@mailnator.com"
-            with self.assertRaisesRegex(ZulipLDAPException, "Email validation failed."):
+            with self.assertRaisesRegex(ZulipLDAPError, "Email validation failed."):
                 self.backend.get_or_build_user(email, _LDAPUser())
 
             email = "spam@acme.com"
             with self.assertRaisesRegex(
-                ZulipLDAPException, "This email domain isn't allowed in this organization."
+                ZulipLDAPError, "This email domain isn't allowed in this organization."
             ):
                 self.backend.get_or_build_user(email, _LDAPUser())
 
@@ -6167,7 +6167,7 @@ class TestZulipLDAPUserPopulator(ZulipLDAPTestCase):
     def test_too_short_name(self) -> None:
         self.change_ldap_user_attr("hamlet", "cn", "a")
 
-        with self.assertRaises(ZulipLDAPException), self.assertLogs(
+        with self.assertRaises(ZulipLDAPError), self.assertLogs(
             "django_auth_ldap", "WARNING"
         ) as warn_log:
             self.perform_ldap_sync(self.example_user("hamlet"))
@@ -6417,7 +6417,7 @@ class TestZulipLDAPUserPopulator(ZulipLDAPTestCase):
             }
         ):
             with self.assertRaisesRegex(
-                ZulipLDAPException, "Custom profile field with name non_existent not found"
+                ZulipLDAPError, "Custom profile field with name non_existent not found"
             ), self.assertLogs("django_auth_ldap", "WARNING") as warn_log:
                 self.perform_ldap_sync(self.example_user("hamlet"))
             self.assertEqual(
@@ -6437,7 +6437,7 @@ class TestZulipLDAPUserPopulator(ZulipLDAPTestCase):
             }
         ):
             with self.assertRaisesRegex(
-                ZulipLDAPException, "Invalid data for birthday field"
+                ZulipLDAPError, "Invalid data for birthday field"
             ), self.assertLogs("django_auth_ldap", "WARNING") as warn_log:
                 self.perform_ldap_sync(self.example_user("hamlet"))
             self.assertEqual(

zerver/tests/test_cache.py

@@ -6,7 +6,7 @@ from django.conf import settings
 from zerver.apps import flush_cache
 from zerver.lib.cache import (
     MEMCACHED_MAX_KEY_LENGTH,
-    InvalidCacheKeyException,
+    InvalidCacheKeyError,
     bulk_cached_fetch,
     cache_delete,
     cache_delete_many,
@@ -38,18 +38,18 @@ class AppsTest(ZulipTestCase):
 class CacheKeyValidationTest(ZulipTestCase):
     def test_validate_cache_key(self) -> None:
         validate_cache_key("nice_Ascii:string!~")
-        with self.assertRaises(InvalidCacheKeyException):
+        with self.assertRaises(InvalidCacheKeyError):
             validate_cache_key("utf8_character:ą")
-        with self.assertRaises(InvalidCacheKeyException):
+        with self.assertRaises(InvalidCacheKeyError):
             validate_cache_key("new_line_character:\n")
-        with self.assertRaises(InvalidCacheKeyException):
+        with self.assertRaises(InvalidCacheKeyError):
             validate_cache_key("control_character:\r")
-        with self.assertRaises(InvalidCacheKeyException):
+        with self.assertRaises(InvalidCacheKeyError):
             validate_cache_key("whitespace_character: ")
-        with self.assertRaises(InvalidCacheKeyException):
+        with self.assertRaises(InvalidCacheKeyError):
             validate_cache_key("too_long:" + "X" * MEMCACHED_MAX_KEY_LENGTH)
 
-        with self.assertRaises(InvalidCacheKeyException):
+        with self.assertRaises(InvalidCacheKeyError):
             # validate_cache_key does validation on a key with the
             # KEY_PREFIX appended to the start, so even though we're
             # passing something "short enough" here, it becomes too
@@ -59,18 +59,18 @@ class CacheKeyValidationTest(ZulipTestCase):
     def test_cache_functions_raise_exception(self) -> None:
         invalid_key = "invalid_character:\n"
         good_key = "good_key"
-        with self.assertRaises(InvalidCacheKeyException):
+        with self.assertRaises(InvalidCacheKeyError):
             cache_get(invalid_key)
-        with self.assertRaises(InvalidCacheKeyException):
+        with self.assertRaises(InvalidCacheKeyError):
             cache_set(invalid_key, 0)
-        with self.assertRaises(InvalidCacheKeyException):
+        with self.assertRaises(InvalidCacheKeyError):
             cache_delete(invalid_key)
 
-        with self.assertRaises(InvalidCacheKeyException):
+        with self.assertRaises(InvalidCacheKeyError):
             cache_get_many([good_key, invalid_key])
-        with self.assertRaises(InvalidCacheKeyException):
+        with self.assertRaises(InvalidCacheKeyError):
             cache_set_many({good_key: 0, invalid_key: 1})
-        with self.assertRaises(InvalidCacheKeyException):
+        with self.assertRaises(InvalidCacheKeyError):
             cache_delete_many([good_key, invalid_key])
 
 
@@ -248,11 +248,11 @@ class GenericBulkCachedFetchTest(ZulipTestCase):
         # Get the user cached:
         get_user_profile_by_id(hamlet.id)
 
-        class CustomException(Exception):
+        class CustomError(Exception):
             pass
 
         def query_function(ids: List[int]) -> List[UserProfile]:
-            raise CustomException("The query function was called")
+            raise CustomError("The query function was called")
 
         # query_function shouldn't be called, because the only requested object
         # is already cached:
@@ -268,7 +268,7 @@ class GenericBulkCachedFetchTest(ZulipTestCase):
         self.assertEqual(info_log.output, ["INFO:root:Clearing memcached cache after migrations"])
 
         # With the cache flushed, the query_function should get called:
-        with self.assertRaises(CustomException):
+        with self.assertRaises(CustomError):
             result = bulk_cached_fetch(
                 cache_key_function=user_profile_by_id_cache_key,
                 query_function=query_function,
@@ -277,18 +277,18 @@ class GenericBulkCachedFetchTest(ZulipTestCase):
             )
 
     def test_empty_object_ids_list(self) -> None:
-        class CustomException(Exception):
+        class CustomError(Exception):
             pass
 
         def cache_key_function(
             email: str,
         ) -> str:  # nocoverage -- this is just here to make sure it's not called
-            raise CustomException("The cache key function was called")
+            raise CustomError("The cache key function was called")
 
         def query_function(
             emails: List[str],
         ) -> List[UserProfile]:  # nocoverage -- this is just here to make sure it's not called
-            raise CustomException("The query function was called")
+            raise CustomError("The query function was called")
 
         # query_function and cache_key_function shouldn't be called, because
         # objects_ids is empty, so there's nothing to do.

zerver/tests/test_decorators.py

@@ -43,7 +43,7 @@ from zerver.lib.exceptions import (
     InvalidAPIKeyFormatError,
     InvalidJSONError,
     JsonableError,
-    UnsupportedWebhookEventType,
+    UnsupportedWebhookEventTypeError,
 )
 from zerver.lib.initial_password import initial_password
 from zerver.lib.rate_limiter import is_local_addr
@@ -315,7 +315,7 @@ class DecoratorTestCase(ZulipTestCase):
         def my_webhook_raises_exception_unsupported_event(
             request: HttpRequest, user_profile: UserProfile
         ) -> HttpResponse:
-            raise UnsupportedWebhookEventType("test_event")
+            raise UnsupportedWebhookEventTypeError("test_event")
 
         webhook_bot_email = "webhook-bot@zulip.com"
         webhook_bot_realm = get_realm("zulip")
@@ -410,7 +410,7 @@ class DecoratorTestCase(ZulipTestCase):
         request.POST["api_key"] = webhook_bot_api_key
         exception_msg = "The 'test_event' event isn't currently supported by the ClientName webhook"
         with self.assertLogs("zulip.zerver.webhooks.unsupported", level="ERROR") as log:
-            with self.assertRaisesRegex(UnsupportedWebhookEventType, exception_msg):
+            with self.assertRaisesRegex(UnsupportedWebhookEventTypeError, exception_msg):
                 request.body = b"invalidjson"
                 request.content_type = "application/json"
                 request.META["HTTP_X_CUSTOM_HEADER"] = "custom_value"
@@ -564,7 +564,7 @@ class DecoratorLoggingTestCase(ZulipTestCase):
         def my_webhook_raises_exception(
             request: HttpRequest, user_profile: UserProfile
         ) -> HttpResponse:
-            raise UnsupportedWebhookEventType("test_event")
+            raise UnsupportedWebhookEventTypeError("test_event")
 
         webhook_bot_email = "webhook-bot@zulip.com"
 
@@ -582,7 +582,7 @@ class DecoratorLoggingTestCase(ZulipTestCase):
             exception_msg = (
                 "The 'test_event' event isn't currently supported by the ClientName webhook"
             )
-            with self.assertRaisesRegex(UnsupportedWebhookEventType, exception_msg):
+            with self.assertRaisesRegex(UnsupportedWebhookEventTypeError, exception_msg):
                 my_webhook_raises_exception(request)
 
         mock_exception.assert_called_with(exception_msg, stack_info=True)

zerver/tests/test_email_notifications.py

@@ -110,10 +110,10 @@ class TestCustomEmails(ZulipTestCase):
         email_subject = "subject_test"
         markdown_template_path = "zerver/tests/fixtures/email/custom_emails/email_base_headers_no_headers_test.source.html"
 
-        from zerver.lib.send_email import NoEmailArgumentException
+        from zerver.lib.send_email import NoEmailArgumentError
 
         self.assertRaises(
-            NoEmailArgumentException,
+            NoEmailArgumentError,
             send_custom_email,
             [hamlet],
             options={
@@ -124,7 +124,7 @@ class TestCustomEmails(ZulipTestCase):
         )
 
         self.assertRaises(
-            NoEmailArgumentException,
+            NoEmailArgumentError,
             send_custom_email,
             [hamlet],
             options={
@@ -142,10 +142,10 @@ class TestCustomEmails(ZulipTestCase):
             "zerver/tests/fixtures/email/custom_emails/email_base_headers_test.source.html"
         )
 
-        from zerver.lib.send_email import DoubledEmailArgumentException
+        from zerver.lib.send_email import DoubledEmailArgumentError
 
         self.assertRaises(
-            DoubledEmailArgumentException,
+            DoubledEmailArgumentError,
             send_custom_email,
             [hamlet],
             options={
@@ -156,7 +156,7 @@ class TestCustomEmails(ZulipTestCase):
         )
 
         self.assertRaises(
-            DoubledEmailArgumentException,
+            DoubledEmailArgumentError,
             send_custom_email,
             [hamlet],
             options={

zerver/tests/test_embedded_bot_system.py

@@ -2,7 +2,7 @@ from unittest.mock import patch
 
 import orjson
 
-from zerver.lib.bot_lib import EmbeddedBotQuitException
+from zerver.lib.bot_lib import EmbeddedBotQuitError
 from zerver.lib.test_classes import ZulipTestCase
 from zerver.models import (
     UserProfile,
@@ -75,7 +75,7 @@ class TestEmbeddedBotMessaging(ZulipTestCase):
         assert self.bot_profile is not None
         with patch(
             "zulip_bots.bots.helloworld.helloworld.HelloWorldHandler.handle_message",
-            side_effect=EmbeddedBotQuitException("I'm quitting!"),
+            side_effect=EmbeddedBotQuitError("I'm quitting!"),
         ):
             with self.assertLogs(level="WARNING") as m:
                 self.send_stream_message(

zerver/tests/test_events.py

@@ -182,7 +182,7 @@ from zerver.lib.event_schema import (
     check_user_topic,
 )
 from zerver.lib.events import (
-    RestartEventException,
+    RestartEventError,
     apply_events,
     fetch_initial_state_data,
     post_process_state,
@@ -2499,7 +2499,7 @@ class NormalActionsTest(BaseAction):
         check_has_zoom_token("events[0]", events[0], value=False)
 
     def test_restart_event(self) -> None:
-        with self.assertRaises(RestartEventException):
+        with self.assertRaises(RestartEventError):
             self.verify_action(lambda: send_restart_events(immediate=True))
 
     def test_display_setting_event_not_sent(self) -> None:

zerver/tests/test_external.py

@@ -17,7 +17,7 @@ from zerver.lib.cache import cache_delete
 from zerver.lib.rate_limiter import (
     RateLimitedIPAddr,
     RateLimitedUser,
-    RateLimiterLockingException,
+    RateLimiterLockingError,
     add_ratelimit_rule,
     get_tor_ips,
     remove_ratelimit_rule,
@@ -447,7 +447,7 @@ class RateLimitTests(ZulipTestCase):
 
         with mock.patch(
             "zerver.lib.rate_limiter.RedisRateLimiterBackend.incr_ratelimit",
-            side_effect=RateLimiterLockingException,
+            side_effect=RateLimiterLockingError,
         ):
             with self.assertLogs("zerver.lib.rate_limiter", level="WARNING") as m:
                 result = self.send_api_message(user, "some stuff")

zerver/tests/test_github.py

@@ -2,7 +2,10 @@ import requests
 import responses
 
 from zerver.lib.cache import cache_delete
-from zerver.lib.github import InvalidPlatform, get_latest_github_release_download_link_for_platform
+from zerver.lib.github import (
+    InvalidPlatformError,
+    get_latest_github_release_download_link_for_platform,
+)
 from zerver.lib.test_classes import ZulipTestCase
 
 logger_string = "zerver.lib.github"
@@ -81,5 +84,5 @@ class GitHubTestCase(ZulipTestCase):
                 [f"ERROR:{logger_string}:App download link is broken {download_link}"],
             )
 
-        with self.assertRaises(InvalidPlatform):
+        with self.assertRaises(InvalidPlatformError):
             get_latest_github_release_download_link_for_platform("plan9")

zerver/tests/test_markdown.py

@@ -21,7 +21,7 @@ from zerver.lib.alert_words import get_alert_word_automaton
 from zerver.lib.camo import get_camo_url
 from zerver.lib.create_user import create_user
 from zerver.lib.emoji import get_emoji_url
-from zerver.lib.exceptions import JsonableError, MarkdownRenderingException
+from zerver.lib.exceptions import JsonableError, MarkdownRenderingError
 from zerver.lib.markdown import (
     MarkdownListPreprocessor,
     MessageRenderingResult,
@@ -2900,7 +2900,7 @@ class MarkdownApiTests(ZulipTestCase):
 class MarkdownErrorTests(ZulipTestCase):
     def test_markdown_error_handling(self) -> None:
         with self.simulated_markdown_failure():
-            with self.assertRaises(MarkdownRenderingException):
+            with self.assertRaises(MarkdownRenderingError):
                 markdown_convert_wrapper("")
 
     def test_send_message_errors(self) -> None:
@@ -2921,7 +2921,7 @@ class MarkdownErrorTests(ZulipTestCase):
         with mock.patch("zerver.lib.markdown.timeout", return_value=msg), mock.patch(
             "zerver.lib.markdown.markdown_logger"
         ):
-            with self.assertRaises(MarkdownRenderingException):
+            with self.assertRaises(MarkdownRenderingError):
                 markdown_convert_wrapper(msg)
 
     def test_curl_code_block_validation(self) -> None:
@@ -2936,7 +2936,7 @@ class MarkdownErrorTests(ZulipTestCase):
             "```",
         ]
 
-        with self.assertRaises(MarkdownRenderingException):
+        with self.assertRaises(MarkdownRenderingError):
             processor.run(markdown_input)
 
     def test_curl_code_block_without_validation(self) -> None:

zerver/tests/test_message_fetch.py

@@ -28,7 +28,7 @@ from zerver.lib.message import (
 )
 from zerver.lib.narrow import (
     LARGER_THAN_MAX_MESSAGE_ID,
-    BadNarrowOperator,
+    BadNarrowOperatorError,
     NarrowBuilder,
     build_narrow_filter,
     exclude_muting_conditions,
@@ -109,7 +109,7 @@ class NarrowBuilderTest(ZulipTestCase):
 
     def test_add_term_using_not_defined_operator(self) -> None:
         term = dict(operator="not-defined", operand="any")
-        self.assertRaises(BadNarrowOperator, self._build_query, term)
+        self.assertRaises(BadNarrowOperatorError, self._build_query, term)
 
     def test_add_term_using_stream_operator(self) -> None:
         term = dict(operator="stream", operand="Scotland")
@@ -123,7 +123,7 @@ class NarrowBuilderTest(ZulipTestCase):
         self,
     ) -> None:  # NEGATED
         term = dict(operator="stream", operand="NonExistingStream")
-        self.assertRaises(BadNarrowOperator, self._build_query, term)
+        self.assertRaises(BadNarrowOperatorError, self._build_query, term)
 
     def test_add_term_using_is_operator_and_private_operand(self) -> None:
         term = dict(operator="is", operand="private")
@@ -133,7 +133,7 @@ class NarrowBuilderTest(ZulipTestCase):
         self,
     ) -> None:  # NEGATED
         term = dict(operator="streams", operand="invalid_operands")
-        self.assertRaises(BadNarrowOperator, self._build_query, term)
+        self.assertRaises(BadNarrowOperatorError, self._build_query, term)
 
     def test_add_term_using_streams_operator_and_public_stream_operand(self) -> None:
         term = dict(operator="streams", operand="public")
@@ -261,7 +261,7 @@ class NarrowBuilderTest(ZulipTestCase):
 
     def test_add_term_using_non_supported_operator_should_raise_error(self) -> None:
         term = dict(operator="is", operand="non_supported")
-        self.assertRaises(BadNarrowOperator, self._build_query, term)
+        self.assertRaises(BadNarrowOperatorError, self._build_query, term)
 
     def test_add_term_using_topic_operator_and_lunch_operand(self) -> None:
         term = dict(operator="topic", operand="lunch")
@@ -291,7 +291,7 @@ class NarrowBuilderTest(ZulipTestCase):
         self,
     ) -> None:  # NEGATED
         term = dict(operator="sender", operand="non-existing@zulip.com")
-        self.assertRaises(BadNarrowOperator, self._build_query, term)
+        self.assertRaises(BadNarrowOperatorError, self._build_query, term)
 
     def test_add_term_using_pm_with_operator_and_not_the_same_user_as_operand(self) -> None:
         term = dict(operator="pm-with", operand=self.othello_email)
@@ -375,13 +375,13 @@ class NarrowBuilderTest(ZulipTestCase):
 
     def test_add_term_using_pm_with_operator_with_comma_noise(self) -> None:
         term = dict(operator="pm-with", operand=" ,,, ,,, ,")
-        self.assertRaises(BadNarrowOperator, self._build_query, term)
+        self.assertRaises(BadNarrowOperatorError, self._build_query, term)
 
     def test_add_term_using_pm_with_operator_with_existing_and_non_existing_user_as_operand(
         self,
     ) -> None:
         term = dict(operator="pm-with", operand=self.othello_email + ",non-existing@zulip.com")
-        self.assertRaises(BadNarrowOperator, self._build_query, term)
+        self.assertRaises(BadNarrowOperatorError, self._build_query, term)
 
     def test_add_term_using_id_operator(self) -> None:
         term = dict(operator="id", operand=555)
@@ -389,10 +389,10 @@ class NarrowBuilderTest(ZulipTestCase):
 
     def test_add_term_using_id_operator_invalid(self) -> None:
         term = dict(operator="id", operand="")
-        self.assertRaises(BadNarrowOperator, self._build_query, term)
+        self.assertRaises(BadNarrowOperatorError, self._build_query, term)
 
         term = dict(operator="id", operand="notanint")
-        self.assertRaises(BadNarrowOperator, self._build_query, term)
+        self.assertRaises(BadNarrowOperatorError, self._build_query, term)
 
     def test_add_term_using_id_operator_and_negated(self) -> None:  # NEGATED
         term = dict(operator="id", operand=555, negated=True)
@@ -419,7 +419,7 @@ class NarrowBuilderTest(ZulipTestCase):
 
     def test_add_term_using_group_pm_operator_with_non_existing_user_as_operand(self) -> None:
         term = dict(operator="group-pm-with", operand="non-existing@zulip.com")
-        self.assertRaises(BadNarrowOperator, self._build_query, term)
+        self.assertRaises(BadNarrowOperatorError, self._build_query, term)
 
     @override_settings(USING_PGROONGA=False)
     def test_add_term_using_search_operator(self) -> None:
@@ -475,7 +475,7 @@ class NarrowBuilderTest(ZulipTestCase):
 
     def test_add_term_using_has_operator_non_supported_operand_should_raise_error(self) -> None:
         term = dict(operator="has", operand="non_supported")
-        self.assertRaises(BadNarrowOperator, self._build_query, term)
+        self.assertRaises(BadNarrowOperatorError, self._build_query, term)
 
     def test_add_term_using_in_operator(self) -> None:
         mute_stream(self.realm, self.user_profile, "Verona")
@@ -503,7 +503,7 @@ class NarrowBuilderTest(ZulipTestCase):
 
     def test_add_term_using_in_operator_and_not_defined_operand(self) -> None:
         term = dict(operator="in", operand="not_defined")
-        self.assertRaises(BadNarrowOperator, self._build_query, term)
+        self.assertRaises(BadNarrowOperatorError, self._build_query, term)
 
     def test_add_term_using_near_operator(self) -> None:
         term = dict(operator="near", operand="operand")
@@ -518,7 +518,7 @@ class NarrowBuilderTest(ZulipTestCase):
         def _build_query(term: Dict[str, Any]) -> Select:
             return builder.add_term(self.raw_query, term)
 
-        self.assertRaises(BadNarrowOperator, _build_query, term)
+        self.assertRaises(BadNarrowOperatorError, _build_query, term)
 
     def _do_add_term_test(
         self, term: Dict[str, Any], where_clause: str, params: Optional[Dict[str, Any]] = None

zerver/tests/test_message_flags.py

@@ -22,7 +22,7 @@ from zerver.lib.message import (
 )
 from zerver.lib.test_classes import ZulipTestCase
 from zerver.lib.test_helpers import get_subscription, timeout_mock
-from zerver.lib.timeout import TimeoutExpired
+from zerver.lib.timeout import TimeoutExpiredError
 from zerver.lib.user_topics import add_topic_mute
 from zerver.models import (
     Message,
@@ -688,7 +688,7 @@ class MarkAllAsReadEndpointTest(ZulipTestCase):
 
     def test_mark_all_as_read_timeout_response(self) -> None:
         self.login("hamlet")
-        with mock.patch("zerver.views.message_flags.timeout", side_effect=TimeoutExpired):
+        with mock.patch("zerver.views.message_flags.timeout", side_effect=TimeoutExpiredError):
             result = self.client_post("/json/mark_all_as_read", {})
             self.assertEqual(result.status_code, 200)
 

zerver/tests/test_message_send.py

@@ -63,7 +63,7 @@ from zerver.models import (
     get_system_bot,
     get_user,
 )
-from zerver.views.message_send import InvalidMirrorInput
+from zerver.views.message_send import InvalidMirrorInputError
 
 if sys.version_info < (3, 9):  # nocoverage
     from backports import zoneinfo
@@ -1098,7 +1098,7 @@ class MessagePOSTTest(ZulipTestCase):
     def test_send_message_create_mirrored_message_user_returns_invalid_input(
         self, create_mirrored_message_users_mock: Any
     ) -> None:
-        create_mirrored_message_users_mock.side_effect = InvalidMirrorInput()
+        create_mirrored_message_users_mock.side_effect = InvalidMirrorInputError()
         result = self.api_post(
             self.mit_user("starnine"),
             "/api/v1/messages",

zerver/tests/test_message_topics.py

@@ -6,7 +6,7 @@ from django.utils.timezone import now as timezone_now
 from zerver.actions.streams import do_change_stream_permission
 from zerver.lib.test_classes import ZulipTestCase
 from zerver.lib.test_helpers import timeout_mock
-from zerver.lib.timeout import TimeoutExpired
+from zerver.lib.timeout import TimeoutExpiredError
 from zerver.models import Message, UserMessage, get_client, get_realm, get_stream
 
 
@@ -322,7 +322,7 @@ class TopicDeleteTest(ZulipTestCase):
 
         self.login_user(user_profile)
         endpoint = "/json/streams/" + str(stream.id) + "/delete_topic"
-        with mock.patch("zerver.views.streams.timeout", side_effect=TimeoutExpired):
+        with mock.patch("zerver.views.streams.timeout", side_effect=TimeoutExpiredError):
             result = self.client_post(
                 endpoint,
                 {

zerver/tests/test_mirror_users.py

@@ -9,7 +9,7 @@ from zerver.lib.create_user import create_user_profile
 from zerver.lib.test_classes import ZulipTestCase
 from zerver.lib.test_helpers import reset_emails_in_zulip_realm
 from zerver.models import UserProfile, get_client, get_realm, get_user
-from zerver.views.message_send import InvalidMirrorInput, create_mirrored_message_users
+from zerver.views.message_send import InvalidMirrorInputError, create_mirrored_message_users
 
 
 class MirroredMessageUsersTest(ZulipTestCase):
@@ -22,7 +22,7 @@ class MirroredMessageUsersTest(ZulipTestCase):
         message_type = "private"
         client = get_client("banned_mirror")
 
-        with self.assertRaises(InvalidMirrorInput):
+        with self.assertRaises(InvalidMirrorInputError):
             create_mirrored_message_users(client, user, recipients, sender.email, message_type)
 
     def test_invalid_email(self) -> None:
@@ -38,7 +38,7 @@ class MirroredMessageUsersTest(ZulipTestCase):
         for client_name in ["zephyr_mirror", "irc_mirror", "jabber_mirror"]:
             client = get_client(client_name)
 
-            with self.assertRaises(InvalidMirrorInput):
+            with self.assertRaises(InvalidMirrorInputError):
                 create_mirrored_message_users(client, user, recipients, sender.email, message_type)
 
     @mock.patch(

zerver/tests/test_push_notifications.py

@@ -49,7 +49,7 @@ from zerver.lib.push_notifications import (
     send_notifications_to_bouncer,
 )
 from zerver.lib.remote_server import (
-    PushNotificationBouncerException,
+    PushNotificationBouncerError,
     PushNotificationBouncerRetryLaterError,
     build_analytics_data,
     send_analytics_to_remote_server,
@@ -2220,7 +2220,7 @@ class TestSendToPushBouncer(ZulipTestCase):
         # This is the exception our decorator uses for an invalid Zulip server
         error_response = json_response_from_error(InvalidZulipServerError("testRole"))
         self.add_mock_response(body=error_response.content, status=error_response.status_code)
-        with self.assertRaises(PushNotificationBouncerException) as exc:
+        with self.assertRaises(PushNotificationBouncerError) as exc:
             send_to_push_bouncer("POST", "register", {"msg": "true"})
         self.assertEqual(
             str(exc.exception),
@@ -2237,7 +2237,7 @@ class TestSendToPushBouncer(ZulipTestCase):
     @responses.activate
     def test_300_error(self) -> None:
         self.add_mock_response(body=b"/", status=300)
-        with self.assertRaises(PushNotificationBouncerException) as exc:
+        with self.assertRaises(PushNotificationBouncerError) as exc:
             send_to_push_bouncer("POST", "register", {"msg": "true"})
         self.assertEqual(
             str(exc.exception), "Push notification bouncer returned unexpected status code 300"

zerver/tests/test_queue_worker.py

@@ -17,9 +17,9 @@ from django.test import override_settings
 from zerver.lib.email_mirror import RateLimitedRealmMirror
 from zerver.lib.email_mirror_helpers import encode_email_address
 from zerver.lib.queue import MAX_REQUEST_RETRIES
-from zerver.lib.rate_limiter import RateLimiterLockingException
+from zerver.lib.rate_limiter import RateLimiterLockingError
 from zerver.lib.remote_server import PushNotificationBouncerRetryLaterError
-from zerver.lib.send_email import EmailNotDeliveredException, FromAddress
+from zerver.lib.send_email import EmailNotDeliveredError, FromAddress
 from zerver.lib.test_classes import ZulipTestCase
 from zerver.lib.test_helpers import mock_queue_publish
 from zerver.models import (
@@ -507,10 +507,10 @@ class WorkerTest(ZulipTestCase):
                 worker.start()
                 self.assertEqual(mock_mirror_email.call_count, 4)
 
-                # If RateLimiterLockingException is thrown, we rate-limit the new message:
+                # If RateLimiterLockingError is thrown, we rate-limit the new message:
                 with patch(
                     "zerver.lib.rate_limiter.RedisRateLimiterBackend.incr_ratelimit",
-                    side_effect=RateLimiterLockingException,
+                    side_effect=RateLimiterLockingError,
                 ):
                     with self.assertLogs("zerver.lib.rate_limiter", "WARNING") as mock_warn:
                         fake_client.enqueue("email_mirror", data[0])
@@ -553,14 +553,14 @@ class WorkerTest(ZulipTestCase):
             worker = queue_processors.EmailSendingWorker()
             worker.setup()
             with patch(
-                "zerver.lib.send_email.build_email", side_effect=EmailNotDeliveredException
+                "zerver.lib.send_email.build_email", side_effect=EmailNotDeliveredError
             ), mock_queue_publish(
                 "zerver.lib.queue.queue_json_publish", side_effect=fake_publish
             ), self.assertLogs(
                 level="ERROR"
             ) as m:
                 worker.start()
-                self.assertIn("failed due to exception EmailNotDeliveredException", m.output[0])
+                self.assertIn("failed due to exception EmailNotDeliveredError", m.output[0])
 
         self.assertEqual(data["failed_tries"], 1 + MAX_REQUEST_RETRIES)
 
@@ -764,7 +764,7 @@ class WorkerTest(ZulipTestCase):
             def consume(self, data: Mapping[str, Any]) -> None:
                 pass  # nocoverage # this is intentionally not called
 
-        with self.assertRaises(queue_processors.WorkerDeclarationException):
+        with self.assertRaises(queue_processors.WorkerDeclarationError):
             TestWorker()
 
     def test_get_active_worker_queues(self) -> None:

zerver/tests/test_send_email.py

@@ -6,7 +6,7 @@ from django.core.mail.backends.smtp import EmailBackend as SMTPBackend
 from django.core.mail.message import sanitize_address
 
 from zerver.lib.send_email import (
-    EmailNotDeliveredException,
+    EmailNotDeliveredError,
     FromAddress,
     build_email,
     initialize_connection,
@@ -118,7 +118,7 @@ class TestSendEmail(ZulipTestCase):
         )
         self.assertEqual(mail.extra_headers["From"], f"{from_name} <{FromAddress.NOREPLY}>")
 
-        # We test the cases that should raise an EmailNotDeliveredException
+        # We test the cases that should raise an EmailNotDeliveredError
         errors = {
             f"Unknown error sending password_reset email to {mail.to}": [0],
             f"Error sending password_reset email to {mail.to}": [SMTPException()],
@@ -133,7 +133,7 @@ class TestSendEmail(ZulipTestCase):
         for message, side_effect in errors.items():
             with mock.patch.object(EmailBackend, "send_messages", side_effect=side_effect):
                 with self.assertLogs(logger=logger) as info_log:
-                    with self.assertRaises(EmailNotDeliveredException):
+                    with self.assertRaises(EmailNotDeliveredError):
                         send_email(
                             "zerver/emails/password_reset",
                             to_emails=[hamlet.email],

zerver/tests/test_service_bot_system.py

@@ -10,7 +10,7 @@ from typing_extensions import Concatenate, ParamSpec
 from zerver.actions.create_user import do_create_user
 from zerver.actions.message_send import get_service_bot_events
 from zerver.lib.bot_config import ConfigError, load_bot_config_template, set_bot_config
-from zerver.lib.bot_lib import EmbeddedBotEmptyRecipientsList, EmbeddedBotHandler, StateHandler
+from zerver.lib.bot_lib import EmbeddedBotEmptyRecipientsListError, EmbeddedBotHandler, StateHandler
 from zerver.lib.bot_storage import StateError
 from zerver.lib.test_classes import ZulipTestCase
 from zerver.lib.test_helpers import mock_queue_publish
@@ -409,7 +409,7 @@ class TestServiceBotConfigHandler(ZulipTestCase):
 
     def test_bot_send_pm_with_empty_recipients_list(self) -> None:
         with self.assertRaisesRegex(
-            EmbeddedBotEmptyRecipientsList, "Message must have recipients!"
+            EmbeddedBotEmptyRecipientsListError, "Message must have recipients!"
         ):
             self.bot_handler.send_message(message={"type": "private", "to": []})
 

zerver/tests/test_signup.py

@@ -23,7 +23,7 @@ from django.utils.translation import gettext as _
 from confirmation import settings as confirmation_settings
 from confirmation.models import (
     Confirmation,
-    ConfirmationKeyException,
+    ConfirmationKeyError,
     create_confirmation_link,
     get_object_from_key,
     one_click_unsubscribe_link,
@@ -67,7 +67,7 @@ from zerver.lib.mobile_auth_otp import (
 from zerver.lib.name_restrictions import is_disposable_domain
 from zerver.lib.rate_limiter import add_ratelimit_rule, remove_ratelimit_rule
 from zerver.lib.send_email import (
-    EmailNotDeliveredException,
+    EmailNotDeliveredError,
     FromAddress,
     deliver_scheduled_emails,
     send_future_email,
@@ -2160,9 +2160,9 @@ so we didn't send them an invitation. We did send invitations to everyone else!"
         registration_key = url.split("/")[-1]
 
         # Mainly a test of get_object_from_key, rather than of the invitation pathway
-        with self.assertRaises(ConfirmationKeyException) as cm:
+        with self.assertRaises(ConfirmationKeyError) as cm:
             get_object_from_key(registration_key, [Confirmation.INVITATION], mark_object_used=True)
-        self.assertEqual(cm.exception.error_type, ConfirmationKeyException.DOES_NOT_EXIST)
+        self.assertEqual(cm.exception.error_type, ConfirmationKeyError.DOES_NOT_EXIST)
 
         # Verify that using the wrong type doesn't work in the main confirm code path
         email_change_url = create_confirmation_link(prereg_user, Confirmation.EMAIL_CHANGE)
@@ -4093,13 +4093,13 @@ class UserSignUpTest(InviteUserBase):
 
     def test_bad_email_configuration_for_accounts_home(self) -> None:
         """
-        Make sure we redirect for EmailNotDeliveredException.
+        Make sure we redirect for EmailNotDeliveredError.
         """
         email = self.nonreg_email("newguy")
 
         smtp_mock = patch(
             "zerver.views.registration.send_confirm_registration_email",
-            side_effect=EmailNotDeliveredException,
+            side_effect=EmailNotDeliveredError,
         )
 
         with smtp_mock, self.assertLogs(level="ERROR") as m:
@@ -4110,13 +4110,13 @@ class UserSignUpTest(InviteUserBase):
 
     def test_bad_email_configuration_for_create_realm(self) -> None:
         """
-        Make sure we redirect for EmailNotDeliveredException.
+        Make sure we redirect for EmailNotDeliveredError.
         """
         email = self.nonreg_email("newguy")
 
         smtp_mock = patch(
             "zerver.views.registration.send_confirm_registration_email",
-            side_effect=EmailNotDeliveredException,
+            side_effect=EmailNotDeliveredError,
         )
 
         with smtp_mock, self.assertLogs(level="ERROR") as m:

zerver/tests/test_templates.py

@@ -1,6 +1,6 @@
 from django.template.loader import get_template
 
-from zerver.lib.exceptions import InvalidMarkdownIncludeStatement
+from zerver.lib.exceptions import InvalidMarkdownIncludeStatementError
 from zerver.lib.test_classes import ZulipTestCase
 
 
@@ -123,7 +123,7 @@ footer
         }
 
         with self.assertRaisesRegex(
-            InvalidMarkdownIncludeStatement, "Invalid Markdown include statement"
+            InvalidMarkdownIncludeStatementError, "Invalid Markdown include statement"
         ):
             template.render(context)
 

zerver/tests/test_timeout.py

@@ -2,7 +2,7 @@ import time
 import traceback
 
 from zerver.lib.test_classes import ZulipTestCase
-from zerver.lib.timeout import TimeoutExpired, timeout
+from zerver.lib.timeout import TimeoutExpiredError, timeout
 
 
 class TimeoutTestCase(ZulipTestCase):
@@ -25,7 +25,7 @@ class TimeoutTestCase(ZulipTestCase):
         try:
             timeout(1, lambda: self.sleep_x_seconds_y_times(0.1, 50))
             raise AssertionError("Failed to raise a timeout")
-        except TimeoutExpired as exc:
+        except TimeoutExpiredError as exc:
             tb = traceback.format_tb(exc.__traceback__)
             self.assertIn("in sleep_x_seconds_y_times", tb[-1])
             self.assertIn("time.sleep(x)", tb[-1])
@@ -46,8 +46,8 @@ class TimeoutTestCase(ZulipTestCase):
             try:
                 timeout(1, lambda: self.sleep_x_seconds_y_times(5, 1))
                 raise AssertionError("Failed to raise a timeout")
-            except TimeoutExpired as exc:
+            except TimeoutExpiredError as exc:
                 tb = traceback.format_tb(exc.__traceback__)
                 self.assertNotIn("in sleep_x_seconds_y_times", tb[-1])
-                self.assertIn("raise TimeoutExpired", tb[-1])
+                self.assertIn("raise TimeoutExpiredError", tb[-1])
         self.assertEqual(m.output, ["WARNING:root:Failed to time out backend thread"])

zerver/tests/test_timestamp.py

@@ -4,7 +4,7 @@ from dateutil import parser
 
 from zerver.lib.test_classes import ZulipTestCase
 from zerver.lib.timestamp import (
-    TimeZoneNotUTCException,
+    TimeZoneNotUTCError,
     ceiling_to_hour,
     convert_to_UTC,
     datetime_to_timestamp,
@@ -28,7 +28,7 @@ class TestTimestamp(ZulipTestCase):
             parser.parse("2017-01-01 00:00:00.123+01:00"),
             parser.parse("2017-01-01 00:00:00.123"),
         ]:
-            with self.assertRaises(TimeZoneNotUTCException):
+            with self.assertRaises(TimeZoneNotUTCError):
                 datetime_to_timestamp(dt)
 
     def test_convert_to_UTC(self) -> None:
@@ -43,5 +43,5 @@ class TestTimestamp(ZulipTestCase):
     def test_enforce_UTC(self) -> None:
         non_utc_datetime = parser.parse("2017-01-01 00:00:00.123")
         for function in [floor_to_hour, floor_to_day, ceiling_to_hour, ceiling_to_hour]:
-            with self.assertRaises(TimeZoneNotUTCException):
+            with self.assertRaises(TimeZoneNotUTCError):
                 function(non_utc_datetime)

zerver/tests/test_users.py

@@ -51,7 +51,7 @@ from zerver.lib.users import Accounts, access_user_by_id, get_accounts_for_email
 from zerver.lib.utils import assert_is_not_none
 from zerver.models import (
     CustomProfileField,
-    InvalidFakeEmailDomain,
+    InvalidFakeEmailDomainError,
     Message,
     PreregistrationUser,
     Realm,
@@ -2304,12 +2304,12 @@ class FakeEmailDomainTest(ZulipTestCase):
     @override_settings(FAKE_EMAIL_DOMAIN="invaliddomain", REALM_HOSTS={"zulip": "127.0.0.1"})
     def test_invalid_fake_email_domain(self) -> None:
         realm = get_realm("zulip")
-        with self.assertRaises(InvalidFakeEmailDomain):
+        with self.assertRaises(InvalidFakeEmailDomainError):
             get_fake_email_domain(realm)
 
     @override_settings(FAKE_EMAIL_DOMAIN="127.0.0.1", REALM_HOSTS={"zulip": "127.0.0.1"})
     def test_invalid_fake_email_domain_ip(self) -> None:
-        with self.assertRaises(InvalidFakeEmailDomain):
+        with self.assertRaises(InvalidFakeEmailDomainError):
             realm = get_realm("zulip")
             get_fake_email_domain(realm)
 

zerver/tests/test_webhooks_common.py

@@ -15,7 +15,7 @@ from zerver.lib.users import get_api_key
 from zerver.lib.webhooks.common import (
     INVALID_JSON_MESSAGE,
     MISSING_EVENT_HEADER_MESSAGE,
-    MissingHTTPEventHeader,
+    MissingHTTPEventHeaderError,
     get_fixture_http_headers,
     standardize_headers,
     validate_extract_webhook_http_header,
@@ -46,7 +46,7 @@ class WebhooksCommonTestCase(ZulipTestCase):
         request.path = "some/random/path"
 
         exception_msg = "Missing the HTTP event header 'X-Custom-Header'"
-        with self.assertRaisesRegex(MissingHTTPEventHeader, exception_msg):
+        with self.assertRaisesRegex(MissingHTTPEventHeaderError, exception_msg):
             validate_extract_webhook_http_header(request, "X-Custom-Header", "test_webhook")
 
         msg = self.get_last_message()

zerver/views/auth.py

@@ -33,7 +33,7 @@ from typing_extensions import Concatenate, ParamSpec
 
 from confirmation.models import (
     Confirmation,
-    ConfirmationKeyException,
+    ConfirmationKeyError,
     create_confirmation_link,
     get_object_from_key,
     render_confirmation_key_error,
@@ -54,7 +54,7 @@ from zerver.lib.exceptions import (
     JsonableError,
     PasswordAuthDisabledError,
     PasswordResetRequiredError,
-    RateLimited,
+    RateLimitedError,
     RealmDeactivatedError,
     UserDeactivatedError,
 )
@@ -200,7 +200,7 @@ def maybe_send_to_registration(
             confirmation_obj = get_object_from_key(
                 multiuse_object_key, [Confirmation.MULTIUSE_INVITE], mark_object_used=False
             )
-        except ConfirmationKeyException as exception:
+        except ConfirmationKeyError as exception:
             return render_confirmation_key_error(request, exception)
 
         assert isinstance(confirmation_obj, MultiuseInvite)
@@ -1037,7 +1037,7 @@ def password_reset(request: HttpRequest) -> HttpResponse:
             form_class=ZulipPasswordResetForm,
             success_url="/accounts/password/reset/done/",
         )(request)
-    except RateLimited as e:
+    except RateLimitedError as e:
         assert e.secs_to_freedom is not None
         return render(
             request,

zerver/views/invite.py

@@ -15,7 +15,7 @@ from zerver.actions.invites import (
     do_revoke_user_invite,
 )
 from zerver.decorator import require_member_or_admin, require_realm_admin
-from zerver.lib.exceptions import JsonableError, OrganizationOwnerRequired
+from zerver.lib.exceptions import JsonableError, OrganizationOwnerRequiredError
 from zerver.lib.request import REQ, has_request_variables
 from zerver.lib.response import json_success
 from zerver.lib.streams import access_stream_by_id
@@ -34,7 +34,7 @@ def check_if_owner_required(invited_as: int, user_profile: UserProfile) -> None:
         invited_as == PreregistrationUser.INVITE_AS["REALM_OWNER"]
         and not user_profile.is_realm_owner
     ):
-        raise OrganizationOwnerRequired()
+        raise OrganizationOwnerRequiredError()
 
 
 @require_member_or_admin

zerver/views/message_flags.py

@@ -18,7 +18,7 @@ from zerver.lib.narrow import (
 from zerver.lib.request import REQ, RequestNotes, has_request_variables
 from zerver.lib.response import json_partial_success, json_success
 from zerver.lib.streams import access_stream_by_id
-from zerver.lib.timeout import TimeoutExpired, timeout
+from zerver.lib.timeout import TimeoutExpiredError, timeout
 from zerver.lib.topic import user_message_exists_for_topic
 from zerver.lib.validator import check_bool, check_int, check_list, to_non_negative_int
 from zerver.models import UserActivity, UserProfile
@@ -121,7 +121,7 @@ def mark_all_as_read(request: HttpRequest, user_profile: UserProfile) -> HttpRes
     request_notes = RequestNotes.get_notes(request)
     try:
         count = timeout(50, lambda: do_mark_all_as_read(user_profile))
-    except TimeoutExpired:
+    except TimeoutExpiredError:
         return json_partial_success(request, data={"code": ErrorCode.REQUEST_TIMEOUT.name})
 
     log_data_str = f"[{count} updated]"

zerver/views/message_send.py

@@ -42,7 +42,7 @@ else:  # nocoverage
     import zoneinfo
 
 
-class InvalidMirrorInput(Exception):
+class InvalidMirrorInputError(Exception):
     pass
 
 
@@ -70,12 +70,12 @@ def create_mirrored_message_users(
         user_check = same_realm_jabber_user
         fullname_function = compute_jabber_user_fullname
     else:
-        raise InvalidMirrorInput("Unrecognized mirroring client")
+        raise InvalidMirrorInputError("Unrecognized mirroring client")
 
     for email in referenced_users:
         # Check that all referenced users are in our realm:
         if not user_check(user_profile, email):
-            raise InvalidMirrorInput("At least one user cannot be mirrored")
+            raise InvalidMirrorInputError("At least one user cannot be mirrored")
 
     # Create users for the referenced users, if needed.
     for email in referenced_users:
@@ -278,7 +278,7 @@ def send_message_backend(
             mirror_sender = create_mirrored_message_users(
                 client, user_profile, message_to, req_sender, message_type_name
             )
-        except InvalidMirrorInput:
+        except InvalidMirrorInputError:
             raise JsonableError(_("Invalid mirrored message"))
 
         if client.name == "zephyr_mirror" and not user_profile.realm.is_zephyr_mirror_realm:

zerver/views/realm.py

@@ -6,7 +6,7 @@ from django.shortcuts import render
 from django.utils.translation import gettext as _
 from django.views.decorators.http import require_safe
 
-from confirmation.models import Confirmation, ConfirmationKeyException, get_object_from_key
+from confirmation.models import Confirmation, ConfirmationKeyError, get_object_from_key
 from zerver.actions.create_realm import do_change_realm_subdomain
 from zerver.actions.realm_settings import (
     do_change_realm_org_type,
@@ -20,7 +20,7 @@ from zerver.actions.realm_settings import (
 )
 from zerver.decorator import require_realm_admin, require_realm_owner
 from zerver.forms import check_subdomain_available as check_subdomain
-from zerver.lib.exceptions import JsonableError, OrganizationOwnerRequired
+from zerver.lib.exceptions import JsonableError, OrganizationOwnerRequiredError
 from zerver.lib.i18n import get_available_language_codes
 from zerver.lib.message import parse_message_content_edit_or_delete_limit
 from zerver.lib.request import REQ, has_request_variables
@@ -155,7 +155,7 @@ def update_realm(
         raise JsonableError(_("Invalid language '{}'").format(default_language))
     if authentication_methods is not None:
         if not user_profile.is_realm_owner:
-            raise OrganizationOwnerRequired()
+            raise OrganizationOwnerRequiredError()
         if True not in list(authentication_methods.values()):
             raise JsonableError(_("At least one authentication method must be enabled."))
     if video_chat_provider is not None and video_chat_provider not in {
@@ -170,7 +170,7 @@ def update_realm(
     message_retention_days: Optional[int] = None
     if message_retention_days_raw is not None:
         if not user_profile.is_realm_owner:
-            raise OrganizationOwnerRequired()
+            raise OrganizationOwnerRequiredError()
         realm.ensure_not_on_limited_plan()
         message_retention_days = parse_message_retention_days(
             message_retention_days_raw, Realm.MESSAGE_RETENTION_SPECIAL_VALUES_MAP
@@ -180,15 +180,15 @@ def update_realm(
     if (
         invite_to_realm_policy is not None or invite_required is not None
     ) and not user_profile.is_realm_owner:
-        raise OrganizationOwnerRequired()
+        raise OrganizationOwnerRequiredError()
 
     if (
         emails_restricted_to_domains is not None or disallow_disposable_email_addresses is not None
     ) and not user_profile.is_realm_owner:
-        raise OrganizationOwnerRequired()
+        raise OrganizationOwnerRequiredError()
 
     if waiting_period_threshold is not None and not user_profile.is_realm_owner:
-        raise OrganizationOwnerRequired()
+        raise OrganizationOwnerRequiredError()
 
     if enable_spectator_access:
         realm.ensure_not_on_limited_plan()
@@ -307,7 +307,7 @@ def update_realm(
 
     if string_id is not None:
         if not user_profile.is_realm_owner:
-            raise OrganizationOwnerRequired()
+            raise OrganizationOwnerRequiredError()
 
         if realm.demo_organization_scheduled_deletion_date is None:
             raise JsonableError(_("Must be a demo organization."))
@@ -349,7 +349,7 @@ def realm_reactivation(request: HttpRequest, confirmation_key: str) -> HttpRespo
         obj = get_object_from_key(
             confirmation_key, [Confirmation.REALM_REACTIVATION], mark_object_used=True
         )
-    except ConfirmationKeyException:
+    except ConfirmationKeyError:
         return render(request, "zerver/realm_reactivation_link_error.html", status=404)
 
     assert isinstance(obj, RealmReactivationStatus)

zerver/views/registration.py

@@ -17,7 +17,7 @@ from django_auth_ldap.backend import LDAPBackend, _LDAPUser
 
 from confirmation.models import (
     Confirmation,
-    ConfirmationKeyException,
+    ConfirmationKeyError,
     RealmCreationKey,
     create_confirmation_link,
     get_object_from_key,
@@ -42,12 +42,12 @@ from zerver.forms import (
     RegistrationForm,
 )
 from zerver.lib.email_validation import email_allowed_for_realm, validate_email_not_already_in_realm
-from zerver.lib.exceptions import RateLimited
+from zerver.lib.exceptions import RateLimitedError
 from zerver.lib.i18n import get_default_language_for_new_user
 from zerver.lib.pysa import mark_sanitized
 from zerver.lib.rate_limiter import rate_limit_request_by_ip
 from zerver.lib.request import REQ, has_request_variables
-from zerver.lib.send_email import EmailNotDeliveredException, FromAddress, send_email
+from zerver.lib.send_email import EmailNotDeliveredError, FromAddress, send_email
 from zerver.lib.sessions import get_expirable_session_var
 from zerver.lib.subdomains import get_subdomain, is_root_domain_available
 from zerver.lib.url_encoding import append_url_query_string
@@ -79,8 +79,8 @@ from zerver.views.auth import (
 )
 from zproject.backends import (
     ExternalAuthResult,
+    NoMatchingLDAPUserError,
     ZulipLDAPAuthBackend,
-    ZulipLDAPExceptionNoMatchingLDAPUser,
     email_auth_enabled,
     email_belongs_to_ldap,
     get_external_method_dicts,
@@ -114,7 +114,7 @@ def get_prereg_key_and_redirect(
     """
     try:
         check_prereg_key(request, confirmation_key)
-    except ConfirmationKeyException as e:
+    except ConfirmationKeyError as e:
         return render_confirmation_key_error(request, e)
 
     return render(
@@ -127,7 +127,7 @@ def get_prereg_key_and_redirect(
 def check_prereg_key(request: HttpRequest, confirmation_key: str) -> PreregistrationUser:
     """
     Checks if the Confirmation key is valid, returning the PreregistrationUser object in case of success
-    and raising an appropriate ConfirmationKeyException otherwise.
+    and raising an appropriate ConfirmationKeyError otherwise.
     """
     confirmation_types = [
         Confirmation.USER_REGISTRATION,
@@ -159,7 +159,7 @@ def accounts_register(
 ) -> HttpResponse:
     try:
         prereg_user = check_prereg_key(request, key)
-    except ConfirmationKeyException as e:
+    except ConfirmationKeyError as e:
         return render_confirmation_key_error(request, e)
 
     email = prereg_user.email
@@ -182,7 +182,7 @@ def accounts_register(
         assert prereg_user.realm is not None
         if get_subdomain(request) != prereg_user.realm.string_id:
             return render_confirmation_key_error(
-                request, ConfirmationKeyException(ConfirmationKeyException.DOES_NOT_EXIST)
+                request, ConfirmationKeyError(ConfirmationKeyError.DOES_NOT_EXIST)
             )
         realm = prereg_user.realm
         try:
@@ -239,7 +239,7 @@ def accounts_register(
                 if isinstance(backend, LDAPBackend):
                     try:
                         ldap_username = backend.django_to_ldap_username(email)
-                    except ZulipLDAPExceptionNoMatchingLDAPUser:
+                    except NoMatchingLDAPUserError:
                         logging.warning("New account email %s could not be found in LDAP", email)
                         break
 
@@ -607,7 +607,7 @@ def redirect_to_email_login_url(email: str) -> HttpResponseRedirect:
 def create_realm(request: HttpRequest, creation_key: Optional[str] = None) -> HttpResponse:
     try:
         key_record = validate_key(creation_key)
-    except RealmCreationKey.Invalid:
+    except RealmCreationKey.InvalidError:
         return render(
             request,
             "zerver/realm_creation_link_invalid.html",
@@ -626,7 +626,7 @@ def create_realm(request: HttpRequest, creation_key: Optional[str] = None) -> Ht
         if form.is_valid():
             try:
                 rate_limit_request_by_ip(request, domain="sends_email_by_ip")
-            except RateLimited as e:
+            except RateLimitedError as e:
                 assert e.secs_to_freedom is not None
                 return render(
                     request,
@@ -649,7 +649,7 @@ def create_realm(request: HttpRequest, creation_key: Optional[str] = None) -> Ht
 
             try:
                 send_confirm_registration_email(email, activation_url, request=request)
-            except EmailNotDeliveredException:
+            except EmailNotDeliveredError:
                 logging.error("Error in create_realm")
                 return HttpResponseRedirect("/config-error/smtp")
 
@@ -701,7 +701,7 @@ def accounts_home(
         if form.is_valid():
             try:
                 rate_limit_request_by_ip(request, domain="sends_email_by_ip")
-            except RateLimited as e:
+            except RateLimitedError as e:
                 assert e.secs_to_freedom is not None
                 return render(
                     request,
@@ -727,7 +727,7 @@ def accounts_home(
             )
             try:
                 send_confirm_registration_email(email, activation_url, request=request, realm=realm)
-            except EmailNotDeliveredException:
+            except EmailNotDeliveredError:
                 logging.error("Error in accounts_home")
                 return HttpResponseRedirect("/config-error/smtp")
 
@@ -757,7 +757,7 @@ def accounts_home_from_multiuse_invite(request: HttpRequest, confirmation_key: s
         if realm != multiuse_object.realm:
             return render(request, "confirmation/link_does_not_exist.html", status=404)
         # Required for OAuth 2
-    except ConfirmationKeyException as exception:
+    except ConfirmationKeyError as exception:
         if realm is None or realm.invite_required:
             return render_confirmation_key_error(request, exception)
     return accounts_home(
@@ -779,7 +779,7 @@ def find_account(
             for i in range(len(emails)):
                 try:
                     rate_limit_request_by_ip(request, domain="sends_email_by_ip")
-                except RateLimited as e:
+                except RateLimitedError as e:
                     assert e.secs_to_freedom is not None
                     return render(
                         request,

zerver/views/streams.py

@@ -49,7 +49,7 @@ from zerver.decorator import (
 from zerver.lib.exceptions import (
     ErrorCode,
     JsonableError,
-    OrganizationOwnerRequired,
+    OrganizationOwnerRequiredError,
     ResourceNotFoundError,
 )
 from zerver.lib.mention import MentionBackend, silent_mention_syntax_for_user
@@ -72,7 +72,7 @@ from zerver.lib.streams import (
 )
 from zerver.lib.string_validation import check_stream_name
 from zerver.lib.subscription_info import gather_subscriptions
-from zerver.lib.timeout import TimeoutExpired, timeout
+from zerver.lib.timeout import TimeoutExpiredError, timeout
 from zerver.lib.topic import (
     get_topic_history_for_public_stream,
     get_topic_history_for_stream,
@@ -346,7 +346,7 @@ def update_stream_backend(
 
     if message_retention_days is not None:
         if not user_profile.is_realm_owner:
-            raise OrganizationOwnerRequired()
+            raise OrganizationOwnerRequiredError()
         user_profile.realm.ensure_not_on_limited_plan()
         new_message_retention_days_value = parse_message_retention_days(
             message_retention_days, Stream.MESSAGE_RETENTION_SPECIAL_VALUES_MAP
@@ -889,7 +889,7 @@ def delete_in_topic(
 
     try:
         timeout(50, delete_in_batches)
-    except TimeoutExpired:
+    except TimeoutExpiredError:
         return json_partial_success(request, data={"code": ErrorCode.REQUEST_TIMEOUT.name})
 
     return json_success(request)

zerver/views/unsubscribe.py

@@ -4,7 +4,7 @@ from django.http import HttpRequest, HttpResponse
 from django.shortcuts import render
 from django.views.decorators.csrf import csrf_exempt
 
-from confirmation.models import Confirmation, ConfirmationKeyException, get_object_from_key
+from confirmation.models import Confirmation, ConfirmationKeyError, get_object_from_key
 from zerver.actions.user_settings import do_change_user_setting
 from zerver.context_processors import common_context
 from zerver.lib.send_email import clear_scheduled_emails
@@ -21,7 +21,7 @@ def process_unsubscribe(
         user_profile = get_object_from_key(
             confirmation_key, [Confirmation.UNSUBSCRIBE], mark_object_used=False
         )
-    except ConfirmationKeyException:
+    except ConfirmationKeyError:
         return render(request, "zerver/unsubscribe_link_error.html")
 
     assert isinstance(user_profile, UserProfile)

zerver/views/user_settings.py

@@ -13,7 +13,7 @@ from django.utils.translation import gettext_lazy
 
 from confirmation.models import (
     Confirmation,
-    ConfirmationKeyException,
+    ConfirmationKeyError,
     get_object_from_key,
     render_confirmation_key_error,
 )
@@ -33,7 +33,7 @@ from zerver.lib.email_validation import (
     validate_email_is_valid,
     validate_email_not_already_in_realm,
 )
-from zerver.lib.exceptions import JsonableError, RateLimited, UserDeactivatedError
+from zerver.lib.exceptions import JsonableError, RateLimitedError, UserDeactivatedError
 from zerver.lib.i18n import get_available_language_codes
 from zerver.lib.rate_limiter import RateLimitedUser
 from zerver.lib.request import REQ, has_request_variables
@@ -65,7 +65,7 @@ def confirm_email_change(request: HttpRequest, confirmation_key: str) -> HttpRes
         email_change_object = get_object_from_key(
             confirmation_key, [Confirmation.EMAIL_CHANGE], mark_object_used=True
         )
-    except ConfirmationKeyException as exception:
+    except ConfirmationKeyError as exception:
         return render_confirmation_key_error(request, exception)
 
     assert isinstance(email_change_object, EmailChangeStatus)
@@ -244,7 +244,7 @@ def json_change_settings(
                 return_data=return_data,
             ):
                 raise JsonableError(_("Wrong password!"))
-        except RateLimited as e:
+        except RateLimitedError as e:
             assert e.secs_to_freedom is not None
             secs_to_freedom = int(e.secs_to_freedom)
             raise JsonableError(
@@ -300,7 +300,7 @@ def json_change_settings(
                 user_profile, domain="email_change_by_user"
             ).rate_limit()
             if ratelimited:
-                raise RateLimited(time_until_free)
+                raise RateLimitedError(time_until_free)
 
             do_start_email_change_process(user_profile, new_email)
 

zerver/views/users.py

@@ -41,8 +41,8 @@ from zerver.lib.exceptions import (
     CannotDeactivateLastUserError,
     JsonableError,
     MissingAuthenticationError,
-    OrganizationAdministratorRequired,
+    OrganizationAdministratorRequiredError,
-    OrganizationOwnerRequired,
+    OrganizationOwnerRequiredError,
 )
 from zerver.lib.integrations import EMBEDDED_BOTS
 from zerver.lib.rate_limiter import rate_limit_spectator_attachment_access_by_file
@@ -87,7 +87,7 @@ from zerver.models import (
     DisposableEmailError,
     DomainNotAllowedForRealmError,
     EmailContainsPlusError,
-    InvalidFakeEmailDomain,
+    InvalidFakeEmailDomainError,
     Message,
     Realm,
     Service,
@@ -117,7 +117,7 @@ def deactivate_user_backend(
 ) -> HttpResponse:
     target = access_user_by_id(user_profile, user_id, for_admin=True)
     if target.is_realm_owner and not user_profile.is_realm_owner:
-        raise OrganizationOwnerRequired()
+        raise OrganizationOwnerRequiredError()
     if check_last_owner(target):
         raise JsonableError(_("Cannot deactivate the only organization owner"))
     if deactivation_notification_comment is not None:
@@ -231,9 +231,9 @@ def update_user_backend(
         #
         # Logic replicated in patch_bot_backend.
         if UserProfile.ROLE_REALM_OWNER in [role, target.role] and not user_profile.is_realm_owner:
-            raise OrganizationOwnerRequired()
+            raise OrganizationOwnerRequiredError()
         elif not user_profile.is_realm_admin:
-            raise OrganizationAdministratorRequired()
+            raise OrganizationAdministratorRequiredError()
 
         if target.role == UserProfile.ROLE_REALM_OWNER and check_last_owner(target):
             raise JsonableError(
@@ -367,9 +367,9 @@ def patch_bot_backend(
     if role is not None and bot.role != role:
         # Logic duplicated from update_user_backend.
         if UserProfile.ROLE_REALM_OWNER in [role, bot.role] and not user_profile.is_realm_owner:
-            raise OrganizationOwnerRequired()
+            raise OrganizationOwnerRequiredError()
         elif not user_profile.is_realm_admin:
-            raise OrganizationAdministratorRequired()
+            raise OrganizationAdministratorRequiredError()
 
         do_change_user_role(bot, role, acting_user=user_profile)
 
@@ -484,7 +484,7 @@ def add_bot_backend(
     full_name = check_full_name(full_name_raw)
     try:
         email = Address(username=short_name, domain=user_profile.realm.get_bot_domain()).addr_spec
-    except InvalidFakeEmailDomain:
+    except InvalidFakeEmailDomainError:
         raise JsonableError(
             _(
                 "Can't create bots until FAKE_EMAIL_DOMAIN is correctly configured.\n"

zerver/webhooks/azuredevops/view.py

@@ -3,7 +3,7 @@ from typing import Callable, Dict, Optional
 from django.http import HttpRequest, HttpResponse
 
 from zerver.decorator import webhook_view
-from zerver.lib.exceptions import UnsupportedWebhookEventType
+from zerver.lib.exceptions import UnsupportedWebhookEventTypeError
 from zerver.lib.request import REQ, has_request_variables
 from zerver.lib.response import json_success
 from zerver.lib.validator import WildValue, check_int, check_string, to_wild_value
@@ -148,7 +148,7 @@ def get_event_name(payload: WildValue, branches: Optional[str]) -> Optional[str]
             return None
     if event_name in EVENT_FUNCTION_MAPPER:
         return event_name
-    raise UnsupportedWebhookEventType(event_name)
+    raise UnsupportedWebhookEventTypeError(event_name)
 
 
 EVENT_FUNCTION_MAPPER: Dict[str, Callable[[WildValue], str]] = {

zerver/webhooks/basecamp/view.py

@@ -4,7 +4,7 @@ import string
 from django.http import HttpRequest, HttpResponse
 
 from zerver.decorator import webhook_view
-from zerver.lib.exceptions import UnsupportedWebhookEventType
+from zerver.lib.exceptions import UnsupportedWebhookEventTypeError
 from zerver.lib.request import REQ, has_request_variables
 from zerver.lib.response import json_success
 from zerver.lib.validator import WildValue, check_string, to_wild_value
@@ -47,7 +47,7 @@ def api_basecamp_webhook(
     event = get_event_type(payload)
 
     if event not in SUPPORT_EVENTS:
-        raise UnsupportedWebhookEventType(event)
+        raise UnsupportedWebhookEventTypeError(event)
 
     subject = get_project_name(payload)
     if event.startswith("document_"):
@@ -72,7 +72,7 @@ def api_basecamp_webhook(
         body = get_comment_body(event, payload)
         event = "comment"
     else:
-        raise UnsupportedWebhookEventType(event)
+        raise UnsupportedWebhookEventTypeError(event)
 
     check_send_webhook_message(request, user_profile, subject, body, event)
     return json_success(request)

zerver/webhooks/bitbucket2/view.py

@@ -7,7 +7,7 @@ from typing import Dict, List, Optional, Protocol
 from django.http import HttpRequest, HttpResponse
 
 from zerver.decorator import log_unsupported_webhook_event, webhook_view
-from zerver.lib.exceptions import UnsupportedWebhookEventType
+from zerver.lib.exceptions import UnsupportedWebhookEventTypeError
 from zerver.lib.request import REQ, has_request_variables
 from zerver.lib.response import json_success
 from zerver.lib.validator import WildValue, check_bool, check_int, check_string, to_wild_value
@@ -196,7 +196,7 @@ def get_type(request: HttpRequest, payload: WildValue) -> str:
         if event_key == "repo:updated":
             return event_key
 
-    raise UnsupportedWebhookEventType(event_key)
+    raise UnsupportedWebhookEventTypeError(event_key)
 
 
 class BodyGetter(Protocol):

zerver/webhooks/bitbucket3/view.py

@@ -5,7 +5,7 @@ from typing import Dict, List, Optional, Protocol
 from django.http import HttpRequest, HttpResponse
 
 from zerver.decorator import webhook_view
-from zerver.lib.exceptions import UnsupportedWebhookEventType
+from zerver.lib.exceptions import UnsupportedWebhookEventTypeError
 from zerver.lib.request import REQ, has_request_variables
 from zerver.lib.response import json_success
 from zerver.lib.validator import WildValue, check_int, check_none_or, check_string, to_wild_value
@@ -169,7 +169,7 @@ def repo_push_branch_data(payload: WildValue, change: WildValue) -> Dict[str, st
         body = get_remove_branch_event_message(user_name, branch_name)
     else:
         message = "{}.{}".format(payload["eventKey"].tame(check_string), event_type)  # nocoverage
-        raise UnsupportedWebhookEventType(message)
+        raise UnsupportedWebhookEventTypeError(message)
 
     subject = TOPIC_WITH_BRANCH_TEMPLATE.format(repo=repo_name, branch=branch_name)
     return {"subject": subject, "body": body}
@@ -186,7 +186,7 @@ def repo_push_tag_data(payload: WildValue, change: WildValue) -> Dict[str, str]:
         action = "removed"
     else:
         message = "{}.{}".format(payload["eventKey"].tame(check_string), event_type)  # nocoverage
-        raise UnsupportedWebhookEventType(message)
+        raise UnsupportedWebhookEventTypeError(message)
 
     subject = BITBUCKET_TOPIC_TEMPLATE.format(repository_name=repo_name)
     body = get_push_tag_event_message(get_user_name(payload), tag_name, action=action)
@@ -213,7 +213,7 @@ def repo_push_handler(
             message = "{}.{}".format(
                 payload["eventKey"].tame(check_string), event_target_type
             )  # nocoverage
-            raise UnsupportedWebhookEventType(message)
+            raise UnsupportedWebhookEventTypeError(message)
     return data
 
 
@@ -446,7 +446,7 @@ def api_bitbucket3_webhook(
         assert eventkey is not None
     handler = EVENT_HANDLER_MAP.get(eventkey)
     if handler is None:
-        raise UnsupportedWebhookEventType(eventkey)
+        raise UnsupportedWebhookEventTypeError(eventkey)
 
     data = handler(payload, branches=branches, include_title=user_specified_topic)
     for element in data:

zerver/webhooks/clubhouse/view.py

@@ -4,7 +4,7 @@ from typing import Callable, Dict, Iterable, Iterator, List, Optional
 from django.http import HttpRequest, HttpResponse
 
 from zerver.decorator import webhook_view
-from zerver.lib.exceptions import UnsupportedWebhookEventType
+from zerver.lib.exceptions import UnsupportedWebhookEventTypeError
 from zerver.lib.request import REQ, has_request_variables
 from zerver.lib.response import json_success
 from zerver.lib.validator import (
@@ -695,7 +695,7 @@ def send_stream_messages_for_actions(
     body_func = EVENT_BODY_FUNCTION_MAPPER.get(event)
     topic_func = get_topic_function_based_on_type(payload, action)
     if body_func is None or topic_func is None:
-        raise UnsupportedWebhookEventType(event)
+        raise UnsupportedWebhookEventTypeError(event)
 
     topic = topic_func(payload, action)
     body = body_func(payload, action)

zerver/webhooks/freshping/view.py

@@ -1,7 +1,7 @@
 from django.http import HttpRequest, HttpResponse
 
 from zerver.decorator import webhook_view
-from zerver.lib.exceptions import UnsupportedWebhookEventType
+from zerver.lib.exceptions import UnsupportedWebhookEventTypeError
 from zerver.lib.request import REQ, has_request_variables
 from zerver.lib.response import json_success
 from zerver.lib.validator import WildValue, check_int, check_string, to_wild_value
@@ -32,7 +32,7 @@ def api_freshping_webhook(
     subject = get_subject_for_http_request(payload)
     check_state_name = payload["webhook_event_data"]["check_state_name"].tame(check_string)
     if check_state_name not in CHECK_STATE_NAME_TO_EVENT_TYPE:
-        raise UnsupportedWebhookEventType(check_state_name)
+        raise UnsupportedWebhookEventTypeError(check_state_name)
 
     check_send_webhook_message(
         request,

zerver/webhooks/gci/view.py

@@ -17,7 +17,7 @@ def build_instance_url(instance_id: int) -> str:
     return f"https://codein.withgoogle.com/dashboard/task-instances/{instance_id}/"
 
 
-class UnknownEventType(Exception):
+class UnknownEventTypeError(Exception):
     pass
 
 
@@ -155,7 +155,7 @@ def get_event(payload: WildValue) -> Optional[str]:
     if event in EVENTS_FUNCTION_MAPPER:
         return event
 
-    raise UnknownEventType(f"Event '{event}' is unknown and cannot be handled")  # nocoverage
+    raise UnknownEventTypeError(f"Event '{event}' is unknown and cannot be handled")  # nocoverage
 
 
 def get_body_based_on_event(event: str) -> Callable[[WildValue], str]:

zerver/webhooks/github/view.py

@@ -5,7 +5,7 @@ from typing import Callable, Dict, Optional
 from django.http import HttpRequest, HttpResponse
 
 from zerver.decorator import log_unsupported_webhook_event, webhook_view
-from zerver.lib.exceptions import UnsupportedWebhookEventType
+from zerver.lib.exceptions import UnsupportedWebhookEventTypeError
 from zerver.lib.request import REQ, has_request_variables
 from zerver.lib.response import json_success
 from zerver.lib.validator import (
@@ -759,7 +759,7 @@ def api_github_webhook(
     """
     header_event = validate_extract_webhook_http_header(request, "X-GitHub-Event", "GitHub")
     if header_event is None:
-        raise UnsupportedWebhookEventType("no header provided")
+        raise UnsupportedWebhookEventTypeError("no header provided")
 
     event = get_zulip_event_name(header_event, payload, branches)
     if event is None:
@@ -832,7 +832,7 @@ def get_zulip_event_name(
         else:
             # this means GH has actually added new actions since September 2020,
             # so it's a bit more cause for alarm
-            raise UnsupportedWebhookEventType(f"unsupported team action {action}")
+            raise UnsupportedWebhookEventTypeError(f"unsupported team action {action}")
     elif header_event in list(EVENT_FUNCTION_MAPPER.keys()):
         return header_event
     elif header_event in IGNORED_EVENTS:
@@ -841,4 +841,4 @@ def get_zulip_event_name(
     complete_event = "{}:{}".format(
         header_event, payload.get("action", "???").tame(check_string)
     )  # nocoverage
-    raise UnsupportedWebhookEventType(complete_event)
+    raise UnsupportedWebhookEventTypeError(complete_event)

zerver/webhooks/gitlab/view.py

@@ -5,7 +5,7 @@ from typing import Dict, List, Optional, Protocol, Union
 from django.http import HttpRequest, HttpResponse
 
 from zerver.decorator import webhook_view
-from zerver.lib.exceptions import UnsupportedWebhookEventType
+from zerver.lib.exceptions import UnsupportedWebhookEventTypeError
 from zerver.lib.request import REQ, has_request_variables
 from zerver.lib.response import json_success
 from zerver.lib.validator import WildValue, check_bool, check_int, check_string, to_wild_value
@@ -517,4 +517,4 @@ def get_event(request: HttpRequest, payload: WildValue, branches: Optional[str])
     if event in list(EVENT_FUNCTION_MAPPER.keys()):
         return event
 
-    raise UnsupportedWebhookEventType(event)
+    raise UnsupportedWebhookEventTypeError(event)

zerver/webhooks/gogs/view.py

@@ -4,7 +4,7 @@ from typing import Dict, List, Optional, Protocol
 from django.http import HttpRequest, HttpResponse
 
 from zerver.decorator import webhook_view
-from zerver.lib.exceptions import UnsupportedWebhookEventType
+from zerver.lib.exceptions import UnsupportedWebhookEventTypeError
 from zerver.lib.request import REQ, has_request_variables
 from zerver.lib.response import json_success
 from zerver.lib.validator import WildValue, check_bool, check_int, check_string, to_wild_value
@@ -247,7 +247,7 @@ def gogs_webhook_main(
         )
 
     else:
-        raise UnsupportedWebhookEventType(event)
+        raise UnsupportedWebhookEventTypeError(event)
 
     check_send_webhook_message(request, user_profile, topic, body, event)
     return json_success(request)

zerver/webhooks/gosquared/view.py

@@ -1,7 +1,7 @@
 from django.http import HttpRequest, HttpResponse
 
 from zerver.decorator import webhook_view
-from zerver.lib.exceptions import UnsupportedWebhookEventType
+from zerver.lib.exceptions import UnsupportedWebhookEventTypeError
 from zerver.lib.request import REQ, has_request_variables
 from zerver.lib.response import json_success
 from zerver.lib.validator import WildValue, check_bool, check_int, check_string, to_wild_value
@@ -58,6 +58,6 @@ def api_gosquared_webhook(
             )
             check_send_webhook_message(request, user_profile, topic, body, "chat_message")
     else:
-        raise UnsupportedWebhookEventType("unknown_event")
+        raise UnsupportedWebhookEventTypeError("unknown_event")
 
     return json_success(request)

zerver/webhooks/groove/view.py

@@ -5,7 +5,7 @@ from typing import Callable, Dict, Optional
 from django.http import HttpRequest, HttpResponse
 
 from zerver.decorator import webhook_view
-from zerver.lib.exceptions import UnsupportedWebhookEventType
+from zerver.lib.exceptions import UnsupportedWebhookEventTypeError
 from zerver.lib.request import REQ, has_request_variables
 from zerver.lib.response import json_success
 from zerver.lib.validator import (
@@ -121,7 +121,7 @@ def api_groove_webhook(
     assert event is not None
     handler = EVENTS_FUNCTION_MAPPER.get(event)
     if handler is None:
-        raise UnsupportedWebhookEventType(event)
+        raise UnsupportedWebhookEventTypeError(event)
 
     body = handler(payload)
     topic = "notifications"

zerver/webhooks/harbor/view.py

@@ -5,7 +5,7 @@ from django.db.models import Q
 from django.http import HttpRequest, HttpResponse
 
 from zerver.decorator import webhook_view
-from zerver.lib.exceptions import UnsupportedWebhookEventType
+from zerver.lib.exceptions import UnsupportedWebhookEventTypeError
 from zerver.lib.request import REQ, has_request_variables
 from zerver.lib.response import json_success
 from zerver.lib.validator import WildValue, check_int, check_string, to_wild_value
@@ -59,7 +59,7 @@ def handle_scanning_completed_event(
     scan_results = ""
     scan_overview = payload["event_data"]["resources"][0]["scan_overview"]
     if "application/vnd.security.vulnerability.report; version=1.1" not in scan_overview:
-        raise UnsupportedWebhookEventType("Unsupported harbor scanning webhook payload")
+        raise UnsupportedWebhookEventTypeError("Unsupported harbor scanning webhook payload")
     scan_summaries = scan_overview["application/vnd.security.vulnerability.report; version=1.1"][
         "summary"
     ]["summary"]
@@ -109,7 +109,7 @@ def api_harbor_webhook(
     content_func = EVENT_FUNCTION_MAPPER.get(event)
 
     if content_func is None:
-        raise UnsupportedWebhookEventType(event)
+        raise UnsupportedWebhookEventTypeError(event)
 
     content: str = content_func(payload, user_profile, operator_username)
 

zerver/webhooks/intercom/view.py

@@ -5,7 +5,7 @@ from typing import Callable, Dict, List, Tuple
 from django.http import HttpRequest, HttpResponse
 
 from zerver.decorator import webhook_view
-from zerver.lib.exceptions import UnsupportedWebhookEventType
+from zerver.lib.exceptions import UnsupportedWebhookEventTypeError
 from zerver.lib.request import REQ, has_request_variables
 from zerver.lib.response import json_success
 from zerver.lib.validator import WildValue, check_int, check_none_or, check_string, to_wild_value
@@ -337,7 +337,7 @@ def api_intercom_webhook(
 
     handler = EVENT_TO_FUNCTION_MAPPER.get(event_type)
     if handler is None:
-        raise UnsupportedWebhookEventType(event_type)
+        raise UnsupportedWebhookEventTypeError(event_type)
     topic, body = handler(payload)
 
     check_send_webhook_message(request, user_profile, topic, body, event_type)

zerver/webhooks/jira/view.py

@@ -8,7 +8,7 @@ from django.db.models import Q
 from django.http import HttpRequest, HttpResponse
 
 from zerver.decorator import webhook_view
-from zerver.lib.exceptions import AnomalousWebhookPayload, UnsupportedWebhookEventType
+from zerver.lib.exceptions import AnomalousWebhookPayloadError, UnsupportedWebhookEventTypeError
 from zerver.lib.request import REQ, has_request_variables
 from zerver.lib.response import json_success
 from zerver.lib.validator import WildValue, check_none_or, check_string, to_wild_value
@@ -363,13 +363,13 @@ def api_jira_webhook(
         return json_success(request)
 
     if event is None:
-        raise AnomalousWebhookPayload()
+        raise AnomalousWebhookPayloadError()
 
     if event is not None:
         content_func = JIRA_CONTENT_FUNCTION_MAPPER.get(event)
 
     if content_func is None:
-        raise UnsupportedWebhookEventType(event)
+        raise UnsupportedWebhookEventTypeError(event)
 
     subject = get_issue_subject(payload)
     content: str = content_func(payload, user_profile)

zerver/webhooks/lidarr/view.py

@@ -3,7 +3,7 @@ from typing import Dict, List
 from django.http import HttpRequest, HttpResponse
 
 from zerver.decorator import webhook_view
-from zerver.lib.exceptions import UnsupportedWebhookEventType
+from zerver.lib.exceptions import UnsupportedWebhookEventTypeError
 from zerver.lib.request import REQ, has_request_variables
 from zerver.lib.response import json_success
 from zerver.lib.validator import WildValue, check_bool, check_string, to_wild_value
@@ -141,4 +141,4 @@ def get_body_for_http_request(payload: WildValue) -> str:
         else:
             return get_body_for_tracks_imported_event(payload)
     else:
-        raise UnsupportedWebhookEventType(event_type)
+        raise UnsupportedWebhookEventTypeError(event_type)

zerver/webhooks/netlify/view.py

@@ -3,7 +3,7 @@ from typing import Tuple
 from django.http import HttpRequest, HttpResponse
 
 from zerver.decorator import webhook_view
-from zerver.lib.exceptions import UnsupportedWebhookEventType
+from zerver.lib.exceptions import UnsupportedWebhookEventTypeError
 from zerver.lib.request import REQ, has_request_variables
 from zerver.lib.response import json_success
 from zerver.lib.validator import WildValue, check_string, to_wild_value
@@ -63,6 +63,6 @@ def get_template(request: HttpRequest, payload: WildValue) -> Tuple[str, str]:
     elif event in ALL_EVENT_TYPES:
         message_template += "is now {state}.".format(state=payload["state"].tame(check_string))
     else:
-        raise UnsupportedWebhookEventType(event)
+        raise UnsupportedWebhookEventTypeError(event)
 
     return message_template, event

zerver/webhooks/pagerduty/view.py

@@ -4,7 +4,7 @@ from typing import Dict, Union
 from django.http import HttpRequest, HttpResponse
 
 from zerver.decorator import webhook_view
-from zerver.lib.exceptions import UnsupportedWebhookEventType
+from zerver.lib.exceptions import UnsupportedWebhookEventTypeError
 from zerver.lib.request import REQ, has_request_variables
 from zerver.lib.response import json_success
 from zerver.lib.validator import WildValue, check_int, check_none_or, check_string, to_wild_value
@@ -250,7 +250,7 @@ def api_pagerduty_webhook(
                 break
 
             if message_type not in PAGER_DUTY_EVENT_NAMES:
-                raise UnsupportedWebhookEventType(message_type)
+                raise UnsupportedWebhookEventTypeError(message_type)
 
             format_dict = build_pagerduty_formatdict(message)
             send_formated_pagerduty(request, user_profile, message_type, format_dict)
@@ -264,7 +264,7 @@ def api_pagerduty_webhook(
                 break
 
             if message_event not in PAGER_DUTY_EVENT_NAMES_V2:
-                raise UnsupportedWebhookEventType(message_event)
+                raise UnsupportedWebhookEventTypeError(message_event)
 
             format_dict = build_pagerduty_formatdict_v2(message)
             send_formated_pagerduty(request, user_profile, message_event, format_dict)
@@ -275,7 +275,7 @@ def api_pagerduty_webhook(
             event_type = event.get("event_type").tame(check_none_or(check_string))
 
             if event_type not in PAGER_DUTY_EVENT_NAMES_V3:
-                raise UnsupportedWebhookEventType(event_type)
+                raise UnsupportedWebhookEventTypeError(event_type)
 
             format_dict = build_pagerduty_formatdict_v3(event)
             send_formated_pagerduty(request, user_profile, event_type, format_dict)

zerver/webhooks/pingdom/view.py

@@ -2,7 +2,7 @@
 from django.http import HttpRequest, HttpResponse
 
 from zerver.decorator import webhook_view
-from zerver.lib.exceptions import UnsupportedWebhookEventType
+from zerver.lib.exceptions import UnsupportedWebhookEventTypeError
 from zerver.lib.request import REQ, has_request_variables
 from zerver.lib.response import json_success
 from zerver.lib.validator import WildValue, check_string, to_wild_value
@@ -51,7 +51,7 @@ def api_pingdom_webhook(
         subject = get_subject_for_http_request(payload)
         body = get_body_for_http_request(payload)
     else:
-        raise UnsupportedWebhookEventType(check_type)
+        raise UnsupportedWebhookEventTypeError(check_type)
 
     check_send_webhook_message(request, user_profile, subject, body, check_type)
     return json_success(request)

zerver/webhooks/pivotal/tests.py

@@ -2,7 +2,7 @@ from unittest import mock
 
 import orjson
 
-from zerver.lib.exceptions import UnsupportedWebhookEventType
+from zerver.lib.exceptions import UnsupportedWebhookEventTypeError
 from zerver.lib.test_classes import WebhookTestCase
 from zerver.webhooks.pivotal.view import api_pivotal_webhook_v5
 
@@ -218,7 +218,7 @@ Try again next time
             self.assertEqual(result[0], "#0: ")
 
         bad = orjson.loads(self.get_body("bad_kind"))
-        with self.assertRaisesRegex(UnsupportedWebhookEventType, "'unknown_kind'.* supported"):
+        with self.assertRaisesRegex(UnsupportedWebhookEventTypeError, "'unknown_kind'.* supported"):
             with mock.patch("zerver.webhooks.pivotal.view.orjson.loads", return_value=bad):
                 api_pivotal_webhook_v5(request, hamlet)
 

zerver/webhooks/pivotal/view.py

@@ -8,7 +8,7 @@ from django.http import HttpRequest, HttpResponse
 from django.utils.translation import gettext as _
 
 from zerver.decorator import webhook_view
-from zerver.lib.exceptions import JsonableError, UnsupportedWebhookEventType
+from zerver.lib.exceptions import JsonableError, UnsupportedWebhookEventTypeError
 from zerver.lib.request import has_request_variables
 from zerver.lib.response import json_success
 from zerver.lib.webhooks.common import check_send_webhook_message
@@ -170,7 +170,7 @@ def api_pivotal_webhook_v5(request: HttpRequest, user_profile: UserProfile) -> T
         # Known but unsupported Pivotal event types
         pass
     else:
-        raise UnsupportedWebhookEventType(event_type)
+        raise UnsupportedWebhookEventTypeError(event_type)
 
     return subject, content, f"{event_type}_v5"
 

zerver/webhooks/radarr/view.py

@@ -1,7 +1,7 @@
 from django.http import HttpRequest, HttpResponse
 
 from zerver.decorator import webhook_view
-from zerver.lib.exceptions import UnsupportedWebhookEventType
+from zerver.lib.exceptions import UnsupportedWebhookEventTypeError
 from zerver.lib.request import REQ, has_request_variables
 from zerver.lib.response import json_success
 from zerver.lib.validator import WildValue, check_string, to_wild_value
@@ -103,4 +103,4 @@ def get_body_for_http_request(payload: WildValue) -> str:
     elif event_type == "Grab":
         return get_body_for_movie_grabbed_event(payload)
     else:
-        raise UnsupportedWebhookEventType(event_type)
+        raise UnsupportedWebhookEventTypeError(event_type)

zerver/webhooks/raygun/view.py

@@ -3,7 +3,7 @@ import time
 from django.http import HttpRequest, HttpResponse
 
 from zerver.decorator import webhook_view
-from zerver.lib.exceptions import UnsupportedWebhookEventType
+from zerver.lib.exceptions import UnsupportedWebhookEventTypeError
 from zerver.lib.request import REQ, has_request_variables
 from zerver.lib.response import json_success
 from zerver.lib.validator import (
@@ -43,7 +43,7 @@ def api_raygun_webhook(
     elif event == "error_activity":
         message = compose_activity_message(payload)
     else:
-        raise UnsupportedWebhookEventType(event)
+        raise UnsupportedWebhookEventTypeError(event)
 
     topic = "test"
 
@@ -232,7 +232,7 @@ def compose_notification_message(payload: WildValue) -> str:
     elif "FollowUp" in event_type:
         return notification_message_follow_up(payload)
     else:
-        raise UnsupportedWebhookEventType(event_type)
+        raise UnsupportedWebhookEventTypeError(event_type)
 
 
 def activity_message(payload: WildValue) -> str:
@@ -292,7 +292,7 @@ def compose_activity_message(payload: WildValue) -> str:
     ):
         return activity_message(payload)
     else:
-        raise UnsupportedWebhookEventType(event_type)
+        raise UnsupportedWebhookEventTypeError(event_type)
 
 
 def parse_time(timestamp: str) -> str:

zerver/webhooks/reviewboard/view.py

@@ -1,7 +1,7 @@
 from django.http import HttpRequest, HttpResponse
 
 from zerver.decorator import webhook_view
-from zerver.lib.exceptions import UnsupportedWebhookEventType
+from zerver.lib.exceptions import UnsupportedWebhookEventTypeError
 from zerver.lib.request import REQ, has_request_variables
 from zerver.lib.response import json_success
 from zerver.lib.validator import WildValue, check_int, check_none_or, check_string, to_wild_value
@@ -194,6 +194,6 @@ def api_reviewboard_webhook(
         topic = get_review_request_repo_title(payload)
         check_send_webhook_message(request, user_profile, topic, body, event_type)
     else:
-        raise UnsupportedWebhookEventType(event_type)
+        raise UnsupportedWebhookEventTypeError(event_type)
 
     return json_success(request)

zerver/webhooks/rhodecode/view.py

@@ -4,7 +4,7 @@ from django.core.exceptions import ValidationError
 from django.http import HttpRequest, HttpResponse
 
 from zerver.decorator import webhook_view
-from zerver.lib.exceptions import UnsupportedWebhookEventType
+from zerver.lib.exceptions import UnsupportedWebhookEventTypeError
 from zerver.lib.request import REQ, has_request_variables
 from zerver.lib.response import json_success
 from zerver.lib.validator import WildValue, check_string, to_wild_value
@@ -55,7 +55,7 @@ def get_event_name(payload: WildValue, branches: Optional[str]) -> Optional[str]
                 return None
     if event_name in EVENT_FUNCTION_MAPPER:
         return event_name
-    raise UnsupportedWebhookEventType(event_name)
+    raise UnsupportedWebhookEventTypeError(event_name)
 
 
 def get_repository_name(payload: WildValue) -> str:

zerver/webhooks/sentry/view.py

@@ -6,7 +6,7 @@ from urllib.parse import urljoin
 from django.http import HttpRequest, HttpResponse
 
 from zerver.decorator import webhook_view
-from zerver.lib.exceptions import UnsupportedWebhookEventType
+from zerver.lib.exceptions import UnsupportedWebhookEventTypeError
 from zerver.lib.request import REQ, has_request_variables
 from zerver.lib.response import json_success
 from zerver.lib.webhooks.common import check_send_webhook_message
@@ -95,7 +95,7 @@ def handle_event_payload(event: Dict[str, Any]) -> Tuple[str, str]:
     """Handle either an exception type event or a message type event payload."""
     # We shouldn't support the officially deprecated Raven series of SDKs.
     if int(event["version"]) < 7:
-        raise UnsupportedWebhookEventType("Raven SDK")
+        raise UnsupportedWebhookEventTypeError("Raven SDK")
 
     subject = event["title"]
     platform_name = event["platform"]
@@ -159,7 +159,7 @@ def handle_event_payload(event: Dict[str, Any]) -> Tuple[str, str]:
         body = MESSAGE_EVENT_TEMPLATE.format(**context)
 
     else:
-        raise UnsupportedWebhookEventType("unknown-event type")
+        raise UnsupportedWebhookEventTypeError("unknown-event type")
 
     return (subject, body)
 
@@ -211,7 +211,7 @@ def handle_issue_payload(
         body = ISSUE_IGNORED_MESSAGE_TEMPLATE.format(**context)
 
     else:
-        raise UnsupportedWebhookEventType("unknown-issue-action type")
+        raise UnsupportedWebhookEventTypeError("unknown-issue-action type")
 
     return (subject, body)
 
@@ -266,7 +266,7 @@ def api_sentry_webhook(
         elif "issue" in data:
             subject, body = handle_issue_payload(payload["action"], data["issue"], payload["actor"])
         else:
-            raise UnsupportedWebhookEventType(str(list(data.keys())))
+            raise UnsupportedWebhookEventTypeError(str(list(data.keys())))
     else:
         subject, body = handle_deprecated_payload(payload)
 

zerver/webhooks/sonarr/view.py

@@ -1,7 +1,7 @@
 from django.http import HttpRequest, HttpResponse
 
 from zerver.decorator import webhook_view
-from zerver.lib.exceptions import UnsupportedWebhookEventType
+from zerver.lib.exceptions import UnsupportedWebhookEventTypeError
 from zerver.lib.request import REQ, has_request_variables
 from zerver.lib.response import json_success
 from zerver.lib.validator import WildValue, check_bool, check_int, check_string, to_wild_value
@@ -167,4 +167,4 @@ def get_body_for_http_request(payload: WildValue) -> str:
         else:
             return get_body_for_episode_deleted_event(payload)
     else:
-        raise UnsupportedWebhookEventType(event_type)
+        raise UnsupportedWebhookEventTypeError(event_type)