chore: Add encoding="utf8" everywhere

Author: pawamoy

src/griffe/_internal/cli.py

@@ -59,7 +59,7 @@ def __call__(self, *args: Any, **kwargs: Any) -> None:  # noqa: ARG002
 
 def _print_data(data: str, output_file: str | IO | None) -> None:
     if isinstance(output_file, str):
-        with open(output_file, "w") as fd:  # noqa: PTH123
+        with open(output_file, "w", encoding="utf8") as fd:  # noqa: PTH123
             print(data, file=fd)
     else:
         if output_file is None:

src/griffe/_internal/finder.py

@@ -485,7 +485,7 @@ def _handle_editable_module(path: Path) -> list[_SP]:
         # Support for how 'setuptools' writes these files:
         # example line: `MAPPING = {'griffe': '/media/data/dev/griffe/src/griffe', 'briffe': '/media/data/dev/griffe/src/briffe'}`.
         # with annotation: `MAPPING: dict[str, str] = {...}`.
-        parsed_module = ast.parse(path.read_text())
+        parsed_module = ast.parse(path.read_text(encoding="utf8"))
         for node in parsed_module.body:
             if isinstance(node, ast.Assign):
                 target = node.targets[0]
@@ -499,7 +499,7 @@ def _handle_editable_module(path: Path) -> list[_SP]:
         # Support for how 'meson-python' writes these files:
         # example line: `install({'package', 'module1'}, '/media/data/dev/griffe/build/cp311', ["path"], False)`.
         # Compiled modules then found in the cp311 folder, under src/package.
-        parsed_module = ast.parse(path.read_text())
+        parsed_module = ast.parse(path.read_text(encoding="utf8"))
         for node in parsed_module.body:
             if (
                 isinstance(node, ast.Expr)

src/griffe/_internal/git.py

@@ -34,7 +34,14 @@ def _normalize(value: str) -> str:
 
 
 def _git(*args: str, check: bool = True) -> str:
-    process = subprocess.run(["git", *args], check=False, text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+    process = subprocess.run(
+        ["git", *args],
+        check=False,
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        encoding="utf8",
+    )
     if check and process.returncode != 0:
         raise GitError(process.stdout.strip())
     return process.stdout.strip()

src/griffe/_internal/tests.py

@@ -64,7 +64,7 @@ def temporary_pyfile(code: str, *, module_name: str = "module") -> Iterator[tupl
     """
     with tempfile.TemporaryDirectory(prefix=_TMPDIR_PREFIX) as tmpdir:
         tmpfile = Path(tmpdir) / f"{module_name}.py"
-        tmpfile.write_text(dedent(code))
+        tmpfile.write_text(dedent(code), encoding="utf8")
         yield module_name, tmpfile
 
 
@@ -108,7 +108,7 @@ def temporary_pypackage(
             current_path = package_path
             for part in Path(module_name).parts:
                 if part.endswith((".py", ".pyi")):
-                    current_path.joinpath(part).write_text(dedent(module_contents))
+                    current_path.joinpath(part).write_text(dedent(module_contents), encoding="utf8")
                 else:
                     current_path /= part
                     current_path.mkdir(**mkdir_kwargs)

tests/test_encoders.py

@@ -165,7 +165,7 @@ def test_json_schema() -> None:
     module = loader.load("griffe")
     loader.resolve_aliases()
     data = json.loads(module.as_json(full=True))
-    with open("docs/schema.json") as f:  # noqa: PTH123
+    with open("docs/schema.json", encoding="utf8") as f:  # noqa: PTH123
         schema = json.load(f)
     validate(data, schema)
 
@@ -186,7 +186,7 @@ def func[**P, T, *R](arg: T, *args: P.args, **kwargs: P.kwargs) -> tuple[*R]: pa
         """,
     ) as module:
         data = json.loads(module.as_json(full=True))
-        with open("docs/schema.json") as f:  # noqa: PTH123
+        with open("docs/schema.json", encoding="utf8") as f:  # noqa: PTH123
             schema = json.load(f)
         validate(data, schema)
 
@@ -206,6 +206,6 @@ def func[**P, T, *R](arg: T, *args: P.args, **kwargs: P.kwargs) -> tuple[*R]: pa
         """,
     ) as module:
         data = json.loads(module.as_json(full=True))
-        with open("docs/schema.json") as f:  # noqa: PTH123
+        with open("docs/schema.json", encoding="utf8") as f:  # noqa: PTH123
             schema = json.load(f)
         validate(data, schema)

tests/test_finder.py

@@ -64,8 +64,8 @@ def test_find_pkg_style_namespace_packages(statement: str) -> None:
         temporary_pypackage("namespace/package1") as tmp_package1,
         temporary_pypackage("namespace/package2") as tmp_package2,
     ):
-        tmp_package1.path.parent.joinpath("__init__.py").write_text(statement)
-        tmp_package2.path.parent.joinpath("__init__.py").write_text(statement)
+        tmp_package1.path.parent.joinpath("__init__.py").write_text(statement, encoding="utf8")
+        tmp_package2.path.parent.joinpath("__init__.py").write_text(statement, encoding="utf8")
         finder = ModuleFinder(search_paths=[tmp_package1.tmpdir, tmp_package2.tmpdir])
         _, package = finder.find_spec("namespace")
         assert package.name == "namespace"
@@ -91,6 +91,7 @@ def test_pth_file_handling(tmp_path: Path) -> None:
             tests
             """,
         ),
+        encoding="utf8",
     )
     paths = [sp.path for sp in _handle_pth_file(pth_file)]
     assert paths == [Path("tests")]
@@ -110,6 +111,7 @@ def test_pth_file_handling_with_semi_colon(tmp_path: Path) -> None:
             import thing; import\tthing; /doesnotexist; tests
             """,
         ),
+        encoding="utf8",
     )
     paths = [sp.path for sp in _handle_pth_file(pth_file)]
     assert paths == [Path("tests")]
@@ -123,7 +125,7 @@ def test_editables_file_handling(tmp_path: Path, editable_file_name: str) -> Non
         tmp_path: Pytest fixture.
     """
     pth_file = tmp_path / editable_file_name
-    pth_file.write_text("hello\nF.map_module('griffe', 'src/griffe/__init__.py')")
+    pth_file.write_text("hello\nF.map_module('griffe', 'src/griffe/__init__.py')", encoding="utf8")
     paths = [sp.path for sp in _handle_editable_module(pth_file)]
     assert paths == [Path("src")]
 
@@ -137,7 +139,7 @@ def test_setuptools_file_handling(tmp_path: Path, annotation: str) -> None:
         annotation: The type annotation of the MAPPING variable.
     """
     pth_file = tmp_path / "__editable__whatever.py"
-    pth_file.write_text(f"hello\nMAPPING{annotation} = {{'griffe': 'src/griffe'}}")
+    pth_file.write_text(f"hello\nMAPPING{annotation} = {{'griffe': 'src/griffe'}}", encoding="utf8")
     paths = [sp.path for sp in _handle_editable_module(pth_file)]
     assert paths == [Path("src")]
 
@@ -155,6 +157,7 @@ def test_setuptools_file_handling_multiple_paths(tmp_path: Path, annotation: str
         "hello=1\n"
         f"MAPPING{annotation} = {{\n'griffe':\n 'src1/griffe', 'briffe':'src2/briffe'}}\n"
         "def printer():\n  print(hello)",
+        encoding="utf8",
     )
     paths = [sp.path for sp in _handle_editable_module(pth_file)]
     assert paths == [Path("src1"), Path("src2")]
@@ -169,6 +172,7 @@ def test_scikit_build_core_file_handling(tmp_path: Path) -> None:
     pth_file = tmp_path / "_whatever_editable.py"
     pth_file.write_text(
         "hello=1\ninstall({'whatever': '/path/to/whatever'}, {'whatever.else': '/else'}, None, False, True)",
+        encoding="utf8",
     )
     # The second dict is not handled: scikit-build-core puts these files
     # in a location that Griffe won't be able to discover anyway
@@ -188,6 +192,7 @@ def test_meson_python_file_handling(tmp_path: Path) -> None:
     pth_file.write_text(
         # The path in argument 2 suffixed with src must exist, so we pass `.`.
         "hello=1\ninstall({'griffe', 'hello'}, '.', ['/tmp/ninja'], False)",
+        encoding="utf8",
     )
     search_paths = _handle_editable_module(pth_file)
     assert all(sp.always_scan_for == "griffe" for sp in search_paths)

tests/test_loader.py

@@ -41,9 +41,9 @@ def test_recursive_wildcard_expansion() -> None:
         mod_a = mod_a_dir / "__init__.py"
         mod_b = mod_b_dir / "__init__.py"
         mod_c = mod_b_dir / "mod_c.py"
-        mod_c.write_text("CONST_X = 'X'\nCONST_Y = 'Y'")
-        mod_b.write_text("from .mod_c import *")
-        mod_a.write_text("from .mod_b import *")
+        mod_c.write_text("CONST_X = 'X'\nCONST_Y = 'Y'", encoding="utf8")
+        mod_b.write_text("from .mod_c import *", encoding="utf8")
+        mod_a.write_text("from .mod_b import *", encoding="utf8")
 
         loader = GriffeLoader(search_paths=[tmp_package.tmpdir])
         package = loader.load(tmp_package.name)
@@ -69,9 +69,9 @@ def test_dont_shortcut_alias_chain_after_expanding_wildcards() -> None:
         mod_b = tmp_package.path / "mod_b.py"
         mod_c = tmp_package.path / "mod_c.py"
 
-        mod_a.write_text("from package.mod_b import *\nclass Child(Base): ...\n")
-        mod_b.write_text("from package.mod_c import Base\n__all__ = ['Base']\n")
-        mod_c.write_text("class Base: ...\n")
+        mod_a.write_text("from package.mod_b import *\nclass Child(Base): ...\n", encoding="utf8")
+        mod_b.write_text("from package.mod_c import Base\n__all__ = ['Base']\n", encoding="utf8")
+        mod_c.write_text("class Base: ...\n", encoding="utf8")
 
         loader = GriffeLoader(search_paths=[tmp_package.tmpdir])
         package = loader.load(tmp_package.name)
@@ -90,8 +90,8 @@ def test_dont_overwrite_lower_member_when_expanding_wildcard() -> None:
         mod_a = tmp_package.path / "mod_a.py"
         mod_b = tmp_package.path / "mod_b.py"
 
-        mod_a.write_text("overwritten = 0\nfrom package.mod_b import *\nnot_overwritten = 0\n")
-        mod_b.write_text("overwritten = 1\nnot_overwritten = 1\n")
+        mod_a.write_text("overwritten = 0\nfrom package.mod_b import *\nnot_overwritten = 0\n", encoding="utf8")
+        mod_b.write_text("overwritten = 1\nnot_overwritten = 1\n", encoding="utf8")
 
         loader = GriffeLoader(search_paths=[tmp_package.tmpdir])
         package = loader.load(tmp_package.name)
@@ -129,9 +129,10 @@ def __init__(self, watch_paths: List[str], debug: bool) -> None:
                         debug: if true, print details about all events to stderr
                     """
         '''
-        tmp_package.path.joinpath("_rust_notify.pyi").write_text(dedent(code))
+        tmp_package.path.joinpath("_rust_notify.pyi").write_text(dedent(code), encoding="utf8")
         tmp_package.path.joinpath("__init__.py").write_text(
             "from ._rust_notify import RustNotify\n__all__ = ['RustNotify']",
+            encoding="utf8",
         )
         loader = GriffeLoader(search_paths=[tmp_package.tmpdir])
         package = loader.load(tmp_package.name)
@@ -160,6 +161,7 @@ def function2(self, arg1=2.2):
                         pass
                 """,
             ),
+            encoding="utf8",
         )
         tmp_package.path.joinpath("mod.pyi").write_text(
             dedent(
@@ -179,6 +181,7 @@ def function1(self, arg1: bytes) -> Sequence[bytes]: ...
                     def function2(self, arg1: float) -> float: ...
                 """,
             ),
+            encoding="utf8",
         )
         loader = GriffeLoader(search_paths=[tmp_package.tmpdir])
         package = loader.load(tmp_package.name)
@@ -215,8 +218,8 @@ def function2(self, arg1: float) -> float: ...
 def test_overwrite_module_with_attribute() -> None:
     """Check we are able to overwrite a module with an attribute."""
     with temporary_pypackage("package", ["mod.py"]) as tmp_package:
-        tmp_package.path.joinpath("mod.py").write_text("mod: list = [0, 1, 2]")
-        tmp_package.path.joinpath("__init__.py").write_text("from package.mod import *")
+        tmp_package.path.joinpath("mod.py").write_text("mod: list = [0, 1, 2]", encoding="utf8")
+        tmp_package.path.joinpath("__init__.py").write_text("from package.mod import *", encoding="utf8")
         loader = GriffeLoader(search_paths=[tmp_package.tmpdir])
         loader.load(tmp_package.name)
         loader.resolve_aliases()
@@ -229,8 +232,8 @@ def test_load_package_from_both_py_and_pyi_files() -> None:
     `__init__.pyi` (not so uncommon).
     """
     with temporary_pypackage("package", ["__init__.py", "__init__.pyi"]) as tmp_package:
-        tmp_package.path.joinpath("__init__.py").write_text("globals()['f'] = lambda x: str(x)")
-        tmp_package.path.joinpath("__init__.pyi").write_text("def f(x: int) -> str: ...")
+        tmp_package.path.joinpath("__init__.py").write_text("globals()['f'] = lambda x: str(x)", encoding="utf8")
+        tmp_package.path.joinpath("__init__.pyi").write_text("def f(x: int) -> str: ...", encoding="utf8")
 
         loader = GriffeLoader(search_paths=[tmp_package.tmpdir])
         package = loader.load(tmp_package.name)
@@ -245,8 +248,8 @@ def test_load_single_module_from_both_py_and_pyi_files() -> None:
     """
     with temporary_pypackage("just_a_folder", ["mod.py", "mod.pyi"]) as tmp_folder:
         tmp_folder.path.joinpath("__init__.py").unlink()
-        tmp_folder.path.joinpath("mod.py").write_text("globals()['f'] = lambda x: str(x)")
-        tmp_folder.path.joinpath("mod.pyi").write_text("def f(x: int) -> str: ...")
+        tmp_folder.path.joinpath("mod.py").write_text("globals()['f'] = lambda x: str(x)", encoding="utf8")
+        tmp_folder.path.joinpath("mod.pyi").write_text("def f(x: int) -> str: ...", encoding="utf8")
 
         loader = GriffeLoader(search_paths=[tmp_folder.path])
         package = loader.load("mod")
@@ -261,8 +264,11 @@ def test_unsupported_item_in_all(caplog: pytest.LogCaptureFixture) -> None:
     """
     item_name = "XXX"
     with temporary_pypackage("package", ["mod.py"]) as tmp_folder:
-        tmp_folder.path.joinpath("__init__.py").write_text(f"from .mod import {item_name}\n__all__ = [{item_name}]")
-        tmp_folder.path.joinpath("mod.py").write_text(f"class {item_name}: ...")
+        tmp_folder.path.joinpath("__init__.py").write_text(
+            f"from .mod import {item_name}\n__all__ = [{item_name}]",
+            encoding="utf8",
+        )
+        tmp_folder.path.joinpath("mod.py").write_text(f"class {item_name}: ...", encoding="utf8")
         loader = GriffeLoader(search_paths=[tmp_folder.tmpdir])
         loader.expand_exports(loader.load("package"))  # type: ignore[arg-type]
     assert any(item_name in record.message and record.levelname == "WARNING" for record in caplog.records)
@@ -384,17 +390,17 @@ def test_loading_stubs_only_packages(tmp_path: Path, namespace: bool) -> None:
     package = package_parent / "package"
     package.mkdir()
     if not namespace:
-        package.joinpath("__init__.py").write_text("a: int = 0")
-    package.joinpath("module.py").write_text("a: int = 0")
+        package.joinpath("__init__.py").write_text("a: int = 0", encoding="utf8")
+    package.joinpath("module.py").write_text("a: int = 0", encoding="utf8")
 
     # Create stubs.
     stubs_parent = tmp_path / "stubs_parent"
     stubs_parent.mkdir()
     stubs = stubs_parent / "package-stubs"
     stubs.mkdir()
     if not namespace:
-        stubs.joinpath("__init__.pyi").write_text("b: int")
-    stubs.joinpath("module.pyi").write_text("b: int")
+        stubs.joinpath("__init__.pyi").write_text("b: int", encoding="utf8")
+    stubs.joinpath("module.pyi").write_text("b: int", encoding="utf8")
 
     # Exposing stubs first, to make sure order doesn't matter.
     loader = GriffeLoader(search_paths=[stubs_parent, package_parent])

tests/test_models.py

@@ -65,8 +65,8 @@ def test_handle_aliases_chain_in_has_docstrings() -> None:
     with temporary_pypackage("package", ["mod_a.py", "mod_b.py"]) as tmp_package:
         mod_a = tmp_package.path / "mod_a.py"
         mod_b = tmp_package.path / "mod_b.py"
-        mod_a.write_text("from .mod_b import someobj")
-        mod_b.write_text("from somelib import someobj")
+        mod_a.write_text("from .mod_b import someobj", encoding="utf8")
+        mod_b.write_text("from somelib import someobj", encoding="utf8")
 
         loader = GriffeLoader(search_paths=[tmp_package.tmpdir])
         package = loader.load(tmp_package.name)
@@ -80,8 +80,8 @@ def test_has_docstrings_does_not_trigger_alias_resolution() -> None:
     with temporary_pypackage("package", ["mod_a.py", "mod_b.py"]) as tmp_package:
         mod_a = tmp_package.path / "mod_a.py"
         mod_b = tmp_package.path / "mod_b.py"
-        mod_a.write_text("from .mod_b import someobj")
-        mod_b.write_text("from somelib import someobj")
+        mod_a.write_text("from .mod_b import someobj", encoding="utf8")
+        mod_b.write_text("from somelib import someobj", encoding="utf8")
 
         loader = GriffeLoader(search_paths=[tmp_package.tmpdir])
         package = loader.load(tmp_package.name)

tests/test_visitor.py

@@ -20,7 +20,7 @@
 def test_not_defined_at_runtime() -> None:
     """Assert that objects not defined at runtime are not added to wildcards expansions."""
     with temporary_pypackage("package", ["module_a.py", "module_b.py", "module_c.py"]) as tmp_package:
-        tmp_package.path.joinpath("__init__.py").write_text("from package.module_a import *")
+        tmp_package.path.joinpath("__init__.py").write_text("from package.module_a import *", encoding="utf8")
         tmp_package.path.joinpath("module_a.py").write_text(
             dedent(
                 """
@@ -36,9 +36,10 @@ def test_not_defined_at_runtime() -> None:
                     from package.module_c import TYPE_C
                 """,
             ),
+            encoding="utf8",
         )
-        tmp_package.path.joinpath("module_b.py").write_text("CONST_B = 'hi'\nTYPE_B = str")
-        tmp_package.path.joinpath("module_c.py").write_text("CONST_C = 'ho'\nTYPE_C = str")
+        tmp_package.path.joinpath("module_b.py").write_text("CONST_B = 'hi'\nTYPE_B = str", encoding="utf8")
+        tmp_package.path.joinpath("module_c.py").write_text("CONST_C = 'ho'\nTYPE_C = str", encoding="utf8")
         loader = GriffeLoader(search_paths=[tmp_package.tmpdir])
         package = loader.load(tmp_package.name)
         loader.resolve_aliases()
@@ -208,9 +209,9 @@ def test_parse_complex__all__assignments(statements: str) -> None:
         statements: Parametrized text containing `__all__` [augmented] assignments.
     """
     with temporary_pypackage("package", ["moda.py", "modb.py", "modc.py"]) as tmp_package:
-        tmp_package.path.joinpath("moda.py").write_text("CONST_A = 1\n\n__all__ = ['CONST_A']")
-        tmp_package.path.joinpath("modb.py").write_text("CONST_B = 1\n\n__all__ = ['CONST_B']")
-        tmp_package.path.joinpath("modc.py").write_text("CONST_C = 2\n\n__all__ = ['CONST_C']")
+        tmp_package.path.joinpath("moda.py").write_text("CONST_A = 1\n\n__all__ = ['CONST_A']", encoding="utf8")
+        tmp_package.path.joinpath("modb.py").write_text("CONST_B = 1\n\n__all__ = ['CONST_B']", encoding="utf8")
+        tmp_package.path.joinpath("modc.py").write_text("CONST_C = 2\n\n__all__ = ['CONST_C']", encoding="utf8")
         code = """
             from package.moda import *
             from package.moda import __all__ as moda_all
@@ -221,7 +222,7 @@ def test_parse_complex__all__assignments(statements: str) -> None:
 
             CONST_INIT = 0
         """
-        tmp_package.path.joinpath("__init__.py").write_text(dedent(code) + dedent(statements))
+        tmp_package.path.joinpath("__init__.py").write_text(dedent(code) + dedent(statements), encoding="utf8")
 
         loader = GriffeLoader(search_paths=[tmp_package.tmpdir])
         package = loader.load(tmp_package.name)