add RET, Q, RSE lint

pkgs/clan-cli/clan_cli/config/__init__.py

@@ -22,26 +22,25 @@ log = logging.getLogger(__name__)
 def map_type(nix_type: str) -> Any:
     if nix_type == "boolean":
         return bool
-    elif nix_type in [
+    if nix_type in [
         "integer",
         "signed integer",
         "16 bit unsigned integer; between 0 and 65535 (both inclusive)",
     ]:
         return int
-    elif nix_type.startswith("string"):
+    if nix_type.startswith("string"):
         return str
-    elif nix_type.startswith("null or "):
+    if nix_type.startswith("null or "):
         subtype = nix_type.removeprefix("null or ")
         return map_type(subtype) | None
-    elif nix_type.startswith("attribute set of"):
+    if nix_type.startswith("attribute set of"):
         subtype = nix_type.removeprefix("attribute set of ")
         return dict[str, map_type(subtype)]  # type: ignore
-    elif nix_type.startswith("list of"):
+    if nix_type.startswith("list of"):
         subtype = nix_type.removeprefix("list of ")
         return list[map_type(subtype)]  # type: ignore
-    else:
-        msg = f"Unknown type {nix_type}"
-        raise ClanError(msg)
+    msg = f"Unknown type {nix_type}"
+    raise ClanError(msg)
 
 
 # merge two dicts recursively
@@ -77,31 +76,29 @@ def cast(value: Any, input_type: Any, opt_description: str) -> Any:
         if isinstance(input_type, bool):
             if value[0] in ["true", "True", "yes", "y", "1"]:
                 return True
-            elif value[0] in ["false", "False", "no", "n", "0"]:
+            if value[0] in ["false", "False", "no", "n", "0"]:
                 return False
-            else:
-                msg = f"Invalid value {value} for boolean"
-                raise ClanError(msg)
+            msg = f"Invalid value {value} for boolean"
+            raise ClanError(msg)
         # handle lists
-        elif get_origin(input_type) is list:
+        if get_origin(input_type) is list:
             subtype = input_type.__args__[0]
             return [cast([x], subtype, opt_description) for x in value]
         # handle dicts
-        elif get_origin(input_type) is dict:
+        if get_origin(input_type) is dict:
             if not isinstance(value, dict):
                 msg = f"Cannot set {opt_description} directly. Specify a suboption like {opt_description}.<name>"
                 raise ClanError(msg)
             subtype = input_type.__args__[1]
             return {k: cast(v, subtype, opt_description) for k, v in value.items()}
-        elif str(input_type) == "str | None":
+        if str(input_type) == "str | None":
             if value[0] in ["null", "None"]:
                 return None
             return value[0]
-        else:
-            if len(value) > 1:
-                msg = f"Too many values for {opt_description}"
-                raise ClanError(msg)
-            return input_type(value[0])
+        if len(value) > 1:
+            msg = f"Too many values for {opt_description}"
+            raise ClanError(msg)
+        return input_type(value[0])
     except ValueError as e:
         msg = f"Invalid type for option {opt_description} (expected {input_type.__name__})"
         raise ClanError(msg) from e

pkgs/clan-cli/clan_cli/config/parsing.py

@@ -41,20 +41,18 @@ def subtype_from_schema(schema: dict[str, Any]) -> type:
         if "additionalProperties" in schema:
             sub_type = subtype_from_schema(schema["additionalProperties"])
             return dict[str, sub_type]  # type: ignore
-        elif "properties" in schema:
+        if "properties" in schema:
             msg = "Nested dicts are not supported"
             raise ClanError(msg)
-        else:
-            msg = "Unknown object type"
-            raise ClanError(msg)
-    elif schema["type"] == "array":
+        msg = "Unknown object type"
+        raise ClanError(msg)
+    if schema["type"] == "array":
         if "items" not in schema:
             msg = "Untyped arrays are not supported"
             raise ClanError(msg)
         sub_type = subtype_from_schema(schema["items"])
         return list[sub_type]  # type: ignore
-    else:
-        return type_map[schema["type"]]
+    return type_map[schema["type"]]
 
 
 def type_from_schema_path(
@@ -66,19 +64,17 @@ def type_from_schema_path(
         full_path = path
     if len(path) == 0:
         return subtype_from_schema(schema)
-    elif schema["type"] == "object":
+    if schema["type"] == "object":
         if "properties" in schema:
             subtype = type_from_schema_path(schema["properties"][path[0]], path[1:])
             return subtype
-        elif "additionalProperties" in schema:
+        if "additionalProperties" in schema:
             subtype = type_from_schema_path(schema["additionalProperties"], path[1:])
             return subtype
-        else:
-            msg = f"Unknown type for path {path}"
-            raise ClanError(msg)
-    else:
         msg = f"Unknown type for path {path}"
         raise ClanError(msg)
+    msg = f"Unknown type for path {path}"
+    raise ClanError(msg)
 
 
 def options_types_from_schema(schema: dict[str, Any]) -> dict[str, type]:
@@ -100,7 +96,7 @@ def options_types_from_schema(schema: dict[str, Any]) -> dict[str, type]:
             for sub_name, sub_type in sub_result.items():
                 result[f"{name}.{sub_name}"] = sub_type
             continue
-        elif type_ == "array":
+        if type_ == "array":
             if "items" not in value:
                 msg = f"Untyped arrays are not supported (field: {name})"
                 raise ClanError(msg)