proj-flow 0.9.4__py3-none-any.whl → 0.11.0__py3-none-any.whl

proj_flow/__init__.py

@@ -1,4 +1,9 @@
 # Copyright (c) 2025 Marcin Zdun
 # This code is licensed under MIT license (see LICENSE for details)
 
-__version__ = "0.9.4"
+"""
+The **proj_flow** contains only ``__version__`` to be updated, nothing more.
+This is in an attempt to make this module easy to load initially.
+"""
+
+__version__ = "0.11.0"

proj_flow/api/arg.py

@@ -12,48 +12,71 @@ from dataclasses import dataclass, field
 
 from proj_flow.base import inspect as _inspect
 
+T = typing.TypeVar("T")
+LazyArgument = typing.Union[T, typing.Callable[[], T]]
+
+
+def _eval(arg: LazyArgument[T]) -> T:
+    if callable(arg):
+        return typing.cast(T, arg())
+    return arg
+
+
+class _Completable(typing.Protocol):
+    completer: _inspect.Function
+
 
 @dataclass
 class Argument:
-    help: str = ""
+    help: LazyArgument[str] = ""
     pos: bool = False
-    names: typing.List[str] = field(default_factory=list)
-    nargs: typing.Union[str, int, None] = None
-    opt: typing.Optional[bool] = None
-    meta: typing.Optional[str] = None
-    action: typing.Union[str, argparse.Action, None] = None
-    default: typing.Optional[typing.Any] = None
-    choices: typing.Optional[typing.List[str]] = None
+    names: LazyArgument[typing.List[str]] = field(default_factory=list)
+    nargs: LazyArgument[typing.Union[str, int, None]] = None
+    opt: LazyArgument[typing.Optional[bool]] = None
+    meta: LazyArgument[typing.Optional[str]] = None
+    action: LazyArgument[typing.Union[str, argparse.Action, None]] = None
+    default: LazyArgument[typing.Optional[typing.Any]] = None
+    choices: LazyArgument[typing.Optional[typing.List[str]]] = None
     completer: typing.Optional[_inspect.Function] = None
 
     def visit(self, parser: argparse.ArgumentParser, name: str):
         kwargs = {}
-        if self.help is not None:
-            kwargs["help"] = self.help
-        if self.nargs is not None:
-            kwargs["nargs"] = self.nargs
-        if self.meta is not None:
-            kwargs["metavar"] = self.meta
-        if self.default is not None:
-            kwargs["default"] = self.default
-        if self.action is not None:
-            kwargs["action"] = self.action
-        if self.choices is not None:
-            kwargs["choices"] = self.choices
+
+        self_help = _eval(self.help)
+        self_names = _eval(self.names)
+        self_nargs = _eval(self.nargs)
+        self_opt = _eval(self.opt)
+        self_meta = _eval(self.meta)
+        self_action = _eval(self.action)
+        self_default = _eval(self.default)
+        self_choices = _eval(self.choices)
+
+        if self_help is not None:
+            kwargs["help"] = self_help
+        if self_nargs is not None:
+            kwargs["nargs"] = self_nargs
+        if self_meta is not None:
+            kwargs["metavar"] = self_meta
+        if self_default is not None:
+            kwargs["default"] = self_default
+        if self_action is not None:
+            kwargs["action"] = self_action
+        if self_choices is not None:
+            kwargs["choices"] = self_choices
 
         names = (
-            [name] if self.pos else self.names if len(self.names) > 0 else [f"--{name}"]
+            [name] if self.pos else self_names if len(self_names) > 0 else [f"--{name}"]
         )
 
         if self.pos:
-            kwargs["nargs"] = "?" if self.opt else 1
+            kwargs["nargs"] = "?" if self_opt else 1
         else:
             kwargs["dest"] = name
-            kwargs["required"] = not self.opt
+            kwargs["required"] = not self_opt
 
         action = parser.add_argument(*names, **kwargs)
         if self.completer:
-            action.completer = self.completer  # type: ignore
+            typing.cast(_Completable, action).completer = self.completer
 
         return action
 

proj_flow/api/ctx.py

@@ -9,9 +9,10 @@ import datetime
 import inspect
 import os
 from dataclasses import dataclass
-from typing import Callable, Dict, Iterable, List, Optional, Union
+from typing import Any, Callable, Dict, Iterable, List, Optional, Union, cast
 
 from proj_flow.base import cmd
+from proj_flow.base import inspect as _inspect
 
 package_root = os.path.dirname(os.path.dirname(__file__))
 template_dir = "template"
@@ -26,32 +27,44 @@ SettingsType = Dict[str, StrOrBool]
 class Setting:
     json_key: str
     prompt: str = ""
-    value: Union[Values, Callable[[], Values]] = ""
+    value: Union[Values, Callable[[], Values], Callable[[SettingsType], Values]] = ""
     fix: Optional[str] = None
     force_fix: bool = False
+    project: Optional[str] = None
 
     def calc_value(self, previous: SettingsType):
-        if isinstance(self.value, Callable):
+        if callable(self.value):
             kwargs = {}
 
             params = inspect.signature(self.value).parameters
             if "settings" in params:
                 kwargs["settings"] = previous
 
-            return self.value(**kwargs)
+            return cast(_inspect.Function, self.value)(**kwargs)
 
         return self.value
 
 
-def register_init_setting(*setting: Setting, is_hidden=False):
+def register_init_setting(*settings: Setting, is_hidden=False, project: Optional[str]):
+    if project is not None:
+        for setting in settings:
+            setting.project = project
+    (hidden if is_hidden else defaults).extend(settings)
+
+
+def register_common_init_setting(*setting: Setting, is_hidden=False):
     (hidden if is_hidden else defaults).extend(setting)
 
 
-def register_switch(key: str, prompt: str, enabled: bool):
+def register_switch(key: str, prompt: str, enabled: bool, project: Optional[str]):
+    switches.append(Setting(key, prompt, value=enabled, project=project))
+
+
+def register_common_switch(key: str, prompt: str, enabled: bool):
     switches.append(Setting(key, prompt, value=enabled))
 
 
-def register_internal(key: str, value: any):
+def register_internal(key: str, value: Any):
     internals[key] = value
 
 
@@ -59,17 +72,20 @@ def _git_config(name: str):
     def wrap():
         proc = cmd.run("git", "config", name, capture_output=True)
         if proc is None or proc.returncode != 0:
-            return None
+            return ""
         return proc.stdout.strip()
 
     return wrap
 
 
-def move_to_front(preferred: str, values: Iterable[str]):
+def move_to_front(preferred: str, values: Iterable[Optional[str]]):
     result: List[str] = []
 
     has_preferred = False
     for value in values:
+        if value is None:
+            continue
+
         if value == preferred:
             has_preferred = True
         else:
@@ -94,7 +110,7 @@ def _enum_licenses():
     root = os.path.abspath(os.path.join(package_root, template_dir, "licenses"))
     for _, dirnames, filenames in os.walk(root):
         dirnames[:] = []
-        iter = filter(lambda x: x is not None, map(_as_mustache, filenames))
+        iter = map(_as_mustache, filenames)
         return move_to_front("MIT", iter)
     return []
 
@@ -114,11 +130,11 @@ def _get_nothing(_: SettingsType) -> StrOrBool:
 
 
 def _map(internal_key: str):
-    def impl(key: str):
+    def impl(key: StrOrBool) -> StrOrBool:
         mapped = internals.get(internal_key)
         if not isinstance(mapped, dict):
-            return None
-        return mapped.get(key)
+            return ""
+        return mapped.get(key, "")
 
     return impl
 
@@ -152,12 +168,12 @@ def _build_fixup(settings: SettingsType, fixup: str):
         value = code(settings)
 
         if result:
-            result += value
+            result = f"{result}{value}"
         else:
             result = value
 
         if verbose:
-            result += verbose
+            result = f"{result}{verbose}"
 
     return result
 
@@ -169,7 +185,7 @@ def _fixed(fixup: str):
     return wrap
 
 
-internals = {}
+internals: Dict[str, Any] = {}
 
 switches: List[Setting] = []
 
@@ -200,18 +216,21 @@ defaults: List[Setting] = [
         "INCLUDE_PREFIX",
         'Prefix for includes (as in #include "{PREFIX}/version.hpp")',
         _fixed("{PROJECT.NAME}"),
+        project="cxx",
     ),
     Setting(
         "NAME_PREFIX",
         "CMake variable name prefix",
         _fixed("{PROJECT.NAME$safe$upper}"),
+        project="cxx",
     ),
     Setting(
         "NAMESPACE",
         "C++ namespace for the project",
         _fixed("{PROJECT.NAME$safe}"),
+        project="cxx",
     ),
-    Setting("EXT", "Extension for code files", _list_ext),
+    Setting("EXT", "Extension for code files", _list_ext, project="cxx"),
     Setting("SRCDIR", "Directory for code files", "src"),
     Setting(
         "INCLUDEDIR",
@@ -219,20 +238,21 @@ defaults: List[Setting] = [
         "include",
         "{INCLUDEDIR}/{INCLUDE_PREFIX}",
         force_fix=True,
+        project="cxx",
     ),
 ]
 
 hidden: List[Setting] = [
-    Setting("EXT.cxx", fix="{EXT}"),
-    Setting("EXT.hxx", fix="{EXT.cxx$header}"),
+    Setting("EXT.cxx", fix="{EXT}", project="cxx"),
+    Setting("EXT.hxx", fix="{EXT.cxx$header}", project="cxx"),
 ]
 
 _fileext = {".cc": ".hh", ".cxx": ".hxx", ".cpp": ".hpp"}
 
 
 _filters: Dict[str, Callable[[StrOrBool], StrOrBool]] = {
-    "safe": lambda value: value.replace("-", "_"),
-    "upper": lambda value: value.upper(),
-    "lower": lambda value: value.lower(),
-    "header": lambda cxx_ext: _fileext.get(cxx_ext, ".hpp"),
+    "safe": lambda value: str(value).replace("-", "_"),
+    "upper": lambda value: str(value).upper(),
+    "lower": lambda value: str(value).lower(),
+    "header": lambda cxx_ext: _fileext.get(str(cxx_ext), ".hpp"),
 }

proj_flow/api/env.py

@@ -23,6 +23,7 @@ from dataclasses import dataclass
 from enum import Enum
 from typing import Any, Callable, Dict, List, Optional, Union, cast
 
+from proj_flow.api import ctx
 from proj_flow.base import plugins, uname
 
 platform = uname.uname()[0]
@@ -115,6 +116,59 @@ class RunAlias:
         return RunAlias(name, doc, steps)
 
 
+def _merge_dicts(dst: dict, src: dict):
+    for key in src:
+        if key not in dst:
+            dst[key] = src[key]
+            continue
+
+        src_val = src[key]
+        dst_val = dst[key]
+
+        if isinstance(src_val, dict):
+            if isinstance(dst_val, dict):
+                _merge_dicts(dst_val, src_val)
+                continue
+
+        dst[key] = src_val
+
+
+def _flatten_dict(dst: ctx.SettingsType, defaults: Dict[str, Any], prefix=""):
+    for key, val in defaults.items():
+        this_key = f"{prefix}{key}"
+
+        if isinstance(val, dict):
+            _flatten_dict(dst, val, f"{this_key}.")
+            continue
+
+        if val is None:
+            dst[this_key] = ""
+            continue
+
+        if isinstance(val, bool):
+            dst[this_key] = val
+            continue
+
+        dst[this_key] = str(val)
+
+
+def _merge(cfg: dict, defaults: ctx.SettingsType, path: str):
+    config = plugins.load_data(path)
+    if not isinstance(config, dict):
+        return
+
+    stored_defaults = config.get("defaults", {})
+    try:
+        del config["defaults"]
+    except KeyError:
+        pass
+
+    _merge_dicts(cfg, config)
+
+    if isinstance(stored_defaults, dict):
+        _flatten_dict(defaults, stored_defaults)
+
+
 class FlowConfig:
     _cfg: dict
     steps: list = []
@@ -129,9 +183,18 @@ class FlowConfig:
             self.root = cfg.root
         else:
             self.root = os.path.abspath(root)
-            self._cfg = plugins.load_data(
-                os.path.join(self.root, ".flow", "config.json")
+            defaults: ctx.SettingsType = {}
+            dest: dict = {}
+
+            _merge(
+                dest,
+                defaults,
+                os.path.join(os.path.expanduser("~"), ".config", "proj-flow.json"),
             )
+            _merge(dest, defaults, os.path.join(self.root, ".flow", "config.json"))
+
+            self._cfg = dest
+            self._cfg["defaults"] = defaults
 
             self._propagate_compilers()
             self._load_extensions()

proj_flow/api/step.py

@@ -12,6 +12,7 @@ from typing import List, cast
 from proj_flow.api.env import Config, Runtime
 from proj_flow.base import inspect as _inspect
 from proj_flow.base import matrix
+from proj_flow.base.name_list import name_list
 
 
 class Step(ABC):
@@ -111,11 +112,8 @@ def _name_list(label: str, names: List[str], template="`{}`") -> str:
     if len(names) == 0:
         return ""
 
-    em = [template.format(name) for name in names]
-    prefix = ", ".join(em[:-1])
-    if prefix:
-        prefix += " and "
-    return f"\n:{label}: {prefix}{em[-1]}"
+    joined = name_list([template.format(name) for name in names])
+    return f"\n:{label}: {joined}"
 
 
 def _make_private(f: _inspect.Function):

proj_flow/{ext/cplusplus/cmake/__version__.py → base/__cmake_version__.py}

@@ -1,5 +1,10 @@
 # Copyright (c) 2025 Marcin Zdun
 # This code is licensed under MIT license (see LICENSE for details)
 
+"""
+The **proj_flow.ext.cplusplus.cmake.__version__** contains only the value of
+expected version of CMake.
+"""
+
 
 CMAKE_VERSION = "3.28"

proj_flow/base/name_list.py

@@ -0,0 +1,19 @@
+# Copyright (c) 2025 Marcin Zdun
+# This code is licensed under MIT license (see LICENSE for details)
+
+"""
+The **proj_flow.base.name_list** provides name list helper for arguments with
+choices
+"""
+
+from typing import List
+
+
+def name_list(names: List[str]) -> str:
+    if len(names) == 0:
+        return ""
+
+    prefix = ", ".join(names[:-1])
+    if prefix:
+        prefix += " and "
+    return f"{prefix}{names[-1]}"

proj_flow/base/registry.py

@@ -7,6 +7,7 @@ to register the plugins with a decorator.
 """
 
 import typing
+from collections import OrderedDict
 
 T = typing.TypeVar("T")
 K = typing.TypeVar("K")
@@ -97,10 +98,29 @@ class Registry(typing.Generic[T]):
 
 _debug_copies: typing.List[Registry] = []
 
+def quoted(s: str) -> str:
+    if '"' in s:
+        return "'{}'".format(s.replace("\\", r"\\").replace("'", r"\'"))
+    if "'" in s or " " in s:
+        return '"{}"'.format(s)
+    return s
 
 def verbose_info():
     for registry in _debug_copies:
         for item in registry.container:
-            print(
-                f"-- {registry.name}: adding `{item.__module__}.{item.__class__.__name__}`"
-            )
+            full_name = f"{item.__module__}.{item.__class__.__name__}"
+
+            kw = OrderedDict()
+
+            if hasattr(item, "name"):
+                kw["name"] = quoted(getattr(item, "name"))
+            elif hasattr(item, "__name__"):
+                kw["name"] = quoted(getattr(item, "__name__"))
+
+            if hasattr(item, "id"):
+                kw["id"] = quoted(getattr(item, "id"))
+
+            items = ", ".join([f"{key}={value}" for key, value in kw.items()])
+            if len(items) > 0:
+                items = f" ({items})"
+            print(f"-- {registry.name}: adding `{full_name}`{items}")

proj_flow/cli/__init__.py

@@ -29,7 +29,7 @@ def main():
 def _change_dir():
     root = argparse.ArgumentParser(
         prog="proj-flow",
-        usage="proj-flow [-h] [--version] [-C [dir]] {command} ...",
+        usage="proj-flow [-h] [--version] [-C [dir]] command ...",
         add_help=False,
     )
     root.add_argument("-C", dest="cd", nargs="?")

proj_flow/cli/argument.py

@@ -192,7 +192,7 @@ class Command:
         if len(self.children):
             subparsers = parser.add_subparsers(
                 dest=f"command_{level}",
-                metavar="{command}",
+                metavar="command",
                 help="Known command name, see below",
             )
             subparsers.parent = parser  # type: ignore
@@ -254,7 +254,7 @@ def _argparse_visit_all(
     parser.shortcuts = shortcut_configs
 
     subparsers = parser.add_subparsers(
-        dest="command", metavar="{command}", help="Known command name, see below"
+        dest="command", metavar="command", help="Known command name, see below"
     )
 
     subparsers.parent = parser  # type: ignore

proj_flow/{flow/dependency.py → dependency.py}

@@ -2,7 +2,7 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.flow.dependency** verifies availabilty of Step's external tools.
+The **proj_flow.dependency** verifies availabilty of Step's external tools.
 """
 
 import re

proj_flow/ext/cplusplus/cmake/__init__.py

@@ -7,6 +7,6 @@ The **proj_flow.ext.cplusplus.cmake** provides ``"CMake"``, ``"Build"``,
 context.
 """
 
-from . import context, parser, steps, version
+from . import parser, steps, version
 
-__all__ = ["context", "parser", "steps", "version"]
+__all__ = ["parser", "steps", "version"]

proj_flow/ext/cplusplus/cmake/steps.py

@@ -12,7 +12,7 @@ from typing import Dict, List, cast
 from proj_flow import api
 from proj_flow.api import env, step
 
-from .__version__ import CMAKE_VERSION
+from proj_flow.base.__cmake_version__ import CMAKE_VERSION
 
 
 class CMakeBase(api.step.Step):

proj_flow/ext/cplusplus/conan/__init__.py

@@ -9,7 +9,8 @@ import os
 import textwrap
 from typing import List
 
-from proj_flow.api import ctx, env, step
+from proj_flow.api import env, step
+from proj_flow.project import cplusplus
 
 from ._conan import conan_api
 
@@ -62,6 +63,3 @@ class ConanConfig:
         if not rt.dry_run and os.path.exists("CMakeUserPresets.json"):
             os.remove("CMakeUserPresets.json")
         return 0
-
-
-ctx.register_switch("with_conan", "Use Conan for dependency manager", True)

proj_flow/ext/cplusplus/conan/_conan.py

@@ -13,7 +13,7 @@ from typing import Callable, List, cast
 
 from proj_flow.api.env import Config, Runtime
 from proj_flow.base import cmd
-from proj_flow.flow.dependency import VER_REGEX
+from proj_flow.dependency import VER_REGEX
 
 
 class conan(ABC):

proj_flow/ext/github/cli.py

@@ -16,22 +16,13 @@ import typing
 
 from proj_flow import log
 from proj_flow.api import arg, env
+from proj_flow.base.name_list import name_list
 from proj_flow.flow.configs import Configs
 from proj_flow.log import commit, hosting, rich_text
 
 FORCED_LEVEL_CHOICES = list(commit.FORCED_LEVEL.keys())
 
 
-def _name_list(names: typing.List[str]) -> str:
-    if len(names) == 0:
-        return ""
-
-    prefix = ", ".join(names[:-1])
-    if prefix:
-        prefix += " and "
-    return f"{prefix}{names[-1]}"
-
-
 @arg.command("github")
 def github():
     """Interact with GitHub workflows and releases"""
@@ -81,7 +72,7 @@ def release(
         typing.Optional[str],
         arg.Argument(
             help="Ignore the version change from changelog and instead use this value. "
-            f"Allowed values are: {_name_list(FORCED_LEVEL_CHOICES)}",
+            f"Allowed values are: {name_list(FORCED_LEVEL_CHOICES)}",
             meta="level",
             choices=FORCED_LEVEL_CHOICES,
         ),

proj_flow/ext/github/switches.py

@@ -7,7 +7,7 @@ projects.
 
 from proj_flow.api import ctx
 
-ctx.register_switch("with_github_actions", "Use Github Actions", True)
-ctx.register_switch(
+ctx.register_common_switch("with_github_actions", "Use Github Actions", True)
+ctx.register_common_switch(
     "with_github_social", "Use Github ISSUE_TEMPLATE, CONTRIBUTING.md, etc.", True
 )

proj_flow/flow/__init__.py

@@ -6,6 +6,6 @@ The **proj_flow.flow** contains the inner workings of various *Project Flow*
 components.
 """
 
-from . import configs, dependency, init, interact, layer, steps
+from . import configs, layer, steps
 
-__all__ = ["configs", "dependency", "init", "interact", "layer", "steps"]
+__all__ = ["configs", "layer", "steps"]

proj_flow/minimal/base.py

@@ -26,5 +26,6 @@ api.init.register_init_step(GitInit())
 api.ctx.register_init_setting(
     api.ctx.Setting("__flow_version__", value=__version__),
     api.ctx.Setting("${", value="${"),
+    project=None,
     is_hidden=True,
 )