Force run pre-commit

codebasin/source.py

@@ -3,10 +3,9 @@
 
 import os
 from pathlib import Path
-from typing import Union
 
 
-def is_source_file(filename: Union[str, os.PathLike]) -> bool:
+def is_source_file(filename: str | os.PathLike) -> bool:
  """
  Parameters
  ----------

tests/comments/test_comments.py

@@ -1,10 +1,10 @@
 # Copyright (C) 2019 Intel Corporation
 # SPDX-License-Identifier: BSD-3-Clause
 
-import unittest
-import logging
 import os
-from codebasin import preprocessor, file_parser
+import unittest
+
+from codebasin import file_parser
 
 
 class TestExampleFortranFile(unittest.TestCase):
@@ -27,11 +27,13 @@ class TestExampleCFile(unittest.TestCase):
 
  def test_c_comments(self):
  rootdir = "./tests/comments/"
- parser = file_parser.FileParser(os.path.join(rootdir, "continuation.cpp"))
+ parser = file_parser.FileParser(
+ os.path.join(rootdir, "continuation.cpp"),
+ )
 
  tree = parser.parse_file()
  self.assertEqual(tree.root.total_sloc, 25)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
  unittest.main()

tests/compilers/test_compilers.py

@@ -1,10 +1,12 @@
 # Copyright (C) 2019-2024 Intel Corporation
 # SPDX-License-Identifier: BSD-3-Clause
 
-import unittest
 import logging
+import unittest
+
 from codebasin import config
 
+
 class TestCompilers(unittest.TestCase):
  """
  Test that a subset of common compilers and their arguments are recognized
@@ -16,41 +18,29 @@ def setUp(self):
 
  def test_clang(self):
  """compilers/clang"""
- args = [
- "clang",
- "-fsycl-is-device",
- "test.cpp"
- ]
+ args = ["clang", "-fsycl-is-device", "test.cpp"]
 
  compiler = config.recognize_compiler(args)
  self.assertTrue(type(compiler) is config.ClangCompiler)
 
  passes = compiler.get_passes()
- self.assertEqual(passes, set(["default"]))
+ self.assertEqual(passes, {"default"})
 
  self.assertTrue(compiler.has_implicit_behavior("default"))
  defines = compiler.get_defines("default")
  self.assertEqual(defines, ["__SYCL_DEVICE_ONLY__"])
 
  def test_intel_sycl(self):
  """compilers/intel_sycl"""
- args = [
- "icpx",
- "-fsycl",
- "test.cpp"
- ]
+ args = ["icpx", "-fsycl", "test.cpp"]
 
  compiler = config.recognize_compiler(args)
  self.assertTrue(type(compiler) is config.IntelCompiler)
 
  passes = compiler.get_passes()
- self.assertEqual(passes, set(["default", "spir64"]))
+ self.assertEqual(passes, {"default", "spir64"})
 
- expected = [
- "__SYCL_DEVICE_ONLY__",
- "__SPIR__",
- "__SPIRV__"
- ]
+ expected = ["__SYCL_DEVICE_ONLY__", "__SPIR__", "__SPIRV__"]
  self.assertTrue(compiler.has_implicit_behavior("spir64"))
  defines = compiler.get_defines("spir64")
  self.assertEqual(defines, expected)
@@ -62,24 +52,20 @@ def test_intel_targets(self):
  "-fsycl",
  "-fsycl-targets=spir64,x86_64",
  "-fopenmp",
- "test.cpp"
+ "test.cpp",
  ]
 
  compiler = config.recognize_compiler(args)
  self.assertTrue(type(compiler) is config.IntelCompiler)
 
  passes = compiler.get_passes()
- self.assertEqual(passes, set(["default", "spir64", "x86_64"]))
+ self.assertEqual(passes, {"default", "spir64", "x86_64"})
 
  self.assertTrue(compiler.has_implicit_behavior("default"))
  defines = compiler.get_defines("default")
  self.assertEqual(defines, ["_OPENMP"])
 
- expected = [
- "__SYCL_DEVICE_ONLY__",
- "__SPIR__",
- "__SPIRV__"
- ]
+ expected = ["__SYCL_DEVICE_ONLY__", "__SPIR__", "__SPIRV__"]
  self.assertTrue(compiler.has_implicit_behavior("spir64"))
  defines = compiler.get_defines("spir64")
  self.assertEqual(defines, expected)
@@ -93,19 +79,16 @@ def test_nvcc(self):
  "nvcc",
  "--gpu-architecture=compute_50",
  "--gpu-code=compute_50,sm_50,sm_52",
- "test.cpp"
+ "test.cpp",
  ]
 
  compiler = config.recognize_compiler(args)
  self.assertTrue(type(compiler) is config.NvccCompiler)
 
  passes = compiler.get_passes()
- self.assertEqual(passes, set(["default", "50", "52"]))
+ self.assertEqual(passes, {"default", "50", "52"})
 
- defaults = [
- "__NVCC__",
- "__CUDACC__"
- ]
+ defaults = ["__NVCC__", "__CUDACC__"]
  self.assertTrue(compiler.has_implicit_behavior("default"))
  defines = compiler.get_defines("default")
  self.assertEqual(defines, defaults)
@@ -118,5 +101,6 @@ def test_nvcc(self):
  defines = compiler.get_defines("52")
  self.assertEqual(defines, defaults + ["__CUDA_ARCH__=520"])
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
  unittest.main()

tests/failure/test_bignum.py

@@ -2,6 +2,7 @@
 # SPDX-License-Identifier: BSD-3-Clause
 
 import unittest
+
 from codebasin import preprocessor
 
 
@@ -13,13 +14,17 @@ class TestBigNum(unittest.TestCase):
  def test_oversized_constant(self):
  """oversized constant"""
  with self.assertRaises(OverflowError):
- tokens = preprocessor.Lexer("10000000000000000000000000000000000000").tokenize()
+ tokens = preprocessor.Lexer(
+ "10000000000000000000000000000000000000",
+ ).tokenize()
  preprocessor.ExpressionEvaluator(tokens).evaluate()
 
  def test_overflow(self):
  """integer overflow"""
  with self.assertRaises(OverflowError):
- tokens = preprocessor.Lexer("0xFFFFFFFFFFFFFFFF * 0xFFFFFFFFFFFFFFFF").tokenize()
+ tokens = preprocessor.Lexer(
+ "0xFFFFFFFFFFFFFFFF * 0xFFFFFFFFFFFFFFFF",
+ ).tokenize()
  preprocessor.ExpressionEvaluator(tokens).evaluate()
 
  def test_power(self):

tests/lexer/test_lexer.py

@@ -2,6 +2,7 @@
 # SPDX-License-Identifier: BSD-3-Clause
 
 import unittest
+
 from codebasin import preprocessor
 
 
@@ -18,28 +19,56 @@ def test_character(self):
 
  def test_numerical(self):
  """numbers"""
- numbers = ["123", "123ul", "123.4", "123.4e+05", ".123", "0xFF", "0b10"]
+ numbers = [
+ "123",
+ "123ul",
+ "123.4",
+ "123.4e+05",
+ ".123",
+ "0xFF",
+ "0b10",
+ ]
  for number in numbers:
  tokens = preprocessor.Lexer(number).tokenize()
  self.assertTrue(len(tokens) == 1)
- self.assertTrue(isinstance(tokens[0], preprocessor.NumericalConstant))
+ self.assertTrue(
+ isinstance(tokens[0], preprocessor.NumericalConstant),
+ )
 
  def test_string(self):
  """strings"""
- tokens = preprocessor.Lexer("\"this is a string constant\"").tokenize()
+ tokens = preprocessor.Lexer('"this is a string constant"').tokenize()
  self.assertTrue(len(tokens) == 1)
  self.assertTrue(isinstance(tokens[0], preprocessor.StringConstant))
 
  def test_identifier(self):
  """identifiers"""
  tokens = preprocessor.Lexer("this is a string of words").tokenize()
  self.assertTrue(len(tokens) == 6)
- self.assertTrue(all([isinstance(t, preprocessor.Identifier) for t in tokens]))
+ self.assertTrue(
+ all([isinstance(t, preprocessor.Identifier) for t in tokens]),
+ )
 
  def test_operator(self):
  """operators"""
- operators = ["||", "&&", ">>", "<<", "!=", ">=", "<=", "==", "##"] + \
- ["-", "+", "!", "*", "/", "|", "&", "^", "<", ">", "?", ":", "~", "#", "=", "%"]
+ operators = ["||", "&&", ">>", "<<", "!=", ">=", "<=", "==", "##"] + [
+ "-",
+ "+",
+ "!",
+ "*",
+ "/",
+ "|",
+ "&",
+ "^",
+ "<",
+ ">",
+ "?",
+ ":",
+ "~",
+ "#",
+ "=",
+ "%",
+ ]
  for op in operators:
  tokens = preprocessor.Lexer(op).tokenize()
  self.assertTrue(len(tokens) == 1)
@@ -48,7 +77,20 @@ def test_operator(self):
 
  def test_puncuator(self):
  """punctuators"""
- punctuators = ["(", ")", "{", "}", "[", "]", ",", ".", ";", "'", "\"", "\\"]
+ punctuators = [
+ "(",
+ ")",
+ "{",
+ "}",
+ "[",
+ "]",
+ ",",
+ ".",
+ ";",
+ "'",
+ '"',
+ "\\",
+ ]
  for punc in punctuators:
  tokens = preprocessor.Lexer(punc).tokenize()
  self.assertTrue(len(tokens) == 1)
@@ -70,7 +112,9 @@ def test_expression(self):
  self.assertTrue(isinstance(tokens[8], preprocessor.Operator))
  self.assertTrue(isinstance(tokens[9], preprocessor.CharacterConstant))
 
- tokens = preprocessor.Lexer("a > b ? \"true_string\" : \"false_string\"").tokenize()
+ tokens = preprocessor.Lexer(
+ 'a > b ? "true_string" : "false_string"',
+ ).tokenize()
  self.assertTrue(len(tokens) == 7)
  self.assertTrue(isinstance(tokens[0], preprocessor.Identifier))
  self.assertTrue(isinstance(tokens[1], preprocessor.Operator))
@@ -81,5 +125,5 @@ def test_expression(self):
  self.assertTrue(isinstance(tokens[6], preprocessor.StringConstant))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
  unittest.main()

tests/parsers/test_directive_parser.py

@@ -2,6 +2,7 @@
 # SPDX-License-Identifier: BSD-3-Clause
 
 import unittest
+
 from codebasin import preprocessor
 
 
@@ -68,13 +69,17 @@ def test_undef(self):
 
  def test_include(self):
  """include"""
- tokens = preprocessor.Lexer("#include <path/to/system/header>").tokenize()
+ tokens = preprocessor.Lexer(
+ "#include <path/to/system/header>",
+ ).tokenize()
  node = preprocessor.DirectiveParser(tokens).parse()
  self.assertTrue(isinstance(node, preprocessor.IncludeNode))
  self.assertTrue(isinstance(node.value, preprocessor.IncludePath))
  self.assertTrue(node.value.system)
 
- tokens = preprocessor.Lexer("#include \"path/to/local/header\"").tokenize()
+ tokens = preprocessor.Lexer(
+ '#include "path/to/local/header"',
+ ).tokenize()
  node = preprocessor.DirectiveParser(tokens).parse()
  self.assertTrue(isinstance(node, preprocessor.IncludeNode))
  self.assertTrue(isinstance(node.value, preprocessor.IncludePath))
@@ -143,8 +148,10 @@ def test_unsupported(self):
  for directive in ["#line", "#warning", "#error"]:
  tokens = preprocessor.Lexer(directive).tokenize()
  node = preprocessor.DirectiveParser(tokens).parse()
- self.assertTrue(isinstance(node, preprocessor.UnrecognizedDirectiveNode))
+ self.assertTrue(
+ isinstance(node, preprocessor.UnrecognizedDirectiveNode),
+ )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
  unittest.main()

tests/safe_write/test_safe_write.py

@@ -1,10 +1,10 @@
 # Copyright (C) 2019 Intel Corporation
 # SPDX-License-Identifier: BSD-3-Clause
 
-import unittest
-import tempfile
-import shutil
 import os
+import shutil
+import tempfile
+import unittest
 
 from codebasin import util
 
@@ -76,5 +76,5 @@ def test_create(self):
  self.assertEqual(st.st_mode & 0o111, 0)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
  unittest.main()

tests/valid_path/test_valid_path.py

@@ -29,5 +29,5 @@ def test_line_feed(self):
  self.assertFalse(util.valid_path("/invalid/\n/path/"))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
  unittest.main()