proj-flow 0.9.3__py3-none-any.whl → 0.10.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.3"
+"""
+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.10.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

@@ -24,7 +24,6 @@ from enum import Enum
 from typing import Any, Callable, Dict, List, Optional, Union, cast
 
 from proj_flow.base import plugins, uname
-from proj_flow.base.plugins import load_module_plugins
 
 platform = uname.uname()[0]
 
@@ -152,7 +151,13 @@ class FlowConfig:
             sys.path.insert(0, local_extensions)
 
         for extension in extensions:
-            importlib.import_module(extension)
+            try:
+                importlib.import_module(extension)
+            except ModuleNotFoundError:
+                print(
+                    f"-- error: module `{extension}` was no found, ignoring",
+                    file=sys.stderr,
+                )
 
     @property
     def entry(self) -> Dict[str, dict]:

proj_flow/api/makefile.py

@@ -2,7 +2,7 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.api.makefiles** exposes simple makefiles APIs, so extensions can
+The **proj_flow.api.makefile** exposes simple makefile APIs, so extensions can
 easily provide run steps with multiple scripts being called.
 """
 

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/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/plugins.py

@@ -5,11 +5,9 @@
 The **proj_flow.base.plugins** provide the plugin enumeration helpers.
 """
 
-import importlib
 import json
 import os
-from types import ModuleType
-from typing import Optional, cast
+from typing import cast
 
 import yaml
 
@@ -48,36 +46,3 @@ def load_data(filename: str):
             pass
 
     return {}
-
-
-def _load_plugins(directory: str, package: Optional[str], can_fail=False):
-    for _, dirnames, filenames in os.walk(directory):
-        for dirname in dirnames:
-            if dirname == "__pycache__":
-                continue
-
-            try:
-                importlib.import_module(f".{dirname}", package=package)
-            except ModuleNotFoundError as err:
-                if not can_fail:
-                    raise err
-        for filename in filenames:
-            if filename == "__init__.py":
-                continue
-
-            try:
-                importlib.import_module(
-                    f".{os.path.splitext(filename)[0]}", package=package
-                )
-            except ModuleNotFoundError as err:
-                if not can_fail:
-                    raise err
-        dirnames[:] = []
-
-
-def load_module_plugins(mod: ModuleType, can_fail=False):
-    spec = mod.__spec__
-    if not spec:
-        return
-    for location in spec.submodule_search_locations:  # type: ignore
-        _load_plugins(location, spec.name, can_fail)

proj_flow/base/registry.py

@@ -2,10 +2,12 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.base.registry**
+The **proj_flow.base.registry** allows building extension points, with ability
+to register the plugins with a decorator.
 """
 
 import typing
+from collections import OrderedDict
 
 T = typing.TypeVar("T")
 K = typing.TypeVar("K")
@@ -100,6 +102,19 @@ _debug_copies: typing.List[Registry] = []
 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"] = getattr(item, "name")
+            elif hasattr(item, "__name__"):
+                kw["name"] = getattr(item, "__name__")
+
+            if hasattr(item, "id"):
+                kw["id"] = 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

@@ -10,10 +10,8 @@ The **proj_flow.cli** provides command-line entry for the *Project Flow*.
 import argparse
 import os
 import sys
-from pprint import pprint
-from typing import Dict, Optional, Tuple
 
-from proj_flow.api import arg, env
+from proj_flow.api import env
 from proj_flow.cli import argument, finder
 from proj_flow.flow import steps
 
@@ -31,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

@@ -2,7 +2,7 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.cli.arguments** provides command-line builders and runners,
+The **proj_flow.cli.argument** provides command-line builders and runners,
 supporting the functions decorated with :func:`@arg.command()
 <proj_flow.api.arg.command>`.
 """
@@ -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/__init__.py

@@ -0,0 +1,10 @@
+# Copyright (c) 2025 Marcin Zdun
+# This code is licensed under MIT license (see LICENSE for details)
+
+"""
+The **proj_flow.ext.cplusplus** defines steps and commands for C++ projects.
+"""
+
+from . import cmake, conan
+
+__all__ = ["cmake", "conan"]

proj_flow/ext/cplusplus/cmake/__init__.py

@@ -0,0 +1,12 @@
+# Copyright (c) 2025 Marcin Zdun
+# This code is licensed under MIT license (see LICENSE for details)
+
+"""
+The **proj_flow.ext.cplusplus.cmake** provides ``"CMake"``, ``"Build"``,
+``"Pack"`` and ``"Test"`` steps, as well as CMake-specific initialization
+context.
+"""
+
+from . import context, parser, steps, version
+
+__all__ = ["context", "parser", "steps", "version"]

proj_flow/{plugins → ext/cplusplus}/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/{plugins → ext/cplusplus}/cmake/context.py

@@ -2,8 +2,8 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.plugins.cmake.context** provides CMake-specific initialization
-context.
+The **proj_flow.ext.cplusplus.cmake.context** provides CMake-specific
+initialization context.
 """
 
 import re
@@ -11,7 +11,8 @@ import uuid
 
 import chevron
 
-from proj_flow import api, flow
+from proj_flow import api, project
+from proj_flow.project import cplusplus
 
 from .__version__ import CMAKE_VERSION
 
@@ -49,22 +50,23 @@ class CMakeInit(api.init.InitStep):
 def _list_cmake_types():
     return api.ctx.move_to_front(
         "console-application",
-        sorted(key for key in flow.init.get_internal("cmake").keys() if key),
+        sorted(key for key in project.data.get_internal("cmake").keys() if key),
     )
 
 
 api.init.register_init_step(CMakeInit())
-api.ctx.register_init_setting(
+
+cplusplus.project.register_init_setting(
     api.ctx.Setting("PROJECT.TYPE", "CMake project type", _list_cmake_types)
 )
-api.ctx.register_init_setting(
+cplusplus.project.register_init_setting(
     api.ctx.Setting("cmake", fix="{PROJECT.TYPE$map:cmake}"),
     api.ctx.Setting("CMAKE_VERSION", value=CMAKE_VERSION),
     api.ctx.Setting("PROJECT.WIX.UPGRADE_GUID", value=lambda: str(uuid.uuid4())),
     is_hidden=True,
 )
-api.ctx.register_switch("with_cmake", "Use CMake", True)
-api.ctx.register_internal(
+cplusplus.project.register_switch("with_cmake", "Use CMake", True)
+cplusplus.project.register_internal(
     "cmake",
     {
         "": {"cmd": "add_executable", "type": ""},

proj_flow/{plugins → ext/cplusplus}/cmake/parser.py

@@ -2,13 +2,15 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.plugins.cmake.parser** contains simple CMake parser.
+The **proj_flow.ext.cplusplus.cmake.parser** contains simple CMake parser.
 """
 
 import os
 import re
 from typing import Iterator, List, NamedTuple, Optional
 
+from proj_flow.api.release import NO_ARG, Arg
+
 TOKENS = [
     ("COMMENT", r"#.*"),
     ("STR", r'"[^"]*"'),
@@ -25,39 +27,18 @@ class Token(NamedTuple):
     offset: int
 
 
-class Arg(NamedTuple):
-    value: str
-    offset: int
-
-
 class Command(NamedTuple):
     name: str
     args: List[Arg]
     offset: int
 
 
-class Project(NamedTuple):
+class CMakeProject(NamedTuple):
     name: Arg
     version: Arg
     stability: Arg
     description: Arg
 
-    def set_version(self, directory: str, next_version: str):
-        _patch(directory, self.version, next_version)
-        return ["proj_flow/__init__.py"]
-
-    @property
-    def ver(self):
-        return f"{self.version.value}{self.stability.value}"
-
-    @property
-    def pkg(self):
-        return f"{self.name.value}-{self.ver}"
-
-    @property
-    def tag(self):
-        return f"v{self.ver}"
-
 
 def _token_stream(text: str) -> Iterator[Token]:
     tok_regex = "|".join("(?P<%s>%s)" % pair for pair in TOKENS)
@@ -121,10 +102,7 @@ def _patch(directory: str, arg: Arg, value: str):
         input.write(patched)
 
 
-NO_ARG = Arg("", -1)
-
-
-def get_project(dirname: str) -> Optional[Project]:
+def get_project(dirname: str) -> Optional[CMakeProject]:
     try:
         commands = _cmake(os.path.join(dirname, "CMakeLists.txt"))
     except FileNotFoundError:
@@ -158,7 +136,7 @@ def get_project(dirname: str) -> Optional[Project]:
     if version_stability is None:
         version_stability = NO_ARG
 
-    return Project(
+    return CMakeProject(
         name=project_name,
         version=version,
         stability=version_stability,