First ruff fix

Author: Mattia Baldari

schemadiff/__init__.py

@@ -1,44 +1,48 @@
-from typing import Union, List
+from typing import List, Union
 
-from graphql import GraphQLSchema as GQLSchema, is_schema
+from graphql import GraphQLSchema as GQLSchema
+from graphql import is_schema
 
 from schemadiff.changes import Change
 from schemadiff.diff.schema import Schema
+from schemadiff.formatting import format_diff, print_diff
 from schemadiff.schema_loader import SchemaLoader
-from schemadiff.formatting import print_diff, format_diff
 from schemadiff.validation import validate_changes
 
-
 SDL = str  # Alias for string describing schema through schema definition language
 
 
-def diff(old_schema: Union[SDL, GQLSchema], new_schema: Union[SDL, GQLSchema]) -> List[Change]:
-    """Compare two graphql schemas highlighting dangerous and breaking changes.
+def diff(old_schema: SDL | GQLSchema, new_schema: SDL | GQLSchema) -> list[Change]:
+    """
+    Compare two graphql schemas highlighting dangerous and breaking changes.
 
     Returns:
         changes (List[Change]): List of differences between both schemas with details about each change
+
     """
     first = SchemaLoader.from_sdl(old_schema) if not is_schema(old_schema) else old_schema
     second = SchemaLoader.from_sdl(new_schema) if not is_schema(new_schema) else new_schema
     return Schema(first, second).diff()
 
 
 def diff_from_file(schema_file: str, other_schema_file: str):
-    """Compare two graphql schema files highlighting dangerous and breaking changes.
+    """
+    Compare two graphql schema files highlighting dangerous and breaking changes.
 
     Returns:
         changes (List[Change]): List of differences between both schemas with details about each change
+
     """
     first = SchemaLoader.from_file(schema_file)
     second = SchemaLoader.from_file(other_schema_file)
     return Schema(first, second).diff()
 
 
 __all__ = [
-    'diff',
-    'diff_from_file',
-    'format_diff',
-    'print_diff',
-    'validate_changes',
-    'Change',
+    "Change",
+    "diff",
+    "diff_from_file",
+    "format_diff",
+    "print_diff",
+    "validate_changes",
 ]

schemadiff/__main__.py

@@ -1,10 +1,10 @@
-import sys
 import argparse
+import sys
 
 from schemadiff.allow_list import read_allowed_changes
 from schemadiff.diff.schema import Schema
-from schemadiff.schema_loader import SchemaLoader
 from schemadiff.formatting import print_diff, print_json
+from schemadiff.schema_loader import SchemaLoader
 from schemadiff.validation import rules_list, validate_changes
 
 
@@ -14,32 +14,55 @@ def cli():
 
 
 def parse_args(arguments):
-    parser = argparse.ArgumentParser(description='Schema comparator')
-    parser.add_argument('-o', '--old-schema',
-                        dest='old_schema',
-                        type=argparse.FileType('r', encoding='UTF-8'),
-                        help='Path to old graphql schema file',
-                        required=True)
-    parser.add_argument('-n', '--new-schema',
-                        dest='new_schema',
-                        type=argparse.FileType('r', encoding='UTF-8'),
-                        help='Path to new graphql schema file',
-                        required=True)
-    parser.add_argument('-j', '--as-json',
-                        action='store_true',
-                        help='Output a detailed summary of changes in json format',
-                        required=False)
-    parser.add_argument('-a', '--allow-list',
-                        type=argparse.FileType('r', encoding='UTF-8'),
-                        help='Path to the allowed list of changes')
-    parser.add_argument('-t', '--tolerant',
-                        action='store_true',
-                        help="Tolerant mode. Error out only if there's a breaking change but allow dangerous changes")
-    parser.add_argument('-s', '--strict',
-                        action='store_true',
-                        help="Strict mode. Error out on dangerous and breaking changes.")
-    parser.add_argument('-r', '--validation-rules', choices=rules_list(), nargs='*',
-                        help="Evaluate rules mode. Error out on changes that fail some validation rule.")
+    parser = argparse.ArgumentParser(description="Schema comparator")
+    parser.add_argument(
+        "-o",
+        "--old-schema",
+        dest="old_schema",
+        type=argparse.FileType("r", encoding="UTF-8"),
+        help="Path to old graphql schema file",
+        required=True,
+    )
+    parser.add_argument(
+        "-n",
+        "--new-schema",
+        dest="new_schema",
+        type=argparse.FileType("r", encoding="UTF-8"),
+        help="Path to new graphql schema file",
+        required=True,
+    )
+    parser.add_argument(
+        "-j",
+        "--as-json",
+        action="store_true",
+        help="Output a detailed summary of changes in json format",
+        required=False,
+    )
+    parser.add_argument(
+        "-a",
+        "--allow-list",
+        type=argparse.FileType("r", encoding="UTF-8"),
+        help="Path to the allowed list of changes",
+    )
+    parser.add_argument(
+        "-t",
+        "--tolerant",
+        action="store_true",
+        help="Tolerant mode. Error out only if there's a breaking change but allow dangerous changes",
+    )
+    parser.add_argument(
+        "-s",
+        "--strict",
+        action="store_true",
+        help="Strict mode. Error out on dangerous and breaking changes.",
+    )
+    parser.add_argument(
+        "-r",
+        "--validation-rules",
+        choices=rules_list(),
+        nargs="*",
+        help="Evaluate rules mode. Error out on changes that fail some validation rule.",
+    )
 
     return parser.parse_args(arguments)
 
@@ -79,5 +102,5 @@ def exit_code(changes, strict, some_change_is_restricted, tolerant) -> int:
     return exit_code
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     sys.exit(cli())

schemadiff/allow_list.py

@@ -4,11 +4,12 @@
 
 
 class InvalidAllowlist(Exception):
-    """Exception raised when the user provides an invalid json file of allowed changes"""
+    """Exception raised when the user provides an invalid json file of allowed changes."""
 
 
 def read_allowed_changes(file_content):
-    """Read a json file that defines a mapping of changes checksums to the reasons of why it is allowed.
+    """
+    Read a json file that defines a mapping of changes checksums to the reasons of why it is allowed.
 
     Compliant formats:
         {
@@ -36,8 +37,8 @@ def read_allowed_changes(file_content):
     if not isinstance(allowlist, dict):
         raise InvalidAllowlist("Allowlist must be a mapping.")
 
-    CHECKSUM_REGEX = re.compile(r'[a-fA-F0-9]{32}')
-    if any(not CHECKSUM_REGEX.match(checksum) for checksum in allowlist.keys()):
+    CHECKSUM_REGEX = re.compile(r"[a-fA-F0-9]{32}")
+    if any(not CHECKSUM_REGEX.match(checksum) for checksum in allowlist):
         raise InvalidAllowlist("All keys must be a valid md5 checksum")
 
     return allowlist

schemadiff/changes/__init__.py

@@ -1,17 +1,17 @@
 import hashlib
 import json
-from abc import abstractmethod, ABC
+from abc import ABC, abstractmethod
 from enum import Enum
 from typing import Optional
 
 from attr import dataclass
-from graphql import is_wrapping_type, is_non_null_type, is_list_type
+from graphql import is_list_type, is_non_null_type, is_wrapping_type
 
 
 class CriticalityLevel(Enum):
-    NonBreaking = 'NON_BREAKING'
-    Dangerous = 'DANGEROUS'
-    Breaking = 'BREAKING'
+    NonBreaking = "NON_BREAKING"
+    Dangerous = "DANGEROUS"
+    Breaking = "BREAKING"
 
 
 @dataclass(repr=False)
@@ -21,26 +21,27 @@ class Criticality:
 
     @classmethod
     def breaking(cls, reason):
-        """Helper constructor of a breaking change"""
+        """Helper constructor of a breaking change."""
         return cls(level=CriticalityLevel.Breaking, reason=reason)
 
     @classmethod
     def dangerous(cls, reason):
-        """Helper constructor of a dangerous change"""
+        """Helper constructor of a dangerous change."""
         return cls(level=CriticalityLevel.Dangerous, reason=reason)
 
     @classmethod
     def safe(cls, reason="This change won't break any preexisting query"):
-        """Helper constructor of a safe change"""
+        """Helper constructor of a safe change."""
         return cls(level=CriticalityLevel.NonBreaking, reason=reason)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         # Replace repr because of attrs bug https://github.com/python-attrs/attrs/issues/95
         return f"Criticality(level={self.level}, reason={self.reason})"
 
 
 def is_safe_type_change(old_type, new_type) -> bool:
-    """Depending on the old an new type, a field type change may be breaking, dangerous or safe
+    """
+    Depending on the old an new type, a field type change may be breaking, dangerous or safe.
 
     * If both fields are 'leafs' in the sense they don't wrap an inner type, just compare their type.
     * If the new type has a non-null constraint, check that it was already non-null and compare against the contained
@@ -59,14 +60,8 @@ def is_safe_type_change(old_type, new_type) -> bool:
         # If both types are lists, compare their inner type.
         # If the new type has a non-null constraint, compare with its inner type (may be a list or not)
         return (
-            (
-                    is_list_type(new_type) and is_safe_type_change(old_type.of_type, new_type.of_type)
-            )
-            or
-            (
-                    is_non_null_type(new_type) and is_safe_type_change(old_type, new_type.of_type)
-            )
-        )
+            is_list_type(new_type) and is_safe_type_change(old_type.of_type, new_type.of_type)
+        ) or (is_non_null_type(new_type) and is_safe_type_change(old_type, new_type.of_type))
 
     return False
 
@@ -86,16 +81,17 @@ def is_safe_change_for_input_value(old_type, new_type):
 
 
 class Change(ABC):
-    """Common interface of all schema changes
-    
+    """
+    Common interface of all schema changes.
+
     This class offers the common operations and properties of all
     schema changes. You may use it as a type hint to get better
     suggestions in your editor of choice.
     """
 
     criticality: Criticality = None
 
-    restricted: Optional[str] = None
+    restricted: str | None = None
     """Descriptive message only present when a change was restricted"""
 
     @property
@@ -116,12 +112,12 @@ def safe(self) -> bool:
     @property
     @abstractmethod
     def message(self) -> str:
-        """Formatted change message"""
+        """Formatted change message."""
 
     @property
     @abstractmethod
     def path(self) -> str:
-        """Path to the affected schema member"""
+        """Path to the affected schema member."""
 
     def __repr__(self) -> str:
         return f"Change(criticality={self.criticality!r}, message={self.message!r}, path={self.path!r})"
@@ -130,22 +126,22 @@ def __str__(self) -> str:
         return self.message
 
     def to_dict(self) -> dict:
-        """Get detailed representation of a change"""
+        """Get detailed representation of a change."""
         return {
-            'message': self.message,
-            'path': self.path,
-            'is_safe_change': self.safe,
-            'criticality': {
-                'level': self.criticality.level.value,
-                'reason': self.criticality.reason
+            "message": self.message,
+            "path": self.path,
+            "is_safe_change": self.safe,
+            "criticality": {
+                "level": self.criticality.level.value,
+                "reason": self.criticality.reason,
             },
-            'checksum': self.checksum(),
+            "checksum": self.checksum(),
         }
 
     def to_json(self) -> str:
-        """Get detailed representation of a change as a json string"""
+        """Get detailed representation of a change as a json string."""
         return json.dumps(self.to_dict())
 
     def checksum(self) -> str:
-        """Get and identifier of a change. Used for allowlisting changes"""
-        return hashlib.md5(self.message.encode('utf-8')).hexdigest()
+        """Get and identifier of a change. Used for allowlisting changes."""
+        return hashlib.md5(self.message.encode("utf-8")).hexdigest()

schemadiff/changes/argument.py

@@ -2,24 +2,23 @@
 
 
 class FieldAbstractArgumentChange(Change):
-    def __init__(self, parent_type, field, arg_name, old_arg, new_arg):
+    def __init__(self, parent_type, field, arg_name, old_arg, new_arg) -> None:
         self.parent = parent_type
         self.field_name = field
         self.arg_name = arg_name
         self.old_arg = old_arg
         self.new_arg = new_arg
 
     @property
-    def path(self):
+    def path(self) -> str:
         return f"{self.parent.name}.{self.field_name}"
 
 
 class FieldArgumentDescriptionChanged(FieldAbstractArgumentChange):
-
     criticality = Criticality.safe()
 
     @property
-    def message(self):
+    def message(self) -> str:
         return (
             f"Description for argument `{self.arg_name}` on field `{self.parent}.{self.field_name}` "
             f"changed from `{self.old_arg.description}` to `{self.new_arg.description}`"
@@ -33,27 +32,26 @@ class FieldArgumentDefaultValueChanged(FieldAbstractArgumentChange):
     )
 
     @property
-    def message(self):
+    def message(self) -> str:
         return (
             f"Default value for argument `{self.arg_name}` on field `{self.parent}.{self.field_name}` "
             f"changed from `{self.old_arg.default_value!r}` to `{self.new_arg.default_value!r}`"
         )
 
 
 class FieldArgumentTypeChanged(FieldAbstractArgumentChange):
-
-    def __init__(self, parent_type, field, arg_name, old_arg, new_arg):
+    def __init__(self, parent_type, field, arg_name, old_arg, new_arg) -> None:
         super().__init__(parent_type, field, arg_name, old_arg, new_arg)
         self.criticality = (
-                Criticality.safe()
-                if is_safe_change_for_input_value(old_arg.type, new_arg.type)
-                else Criticality.breaking(
-                    "Changing the type of a field's argument can break existing queries that use this argument."
-                )
+            Criticality.safe()
+            if is_safe_change_for_input_value(old_arg.type, new_arg.type)
+            else Criticality.breaking(
+                "Changing the type of a field's argument can break existing queries that use this argument."
+            )
         )
 
     @property
-    def message(self):
+    def message(self) -> str:
         return (
             f"Type for argument `{self.arg_name}` on field `{self.parent}.{self.field_name}` "
             f"changed from `{self.old_arg.type}` to `{self.new_arg.type}`"