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

proj_flow/__init__.py

@@ -1,4 +1,4 @@
 # Copyright (c) 2025 Marcin Zdun
 # This code is licensed under MIT license (see LICENSE for details)
 
-__version__ = "0.9.2"
+__version__ = "0.9.4"

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/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,7 +2,8 @@
 # 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

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
 

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>`.
 """

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/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

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,

proj_flow/ext/cplusplus/cmake/steps.py

@@ -0,0 +1,142 @@
+# Copyright (c) 2025 Marcin Zdun
+# This code is licensed under MIT license (see LICENSE for details)
+
+"""
+The **proj_flow.ext.cplusplus.cmake.steps** defines steps for configuring,
+building and archiving.
+"""
+
+import os
+from typing import Dict, List, cast
+
+from proj_flow import api
+from proj_flow.api import env, step
+
+from .__version__ import CMAKE_VERSION
+
+
+class CMakeBase(api.step.Step):
+    _name: str
+    _runs_after: List[str] = []
+    _runs_before: List[str] = []
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def runs_after(self):
+        return self._runs_after
+
+    @property
+    def runs_before(self):
+        return self._runs_before
+
+    def __init__(
+        self, name: str, runs_after: List[str] = [], runs_before: List[str] = []
+    ):
+        super().__init__()
+        self._name = name
+        self._runs_after = runs_after
+        self._runs_before = runs_before
+
+    def is_active(self, config: api.env.Config, rt: api.env.Runtime) -> int:
+        return os.path.isfile("CMakeLists.txt") and os.path.isfile("CMakePresets.json")
+
+    def platform_dependencies(self):
+        return [f"cmake>={CMAKE_VERSION}"]
+
+    def dep_with_tool(self, tool: str):
+        return [f"cmake>={CMAKE_VERSION}", f"{tool}>={CMAKE_VERSION}"]
+
+
+@step.register
+class CMakeConfig(CMakeBase):
+    """Configures the project using ``preset`` config."""
+
+    def __init__(self):
+        super().__init__(name="CMake")
+
+    def is_active(self, config: env.Config, rt: env.Runtime) -> int:
+        return os.path.isfile("CMakeLists.txt") and os.path.isfile("CMakePresets.json")
+
+    def directories_to_remove(self, config: env.Config) -> List[str]:
+        return [f"build/{config.build_type}"]
+
+    def run(self, config: env.Config, rt: env.Runtime) -> int:
+        cmake_vars = cast(Dict[str, str], rt._cfg.get("cmake", {}).get("vars", {}))
+        defines: List[str] = []
+        for var in cmake_vars:
+            value = cmake_vars[var]
+
+            is_flag = value.startswith("?")
+            if is_flag:
+                value = value[1:]
+
+            if value.startswith("config:"):
+                value = value[len("config:")]
+                value = config.get_path(value)
+            elif value.startswith("runtime:"):
+                value = value[len("runtime:")]
+                value = getattr(rt, value, None)
+
+            if is_flag:
+                value = "ON" if value else "OFF"
+
+            defines.append(f"-D{var}={value}")
+
+        return rt.cmd(
+            "cmake",
+            "--preset",
+            f"{config.preset}-{config.build_generator}",
+            *defines,
+        )
+
+
+@step.register()
+class CMakeBuild(CMakeBase):
+    """Builds the project using ``preset`` config."""
+
+    def __init__(self):
+        super().__init__(name="Build", runs_after=["CMake"])
+
+    def run(self, config: env.Config, rt: env.Runtime) -> int:
+        return rt.cmd("cmake", "--build", "--preset", config.preset, "--parallel")
+
+
+@step.register
+class CMakeTest(CMakeBase):
+    """Runs tests in the project using ``preset`` config."""
+
+    def __init__(self):
+        super().__init__(name="Test", runs_after=["Build"])
+
+    def platform_dependencies(self):
+        return self.dep_with_tool("ctest")
+
+    def run(self, config: env.Config, rt: env.Runtime) -> int:
+        return rt.cmd("ctest", "--preset", config.preset)
+
+
+@step.register
+class PackStep(CMakeBase):
+    """
+    Packs archives and installers from ``cpack_generator`` config, using
+    ``preset`` config.
+    """
+
+    def __init__(self):
+        super().__init__(name="Pack", runs_after=["Build"])
+
+    def platform_dependencies(self):
+        return self.dep_with_tool("cpack")
+
+    def is_active(self, config: env.Config, rt: env.Runtime) -> int:
+        return (
+            super().is_active(config, rt)
+            and len(config.items.get("cpack_generator", [])) > 0
+        )
+
+    def run(self, config: env.Config, rt: env.Runtime) -> int:
+        generators = ";".join(config.items.get("cpack_generator", []))
+        return rt.cmd("cpack", "--preset", config.preset, "-G", generators)

proj_flow/ext/cplusplus/cmake/version.py

@@ -0,0 +1,35 @@
+# Copyright (c) 2025 Marcin Zdun
+# This code is licensed under MIT license (see LICENSE for details)
+
+"""
+The **proj_flow.ext.cplusplus.cmake.version** provides project suite plugin.
+"""
+
+import os
+import re
+from typing import NamedTuple, Optional
+
+import toml
+
+from proj_flow.api import env, release
+from proj_flow.ext.cplusplus.cmake.parser import get_project
+
+
+class QuickProjectInfo(NamedTuple):
+    name: Optional[str] = None
+    path: Optional[str] = None
+    pattern: Optional[str] = None
+
+
+@release.project_suites.add
+class ProjectSuite(release.ProjectSuite):
+    def get_project(self, rt: env.Runtime) -> Optional[release.Project]:
+        project = get_project(rt.root)
+        if project is None:
+            return None
+        return release.Project(
+            project.name.value, release.Version(project.version, project.stability)
+        )
+
+    def get_version_file_path(self, rt: env.Runtime) -> Optional[str]:
+        return "CMakeLists.txt"

proj_flow/{plugins → ext/cplusplus}/conan/__init__.py

@@ -2,7 +2,7 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.plugins.conan** provides the ``"Conan"`` step.
+The **proj_flow.ext.cplusplus.conan** provides the ``"Conan"`` step.
 """
 
 import os
@@ -23,6 +23,7 @@ class ConanConfig:
     """Configures the project for ``preset`` config using ``build_type`` config."""
 
     name = "Conan"
+    runs_before = ["CMake"]
 
     def platform_dependencies(self):
         return ["conan"]

proj_flow/{plugins → ext/cplusplus}/conan/_conan.py

@@ -2,10 +2,12 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.plugins.conan._conan** adds support for both Conan v1 and v2.
+The **proj_flow.ext.cplusplus.conan._conan** adds support for both Conan v1
+and v2.
 """
 
 import shutil
+import subprocess
 from abc import ABC, abstractmethod
 from typing import Callable, List, cast
 
@@ -119,7 +121,10 @@ def _conan_version():
     if found is None:
         return 1
 
-    proc = cmd.run(found, "--version", capture_output=True)
+    proc = cast(
+        subprocess.CompletedProcess[str],
+        cmd.run(found, "--version", capture_output=True),
+    )
     if proc.returncode != 0:
         return 1
     m = VER_REGEX.search(proc.stdout)

proj_flow/ext/github/__init__.py

@@ -6,6 +6,6 @@ The **proj_flow.ext.github** provides GitHub support through CLI and GitHub
 hosting plugin.
 """
 
-from . import cli, hosting
+from . import cli, hosting, switches
 
-__all__ = ["cli", "hosting"]
+__all__ = ["cli", "hosting", "switches"]

proj_flow/ext/github/cli.py

@@ -107,9 +107,10 @@ def release(
     forced_level = commit.FORCED_LEVEL.get(force) if force else None
     git = commit.Git(rt)
     gh_links = hosting.github.GitHub.from_repo(git) or commit.NoHosting()
+    released = False
 
     try:
-        log.release.add_release(
+        next_tag = log.release.add_release(
             rt=rt,
             forced_level=forced_level,
             take_all=all,
@@ -118,8 +119,16 @@ def release(
             git=git,
             hosting=gh_links,
         )
+        released = not not next_tag
     except log.release.VersionNotAdvancing as err:
         rt.message(err.message, level=env.Msg.STATUS)
-        return 0
+        return
     except log.error.ReleaseError as err:
         rt.fatal(err.message)
+    finally:
+        if "GITHUB_ACTIONS" in os.environ:
+            GITHUB_OUTPUT = os.environ.get("GITHUB_OUTPUT")
+            if GITHUB_OUTPUT is not None:
+                with open(GITHUB_OUTPUT, "a", encoding="UTF-8") as github_output:
+                    print(f"tag={next_tag}", file=github_output)
+                    print(f"released={json.dumps(released)}", file=github_output)

proj_flow/{plugins/github.py → ext/github/switches.py}

@@ -1,7 +1,7 @@
 # Copyright (c) 2025 Marcin Zdun
 # This code is licensed under MIT license (see LICENSE for details)
 """
-The **proj_flow.plugins.github** provides GitHub-related switches for new
+The **proj_flow.ext.github.switches** provides GitHub-related switches for new
 projects.
 """
 

proj_flow/ext/{markdown_changelist.py → markdown_changelog.py}

@@ -2,7 +2,8 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.ext.markdown_changelist** .
+The **proj_flow.ext.markdown_changelog** registers a
+:class:`api.ChangelogGenerator` plugin implemented for markdown changelogs.
 """
 
 from proj_flow.log.rich_text.api import changelog_generators

proj_flow/ext/python/rtdocs.py

@@ -2,7 +2,7 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.ext.python.steps.rtdocs** defines RTDocs step, which uses
+The **proj_flow.ext.python.rtdocs** defines RTDocs step (`"RTD"`), which uses
 .readthedocs.yaml to build the HTML documentation.
 """
 

proj_flow/ext/python/version.py

@@ -2,8 +2,7 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.ext.python.steps** defines steps for building, installing and
-documenting.
+The **proj_flow.ext.python.version** provides project suite plugin.
 """
 
 import os

proj_flow/ext/{re_structured_changelist.py → re_structured_changelog.py}

@@ -2,7 +2,9 @@
 # This code is licensed under MIT license (see LICENSE for details)
 
 """
-The **proj_flow.ext.re_structured_text** .
+The **proj_flow.ext.re_structured_changelog** registers a
+:class:`api.ChangelogGenerator` plugin implemented for reStructuredText
+changelogs.
 """
 
 from proj_flow.log.rich_text.api import changelog_generators