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,31 +14,31 @@ 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',
+    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',
+    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',
+    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',
+    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',
+    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='*',
+    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 +79,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

@@ -8,7 +8,8 @@ class InvalidAllowlist(Exception):
 
 
 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,7 +37,7 @@ 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}')
+    CHECKSUM_REGEX = re.compile(r"[a-fA-F0-9]{32}")
     if any(not CHECKSUM_REGEX.match(checksum) for checksum in allowlist.keys()):
         raise InvalidAllowlist("All keys must be a valid md5 checksum")
 

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)
@@ -40,7 +40,8 @@ def __repr__(self):
 
 
 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
@@ -86,7 +87,8 @@ 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
@@ -95,7 +97,7 @@ class Change(ABC):
 
     criticality: Criticality = None
 
-    restricted: Optional[str] = None
+    restricted: str | None = None
     """Descriptive message only present when a change was restricted"""
 
     @property
@@ -132,14 +134,14 @@ def __str__(self) -> str:
     def to_dict(self) -> dict:
         """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:
@@ -148,4 +150,4 @@ def to_json(self) -> str:
 
     def checksum(self) -> str:
         """Get and identifier of a change. Used for allowlisting changes"""
-        return hashlib.md5(self.message.encode('utf-8')).hexdigest()
+        return hashlib.md5(self.message.encode("utf-8")).hexdigest()

schemadiff/changes/directive.py

@@ -20,7 +20,7 @@ def __init__(self, directive, directive_locations):
 
     @property
     def message(self):
-        locations = ' | '.join(loc.name for loc in self.directive_locations)
+        locations = " | ".join(loc.name for loc in self.directive_locations)
         return f"Directive `{self.directive}` was added to use on `{locations}`"
 
 

schemadiff/changes/enum.py

@@ -91,4 +91,4 @@ def message(self):
 
     @property
     def path(self):
-        return f"{self.enum.name}.{self.name}"
+        return f"{self.enum.name}.{self.name}"

schemadiff/changes/field.py

@@ -1,4 +1,4 @@
-from graphql import is_non_null_type, GraphQLField
+from graphql import GraphQLField, is_non_null_type
 
 from schemadiff.changes import Change, Criticality, is_safe_type_change
 
@@ -22,7 +22,7 @@ def message(self):
 
     @property
     def path(self):
-        return f'{self.type}.{self.field_name}'
+        return f"{self.type}.{self.field_name}"
 
 
 class FieldDeprecationReasonChanged(Change):
@@ -52,7 +52,7 @@ class FieldTypeChanged(Change):
     def __init__(self, type_, field_name, old_field, new_field):
         self.criticality = Criticality.safe()\
                            if is_safe_type_change(old_field.type, new_field.type)\
-                           else Criticality.breaking('Changing a field type will break queries that assume its type')
+                           else Criticality.breaking("Changing a field type will break queries that assume its type")
         self.type_ = type_
         self.field_name = field_name
         self.old_field = old_field
@@ -72,7 +72,7 @@ def path(self):
 
 class FieldArgumentAdded(Change):
     def __init__(self, parent, field_name: str, field: GraphQLField, argument_name, arg_type):
-        self.criticality = Criticality.safe('Adding an optional argument is a safe change')\
+        self.criticality = Criticality.safe("Adding an optional argument is a safe change")\
                            if not is_non_null_type(arg_type.type)\
                            else Criticality.breaking("Adding a required argument to an existing field is a breaking "
                                                    "change because it will break existing uses of this field")

schemadiff/changes/input.py

@@ -34,7 +34,7 @@ def path(self):
 class InputFieldRemoved(Change):
 
     criticality = Criticality.breaking(
-        'Removing an input field will break queries that use this input field.'
+        "Removing an input field will break queries that use this input field."
     )
 
     def __init__(self, input_object, value):
@@ -120,4 +120,4 @@ def message(self):
 
     @property
     def path(self):
-        return f"{self.input_.name}.{self.name}"
+        return f"{self.input_.name}.{self.name}"

schemadiff/changes/interface.py

@@ -116,7 +116,7 @@ def message(self):
 
 
 class InterfaceFieldDeprecationReasonChanged(AbstractInterfaceChange):
-    criticality = Criticality.breaking('Breaking change')  # TODO: Improve this logic to check if it was deprecated before
+    criticality = Criticality.breaking("Breaking change")  # TODO: Improve this logic to check if it was deprecated before
 
     @property
     def message(self):

schemadiff/changes/schema.py

@@ -2,7 +2,7 @@
 
 
 class SchemaChange(Change):
-    criticality = Criticality.breaking('Changing a root type is a breaking change')
+    criticality = Criticality.breaking("Changing a root type is a breaking change")
 
     def __init__(self, old_type, new_type):
         self.old_type = old_type