Run black on all files sans numpy_tests/

Author: honno

autogen/_binary_ufuncs.py

@@ -19,12 +19,12 @@ def get_signature(obj):
         return obj.__name__ + str(inspect.signature(obj))
     except Exception:
         # builtins don't have it, try the first line of the docstring
-        d = obj.__doc__.split('\n')
+        d = obj.__doc__.split("\n")
         if d[0]:
             return d[0].strip()
         else:
             # empty line, maybe the is lines 2-3 (np.vectorize)
-            return '\n'.join((d[1], d[2])).strip()
+            return "\n".join((d[1], d[2])).strip()
 
 
 def dump_signatures(keys, namespace=None, replace=None):
@@ -49,49 +49,47 @@ def dump_signatures(keys, namespace=None, replace=None):
 
 def dump_difference(namespace):
     import torch_np
+
     dct_wrapper = grab_namespace(torch_np)
-    wrapper_funcs =set([obj.__name__ for obj in dct_wrapper['function']])
+    wrapper_funcs = set([obj.__name__ for obj in dct_wrapper["function"]])
 
     dct_api = grab_namespace(namespace)
-    namespace_funcs = set(obj.__name__ for obj in dct_api['function'])
+    namespace_funcs = set(obj.__name__ for obj in dct_api["function"])
 
     missing_names = namespace_funcs.difference(wrapper_funcs)
 
     for name in sorted(missing_names):
-        print('- [ ]', name)
+        print("- [ ]", name)
 
     breakpoint()
 
     extras = wrapper_funcs.difference(namespace_funcs)
-    print('\n\n')
+    print("\n\n")
     for name in sorted(extras):
-        print('- [ ]', name)
+        print("- [ ]", name)
 
 
 if __name__ == "__main__":
 
-#    dct = grab_namespace(np)
-#    print(dct.keys())
-
-#    for obj in dct['function']:
-#        print( get_signature(obj) )
+    #    dct = grab_namespace(np)
+    #    print(dct.keys())
 
+    #    for obj in dct['function']:
+    #        print( get_signature(obj) )
 
-# dump array_api, full_signatures
-  #  from numpy import array_api
+    # dump array_api, full_signatures
+    #  from numpy import array_api
 
- #   keys = ["builtin_function_or_method", "function"]
- #   replace = {"<no value>": "NoValue"}
+    #   keys = ["builtin_function_or_method", "function"]
+    #   replace = {"<no value>": "NoValue"}
 
- #   print(dump_signatures(keys, namespace=array_api, replace=replace))
+    #   print(dump_signatures(keys, namespace=array_api, replace=replace))
 
-# dump the difference
+    # dump the difference
     from numpy import array_api
 
     dump_difference(array_api)
 
-   # keys = ["builtin_function_or_method", "function"]
-   # replace = {"<no value>": "NoValue"}
-   # print(dump_signatures(keys, namespace=array_api, replace=replace))
-
-
+# keys = ["builtin_function_or_method", "function"]
+# replace = {"<no value>": "NoValue"}
+# print(dump_signatures(keys, namespace=array_api, replace=replace))

autogen/_unary_ufuncs.py

@@ -13,14 +13,20 @@ class dtype:
     def __init__(self, name):
         self._name = name
 
-dt_names = ['float16', 'float32', 'float64',
-         'complex64', 'complex128',
-         'uint8',
-         'int8',
-         'int16',
-         'int32',
-         'int64',
-         'bool']
+
+dt_names = [
+    "float16",
+    "float32",
+    "float64",
+    "complex64",
+    "complex128",
+    "uint8",
+    "int8",
+    "int16",
+    "int32",
+    "int64",
+    "bool",
+]
 
 templ = """\
 {name} = dtype("{name}")
@@ -34,13 +40,12 @@ def __init__(self, name):
 print(src)
 
 
-
 ############### Output the casting dict ############3
 
-_casting_modes = ['no', 'equiv', 'safe', 'same_kind',  'unsafe']
+_casting_modes = ["no", "equiv", "safe", "same_kind", "unsafe"]
 
-# The structure is 
-#_can_cast_dict["safe"]["dtyp1"]["dtyp2"]
+# The structure is
+# _can_cast_dict["safe"]["dtyp1"]["dtyp2"]
 
 
 def generate_can_cast(casting):
@@ -49,8 +54,7 @@ def generate_can_cast(casting):
     for dtyp1 in dt_names:
         dct_dtyp1 = {}
         for dtyp2 in dt_names:
-            can_cast = np.can_cast(np.dtype(dtyp1), np.dtype(dtyp2),
-                                            casting=casting)
+            can_cast = np.can_cast(np.dtype(dtyp1), np.dtype(dtyp2), casting=casting)
             dct_dtyp1[dtyp2] = can_cast
         dct[dtyp1] = dct_dtyp1
     return dct
@@ -69,8 +73,8 @@ def generate_result_type():
 
 
 # pprint compact=True doesn't quite work :-)
-#import pprint
-#pprint.pprint(_can_cast_dict['no']['int32'], compact=True, width=100)
+# import pprint
+# pprint.pprint(_can_cast_dict['no']['int32'], compact=True, width=100)
 
 
 preamble = f"""
@@ -87,4 +91,3 @@ def generate_result_type():
 print("_can_cast_dict = ", _can_cast_dict)
 print("\n")
 print("_result_type_dict = ", generate_result_type())
-

autogen/array_api_dump.py

@@ -10,10 +10,12 @@
 
 _all.remove("ndarray")
 _all.remove("NoValue")
-#_all.remove("mapping")
+# _all.remove("mapping")
 
-pieces = ["     np.{np_name}: {wrapper_name}, ".format(np_name=name, wrapper_name=name)
-          for name in sorted(_all)]
+pieces = [
+    "     np.{np_name}: {wrapper_name}, ".format(np_name=name, wrapper_name=name)
+    for name in sorted(_all)
+]
 
 # XXX: apply additional manual surgery here, if neeeded.
 
@@ -22,4 +24,3 @@
     f.write("mapping = {\n")
     f.write("\n".join(pieces))
     f.write("\n}\n")
-

autogen/dump_namespace.py

@@ -8,33 +8,35 @@
 
 
 # SKIP these (need special handling)
-skip = {np.frexp, np.modf,    # non-standard unary ufunc signatures
-        np.isnat,
-        np.invert,      # bitwise NOT operator
-        np.spacing,     # niche, does not have a direct equivalent
+skip = {
+    np.frexp,
+    np.modf,  # non-standard unary ufunc signatures
+    np.isnat,
+    np.invert,  # bitwise NOT operator
+    np.spacing,  # niche, does not have a direct equivalent
 }
 
 # np functions where torch names differ
-torch_names = {np.radians : "deg2rad",
-               np.degrees : "rad2deg",
-               np.conjugate : "conj_physical",
-               np.fabs : "absolute",       # FIXME: np.fabs raises form complex
-               np.rint : "round"
+torch_names = {
+    np.radians: "deg2rad",
+    np.degrees: "rad2deg",
+    np.conjugate: "conj_physical",
+    np.fabs: "absolute",  # FIXME: np.fabs raises form complex
+    np.rint: "round",
 }
 
 
 # np functions which do not have a torch equivalent
 default_stanza = "torch.{torch_name}(x, out=out)"
 
-stanzas = {np.cbrt : "torch.pow(x, 1/3, out=out)",
-
-           # XXX what on earth is np.positive
-           np.positive: "+x",
-
-           # these three do not have an out arg
-           np.isinf: "torch.isinf(x)",
-           np.isnan: "torch.isnan(x)",
-           np.isfinite: "torch.isfinite(x)",
+stanzas = {
+    np.cbrt: "torch.pow(x, 1/3, out=out)",
+    # XXX what on earth is np.positive
+    np.positive: "+x",
+    # these three do not have an out arg
+    np.isinf: "torch.isinf(x)",
+    np.isnan: "torch.isnan(x)",
+    np.isfinite: "torch.isfinite(x)",
 }
 
 
@@ -57,13 +59,16 @@
 
 """
 
-test_header = header + """\
+test_header = (
+    header
+    + """\
 import numpy as np
 import torch
 
 from _unary_ufuncs import *
 from testing import assert_allclose
 """
+)
 
 
 template = """
@@ -100,7 +105,7 @@ def test_{np_name}():
 main_text = header
 test_text = test_header
 
-for ufunc in dct['ufunc']:
+for ufunc in dct["ufunc"]:
     if ufunc in skip:
         continue
 
@@ -115,11 +120,11 @@ def test_{np_name}():
         if torch_stanza is None:
             torch_stanza = default_stanza.format(torch_name=torch_name)
 
-        out_stanza= add_out_stanza if ufunc in needs_out else ""
+        out_stanza = add_out_stanza if ufunc in needs_out else ""
 
-        main_text += template.format(np_name=ufunc.__name__,
-                                     torch_stanza=torch_stanza,
-                                     out_stanza=out_stanza)
+        main_text += template.format(
+            np_name=ufunc.__name__, torch_stanza=torch_stanza, out_stanza=out_stanza
+        )
         test_text += test_template.format(np_name=ufunc.__name__)
 
         _all_list.append(ufunc.__name__)
@@ -137,14 +142,16 @@ def test_{np_name}():
 ###### BINARY UFUNCS ###################################
 
 
-
-test_header = header + """\
+test_header = (
+    header
+    + """\
 import numpy as np
 import torch
 
 from _binary_ufuncs import *
 from testing import assert_allclose
 """
+)
 
 
 template = """
@@ -174,43 +181,43 @@ def test_{np_name}():
 """
 
 
-
-skip = {np.divmod,    # two outputs
+skip = {
+    np.divmod,  # two outputs
 }
 
 
-torch_names = {np.power: "pow",
-               np.equal: "eq",
+torch_names = {
+    np.power: "pow",
+    np.equal: "eq",
 }
 
 
 _all_list = []
 main_text = header
 test_text = test_header
 
-for ufunc in dct['ufunc']:
+for ufunc in dct["ufunc"]:
 
     if ufunc in skip:
         continue
 
     if ufunc.nin == 2:
-   #     print(get_signature(ufunc))
+        #     print(get_signature(ufunc))
 
         torch_name = torch_names.get(ufunc)
         if torch_name is None:
             torch_name = ufunc.__name__
 
-
-        main_text += template.format(np_name=ufunc.__name__,
-                                     torch_name=torch_name,)
-#                                     out_stanza=out_stanza)
+        main_text += template.format(
+            np_name=ufunc.__name__,
+            torch_name=torch_name,
+        )
+        #                                     out_stanza=out_stanza)
         test_text += test_template.format(np_name=ufunc.__name__)
 
 
-
 with open("_binary_ufuncs.py", "w") as f:
     f.write(main_text)
 
 with open("test_binary_ufuncs.py", "w") as f:
     f.write(test_text)
-