unnecesasry else

Author: benfdking

pyproject.toml

@@ -208,3 +208,8 @@ module = [
     "json_stream.*"
 ]
 ignore_missing_imports = true
+
+[tool.ruff.lint]
+select = [
+    "RET505",  # supkkerfluous-else-return
+]

sqlmesh/cli/main.py

@@ -96,7 +96,7 @@ def cli(
         if ctx.invoked_subcommand in SKIP_CONTEXT_COMMANDS:
             ctx.obj = path
             return
-        elif ctx.invoked_subcommand in SKIP_LOAD_COMMANDS:
+        if ctx.invoked_subcommand in SKIP_LOAD_COMMANDS:
             load = False
 
     configs = load_configs(config, Context.CONFIG_TYPE, paths)

sqlmesh/core/audit/definition.py

@@ -95,18 +95,15 @@ def audit_map_validator(cls: t.Type, v: t.Any, values: t.Any) -> t.Dict[str, t.A
         return dict([_maybe_parse_arg_pair(v.unnest())])
     if isinstance(v, (exp.Tuple, exp.Array)):
         return dict(map(_maybe_parse_arg_pair, v.expressions))
-    elif isinstance(v, dict):
+    if isinstance(v, dict):
         dialect = get_dialect(values)
         return {
             key: value
             if isinstance(value, exp.Expression)
             else d.parse_one(str(value), dialect=dialect)
             for key, value in v.items()
         }
-    else:
-        raise_config_error(
-            "Defaults must be a tuple of exp.EQ or a dict", error_type=AuditConfigError
-        )
+    raise_config_error("Defaults must be a tuple of exp.EQ or a dict", error_type=AuditConfigError)
     return {}
 
 

sqlmesh/core/config/root.py

@@ -255,12 +255,9 @@ def get_gateway(self, name: t.Optional[str] = None) -> GatewayConfig:
                 raise ConfigError(f"Missing gateway with name '{name}'.")
 
             return self.gateways[name]
-        else:
-            if name is not None:
-                raise ConfigError(
-                    "Gateway name is not supported when only one gateway is configured."
-                )
-            return self.gateways
+        if name is not None:
+            raise ConfigError("Gateway name is not supported when only one gateway is configured.")
+        return self.gateways
 
     def get_connection(self, gateway_name: t.Optional[str] = None) -> ConnectionConfig:
         return self.get_gateway(gateway_name).connection or self.default_connection

sqlmesh/core/engine_adapter/base.py

@@ -375,33 +375,32 @@ def replace_query(
                 column_descriptions=column_descriptions,
                 **kwargs,
             )
-        else:
-            if self_referencing:
-                with self.temp_table(
-                    self._select_columns(columns_to_types).from_(target_table),
-                    name=target_table,
-                    columns_to_types=columns_to_types,
-                    **kwargs,
-                ) as temp_table:
-                    for source_query in source_queries:
-                        source_query.add_transform(
-                            lambda node: (  # type: ignore
-                                temp_table  # type: ignore
-                                if isinstance(node, exp.Table)
-                                and quote_identifiers(node) == quote_identifiers(target_table)
-                                else node
-                            )
+        if self_referencing:
+            with self.temp_table(
+                self._select_columns(columns_to_types).from_(target_table),
+                name=target_table,
+                columns_to_types=columns_to_types,
+                **kwargs,
+            ) as temp_table:
+                for source_query in source_queries:
+                    source_query.add_transform(
+                        lambda node: (  # type: ignore
+                            temp_table  # type: ignore
+                            if isinstance(node, exp.Table)
+                            and quote_identifiers(node) == quote_identifiers(target_table)
+                            else node
                         )
-                    return self._insert_overwrite_by_condition(
-                        target_table,
-                        source_queries,
-                        columns_to_types,
                     )
-            return self._insert_overwrite_by_condition(
-                target_table,
-                source_queries,
-                columns_to_types,
-            )
+                return self._insert_overwrite_by_condition(
+                    target_table,
+                    source_queries,
+                    columns_to_types,
+                )
+        return self._insert_overwrite_by_condition(
+            target_table,
+            source_queries,
+            columns_to_types,
+        )
 
     def create_index(
         self,

sqlmesh/core/engine_adapter/bigquery.py

@@ -602,9 +602,12 @@ def insert_overwrite_by_partition(
             raise SQLMeshError(
                 f"The partition expression '{partition_sql}' doesn't contain a column."
             )
-        with self.session({}), self.temp_table(
-            query_or_df, name=table_name, partitioned_by=partitioned_by
-        ) as temp_table_name:
+        with (
+            self.session({}),
+            self.temp_table(
+                query_or_df, name=table_name, partitioned_by=partitioned_by
+            ) as temp_table_name,
+        ):
             if columns_to_types is None or columns_to_types[
                 partition_column.name
             ] == exp.DataType.build("unknown"):
@@ -1158,7 +1161,7 @@ def _is_retryable(self, error: BaseException) -> bool:
 
         if isinstance(error, self.retryable_errors):
             return True
-        elif isinstance(error, Forbidden) and any(
+        if isinstance(error, Forbidden) and any(
             e["reason"] == "rateLimitExceeded" for e in error.errors
         ):
             return True

sqlmesh/core/macros.py

@@ -281,7 +281,7 @@ def evaluate_macros(
                     self.parse_one(node.sql(dialect=self.dialect, copy=False))
                     for node in transformed
                 ]
-            elif isinstance(transformed, exp.Expression):
+            if isinstance(transformed, exp.Expression):
                 return self.parse_one(transformed.sql(dialect=self.dialect, copy=False))
 
         return transformed
@@ -1265,7 +1265,7 @@ def resolve_template(
         if mode.lower() == "table":
             return exp.to_table(result, dialect=evaluator.dialect)
         return exp.Literal.string(result)
-    elif evaluator.runtime_stage != RuntimeStage.LOADING.value:
+    if evaluator.runtime_stage != RuntimeStage.LOADING.value:
         # only error if we are CREATING, EVALUATING or TESTING and @this_model is not present; this could indicate a bug
         # otherwise, for LOADING, it's a no-op
         raise SQLMeshError(
@@ -1391,7 +1391,7 @@ def _coerce(
                 return tuple(expr.expressions)
             if generic[-1] is ...:
                 return tuple(_coerce(expr, generic[0], dialect, path) for expr in expr.expressions)
-            elif len(generic) == len(expr.expressions):
+            if len(generic) == len(expr.expressions):
                 return tuple(
                     _coerce(expr, generic[i], dialect, path)
                     for i, expr in enumerate(expr.expressions)

sqlmesh/core/model/definition.py

@@ -2159,19 +2159,18 @@ def load_sql_based_model(
             time_column_format=time_column_format,
             **common_kwargs,
         )
-    else:
-        seed_properties = {
-            p.name.lower(): p.args.get("value") for p in common_kwargs.pop("kind").expressions
-        }
-        try:
-            return create_seed_model(
-                name,
-                SeedKind(**seed_properties),
-                **common_kwargs,
-            )
-        except Exception as ex:
-            raise_config_error(str(ex), path)
-            raise
+    seed_properties = {
+        p.name.lower(): p.args.get("value") for p in common_kwargs.pop("kind").expressions
+    }
+    try:
+        return create_seed_model(
+            name,
+            SeedKind(**seed_properties),
+            **common_kwargs,
+        )
+    except Exception as ex:
+        raise_config_error(str(ex), path)
+        raise
 
 
 def create_sql_model(
@@ -2565,7 +2564,7 @@ def _split_sql_model_statements(
     if not query_positions:
         return None, sql_statements, [], on_virtual_update, inline_audits
 
-    elif len(query_positions) > 1:
+    if len(query_positions) > 1:
         raise_config_error("Only one SELECT query is allowed per model", path)
 
     query, pos = query_positions[0]

sqlmesh/core/renderer.py

@@ -346,8 +346,7 @@ def _expand(node: exp.Expression) -> exp.Expression:
                                     alias=node.alias or model.view_name,
                                     copy=False,
                                 )
-                            else:
-                                logger.warning("Failed to expand the nested model '%s'", name)
+                            logger.warning("Failed to expand the nested model '%s'", name)
                     return node
 
                 expression = expression.transform(_expand, copy=False)  # type: ignore

sqlmesh/core/schema_diff.py

@@ -90,15 +90,13 @@ def from_struct_kwarg(cls, struct: exp.ColumnDef) -> TableAlterColumn:
 
         if kwarg_type.is_type(exp.DataType.Type.STRUCT):
             return cls.struct(name, quoted=quoted)
-        elif kwarg_type.is_type(exp.DataType.Type.ARRAY):
+        if kwarg_type.is_type(exp.DataType.Type.ARRAY):
             if kwarg_type.expressions and kwarg_type.expressions[0].is_type(
                 exp.DataType.Type.STRUCT
             ):
                 return cls.array_of_struct(name, quoted=quoted)
-            else:
-                return cls.array_of_primitive(name, quoted=quoted)
-        else:
-            return cls.primitive(name, quoted=quoted)
+            return cls.array_of_primitive(name, quoted=quoted)
+        return cls.primitive(name, quoted=quoted)
 
     @property
     def is_array(self) -> bool:
@@ -268,22 +266,21 @@ def expression(
                     )
                 ],
             )
-        elif self.is_add:
+        if self.is_add:
             alter_table = exp.Alter(this=exp.to_table(table_name), kind="TABLE")
             column = self.column_def(array_element_selector)
             alter_table.set("actions", [column])
             if self.add_position:
                 column.set("position", self.add_position.column_position_node)
             return alter_table
-        elif self.is_drop:
+        if self.is_drop:
             alter_table = exp.Alter(this=exp.to_table(table_name), kind="TABLE")
             drop_column = exp.Drop(
                 this=self.column(array_element_selector), kind="COLUMN", cascade=self.cascade
             )
             alter_table.set("actions", [drop_column])
             return alter_table
-        else:
-            raise ValueError(f"Unknown operation {self.op}")
+        raise ValueError(f"Unknown operation {self.op}")
 
 
 class SchemaDiffer(PydanticModel):
@@ -593,7 +590,7 @@ def _alter_operation(
                         )
         if self._is_coerceable_type(current_type, new_type):
             return []
-        elif self._is_compatible_type(current_type, new_type):
+        if self._is_compatible_type(current_type, new_type):
             struct.expressions.pop(pos)
             struct.expressions.insert(pos, new_kwarg)
             col_pos = (
@@ -610,10 +607,9 @@ def _alter_operation(
                     col_pos,
                 )
             ]
-        else:
-            return self._drop_operation(
-                columns, root_struct, pos, root_struct
-            ) + self._add_operation(columns, pos, new_kwarg, struct, root_struct)
+        return self._drop_operation(columns, root_struct, pos, root_struct) + self._add_operation(
+            columns, pos, new_kwarg, struct, root_struct
+        )
 
     def _resolve_alter_operations(
         self,