cmds / lib: Fix more static checker findings

Fix more errors and warnings produced by "make check" as reported by CI and a pyright upgrade.
Signed-off-by: Jan Lindemann <jan@janware.com>

src/python/jw/pkg/cmds/CmdPkg.py

@@ -9,5 +9,5 @@ class CmdPkg(CmdBase):  # export
         super().__init__(parent, 'pkg', help = 'System package manager wrapper')
         self.load_subcommands()
 
-    def add_arguments(self, p: ArgumentParser) -> None:
+    def add_arguments(self, parser: ArgumentParser) -> None:
-        super().add_arguments(p)
+        super().add_arguments(parser)

src/python/jw/pkg/cmds/CmdPlatform.py

@@ -11,5 +11,5 @@ class CmdPlatform(CmdBase):  # export
         )
         self.load_subcommands()
 
-    def add_arguments(self, p: ArgumentParser) -> None:
+    def add_arguments(self, parser: ArgumentParser) -> None:
-        super().add_arguments(p)
+        super().add_arguments(parser)

src/python/jw/pkg/cmds/CmdPosix.py

@@ -16,5 +16,5 @@ class CmdPosix(CmdBase):  # export
         )
         self.load_subcommands()
 
-    def add_arguments(self, p: ArgumentParser) -> None:
+    def add_arguments(self, parser: ArgumentParser) -> None:
-        super().add_arguments(p)
+        super().add_arguments(parser)

src/python/jw/pkg/cmds/CmdProjects.py

@@ -15,8 +15,8 @@ class CmdProjects(CmdBase):  # export
         )
         self.load_subcommands()
 
-    def add_arguments(self, p: ArgumentParser) -> None:
+    def add_arguments(self, parser: ArgumentParser) -> None:
-        super().add_arguments(p)
+        super().add_arguments(parser)
 
     async def _run(self, args):
         # Missing subcommand

src/python/jw/pkg/cmds/CmdSecrets.py

@@ -9,5 +9,5 @@ class CmdSecrets(CmdBase):  # export
         super().__init__(parent, 'secrets', help = 'Manage package secrets')
         self.load_subcommands()
 
-    def add_arguments(self, p: ArgumentParser) -> None:
+    def add_arguments(self, parser: ArgumentParser) -> None:
-        super().add_arguments(p)
+        super().add_arguments(parser)

src/python/jw/pkg/cmds/projects/CmdCreatePkgConfig.py

@@ -3,13 +3,14 @@ from argparse import ArgumentParser, Namespace
 from .Cmd import Cmd, Parent
 from .lib.templates import tmpl_render
 
-
 class CmdCreatePkgConfig(Cmd):  # export
 
     def __init__(self, parent: Parent) -> None:
-        super().__init__(parent,
+        super().__init__(
-                         'create-pkg-config',
+            parent,
-                         help='Generate a pkg-config file for a module')
+            'create-pkg-config',
+            help = 'Generate a pkg-config file for a module'
+        )
 
     @staticmethod
     def __cleanup_requires(string: str) -> str:
@@ -28,17 +29,17 @@ class CmdCreatePkgConfig(Cmd):  # export
 
     def add_arguments(self, parser: ArgumentParser) -> None:
         super().add_arguments(parser)
-        parser.add_argument('-F', '--project-descr-file', default=None)
+        parser.add_argument('-F', '--project-descr-file', default = None)
-        parser.add_argument('-d', '--description', default=None)
+        parser.add_argument('-d', '--description', default = None)
-        parser.add_argument('-n', '--name', default=None)
+        parser.add_argument('-n', '--name', default = None)
-        parser.add_argument('-s', '--summary', default=None)
+        parser.add_argument('-s', '--summary', default = None)
-        parser.add_argument('-p', '--prefix', default=None)
+        parser.add_argument('-p', '--prefix', default = None)
-        parser.add_argument('-v', '--version', default=None)
+        parser.add_argument('-v', '--version', default = None)
-        parser.add_argument('-c', '--cflags', default=None)
+        parser.add_argument('-c', '--cflags', default = None)
-        parser.add_argument('-l', '--libflags', default=None)
+        parser.add_argument('-l', '--libflags', default = None)
-        parser.add_argument('-r', '--requires-run', default=None)
+        parser.add_argument('-r', '--requires-run', default = None)
-        parser.add_argument('-R', '--requires-build', default=None)
+        parser.add_argument('-R', '--requires-build', default = None)
-        parser.add_argument('-V', '--variables', nargs='*')
+        parser.add_argument('-V', '--variables', nargs = '*')
 
     async def _run(self, args: Namespace) -> None:
         project_conf_var_keys = [
@@ -47,7 +48,7 @@ class CmdCreatePkgConfig(Cmd):  # export
             'requires_run',
             'requires_build',
         ]
-        merged: dict[str, str|None] = {}
+        merged: dict[str, str | None] = {}
         for key in project_conf_var_keys:
             val = getattr(args, key)
             if val is not None and args.project_descr_file:

src/python/jw/pkg/cmds/projects/CmdListRepos.py

@@ -3,7 +3,6 @@ import re
 
 from argparse import ArgumentParser, Namespace
 
-from ...lib.base import Input
 from ...lib.log import DEBUG, log
 from ...lib.Uri import Uri
 from ...lib.util import get_password, get_username, run_curl_into
@@ -78,7 +77,7 @@ class CmdListRepos(Cmd):  # export
                     print('\n'.join(result.stdout_str.splitlines()))
                     return
             case 'https':
-                from jw.pkg.lib.base import InputMode
+                from jw.pkg.lib.base import Input, InputMode
 
                 cmd_input: Input = InputMode.NonInteractive
                 if re.match(r'https://github.com', args.base_url):

src/python/jw/pkg/cmds/projects/CmdPythonpath.py

@@ -10,9 +10,9 @@ class CmdPythonpath(Cmd):  # export
             parent, 'pythonpath', help = 'Generate PYTHONPATH for given modules'
         )
 
-    def add_arguments(self, p: ArgumentParser) -> None:
+    def add_arguments(self, parser: ArgumentParser) -> None:
-        super().add_arguments(p)
+        super().add_arguments(parser)
-        p.add_argument('module', help = 'Modules', nargs = '*')
+        parser.add_argument('module', help = 'Modules', nargs = '*')
 
     async def _run(self, args: Namespace) -> None:
         deps = self.app.get_project_refs(

src/python/jw/pkg/cmds/projects/CmdRequiredOsPkg.py

@@ -61,7 +61,6 @@ class CmdRequiredOsPkg(Cmd):  # export
                 vals = self.app.get_values(deps, ['pkg.requires.' + sec], [flavour])
                 if vals:
                     requires |= set(vals)
-        if args.quote:
+        out = [f'"{dep}"' for dep in requires] if args.quote else requires
-            out = [f'"{dep}"' for dep in requires]
         # TODO: add all not in build tree as -devel
         print(' '.join(out))

src/python/jw/pkg/cmds/projects/lib/pkg_relations.py

@@ -68,6 +68,7 @@ def pkg_relations(
             if cur_pkg in visited or cur_pkg in ignore:
                 continue
             for subsec in subsections:
+                version: str | None = None
                 section = 'pkg.' + rel_type + '.' + subsec
                 visited.add(cur_pkg)
                 value = app.get_value(cur_pkg, section, flavour)
@@ -111,37 +112,38 @@ def pkg_relations(
                                 raise Exception('Unknown version specifier in ' + spec)
                     if len(dep) != 3 or not expand_semver_revision_range:
                         expanded_deps = [dep]
+                        continue
+                    assert version is not None
+                    expanded_deps = []
+                    semver = re.split(r'[.-]', version)
+                    if len(semver) != 4:
+                        expanded_deps = [dep]
                     else:
-                        expanded_deps = []
+                        release = int(semver[2])
-                        semver = re.split(r'[.-]', version)
+                        major_minor = f'{semver[0]}.{semver[1]}'
-                        if len(semver) != 4:
+                        match dep[1]:
-                            expanded_deps = [dep]
+                            case '>' | '>=':
-                        else:
+                                expanded_deps.append([dep[0], dep[1], dep[2]])
-                            release = int(semver[2])
+                                expanded_deps.append(
-                            major_minor = f'{semver[0]}.{semver[1]}'
+                                    [dep[0], '<', f'{major_minor}.{release + 1}']
-                            match dep[1]:
+                                )
-                                case '>' | '>=':
+                            case '<' | '<=':
-                                    expanded_deps.append([dep[0], dep[1], dep[2]])
+                                expanded_deps.append([dep[0], dep[1], dep[2]])
-                                    expanded_deps.append(
+                            case '=':
-                                        [dep[0], '<', f'{major_minor}.{release + 1}']
+                                expanded_deps.append(
-                                    )
+                                    [dep[0], '>=', f'{major_minor}.{release}']
-                                case '<' | '<=':
+                                )
-                                    expanded_deps.append([dep[0], dep[1], dep[2]])
+                                expanded_deps.append(
-                                case '=':
+                                    [dep[0], '<', f'{major_minor}.{release + 1}']
-                                    expanded_deps.append(
+                                )
-                                        [dep[0], '>=', f'{major_minor}.{release}']
+                            case _:
-                                    )
+                                raise NotImplementedError(
-                                    expanded_deps.append(
+                                    (
-                                        [dep[0], '<', f'{major_minor}.{release + 1}']
+                                        'Expanding SemVer range '
-                                    )
+                                        f'"{dep[0]} {dep[1]} {dep[3]}" '
-                                case _:
+                                        'is not yet implemented'
-                                    raise NotImplementedError(
-                                        (
-                                            'Expanding SemVer range '
-                                            f'"{dep[0]} {dep[1]} {dep[3]}" '
-                                            'is not yet implemented'
-                                        )
                                     )
+                                )
                     for expanded_dep in expanded_deps:
                         if hide_self and dep_name in seed_pkgs:
                             continue

src/python/jw/pkg/lib/App.py

@@ -180,8 +180,8 @@ class App:  # export
 
             class NoopCompleter(BaseCompleter):
 
-                def __call__(self, **kwargs):
+                def __call__(self, *args, **kwargs):
-                    return ()
+                    return None
 
             import argcomplete
 
@@ -224,6 +224,7 @@ class App:  # export
                     NOTICE,
                     f'Writing profile statistics to {self.__args.write_profile}'
                 )
+                assert self.__args.write_profile is not None, 'args.write_profile'
                 pr.dump_stats(self.__args.write_profile)
 
         if exit_status:

src/python/jw/pkg/lib/ExecContext.py

@@ -587,8 +587,8 @@ class ExecContext(Base):
         cmd = ['mv', src, dst]
         await self.run(cmd, cmd_input = InputMode.NonInteractive)
 
-    async def _mkdir(self, name: str, mode: int) -> None:
+    async def _mkdir(self, path: str, mode: int) -> None:
-        cmd = ['mkdir', name, '-m', self.__mode_str(mode)]
+        cmd = ['mkdir', path, '-m', self.__mode_str(mode)]
         await self.run(cmd, cmd_input = InputMode.NonInteractive)
 
     async def _mktemp(self, tmpl: str, directory: bool) -> str:

src/python/jw/pkg/lib/FileContext.py

@@ -177,10 +177,10 @@ class FileContext(abc.ABC):
     ) -> Result:
         mode_str = None if mode is None else oct(mode).replace('0o', '0')
         if self.__out_pipe is not None:
-            result = await self.__out_pipe.run(content)
+            content = (await self.__out_pipe.run(content)).stdout
         return await self._put(
             self._chroot(path),
-            result.stdout,
+            content,
             wd = wd,
             throw = throw,
             verbose = verbose,

src/python/jw/pkg/lib/base.py

@@ -84,16 +84,14 @@ class Result:
         if err is None:
             return False
         import re
-
         return re.search(pattern, err) is not None
 
     def __summarize(self, cmd: list[str] | None, wd: str | None = None) -> str:
+        from .util import pretty_cmd
         if cmd is None:
             cmd = self.__cmd
         call = ''
         if cmd is not None:
-            from .util import pretty_cmd
-
             if wd is None:
                 wd = self.__wd
             call = f'"{pretty_cmd(cmd, wd)}" '
@@ -164,7 +162,6 @@ class StatResult(NamedTuple):
     def from_os(cls, rhs: os.stat_result) -> StatResult:
         import grp
         import pwd
-
         return StatResult(
             rhs.st_mode,
             pwd.getpwuid(rhs.st_uid).pw_name,

src/python/jw/pkg/lib/ec/Local.py

@@ -161,7 +161,6 @@ class Local(Base):
     async def _erase(self, path: str) -> None:
         if os.path.isdir(path):
             import shutil
-
             shutil.rmtree(path)
             return
         os.unlink(path)
@@ -169,8 +168,8 @@ class Local(Base):
     async def _rename(self, src: str, dst: str) -> None:
         os.rename(src, dst)
 
-    async def _mkdir(self, name: str, mode: int) -> None:
+    async def _mkdir(self, path: str, mode: int) -> None:
-        os.mkdir(name, mode)
+        os.mkdir(path, mode)
 
     async def _stat(self, path: str, follow_symlinks: bool) -> StatResult:
         return StatResult.from_os(os.stat(path, follow_symlinks = follow_symlinks))

src/python/jw/pkg/lib/log.py

@@ -2,62 +2,65 @@ import datetime
 import sys
 import syslog
 
-# fmt: disable # don't conflate
+from typing import TYPE_CHECKING
-EMERG = int(syslog.LOG_EMERG)
-ALERT = int(syslog.LOG_ALERT)
-CRIT = int(syslog.LOG_CRIT)
-ERR = int(syslog.LOG_ERR)
-WARNING = int(syslog.LOG_WARNING)
-NOTICE = int(syslog.LOG_NOTICE)
-INFO = int(syslog.LOG_INFO)
-DEBUG = int(syslog.LOG_DEBUG)
-DEVEL = int(syslog.LOG_DEBUG + 1)
-OFF = DEVEL + 1
 
-_log_level = NOTICE
+if TYPE_CHECKING:
-_last_tstamp = datetime.datetime.now()
+
+    from typing import Final
+
+# fmt: disable # don't conflate
+# yapf: disable # don't conflate
+EMERG         = int(syslog.LOG_EMERG)
+ALERT         = int(syslog.LOG_ALERT)
+CRIT          = int(syslog.LOG_CRIT)
+ERR           = int(syslog.LOG_ERR)
+WARNING       = int(syslog.LOG_WARNING)
+NOTICE        = int(syslog.LOG_NOTICE)
+INFO          = int(syslog.LOG_INFO)
+DEBUG         = int(syslog.LOG_DEBUG)
+DEVEL         = int(syslog.LOG_DEBUG + 1)
+OFF           = DEVEL + 1
+
+_log_level    = NOTICE
+_last_tstamp  = datetime.datetime.now()
 _first_tstamp = _last_tstamp
+
+_LOG_LEVEL_NAME_BY_VALUE: Final[dict[int, str]] = {
+    EMERG:    'EMERG',
+    ALERT:    'ALERT',
+    CRIT:     'CRIT',
+    ERR:      'ERR',
+    WARNING:  'WARNING',
+    NOTICE:   'NOTICE',
+    INFO:     'INFO',
+    DEBUG:    'DEBUG',
+    DEVEL:    'DEVEL',
+    OFF:      'OFF',
+}
+# yapf: enable
 # fmt: enable
 
-def _log_level_name_by_value():
+_LOG_LEVEL_VALUE_BY_NAME: Final[dict[str, int]] = {
-    if _log_level_name_by_value.map is None:
+    alias: value
-        _log_level_name_by_value.map = {
+    for value, name in _LOG_LEVEL_NAME_BY_VALUE.items()
-            EMERG: 'EMERG',
+    for alias in (name, name.lower())
-            ALERT: 'ALERT',
+}
-            CRIT: 'CRIT',
-            ERR: 'ERR',
-            WARNING: 'WARNING',
-            NOTICE: 'NOTICE',
-            INFO: 'INFO',
-            DEBUG: 'DEBUG',
-            DEVEL: 'DEVEL',
-            OFF: 'OFF',
-        }
-    return _log_level_name_by_value.map
-
-_log_level_name_by_value.map: dict[int, str] | None = None  # type: ignore
-
-def _log_level_value_by_name():
-    if _log_level_value_by_name.map is None:
-        _log_level_value_by_name.map = {}
-        for value, name in _log_level_name_by_value().items():
-            _log_level_value_by_name.map[name] = value
-            _log_level_value_by_name.map[name.lower()] = value
-    return _log_level_value_by_name.map
-
-_log_level_value_by_name.map: dict[str, int] | None = None  # type: ignore
 
 def get_log_level_name(level: int) -> str:
-    return _log_level_name_by_value()[level]
+    return _LOG_LEVEL_NAME_BY_VALUE[level]
 
 def parse_log_level(level: str | int) -> int:
-    try:
+
-        ret = int(level)
+    def __int_level(level: int) -> int:
-        if ret >= 0 and ret <= DEVEL:
+        if level >= 0 and level <= DEVEL:
-            return ret
+            return level
-    except ValueError:
+        raise Exception(f'Invalid log level number {level}')
-        return _log_level_value_by_name()[level]
+
-    raise Exception('Invalid log level ', level)
+    if isinstance(level, int):
+        return __int_level(level)
+    if level in _LOG_LEVEL_VALUE_BY_NAME:
+        return _LOG_LEVEL_VALUE_BY_NAME[level]
+    return __int_level(int(level))
 
 def set_log_level(level: str | int | None = None) -> int:
     global _log_level