Codegen: fix autopep8 pre-commit hook

Author: redsun82

.pre-commit-config.yaml

@@ -19,7 +19,7 @@ repos:
     rev: v1.6.0
     hooks:
       - id: autopep8
-        files: ^swift/.*\.py
+        files: ^misc/codegen/.*\.py
 
   - repo: local
     hooks:

misc/codegen/lib/schemadefs.py

@@ -94,6 +94,7 @@ def modify(self, prop: _schema.Property):
             raise _schema.Error(
                 "list should only be applied to simple or optional property types")
 
+
 class _Setifier(_schema.PropertyModifier):
     def modify(self, prop: _schema.Property):
         K = _schema.Property.Kind

misc/codegen/test/test_cppgen.py

@@ -41,8 +41,8 @@ def test_empty_class(generate):
     assert generate([
         schema.Class(name="MyClass"),
     ]) == [
-               cpp.Class(name="MyClass", final=True, trap_name="MyClasses")
-           ]
+        cpp.Class(name="MyClass", final=True, trap_name="MyClasses")
+    ]
 
 
 def test_two_class_hierarchy(generate):
@@ -51,9 +51,9 @@ def test_two_class_hierarchy(generate):
         schema.Class(name="A", derived={"B"}),
         schema.Class(name="B", bases=["A"]),
     ]) == [
-               base,
-               cpp.Class(name="B", bases=[base], final=True, trap_name="Bs"),
-           ]
+        base,
+        cpp.Class(name="B", bases=[base], final=True, trap_name="Bs"),
+    ]
 
 
 @pytest.mark.parametrize("type,expected", [
@@ -73,12 +73,12 @@ def test_class_with_field(generate, type, expected, property_cls, optional, repe
     assert generate([
         schema.Class(name="MyClass", properties=[property_cls("prop", type)]),
     ]) == [
-               cpp.Class(name="MyClass",
-                         fields=[cpp.Field("prop", expected, is_optional=optional,
-                                           is_repeated=repeated, is_unordered=unordered, trap_name=trap_name)],
-                         trap_name="MyClasses",
-                         final=True)
-           ]
+        cpp.Class(name="MyClass",
+                  fields=[cpp.Field("prop", expected, is_optional=optional,
+                                    is_repeated=repeated, is_unordered=unordered, trap_name=trap_name)],
+                  trap_name="MyClasses",
+                  final=True)
+    ]
 
 
 def test_class_field_with_null(generate, input):
@@ -91,26 +91,26 @@ def test_class_field_with_null(generate, input):
             schema.SingleProperty("y", "B"),
         ])
     ]) == [
-               a,
-               cpp.Class(name="B", bases=[a], final=True, trap_name="Bs",
-                         fields=[
-                             cpp.Field("x", "TrapLabel<ATag>"),
-                             cpp.Field("y", "TrapLabel<BOrNoneTag>"),
-                         ]),
-           ]
+        a,
+        cpp.Class(name="B", bases=[a], final=True, trap_name="Bs",
+                  fields=[
+            cpp.Field("x", "TrapLabel<ATag>"),
+            cpp.Field("y", "TrapLabel<BOrNoneTag>"),
+        ]),
+    ]
 
 
 def test_class_with_predicate(generate):
     assert generate([
         schema.Class(name="MyClass", properties=[
             schema.PredicateProperty("prop")]),
     ]) == [
-               cpp.Class(name="MyClass",
-                         fields=[
-                             cpp.Field("prop", "bool", trap_name="MyClassProp", is_predicate=True)],
-                         trap_name="MyClasses",
-                         final=True)
-           ]
+        cpp.Class(name="MyClass",
+                  fields=[
+                      cpp.Field("prop", "bool", trap_name="MyClassProp", is_predicate=True)],
+                  trap_name="MyClasses",
+                  final=True)
+    ]
 
 
 @pytest.mark.parametrize("name",
@@ -120,23 +120,23 @@ def test_class_with_overridden_unsigned_field(generate, name):
         schema.Class(name="MyClass", properties=[
             schema.SingleProperty(name, "bar")]),
     ]) == [
-               cpp.Class(name="MyClass",
-                         fields=[cpp.Field(name, "unsigned")],
-                         trap_name="MyClasses",
-                         final=True)
-           ]
+        cpp.Class(name="MyClass",
+                  fields=[cpp.Field(name, "unsigned")],
+                  trap_name="MyClasses",
+                  final=True)
+    ]
 
 
 def test_class_with_overridden_underscore_field(generate):
     assert generate([
         schema.Class(name="MyClass", properties=[
             schema.SingleProperty("something_", "bar")]),
     ]) == [
-               cpp.Class(name="MyClass",
-                         fields=[cpp.Field("something", "bar")],
-                         trap_name="MyClasses",
-                         final=True)
-           ]
+        cpp.Class(name="MyClass",
+                  fields=[cpp.Field("something", "bar")],
+                  trap_name="MyClasses",
+                  final=True)
+    ]
 
 
 @pytest.mark.parametrize("name", cpp.cpp_keywords)
@@ -145,11 +145,11 @@ def test_class_with_keyword_field(generate, name):
         schema.Class(name="MyClass", properties=[
             schema.SingleProperty(name, "bar")]),
     ]) == [
-               cpp.Class(name="MyClass",
-                         fields=[cpp.Field(name + "_", "bar")],
-                         trap_name="MyClasses",
-                         final=True)
-           ]
+        cpp.Class(name="MyClass",
+                  fields=[cpp.Field(name + "_", "bar")],
+                  trap_name="MyClasses",
+                  final=True)
+    ]
 
 
 def test_classes_with_dirs(generate_grouped):
@@ -161,11 +161,11 @@ def test_classes_with_dirs(generate_grouped):
         schema.Class(name="C", bases=["CBase"], group="bar"),
         schema.Class(name="D", group="foo/bar/baz"),
     ]) == {
-               ".": [cpp.Class(name="A", trap_name="As", final=True)],
-               "foo": [cpp.Class(name="B", trap_name="Bs", final=True)],
-               "bar": [cbase, cpp.Class(name="C", bases=[cbase], trap_name="Cs", final=True)],
-               "foo/bar/baz": [cpp.Class(name="D", trap_name="Ds", final=True)],
-           }
+        ".": [cpp.Class(name="A", trap_name="As", final=True)],
+        "foo": [cpp.Class(name="B", trap_name="Bs", final=True)],
+        "bar": [cbase, cpp.Class(name="C", bases=[cbase], trap_name="Cs", final=True)],
+        "foo/bar/baz": [cpp.Class(name="D", trap_name="Ds", final=True)],
+    }
 
 
 def test_cpp_skip_pragma(generate):
@@ -175,10 +175,10 @@ def test_cpp_skip_pragma(generate):
             schema.SingleProperty("y", "bar", pragmas=["x", "cpp_skip", "y"]),
         ])
     ]) == [
-               cpp.Class(name="A", final=True, trap_name="As", fields=[
-                   cpp.Field("x", "foo"),
-               ]),
-           ]
+        cpp.Class(name="A", final=True, trap_name="As", fields=[
+            cpp.Field("x", "foo"),
+        ]),
+    ]
 
 
 def test_ipa_classes_ignored(generate):
@@ -199,8 +199,8 @@ def test_ipa_classes_ignored(generate):
             name="Z",
         ),
     ]) == [
-               cpp.Class(name="Z", final=True, trap_name="Zs"),
-           ]
+        cpp.Class(name="Z", final=True, trap_name="Zs"),
+    ]
 
 
 if __name__ == '__main__':

misc/codegen/test/test_ql.py

@@ -36,6 +36,7 @@ def test_property_is_a_class(type, expected):
     ("Whatever", "getAWhatever"),
 ]
 
+
 @pytest.mark.parametrize("name,expected_getter", indefinite_getters)
 def test_property_indefinite_article(name, expected_getter):
     prop = ql.Property(name, plural="X")
@@ -47,6 +48,7 @@ def test_property_unordered_getter(name, expected_getter):
     prop = ql.Property(name, plural="X", is_unordered=True)
     assert prop.getter == expected_getter
 
+
 @pytest.mark.parametrize("plural,expected", [
     (None, False),
     ("", False),
@@ -56,6 +58,7 @@ def test_property_is_repeated(plural, expected):
     prop = ql.Property("foo", "Foo", "props", ["result"], plural=plural)
     assert prop.is_repeated is expected
 
+
 @pytest.mark.parametrize("plural,unordered,expected", [
     (None, False, False),
     ("", False, False),

misc/codegen/test/test_qlgen.py

@@ -337,21 +337,22 @@ def test_repeated_property(generate_classes, is_child, prev_child):
                                     ])),
     }
 
+
 def test_repeated_unordered_property(generate_classes):
     assert generate_classes([
         schema.Class("FakeRoot"),
         schema.Class("MyObject", properties=[
             schema.RepeatedUnorderedProperty("foo", "bar")]),
     ]) == {
-               "FakeRoot.qll": (a_ql_stub(name="FakeRoot", base_import=gen_import_prefix + "FakeRoot"),
-                                a_ql_class(name="FakeRoot", final=True)),
-               "MyObject.qll": (a_ql_stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
-                                a_ql_class(name="MyObject", final=True, properties=[
+        "FakeRoot.qll": (a_ql_stub(name="FakeRoot", base_import=gen_import_prefix + "FakeRoot"),
+                         a_ql_class(name="FakeRoot", final=True)),
+        "MyObject.qll": (a_ql_stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
+                         a_ql_class(name="MyObject", final=True, properties=[
                                     ql.Property(singular="Foo", plural="Foos", type="bar", tablename="my_object_foos",
                                                 tableparams=["this", "result"], is_unordered=True,
                                                 doc="foo of this my object", doc_plural="foos of this my object"),
-                                ])),
-           }
+                                    ])),
+    }
 
 
 @pytest.mark.parametrize("is_child,prev_child", [(False, None), (True, "")])
@@ -588,8 +589,8 @@ def test_test_partial_properties(opts, generate_tests):
                                                                         is_indexed=True,
                                                                         type="int")),
         "B/B_getAW.ql": a_ql_property_tester(class_name="B",
-                                            property=ql.PropertyForTest(getter="getAW", is_total=False,
-                                                                        type="string")),
+                                             property=ql.PropertyForTest(getter="getAW", is_total=False,
+                                                                         type="string")),
     }