chore: adding ruff RET

Signed-off-by: Henry Schreiner <[email protected]>

Author: henryiii

pyproject.toml

@@ -113,6 +113,7 @@ extend-select = [
     "PT",    # flake8-pytest-style
     "PYI",   # flake8-pyi
     "Q",     # flake8-quotes
+    "RET",   # flake8-return
     "RSE",   # flake8-raise
     "RUF",   # Ruff-specific rules
     "SIM",   # flake8-simplify

src/packaging/_parser.py

@@ -310,25 +310,21 @@ def _parse_marker_item(tokenizer: Tokenizer) -> MarkerItem:
     return (marker_var_left, marker_op, marker_var_right)
 
 
-def _parse_marker_var(tokenizer: Tokenizer) -> MarkerVar:
+def _parse_marker_var(tokenizer: Tokenizer) -> MarkerVar:  # noqa: RET503
     """
     marker_var = VARIABLE | QUOTED_STRING
     """
     if tokenizer.check("VARIABLE"):
         return process_env_var(tokenizer.read().text.replace(".", "_"))
-    elif tokenizer.check("QUOTED_STRING"):
+    if tokenizer.check("QUOTED_STRING"):
         return process_python_str(tokenizer.read().text)
-    else:
-        tokenizer.raise_syntax_error(
-            message="Expected a marker variable or quoted string"
-        )
+    tokenizer.raise_syntax_error(message="Expected a marker variable or quoted string")
 
 
 def process_env_var(env_var: str) -> Variable:
     if env_var in ("platform_python_implementation", "python_implementation"):
         return Variable("platform_python_implementation")
-    else:
-        return Variable(env_var)
+    return Variable(env_var)
 
 
 def process_python_str(python_str: str) -> Value:
@@ -343,14 +339,13 @@ def _parse_marker_op(tokenizer: Tokenizer) -> Op:
     if tokenizer.check("IN"):
         tokenizer.read()
         return Op("in")
-    elif tokenizer.check("NOT"):
+    if tokenizer.check("NOT"):
         tokenizer.read()
         tokenizer.expect("WS", expected="whitespace after 'not'")
         tokenizer.expect("IN", expected="'in' after 'not'")
         return Op("not in")
-    elif tokenizer.check("OP"):
+    if tokenizer.check("OP"):
         return Op(tokenizer.read().text)
-    else:
-        return tokenizer.raise_syntax_error(
-            "Expected marker operator, one of <=, <, !=, ==, >=, >, ~=, ===, in, not in"
-        )
+    return tokenizer.raise_syntax_error(
+        "Expected marker operator, one of <=, <, !=, ==, >=, >, ~=, ===, in, not in"
+    )

src/packaging/markers.py

@@ -157,12 +157,10 @@ def _format_marker(
         inner = (_format_marker(m, first=False) for m in marker)
         if first:
             return " ".join(inner)
-        else:
-            return "(" + " ".join(inner) + ")"
-    elif isinstance(marker, tuple):
+        return "(" + " ".join(inner) + ")"
+    if isinstance(marker, tuple):
         return " ".join([m.serialize() for m in marker])
-    else:
-        return marker
+    return marker
 
 
 _operators: dict[str, Operator] = {
@@ -204,10 +202,12 @@ def _normalize(
         assert isinstance(rhs, str), "extra value must be a string"
         return (canonicalize_name(lhs), canonicalize_name(rhs))
     if key in MARKERS_ALLOWING_SET:
-        if isinstance(rhs, str):  # pragma: no cover
-            return (canonicalize_name(lhs), canonicalize_name(rhs))
-        else:
-            return (canonicalize_name(lhs), {canonicalize_name(v) for v in rhs})
+        return (
+            canonicalize_name(lhs),
+            canonicalize_name(rhs)
+            if isinstance(rhs, str)
+            else {canonicalize_name(v) for v in rhs},
+        )
 
     # other environment markers don't have such standards
     return lhs, rhs

src/packaging/metadata.py

@@ -236,13 +236,12 @@ def _get_payload(msg: email.message.Message, source: bytes | str) -> str:
         return payload
     # If our source is a bytes, then we're managing the encoding and we need
     # to deal with it.
-    else:
-        bpayload = msg.get_payload(decode=True)
-        assert isinstance(bpayload, bytes)
-        try:
-            return bpayload.decode("utf8", "strict")
-        except UnicodeDecodeError as exc:
-            raise ValueError("payload in an invalid encoding") from exc
+    bpayload = msg.get_payload(decode=True)
+    assert isinstance(bpayload, bytes)
+    try:
+        return bpayload.decode("utf8", "strict")
+    except UnicodeDecodeError as exc:
+        raise ValueError("payload in an invalid encoding") from exc
 
 
 # The various parse_FORMAT functions here are intended to be as lenient as
@@ -658,7 +657,7 @@ def _process_dynamic(self, value: list[str]) -> list[str]:
                 raise self._invalid_metadata(
                     f"{dynamic_field!r} is not allowed as a dynamic field"
                 )
-            elif dynamic_field not in _EMAIL_TO_RAW_MAPPING:
+            if dynamic_field not in _EMAIL_TO_RAW_MAPPING:
                 raise self._invalid_metadata(
                     f"{dynamic_field!r} is not a valid dynamic field"
                 )
@@ -746,7 +745,7 @@ def _process_import_names(self, value: list[str]) -> list[str]:
                         f"{name!r} is invalid for {{field}}; "
                         f"{identifier!r} is not a valid identifier"
                     )
-                elif keyword.iskeyword(identifier):
+                if keyword.iskeyword(identifier):
                     raise self._invalid_metadata(
                         f"{name!r} is invalid for {{field}}; "
                         f"{identifier!r} is a keyword"

src/packaging/specifiers.py

@@ -419,17 +419,16 @@ def _compare_equal(self, prospective: Version, spec: str) -> bool:
             shortened_prospective = padded_prospective[: len(split_spec)]
 
             return shortened_prospective == split_spec
-        else:
-            # Convert our spec string into a Version
-            spec_version = Version(spec)
+        # Convert our spec string into a Version
+        spec_version = Version(spec)
 
-            # If the specifier does not have a local segment, then we want to
-            # act as if the prospective version also does not have a local
-            # segment.
-            if not spec_version.local:
-                prospective = Version(prospective.public)
+        # If the specifier does not have a local segment, then we want to
+        # act as if the prospective version also does not have a local
+        # segment.
+        if not spec_version.local:
+            prospective = Version(prospective.public)
 
-            return prospective == spec_version
+        return prospective == spec_version
 
     def _compare_not_equal(self, prospective: Version, spec: str) -> bool:
         return not self._compare_equal(prospective, spec)

src/packaging/tags.py

@@ -595,14 +595,13 @@ def platform_tags() -> Iterator[str]:
     """
     if platform.system() == "Darwin":
         return mac_platforms()
-    elif platform.system() == "iOS":
+    if platform.system() == "iOS":
         return ios_platforms()
-    elif platform.system() == "Android":
+    if platform.system() == "Android":
         return android_platforms()
-    elif platform.system() == "Linux":
+    if platform.system() == "Linux":
         return _linux_platforms()
-    else:
-        return _generic_platforms()
+    return _generic_platforms()
 
 
 def interpreter_name() -> str:

src/packaging/version.py

@@ -333,8 +333,7 @@ def local(self) -> str | None:
         """
         if self._version.local:
             return ".".join(str(x) for x in self._version.local)
-        else:
-            return None
+        return None
 
     @property
     def public(self) -> str: