Make imports private when only used internally

This is to avoid mistakes from users accidentally importing something
that is not supposed to be exposed by a module but just to be used
internally.

Signed-off-by: Leandro Lucarella <leandro.lucarella@frequenz.com>

Author: llucax

src/frequenz/repo/config/_core.py

@@ -3,10 +3,10 @@
 
 """Base types used accross the project."""
 
-import enum
+import enum as _enum
 
 
-class RepositoryType(enum.Enum):
+class RepositoryType(_enum.Enum):
     """Supported types of repository."""
 
     ACTOR = "actor"

src/frequenz/repo/config/nox/config.py

@@ -12,37 +12,37 @@
 The `configure()` function must be called before `get()` is used.
 """
 
-import dataclasses
+import dataclasses as _dataclasses
 from typing import Self
 
-import nox
+import nox as _nox
 
-from . import util
+from . import util as _util
 
 
-@dataclasses.dataclass(kw_only=True, slots=True)
+@_dataclasses.dataclass(kw_only=True, slots=True)
 class CommandsOptions:
     """Command-line options for each command."""
 
-    black: list[str] = dataclasses.field(default_factory=lambda: [])
+    black: list[str] = _dataclasses.field(default_factory=lambda: [])
     """Command-line options for the `black` command."""
 
-    darglint: list[str] = dataclasses.field(default_factory=lambda: [])
+    darglint: list[str] = _dataclasses.field(default_factory=lambda: [])
     """Command-line options for the `darglint` command."""
 
-    isort: list[str] = dataclasses.field(default_factory=lambda: [])
+    isort: list[str] = _dataclasses.field(default_factory=lambda: [])
     """Command-line options for the `isort` command."""
 
-    mypy: list[str] = dataclasses.field(default_factory=lambda: [])
+    mypy: list[str] = _dataclasses.field(default_factory=lambda: [])
     """Command-line options for the `mypy` command."""
 
-    pydocstyle: list[str] = dataclasses.field(default_factory=lambda: [])
+    pydocstyle: list[str] = _dataclasses.field(default_factory=lambda: [])
     """Command-line options for the `pydocstyle` command."""
 
-    pylint: list[str] = dataclasses.field(default_factory=lambda: [])
+    pylint: list[str] = _dataclasses.field(default_factory=lambda: [])
     """Command-line options for the `pylint` command."""
 
-    pytest: list[str] = dataclasses.field(default_factory=lambda: [])
+    pytest: list[str] = _dataclasses.field(default_factory=lambda: [])
     """Command-line options for the `pytest` command."""
 
     def copy(self) -> Self:
@@ -51,20 +51,20 @@ def copy(self) -> Self:
         Returns:
             The copy of self.
         """
-        return dataclasses.replace(self)
+        return _dataclasses.replace(self)
 
 
-@dataclasses.dataclass(kw_only=True, slots=True)
+@_dataclasses.dataclass(kw_only=True, slots=True)
 class Config:
     """Configuration for nox sessions."""
 
-    opts: CommandsOptions = dataclasses.field(default_factory=CommandsOptions)
+    opts: CommandsOptions = _dataclasses.field(default_factory=CommandsOptions)
     """Command-line options for each command used by sessions."""
 
-    sessions: set[str] = dataclasses.field(default_factory=set)
+    sessions: set[str] = _dataclasses.field(default_factory=set)
     """List of sessions to run."""
 
-    source_paths: set[str] = dataclasses.field(default_factory=set)
+    source_paths: set[str] = _dataclasses.field(default_factory=set)
     """List of paths containing source files that should be analyzed by the sessions.
 
     Source paths are inspected for `__init__.py` files to look for packages.
@@ -77,7 +77,7 @@ class Config:
     checking.
     """
 
-    extra_paths: set[str] = dataclasses.field(default_factory=set)
+    extra_paths: set[str] = _dataclasses.field(default_factory=set)
     """List of extra paths to be analyzed by the sessions.
 
     These are not inspected for packages, as they are passed verbatim to the
@@ -89,7 +89,7 @@ def __post_init__(self) -> None:
 
         This will add extra paths discovered in config files and other sources.
         """
-        for path in util.discover_paths():
+        for path in _util.discover_paths():
             if path not in self.extra_paths:
                 self.extra_paths.add(path)
 
@@ -99,9 +99,9 @@ def copy(self, /) -> Self:
         Returns:
             The copy of self.
         """
-        return dataclasses.replace(self)
+        return _dataclasses.replace(self)
 
-    def path_args(self, session: nox.Session, /) -> set[str]:
+    def path_args(self, session: _nox.Session, /) -> set[str]:
         """Return the file paths to run the checks on.
 
         If positional arguments are present in the nox session, those are used
@@ -118,10 +118,10 @@ def path_args(self, session: nox.Session, /) -> set[str]:
             return set(session.posargs)
 
         return {
-            str(p) for p in util.existing_paths(self.source_paths | self.extra_paths)
+            str(p) for p in _util.existing_paths(self.source_paths | self.extra_paths)
         }
 
-    def package_args(self, session: nox.Session, /) -> set[str]:
+    def package_args(self, session: _nox.Session, /) -> set[str]:
         """Return the package names to run the checks on.
 
         If positional arguments are present in the nox session, those are used
@@ -141,18 +141,18 @@ def package_args(self, session: nox.Session, /) -> set[str]:
             return set(session.posargs)
 
         sources_package_dirs_with_roots = (
-            (p, util.find_toplevel_package_dirs(p))
-            for p in util.existing_paths(self.source_paths)
+            (p, _util.find_toplevel_package_dirs(p))
+            for p in _util.existing_paths(self.source_paths)
         )
 
         source_packages = (
-            util.path_to_package(pkg_path, root=root)
+            _util.path_to_package(pkg_path, root=root)
             for root, pkg_paths in sources_package_dirs_with_roots
             for pkg_path in pkg_paths
         )
 
         extra_packages = (
-            util.path_to_package(p) for p in util.existing_paths(self.extra_paths)
+            _util.path_to_package(p) for p in _util.existing_paths(self.extra_paths)
         )
 
         return {*source_packages, *extra_packages}
@@ -182,4 +182,4 @@ def configure(conf: Config, /) -> None:
     """
     global _config  # pylint: disable=global-statement
     _config = conf
-    nox.options.sessions = _config.sessions
+    _nox.options.sessions = _config.sessions

src/frequenz/repo/config/nox/default.py

@@ -27,7 +27,7 @@
 import dataclasses
 
 from . import config as _config
-from . import util
+from . import util as _util
 
 common_command_options: _config.CommandsOptions = _config.CommandsOptions(
     black=[
@@ -92,7 +92,7 @@
     # We don't check the sources at all because they are automatically generated.
     source_paths=set(),
     # We adapt the path to the tests.
-    extra_paths=set(util.replace(common_config.extra_paths, {"tests": "pytests"})),
+    extra_paths=set(_util.replace(common_config.extra_paths, {"tests": "pytests"})),
 )
 """Default configuration for APIs.
 

src/frequenz/repo/config/nox/session.py

@@ -8,7 +8,8 @@
 
 import nox
 
-from . import config, util
+from . import config as _config
+from . import util as _util
 
 
 @nox.session
@@ -42,7 +43,7 @@ def formatting(session: nox.Session, install_deps: bool = True) -> None:
     if install_deps:
         session.install("-e", ".[dev-formatting]")
 
-    conf = config.get()
+    conf = _config.get()
     session.run("black", *conf.opts.black, *conf.path_args(session))
     session.run("isort", *conf.opts.isort, *conf.path_args(session))
 
@@ -60,8 +61,8 @@ def mypy(session: nox.Session, install_deps: bool = True) -> None:
         # fast local tests with `nox -R -e mypy`.
         session.install("-e", ".[dev-mypy]")
 
-    conf = config.get()
-    pkg_args = util.flatten(("-p", p) for p in conf.package_args(session))
+    conf = _config.get()
+    pkg_args = _util.flatten(("-p", p) for p in conf.package_args(session))
     session.run("mypy", *conf.opts.mypy, *pkg_args)
 
 
@@ -78,7 +79,7 @@ def pylint(session: nox.Session, install_deps: bool = True) -> None:
         # fast local tests with `nox -R -e pylint`.
         session.install("-e", ".[dev-pylint]")
 
-    conf = config.get()
+    conf = _config.get()
     session.run("pylint", *conf.opts.pylint, *conf.path_args(session))
 
 
@@ -93,7 +94,7 @@ def docstrings(session: nox.Session, install_deps: bool = True) -> None:
     if install_deps:
         session.install("-e", ".[dev-docstrings]")
 
-    conf = config.get()
+    conf = _config.get()
     session.run("pydocstyle", *conf.opts.pydocstyle, *conf.path_args(session))
 
     # Darglint checks that function argument and return values are documented.
@@ -136,15 +137,15 @@ def pytest_min(session: nox.Session, install_deps: bool = True) -> None:
     if install_deps:
         # install the package itself as editable, so that it is possible to do
         # fast local tests with `nox -R -e pytest_min`.
-        session.install("-e", ".[dev-pytest]", *util.min_dependencies())
+        session.install("-e", ".[dev-pytest]", *_util.min_dependencies())
 
     _pytest_impl(session, "min")
 
 
 def _pytest_impl(
     session: nox.Session, max_or_min_deps: str  # pylint: disable=unused-argument
 ) -> None:
-    conf = config.get()
+    conf = _config.get()
     session.run("pytest", *conf.opts.pytest, *session.posargs)
 
     # pylint: disable=fixme

src/frequenz/repo/config/nox/util.py

@@ -8,8 +8,8 @@
 """
 
 
-import pathlib
-import tomllib
+import pathlib as _pathlib
+import tomllib as _tomllib
 from collections.abc import Iterable, Mapping
 from typing import TypeVar
 
@@ -51,7 +51,7 @@ def replace(iterable: Iterable[_T], replacements: Mapping[_T, _T], /) -> Iterabl
             yield item
 
 
-def existing_paths(paths: Iterable[str], /) -> Iterable[pathlib.Path]:
+def existing_paths(paths: Iterable[str], /) -> Iterable[_pathlib.Path]:
     """Filter paths to only leave valid paths that exist.
 
     Args:
@@ -63,10 +63,10 @@ def existing_paths(paths: Iterable[str], /) -> Iterable[pathlib.Path]:
     Example:
         >>> assert list(existing_paths([".", "/fake"])) == [pathlib.Path(".")]
     """
-    return (p for p in map(pathlib.Path, paths) if p.exists())
+    return (p for p in map(_pathlib.Path, paths) if p.exists())
 
 
-def is_python_file(path: pathlib.Path, /) -> bool:
+def is_python_file(path: _pathlib.Path, /) -> bool:
     """Check if a path is a Python file.
 
     Args:
@@ -78,7 +78,7 @@ def is_python_file(path: pathlib.Path, /) -> bool:
     return path.suffix in (".py", ".pyi")
 
 
-def path_to_package(path: pathlib.Path, root: pathlib.Path | None = None) -> str:
+def path_to_package(path: _pathlib.Path, root: _pathlib.Path | None = None) -> str:
     """Convert paths to Python package names.
 
     Paths should exist and be either a directory or a file ending with `.pyi?`
@@ -111,8 +111,8 @@ def path_to_package(path: pathlib.Path, root: pathlib.Path | None = None) -> str
 
 
 def find_toplevel_package_dirs(
-    path: pathlib.Path, /, *, root: pathlib.Path | None = None
-) -> Iterable[pathlib.Path]:
+    path: _pathlib.Path, /, *, root: _pathlib.Path | None = None
+) -> Iterable[_pathlib.Path]:
     """Find top-level packages directories in a `path`.
 
     Searches recursively for the top-level packages in `path`, relative to
@@ -176,7 +176,7 @@ def min_dependencies() -> list[str]:
 
     """
     with open("pyproject.toml", "rb") as toml_file:
-        data = tomllib.load(toml_file)
+        data = _tomllib.load(toml_file)
 
     dependencies = data.get("project", {}).get("dependencies", {})
     if not dependencies:
@@ -207,7 +207,7 @@ def discover_paths() -> list[str]:
         The discovered paths to check.
     """
     with open("pyproject.toml", "rb") as toml_file:
-        data = tomllib.load(toml_file)
+        data = _tomllib.load(toml_file)
 
     testpaths: list[str] = (
         data.get("tool", {})

src/frequenz/repo/config/setuptools/grpc_tools.py

@@ -10,17 +10,17 @@
 protocol buffer files are compiled automatically before the project is built.
 """
 
-import pathlib
-import subprocess
-import sys
+import pathlib as _pathlib
+import subprocess as _subprocess
+import sys as _sys
 
-import setuptools
+import setuptools as _setuptools
 
 # The typing stub for this module is missing
-import setuptools.command.build  # type: ignore[import]
+import setuptools.command.build as _build_command  # type: ignore[import]
 
 
-class CompileProto(setuptools.Command):
+class CompileProto(_setuptools.Command):
     """Build the Python protobuf files."""
 
     proto_path: str
@@ -72,15 +72,15 @@ def run(self) -> None:
         """Compile the Python protobuf files."""
         include_paths = self.include_paths.split(",")
         proto_files = [
-            str(p) for p in pathlib.Path(self.proto_path).rglob(self.proto_glob)
+            str(p) for p in _pathlib.Path(self.proto_path).rglob(self.proto_glob)
         ]
 
         if not proto_files:
             print(f"No proto files found in {self.proto_path}/**/{self.proto_glob}/")
             return
 
         protoc_cmd = (
-            [sys.executable, "-m", "grpc_tools.protoc"]
+            [_sys.executable, "-m", "grpc_tools.protoc"]
             + [f"-I{p}" for p in [*include_paths, self.proto_path]]
             + [
                 f"--{opt}={self.py_path}"
@@ -90,12 +90,12 @@ def run(self) -> None:
         )
 
         print(f"Compiling proto files via: {' '.join(protoc_cmd)}")
-        subprocess.run(protoc_cmd, check=True)
+        _subprocess.run(protoc_cmd, check=True)
 
 
 # This adds the compile_proto command to the build sub-command.
 # The name of the command is mapped to the class name in the pyproject.toml file,
 # in the [project.entry-points.distutils.commands] section.
 # The None value is an optional function that can be used to determine if the
 # sub-command should be executed or not.
-setuptools.command.build.build.sub_commands.insert(0, ("compile_proto", None))
+_build_command.build.sub_commands.insert(0, ("compile_proto", None))