Starbase migration

craft_grammar/_compound.py

@@ -50,11 +50,7 @@ def __init__(
 
     @overrides
     def check(self) -> bool:
-        for statement in self.statements:
-            if not statement.check():
-                return False
-
-        return True
+        return all(statement.check() for statement in self.statements)
 
     def __eq__(self, other: object) -> bool:
         if type(other) is type(self):

craft_grammar/_processor.py

@@ -64,7 +64,7 @@ def __init__(
             self._transformer = transformer
         else:
             # By default, no transformation
-            self._transformer = lambda s, p, o: p
+            self._transformer = lambda _s, p, _o: p
 
     def process(
         self,
@@ -165,11 +165,12 @@ def _parse_section_dictionary(
         call_stack: CallStack,
     ) -> tuple[Statement | None, Statement | None]:
         finalized_statement: Statement | None = None
-        for key, value in section.items():
+        for key, value_ in section.items():
             # Grammar is always written as a list of selectors but the value
             # can be a list or a string. In the latter case we wrap it so no
             # special care needs to be taken when fetching the result from the
             # primitive.
+            value = value_
             if not isinstance(value, list):
                 value = [value]
 
@@ -221,7 +222,7 @@ def _parse_section_dictionary(
                     call_stack=call_stack,
                 )
 
-            # TODO remove support for to without on (this statement)
+            # to-do: remove support for to without on (this statement)
             elif _TO_CLAUSE_PATTERN.match(key):
                 # We've come across the beginning of a 'to' statement.
                 # That means any previous statement we found is complete.

craft_grammar/_statement.py

@@ -81,12 +81,7 @@ def process(self) -> list[str]:
         :return: Primitives as determined by evaluating the statement or its
                  else clauses.
         """
-        if self.check():
-            primitives = self._process_body()
-        else:
-            primitives = self._process_else()
-
-        return primitives
+        return self._process_body() if self.check() else self._process_else()
 
     def _process_body(self) -> list[str]:
         """Process the main body of this statement.
@@ -136,10 +131,7 @@ def _validate_primitives(self, primitives: Iterable[str]) -> bool:
         :return: Whether or not all primitives are valid.
         :rtype: bool
         """
-        for primitive in primitives:
-            if not self._processor.checker(primitive):
-                return False
-        return True
+        return all(self._processor.checker(primitive) for primitive in primitives)
 
     def _call_stack(self, *, include_self: bool = False) -> CallStack:
         """Return call stack when processing this statement.

craft_grammar/create.py

@@ -74,15 +74,14 @@ def create_grammar_model(model_class: type[BaseModel]) -> str:
 
         attributes.append(attr_decl)
 
-    lines = [class_decl] + CONFIG_TEMPLATE.split("\n")
-    for attr in attributes:
-        lines.append(f"    {attr}")
+    lines = [class_decl, *CONFIG_TEMPLATE.split("\n")]
+    lines.extend(f"    {attr}" for attr in attributes)
     lines.append("")  # Final newline
 
     return "\n".join(lines)
 
 
-def _get_grammar_type_for(model_type: type) -> str | None:
+def _get_grammar_type_for(model_type: type) -> str | None:  # noqa: PLR0911
     """Get the "grammar" type for ``model_type``.
 
     Returns None if we don't know how to "grammify" ``model_type``.
@@ -105,7 +104,7 @@ def _get_grammar_type_for(model_type: type) -> str | None:
 
         case typing.Union:
             # Type is either a Union[] or an Optional[]
-            if len(args) == 2 and type(None) in args:
+            if len(args) == 2 and type(None) in args:  # noqa: PLR2004
                 # Type is an Optional[]
                 # Optional[T] -> Optional[Grammar[T]]
                 other_type = [t for t in args if t is not type(None)][0]
@@ -116,11 +115,7 @@ def _get_grammar_type_for(model_type: type) -> str | None:
             union_args = []
             for arg in typing.get_args(model_type):
                 if typing.get_origin(arg) is None:
-                    if arg is type(None):
-                        name = "None"
-                    else:
-                        # print int as "int"
-                        name = arg.__name__
+                    name = "None" if arg is type(None) else arg.__name__
                     union_args.append(name)
                 else:
                     # print dict[k, v] as "dict[k,v]"
@@ -142,7 +137,7 @@ def _get_grammar_type_for(model_type: type) -> str | None:
 
         case typing.Literal:
             # Literal["a", "b"] -> Grammar[str]
-            arg_types = set(type(a) for a in typing.get_args(model_type))
+            arg_types = {type(a) for a in typing.get_args(model_type)}
             if len(arg_types) == 1:
                 # For now only handle the case where all possible literal values
                 # have the same type

craft_grammar/errors.py

@@ -31,7 +31,7 @@ def __init__(self, message: str) -> None:
 class OnStatementSyntaxError(GrammarSyntaxError):
     """Error raised on on statement syntax errors."""
 
-    def __init__(self, on_statement: str, *, message: str | None = None):
+    def __init__(self, on_statement: str, *, message: str | None = None) -> None:
         components = [f"{on_statement!r} is not a valid 'on' clause"]
         if message:
             components.append(message)
@@ -41,7 +41,7 @@ def __init__(self, on_statement: str, *, message: str | None = None):
 class ToStatementSyntaxError(GrammarSyntaxError):
     """Error raised on to statement syntax errors."""
 
-    def __init__(self, to_statement: str, *, message: str | None = None):
+    def __init__(self, to_statement: str, *, message: str | None = None) -> None:
         components = [f"{to_statement!r} is not a valid 'to' clause"]
         if message:
             components.append(message)
@@ -51,5 +51,5 @@ def __init__(self, to_statement: str, *, message: str | None = None):
 class UnsatisfiedStatementError(CraftGrammarError):
     """Error raised when a statement cannot be satisfied."""
 
-    def __init__(self, statement: str):
+    def __init__(self, statement: str) -> None:
         super().__init__(f"Unable to satisfy {statement!r}, failure forced.")

craft_grammar/models.py

@@ -16,6 +16,8 @@
 
 """Pydantic models for grammar."""
 
+# ruff: noqa: ANN401 (lots of Anys in this module)
+
 import abc
 import re
 from collections.abc import Callable, Iterator
@@ -71,7 +73,7 @@ def _format_type_error(type_: type, entry: Any) -> str:
         return f"value must be a list: {entry!r}"
 
     if issubclass(origin, dict):
-        if len(args) == 2:
+        if len(args) == 2:  # noqa: PLR2004
             return f"value must be a dict of {args[0].__name__} to {args[1].__name__}: {entry!r}"
         return f"value must be a dict: {entry!r}"
 
@@ -163,7 +165,7 @@ def _ensure_selector_valid(selector: str, *, clause: str) -> None:
         raise ValueError(f"syntax error in {clause!r} selector")
 
 
-def _is_grammar_clause(item: Any) -> bool:  # pylint: disable=too-many-return-statements
+def _is_grammar_clause(item: Any) -> bool:  # noqa: PLR0911
     """Check if the given item is a valid grammar clause."""
     # The 'else fail' clause is a string.
     if item == _ELSE_FAIL:

tests/unit/test_compound.py

@@ -213,7 +213,7 @@ def test_compound_statement(scenario):
 
 @pytest.mark.parametrize("scenario", error_scenarios)
 def test_errors(scenario):
-    with pytest.raises(scenario["expected_exception"]) as grammar_error:
+    with pytest.raises(scenario["expected_exception"]) as grammar_error:  # noqa: PT012
         processor = GrammarProcessor(
             arch="amd64",
             target_arch="armhf",

tests/unit/test_models.py

@@ -326,7 +326,7 @@ class GrammarValidation(pydantic.BaseModel):
         x: Grammar[str]
 
     with pytest.raises(pydantic.ValidationError) as raised:
-        GrammarValidation(x=value)  # type: ignore
+        GrammarValidation(x=value)
 
     err = raised.value.errors()
     assert len(err) == 1
@@ -346,7 +346,7 @@ class GrammarValidation(pydantic.BaseModel):
         x: Grammar[list[str]]
 
     with pytest.raises(pydantic.ValidationError) as raised:
-        GrammarValidation(x=value)  # type: ignore
+        GrammarValidation(x=value)
 
     err = raised.value.errors()
     assert len(err) == 1
@@ -365,7 +365,7 @@ class GrammarValidation(pydantic.BaseModel):
         GrammarValidation(
             x=[
                 {"on arm64,amd64": [{"on arm64": "foo"}, {"else": [35]}]},
-            ],  # type: ignore
+            ],
         )
     err = raised.value.errors()
     assert len(err) == 1
@@ -380,7 +380,7 @@ class GrammarValidation(pydantic.BaseModel):
 
         x: Grammar[str]
 
-    GrammarValidation(x=[{"on arch": "foo"}, "else fail"])  # type: ignore
+    GrammarValidation(x=[{"on arch": "foo"}, "else fail"])
 
 
 def test_grammar_strlist_elsefail():
@@ -389,7 +389,7 @@ class GrammarValidation(pydantic.BaseModel):
 
         x: Grammar[list[str]]
 
-    GrammarValidation(x=[{"on arch": ["foo"]}, "else fail"])  # type: ignore
+    GrammarValidation(x=[{"on arch": ["foo"]}, "else fail"])
 
 
 def test_grammar_try():
@@ -399,7 +399,7 @@ class GrammarValidation(pydantic.BaseModel):
         x: Grammar[str]
 
     with pytest.raises(pydantic.ValidationError) as raised:
-        GrammarValidation(x=[{"try": "foo"}])  # type: ignore
+        GrammarValidation(x=[{"try": "foo"}])
 
     err = raised.value.errors()
     assert len(err) == 1
@@ -409,7 +409,7 @@ class GrammarValidation(pydantic.BaseModel):
 
 
 @pytest.mark.parametrize(
-    "clause,err_msg",
+    ("clause", "err_msg"),
     [
         ("on", "value must be a str: [{'on': 'foo'}]"),
         ("on ,", "syntax error in 'on' selector"),
@@ -442,7 +442,7 @@ class GrammarValidation(pydantic.BaseModel):
         x: Grammar[str]
 
     with pytest.raises(pydantic.ValidationError) as raised:
-        GrammarValidation(x=[{clause: "foo"}])  # type: ignore
+        GrammarValidation(x=[{clause: "foo"}])
 
     err = raised.value.errors()
     assert len(err) == 1

tests/unit/test_on.py

@@ -146,7 +146,7 @@ def test_on_missing():
 
 @pytest.mark.parametrize("scenario", error_scenarios)
 def test_errors(scenario):
-    with pytest.raises(errors.OnStatementSyntaxError) as syntax_error:
+    with pytest.raises(errors.OnStatementSyntaxError) as syntax_error:  # noqa: PT012
         processor = GrammarProcessor(
             arch="amd64",
             target_arch="amd64",

tests/unit/test_processor.py

@@ -309,9 +309,11 @@ def test_basic_grammar(scenario):
 def test_grammar_with_transformer(scenario):
     # Transform all 'to' statements to include arch
     def transformer(call_stack, package_name, target_arch):
-        if any(isinstance(s, ToStatement) for s in call_stack):
-            if ":" not in package_name:
-                package_name = f"{package_name}:{target_arch}"
+        if (
+            any(isinstance(s, ToStatement) for s in call_stack)
+            and ":" not in package_name
+        ):
+            package_name = f"{package_name}:{target_arch}"
 
         return package_name
 

tests/unit/test_to.py

@@ -146,7 +146,7 @@ def test_on_missing():
 
 @pytest.mark.parametrize("scenario", error_scenarios)
 def test_errors(scenario):
-    with pytest.raises(errors.ToStatementSyntaxError) as syntax_error:
+    with pytest.raises(errors.ToStatementSyntaxError) as syntax_error:  # noqa: PT012
         processor = GrammarProcessor(
             arch="amd64",
             target_arch="amd64",