janware/jw-pkg
Watch
1
Code Pull requests Activity Actions

cmds.projects.CmdBuild: Code and log beautification

Browse source 
Improve CmdBuild some more:

 - Fix more broken f-strings
 - Better varable name prereq_type -> dep_flavour
 - Add stricter typing
 - Beautify logging

Signed-off-by: Jan Lindemann <jan@janware.com>
This commit is contained in:
Jan Lindemann 2026-07-11 11:37:17 +02:00
commit db09928ffa
Signed by: Jan Lindemann
GPG key ID: 3750640C9E25DD61
1 changed files with 40 additions and 29 deletions
Download patch file Download diff file Expand all files Collapse all files

69
src/python/jw/pkg/cmds/projects/CmdBuild.py
View file

@ -14,6 +14,8 @@ from .Cmd import Cmd, Parent
if TYPE_CHECKING: if TYPE_CHECKING:
from argparse import ArgumentParser, Namespace from argparse import ArgumentParser, Namespace
from typing import Iterable, TypeAlias
DepNode: TypeAlias = dict[str, set[str]]
class CmdBuild(Cmd): # export class CmdBuild(Cmd): # export
@ -83,55 +85,64 @@ class CmdBuild(Cmd): # export
async def _run(self, args: Namespace) -> None: async def _run(self, args: Namespace) -> None:
@lru_cache(maxsize = None) @lru_cache(maxsize = None)
def read_deps(cur, prereq_type: str) -> list[str]: def read_deps(cur: str, dep_flavour: str) -> list[str]:
# dep cache doesn't make a difference at all # dep cache doesn't make a difference at all
if prereq_type in dep_cache: if dep_flavour in dep_cache:
if cur in dep_cache[prereq_type]: if cur in dep_cache[dep_flavour]:
return dep_cache[prereq_type][cur] return dep_cache[dep_flavour][cur]
else: else:
dep_cache[prereq_type] = {} dep_cache[dep_flavour] = {}
ret = self.app.get_project_refs( ret = self.app.get_project_refs(
[cur], [cur],
['pkg.requires.jw'], ['pkg.requires.jw'],
prereq_type, dep_flavour,
scope = Scope.Subtree, scope = Scope.Subtree,
add_self = False, add_self = False,
names_only = True, names_only = True,
) )
log(DEBUG, 'prerequisites = ' + ' '.join(ret)) log(DEBUG, f'Prerequisites: {" ".join(ret)}')
if cur in ret: if cur in ret:
ret.remove(cur) ret.remove(cur)
log( log(
DEBUG, DEBUG,
(f'Inserting {prereq_type}, prerequisites of {cur}: {" ".join(ret)}'), (f'Inserting {dep_flavour}, prerequisites of {cur}: {" ".join(ret)}'),
) )
dep_cache[prereq_type][cur] = ret dep_cache[dep_flavour][cur] = ret
return ret return ret
def add_dep_tree(cur, prereq_types, tree, all_deps): def add_dep_tree(
log(DEBUG, f'Adding deps "{" ".join(prereq_types)}" of module {cur}') cur: str,
dep_flavours: Iterable[str],
tree: DepNode,
all_deps: set[str],
) -> int:
log(DEBUG, f'Adding deps "{" ".join(dep_flavours)}" of module {cur}')
if cur in all_deps: if cur in all_deps:
log(DEBUG, 'Already handled module "{cur}"') log(DEBUG, f'Already handled module "{cur}"')
return 0 return 0
deps = set() deps: set[str] = set()
all_deps.add(cur) all_deps.add(cur)
for t in prereq_types: for t in dep_flavours:
log(DEBUG, 'Checking deps of type "{t}"') log(DEBUG, f'Checking deps of type "{t}"')
deps.update(read_deps(cur, t)) deps.update(read_deps(cur, t))
for d in deps: for d in deps:
add_dep_tree(d, prereq_types, tree, all_deps) add_dep_tree(d, dep_flavours, tree, all_deps)
tree[cur] = deps tree[cur] = deps
return len(deps) return len(deps)
def calculate_order(order, modules, prereq_types): def calculate_order(
all_deps = set() order: list[str],
dep_tree = {} modules: set[str],
dep_flavours: Iterable[str],
) -> int:
all_deps: set[str] = set()
dep_tree: DepNode = {}
for m in modules: for m in modules:
log(DEBUG, '--- Adding dependency tree of module "{m}"') log(DEBUG, f'--- Adding dependency tree of module "{m}"')
add_dep_tree(m, prereq_types, dep_tree, all_deps) add_dep_tree(m, dep_flavours, dep_tree, all_deps)
while len(all_deps): while len(all_deps):
# Find any leaf # Find any leaf
for d in all_deps: for d in all_deps:
@ -139,9 +150,9 @@ class CmdBuild(Cmd): # export
if not len(dep_tree[d]): if not len(dep_tree[d]):
break # found break # found
else: # no Leaf found else: # no Leaf found
print(all_deps)
raise Exception( raise Exception(
'Fatal: the dependencies between these modules are unresolvable' 'Fatal: Dependencies between these modules are unresolvable: '
', '.join(all_deps)
) )
order.append(d) # do it order.append(d) # do it
# bookkeep it # bookkeep it
@ -220,9 +231,9 @@ class CmdBuild(Cmd): # export
if not len(modules): if not len(modules):
log(NOTICE, 'All modules cleaned') log(NOTICE, 'All modules cleaned')
async def run(args) -> None: async def run(args: Namespace) -> None:
log(DEBUG, f'-------------------------------------- running {pretty_cmd()}') log(DEBUG, f'-------------------------------------- Running {pretty_cmd()}')
modules = set(args.modules) modules = set(args.modules)
exclude = set(args.exclude.split()) exclude = set(args.exclude.split())
@ -236,15 +247,15 @@ class CmdBuild(Cmd): # export
# -- build # -- build
order: list[str] = [] order: list[str] = []
glob_prereq_types = ['build'] dep_flavours = ['build']
if re.match('pkg-.*', target) is not None: if re.match('pkg-.*', target) is not None:
glob_prereq_types = ['build', 'run', 'release', 'devel'] dep_flavours = ['build', 'run', 'release', 'devel']
if target != 'order' and not args.build_order: if target != 'order' and not args.build_order:
log(NOTICE, 'Using prerequisite types ' + ' '.join(glob_prereq_types)) log(NOTICE, 'Using prerequisite flavours ' + ' '.join(dep_flavours))
log(NOTICE, 'Calculating order for modules ... ') log(NOTICE, 'Calculating order for modules ... ')
calculate_order(order, modules, glob_prereq_types) calculate_order(order, modules, dep_flavours)
if args.ignore_deps: if args.ignore_deps:
order = [m for m in order if m in args.modules] order = [m for m in order if m in args.modules]
order = [m for m in order if m not in exclude] order = [m for m in order if m not in exclude]