proj-flow 0.20.3__py3-none-any.whl → 0.22.0__py3-none-any.whl

proj_flow/__init__.py

@@ -6,4 +6,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.20.3"
+__version__ = "0.22.0"

proj_flow/api/arg.py

@@ -159,6 +159,8 @@ def command(*name: str):
         doc = orig_doc or ""
         if doc:
             doc += "\n\n"
+        doc += f":call: ``proj-flow {' '.join(name)}``\n\n"
+        doc += f":call: ``./flow {' '.join(name)}``\n\n"
 
         for arg in _inspect.signature(entry):
             help = ""

proj_flow/api/completers.py

@@ -57,7 +57,7 @@ def _str_arg(arg: Union[bool, str]):
 def matrix_completer(prefix: str, parser, **kwargs):
     flow_cfg = cast(api.env.FlowConfig, parser.flow)
 
-    matrix_yml = os.path.join(flow_cfg.root, ".flow", "matrix.yml")
+    matrix_yml = flow_cfg.root / ".flow" / "matrix.yml"
     with open(matrix_yml, "r", encoding="UTF-8") as contents:
         data: Dict[str, List[Any]] = yaml.load(contents, Loader=yaml.Loader).get(
             "matrix", {}

proj_flow/api/env.py

@@ -21,10 +21,12 @@ import subprocess
 import sys
 from dataclasses import dataclass
 from enum import Enum
+from pathlib import Path
 from typing import Any, Callable, Dict, List, Optional, Union, cast
 
 from proj_flow.api import ctx
 from proj_flow.base import plugins, uname
+from proj_flow.base.cmake_presets import get_binary_dirs
 
 platform = uname.uname()[0]
 
@@ -32,6 +34,25 @@ platform = uname.uname()[0]
 _flow_config_default_compiler: Optional[Dict[str, str]] = None
 
 
+class CMakeBinaryDirsCache:
+    _dirs: dict[str, Path] | None = None
+    _loaded: bool = False
+
+    @property
+    def dirs(self):
+        if not self._loaded:
+            self._loaded = True
+            self._dirs = get_binary_dirs()
+
+        return self._dirs
+
+    def binary_dir(self, key: str):
+        return (self.dirs or {}).get(key)
+
+
+CMAKE_BINARY_DIRS = CMakeBinaryDirsCache()
+
+
 def default_compiler():
     try:
         return os.environ["DEV_CXX"]
@@ -152,7 +173,7 @@ def _flatten_dict(dst: ctx.SettingsType, defaults: Dict[str, Any], prefix=""):
         dst[this_key] = str(val)
 
 
-def _merge(cfg: dict, defaults: ctx.SettingsType, path: str):
+def _merge(cfg: dict, defaults: ctx.SettingsType, path: Path):
     config = plugins.load_data(path)
     if not isinstance(config, dict):
         return
@@ -173,35 +194,41 @@ def load_extensions(extensions: List[str]):
     for extension in extensions:
         try:
             importlib.import_module(extension)
-        except ModuleNotFoundError:
+        except ImportError as ex:
+            print(
+                f"-- error: loading module `{extension}` resulted in import error: {ex}",
+                file=sys.stderr,
+            )
+        except BaseException as ex:
             print(
-                f"-- error: module `{extension}` was no found, ignoring",
+                f"-- error: there was an error while loading module `{extension}`: {ex}",
                 file=sys.stderr,
             )
 
+
 class FlowConfig:
     _cfg: dict
     steps: list = []
     aliases: List[RunAlias] = []
-    root: str
+    root: Path
 
-    def __init__(self, cfg: Optional["FlowConfig"] = None, root: str = "."):
+    def __init__(self, cfg: Optional["FlowConfig"] = None, root: Path = Path()):
         if cfg is not None:
             self._cfg = cfg._cfg
             self.steps = cfg.steps
             self.aliases = cfg.aliases
             self.root = cfg.root
         else:
-            self.root = os.path.abspath(root)
+            self.root = root.absolute()
             defaults: ctx.SettingsType = {}
             dest: dict = {}
 
             _merge(
                 dest,
                 defaults,
-                os.path.join(os.path.expanduser("~"), ".config", "proj-flow.json"),
+                Path("~").expanduser() / ".config" / "proj-flow.json",
             )
-            _merge(dest, defaults, os.path.join(self.root, ".flow", "config.json"))
+            _merge(dest, defaults, self.root / ".flow" / "config.json")
 
             self._cfg = dest
             self._cfg["defaults"] = defaults
@@ -217,11 +244,9 @@ class FlowConfig:
         extensions = cast(List[str], self._cfg.get("extensions", []))
         extensions.insert(0, "proj_flow.minimal")
 
-        local_extensions = os.path.abspath(
-            os.path.join(self.root, ".flow", "extensions")
-        )
-        if os.path.isdir(local_extensions):
-            sys.path.insert(0, local_extensions)
+        local_extensions = (self.root / ".flow" / "extensions").resolve()
+        if local_extensions.is_dir():
+            sys.path.insert(0, local_extensions.as_posix())
 
         load_extensions(extensions)
 
@@ -459,8 +484,13 @@ class Config:
         return self.items.get("build_name", "")
 
     @property
-    def build_dir(self) -> str:
-        return os.path.join("build", self.preset)
+    def build_dir(self) -> Path:
+        cmake_binary_dir = CMAKE_BINARY_DIRS.binary_dir(
+            f"{self.preset}-{self.build_generator}"
+        )
+        if cmake_binary_dir:
+            return cmake_binary_dir
+        return Path("build") / self.preset
 
     @property
     def preset(self) -> str:

proj_flow/api/release.py

@@ -113,5 +113,5 @@ def get_project(rt: env.Runtime):
 
     _, project = project_suites.find(wrap)
     if project is None:
-        rt.fatal(f"Cannot get project information from {rt.root}")
+        rt.fatal(f"Cannot get project information from {rt.root.as_posix()}")
     return project

proj_flow/api/step.py

@@ -7,6 +7,7 @@ The **proj_flow.api.step** exposes APIs used by run extensions.
 
 import os
 from abc import ABC, abstractmethod
+from pathlib import Path
 from typing import List, cast
 
 from proj_flow.api.env import Config, Runtime
@@ -34,7 +35,7 @@ class Step(ABC):
     def is_active(self, config: Config, rt: Runtime) -> bool:
         return True
 
-    def directories_to_remove(self, config: Config) -> List[str]:
+    def directories_to_remove(self, config: Config) -> List[Path]:
         return []
 
     @abstractmethod
@@ -59,7 +60,7 @@ class SerialStep(Step):
                 return False
         return True
 
-    def directories_to_remove(self, config: Config) -> List[str]:
+    def directories_to_remove(self, config: Config) -> List[Path]:
         return matrix.flatten(
             [child.directories_to_remove(config) for child in self.children]
         )
@@ -87,8 +88,10 @@ def _register_step(step: Step, replace: bool):
                 return
 
         if "READTHEDOCS" not in os.environ:
-            raise NameError(f"Step {name} is marked as replacing, but there is no previous step with that name")
-        
+            raise NameError(
+                f"Step {name} is marked as replacing, but there is no previous step with that name"
+            )
+
     if name in [step.name for step in __steps]:
         if "READTHEDOCS" not in os.environ:
             raise NameError(f"Step {name} already registered")
@@ -133,6 +136,12 @@ def _make_private(f: _inspect.Function):
         f.__doc__ = ":meta private:\n"
 
 
+def _make_private_property(f):
+    if isinstance(f, property):
+        _make_private(cast(_inspect.Function, f))
+        return
+
+
 _dummy_config = Config(
     {
         "os": "${os}",
@@ -154,7 +163,10 @@ def _extend_docstring(conv, step: Step):
             _name_list("Requires", step.platform_dependencies(), template="``{}``"),
             _name_list(
                 "Removes",
-                step.directories_to_remove(_dummy_config),
+                [
+                    dirname.as_posix()
+                    for dirname in step.directories_to_remove(_dummy_config)
+                ],
                 template="``{}``",
             ),
         )
@@ -163,6 +175,9 @@ def _extend_docstring(conv, step: Step):
     doc = conv.__doc__ or "*Docstring is missing!*"
     conv.__doc__ = f"{doc}\n{info}"
 
+    _make_private_property(conv.name)
+    _make_private_property(conv.runs_before)
+    _make_private_property(conv.runs_after)
     _make_private(conv.is_active)
     _make_private(conv.run)
     _make_private(conv.platform_dependencies)

proj_flow/{ext/cplusplus/cmake/presets.py → base/cmake_presets.py}

@@ -2,7 +2,7 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.ext.cplusplus.cmake.presets** check build directories for CMake step.
+The **proj_flow.project.cplusplus.cmake_presets** check build directories for CMake step.
 """
 
 import json
@@ -11,7 +11,7 @@ import platform
 from dataclasses import dataclass
 from enum import Enum
 from pathlib import Path
-from typing import cast
+from typing import Callable, TypeVar, cast
 
 
 class MacroType(Enum):
@@ -40,6 +40,7 @@ MACROS: dict[str, Path | str | MacroType] = {
 class Preset:
     name: str
     binary_dir: str | None
+    build_type: str | None
     generator: str | None
     inherits: list[str]
     file_dir: Path
@@ -82,12 +83,15 @@ class Presets:
         if dirname is None:
             return self.result
 
-        includes, presets = Presets.__load_file(filename)
-        self.__visit_includes(dirname, includes)
-        for preset in presets:
-            self.__visit_preset(dirname, preset)
-        for preset in self.result.values():
-            self.__merge_preset(preset)
+        try:
+            includes, presets = Presets.__load_file(filename)
+            self.__visit_includes(dirname, includes)
+            for preset in presets:
+                self.__visit_preset(dirname, preset)
+            for preset in self.result.values():
+                self.__merge_preset(preset)
+        except FileNotFoundError:
+            return None
 
         return self.result
 
@@ -109,9 +113,12 @@ class Presets:
         binary_dir = cast(str | None, preset.get("binaryDir"))
         generator = cast(str | None, preset.get("generator"))
         inherits = cast(list[str], preset.get("inherits", []))
+        cache = cast(dict, preset.get("cacheVariables", {}))
+        build_type = cast(str | None, cache.get("CMAKE_BUILD_TYPE"))
         self.result[name] = Preset(
             name=name,
             binary_dir=binary_dir,
+            build_type=build_type,
             generator=generator,
             inherits=inherits,
             file_dir=dirname,
@@ -132,6 +139,8 @@ class Presets:
                 preset.binary_dir = parent_preset.binary_dir
             if parent_preset.generator and not preset.generator:
                 preset.generator = parent_preset.generator
+            if parent_preset.build_type and not preset.build_type:
+                preset.build_type = parent_preset.build_type
 
     @staticmethod
     def __load_file(filename: Path):
@@ -143,18 +152,33 @@ class Presets:
         return (includes, presets)
 
 
+def binary_dir_from_preset(preset: Preset, cwd: Path):
+    path = preset.expand()
+    if not path:
+        return None
+    if path.is_relative_to(cwd):
+        path = path.relative_to(cwd)
+    return path
+
+
 def get_binary_dirs():
+    return visit_presets(binary_dir_from_preset)
+
+
+T = TypeVar("T")
+
+
+def visit_presets(mapper: Callable[[Preset, Path], T | None]):
     presets = Presets().visit_file(Path("CMakePresets.json"))
+    if presets is None:
+        return None
 
-    cwd = str(Path.cwd().as_posix()) + "/"
-    result: dict[str, str] = {}
+    cwd = Path.cwd()
+    result: dict[str, T] = {}
     for preset in presets.values():
-        dirname = preset.expand()
-        if dirname is None:
+        mapped = mapper(preset, cwd)
+        if mapped is None:
             continue
-        rel = str(dirname.as_posix())
-        if rel[: len(cwd)] == cwd:
-            rel = rel[len(cwd) :]
-        result[preset.name] = rel
+        result[preset.name] = mapped
 
     return result

proj_flow/base/plugins.py

@@ -6,18 +6,23 @@ The **proj_flow.base.plugins** provide the plugin enumeration helpers.
 """
 
 import json
-import os
+from pathlib import Path
 from typing import cast
 
 import yaml
 
+try:
+    from yaml import CLoader as Loader
+except ImportError:
+    from yaml import Loader
 
-def load_yaml(filename: str):
+
+def load_yaml(filename: Path):
     with open(filename) as src:
-        return cast(dict, yaml.load(src, Loader=yaml.Loader))
+        return cast(dict, yaml.load(src, Loader=Loader))
 
 
-def load_json(filename: str):
+def load_json(filename: Path):
     with open(filename) as src:
         return cast(dict, json.load(src))
 
@@ -29,8 +34,8 @@ LOADERS = {
 }
 
 
-def load_data(filename: str):
-    prefix, ext = os.path.splitext(filename)
+def load_data(filename: Path):
+    ext = filename.suffix
     loader = LOADERS.get(ext.lower())
     if loader:
         try:
@@ -39,7 +44,7 @@ def load_data(filename: str):
             pass
 
     for new_ext, loader in LOADERS.items():
-        new_filename = prefix + new_ext
+        new_filename = filename.with_suffix(new_ext)
         try:
             return loader(new_filename)
         except Exception:

proj_flow/cli/finder.py

@@ -9,6 +9,7 @@ contains ``-C`` argument.
 
 import os
 import shlex
+from pathlib import Path
 from typing import List
 
 from argcomplete import finders
@@ -43,7 +44,7 @@ class CompletionFinder(finders.CompletionFinder):
 
     def find_project(self):
         if not self.active():
-            return "."
+            return Path()
 
         comp_line = os.environ["COMP_LINE"]
         comp_point = int(os.environ["COMP_POINT"])
@@ -51,9 +52,9 @@ class CompletionFinder(finders.CompletionFinder):
         pos = find_dash_see(args)
 
         if pos < 0:
-            return "."
+            return Path()
 
-        return args[pos]
+        return Path(args[pos])
 
 
 autocomplete = CompletionFinder()

proj_flow/dependency.py

@@ -57,14 +57,18 @@ class Dependency:
     version_expression: str
     kind: DepKind = DepKind.APP
 
-    def __lt__(self, rhs: "Dependency"):
+    def __lt__(self, rhs: object):
+        if not isinstance(rhs, Dependency):
+            return False
         if self.kind != rhs.kind:
             return self.kind.value < rhs.kind.value
         if self.name != rhs.name:
             return self.name < rhs.name
         return self.version_expression < rhs.version_expression
 
-    def __eq__(self, rhs: "Dependency"):
+    def __eq__(self, rhs: object):
+        if not isinstance(rhs, Dependency):
+            return False
         return (
             self.kind == rhs.kind
             and self.name == rhs.name

proj_flow/ext/cplusplus/cmake/__init__.py

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

proj_flow/ext/cplusplus/cmake/parser.py

@@ -7,6 +7,7 @@ The **proj_flow.ext.cplusplus.cmake.parser** contains simple CMake parser.
 
 import os
 import re
+from pathlib import Path
 from typing import Iterator, List, NamedTuple, Optional
 
 from proj_flow.api.release import NO_ARG, Arg
@@ -76,7 +77,7 @@ def _command(cmd: Token, stream: Iterator[Token]):
     return result
 
 
-def _cmake(filename: str):
+def _cmake(filename: Path):
     commands: List[Command] = []
 
     with open(filename, "r", encoding="UTF-8") as f:
@@ -102,9 +103,9 @@ def _patch(directory: str, arg: Arg, value: str):
         input.write(patched)
 
 
-def get_project(dirname: str) -> Optional[CMakeProject]:
+def get_project(dirname: Path) -> Optional[CMakeProject]:
     try:
-        commands = _cmake(os.path.join(dirname, "CMakeLists.txt"))
+        commands = _cmake(dirname / "CMakeLists.txt")
     except FileNotFoundError:
         return None
 

proj_flow/ext/cplusplus/cmake/steps.py

@@ -7,12 +7,12 @@ building and archiving.
 """
 
 import os
+from pathlib import Path
 from typing import Dict, List, cast
 
 from proj_flow import api
 from proj_flow.api import env, step
 from proj_flow.base.__cmake_version__ import CMAKE_VERSION
-from proj_flow.ext.cplusplus.cmake.presets import get_binary_dirs
 
 
 class CMakeBase(api.step.Step):
@@ -22,14 +22,17 @@ class CMakeBase(api.step.Step):
 
     @property
     def name(self):
+        """:meta private:"""
         return self._name
 
     @property
     def runs_after(self):
+        """:meta private:"""
         return self._runs_after
 
     @property
     def runs_before(self):
+        """:meta private:"""
         return self._runs_before
 
     def __init__(
@@ -47,6 +50,7 @@ class CMakeBase(api.step.Step):
         return [f"cmake>={CMAKE_VERSION}"]
 
     def dep_with_tool(self, tool: str):
+        """:meta private:"""
         return [f"cmake>={CMAKE_VERSION}", f"{tool}>={CMAKE_VERSION}"]
 
 
@@ -56,16 +60,12 @@ class CMakeConfig(CMakeBase):
 
     def __init__(self):
         super().__init__(name="CMake")
-        self.binary_dirs = get_binary_dirs()
 
     def is_active(self, config: env.Config, rt: env.Runtime) -> bool:
         return os.path.isfile("CMakeLists.txt") and os.path.isfile("CMakePresets.json")
 
-    def directories_to_remove(self, config: env.Config) -> List[str]:
-        binary_dir = self.binary_dirs.get(f"{config.preset}-{config.build_generator}")
-        if not binary_dir:
-            return []
-        return [binary_dir]
+    def directories_to_remove(self, config: env.Config) -> List[Path]:
+        return [config.build_dir]
 
     def run(self, config: env.Config, rt: env.Runtime) -> int:
         cmake_vars = cast(Dict[str, str], rt._cfg.get("cmake", {}).get("vars", {}))
@@ -78,10 +78,10 @@ class CMakeConfig(CMakeBase):
                 value = value[1:]
 
             if value.startswith("config:"):
-                value = value[len("config:"):]
+                value = value[len("config:") :]
                 value = config.get_path(value)
             elif value.startswith("runtime:"):
-                value = value[len("runtime:"):]
+                value = value[len("runtime:") :]
                 value = getattr(rt, value, None)
 
             if is_flag:

proj_flow/ext/cplusplus/conan/__init__.py

@@ -7,6 +7,7 @@ The **proj_flow.ext.cplusplus.conan** provides the ``"Conan"`` step.
 
 import os
 import textwrap
+from pathlib import Path
 from typing import List
 
 from proj_flow.api import env, step
@@ -14,7 +15,7 @@ from proj_flow.project import cplusplus
 
 from ._conan import conan_api
 
-CONAN_DIR = "build/conan"
+CONAN_DIR = Path("build/conan")
 CONAN_PROFILE = "_profile-compiler"
 CONAN_PROFILE_GEN = "_profile-build_type"
 
@@ -23,7 +24,9 @@ CONAN_PROFILE_GEN = "_profile-build_type"
 class ConanConfig:
     """Configures the project for ``preset`` config using ``build_type`` config."""
 
+    #: :meta private:
     name = "Conan"
+    #: :meta private:
     runs_before = ["CMake"]
 
     def platform_dependencies(self):
@@ -32,13 +35,13 @@ class ConanConfig:
     def is_active(self, config: env.Config, rt: env.Runtime) -> int:
         return os.path.isfile("conanfile.txt") or os.path.isfile("conanfile.py")
 
-    def directories_to_remove(self, _: env.Config) -> List[str]:
+    def directories_to_remove(self, _: env.Config) -> List[Path]:
         return [CONAN_DIR]
 
     def run(self, config: env.Config, rt: env.Runtime) -> int:
         api = conan_api()
 
-        profile_gen = f"{CONAN_DIR}/{CONAN_PROFILE_GEN}-{config.preset}"
+        profile_gen = f"{CONAN_DIR.as_posix()}/{CONAN_PROFILE_GEN}-{config.preset}"
         if not rt.dry_run:
             os.makedirs(CONAN_DIR, exist_ok=True)
             with open(profile_gen, "w", encoding="UTF-8") as profile:
@@ -58,7 +61,8 @@ class ConanConfig:
                 ]:
                     print(setting, file=profile)
 
-        if api.config(rt, CONAN_DIR, f"./{CONAN_DIR}/{CONAN_PROFILE}", profile_gen):
+        conan_dir = CONAN_DIR.as_posix()
+        if api.config(rt, conan_dir, f"./{conan_dir}/{CONAN_PROFILE}", profile_gen):
             return 1
         if not rt.dry_run and os.path.exists("CMakeUserPresets.json"):
             os.remove("CMakeUserPresets.json")

proj_flow/ext/github/cli.py

@@ -32,9 +32,7 @@ def github():
 
 @arg.command("github", "matrix")
 def matrix(
-    pretty: typing.Annotated[
-        bool, arg.FlagArgument(help="Indent JSON document")
-    ],
+    pretty: typing.Annotated[bool, arg.FlagArgument(help="Indent JSON document")],
     official: typing.Annotated[
         bool, arg.FlagArgument(help="Cut matrix to release builds only")
     ],

proj_flow/ext/github/publishing.py

@@ -31,6 +31,7 @@ def build_regex(project: release.Project):
 
 
 def gather_artifacts(directory: str, matcher: re.Pattern):
+    names: list[str] = []
     if os.path.isdir(directory):
         for _, dirnames, filenames in os.walk(directory):
             dirnames[:] = []