proj-flow 0.9.3__py3-none-any.whl → 0.10.0__py3-none-any.whl

proj_flow/plugins/commands/ci/matrix.py

@@ -1,46 +0,0 @@
-# Copyright (c) 2025 Marcin Zdun
-# This code is licensed under MIT license (see LICENSE for details)
-
-"""
-The **proj_flow.plugins.commands.ci.matrix** implements ``./flow ci matrix`` command.
-"""
-
-import argparse
-import json
-import os
-import sys
-from typing import Annotated, Optional
-
-from proj_flow.api import arg, env
-from proj_flow.flow.configs import Configs
-
-
-@arg.command("ci", "matrix")
-def matrix(
-    official: Annotated[
-        bool, arg.FlagArgument(help="Cut matrix to release builds only")
-    ],
-    rt: env.Runtime,
-):
-    """Supply data for github actions"""
-
-    configs = Configs(
-        rt, argparse.Namespace(configs=[], matrix=True, official=official)
-    )
-
-    usable = [usable.items for usable in configs.usable]
-    for config in usable:
-        if "--orig-compiler" in config:
-            orig_compiler = config["--orig-compiler"]
-            del config["--orig-compiler"]
-            config["compiler"] = orig_compiler
-    if "GITHUB_ACTIONS" in os.environ:
-        var = json.dumps({"include": usable})
-        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"matrix={var}", file=github_output)
-        else:
-            print(f"matrix={var}")
-    else:
-        json.dump(usable, sys.stdout)

proj_flow/plugins/commands/ci/release.py

@@ -1,116 +0,0 @@
-# Copyright (c) 2025 Marcin Zdun
-# This code is licensed under MIT license (see LICENSE for details)
-
-"""
-The **proj_flow.plugins.commands.ci.release** implements
-``./flow ci release`` command.
-"""
-
-import typing
-
-from proj_flow.api import arg, env
-from proj_flow.log import commit, fmt, hosting, release, rich_text
-from proj_flow.plugins import cmake
-
-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]}"
-
-
-def _bump_version(ver: str, level: commit.Level):
-    split = ver.split("-", 1)
-    if len(split) == 2:
-        stability = f"-{split[1]}"
-    else:
-        stability = ""
-
-    semver = [int(s) for s in split[0].split(".")]
-    while len(semver) < 3:
-        semver.append(0)
-    semver = semver[:3]
-
-    if level.value > commit.Level.BENIGN.value:
-        # This turns [1, 2, 3] through 4 - x into [3, 2, 1]
-        lvl = commit.Level.BREAKING.value - level.value
-        semver[lvl] += 1
-        for index in range(lvl + 1, len(semver)):
-            semver[index] = 0
-
-    return ".".join(str(v) for v in semver) + stability
-
-
-@arg.command("ci", "release")
-def main(
-    rt: env.Runtime,
-    all: typing.Annotated[
-        bool, arg.FlagArgument(help="Take all Conventional Commits.")
-    ],
-    force: typing.Annotated[
-        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)}",
-            meta="level",
-            choices=FORCED_LEVEL_CHOICES,
-        ),
-    ],
-    stability: typing.Annotated[
-        typing.Optional[str],
-        arg.Argument(help="Change the stability of the version.", meta="value"),
-    ],
-):
-    """
-    Bumps the project version based on current git logs, in a "chore" commit,
-    attaches an annotated tag with the version number and pushes it all to , if GitHub CLI
-    """
-    generator = rich_text.markdown.ChangelogGenerator()
-
-    forced_level = commit.FORCED_LEVEL.get(force) if force else None
-
-    project = cmake.parser.get_project(rt.root)
-    if not project:
-        rt.fatal("No CMakeLists.txt with project() found.")
-
-    git = commit.Git(rt)
-    tags = git.tag_list(silent=True)
-    gh_links = hosting.github.GitHub.from_repo(git)
-
-    prev_tag = tags[-1] if len(tags) > 0 else None
-
-    setup = commit.LogSetup(gh_links, prev_tag, None, take_all=all)
-    log, log_level = git.get_log(setup)
-
-    project_version = f"{project.version.value}{project.stability.value}"
-    next_version = _bump_version(project_version, forced_level or log_level)
-    setup.curr_tag = f"v{next_version}"
-
-    if setup.curr_tag in tags:
-        rt.fatal(f"Tag {setup.curr_tag} already exists.")
-
-    files_to_commit: typing.List[str] = []
-    if not rt.dry_run and project_version != next_version:
-        files_to_commit.extend(generator.update_changelog(log, setup, rt))
-        files_to_commit.extend(project.set_version(rt.root, next_version))
-        # TODO: plugins for other places a version would need to be updated
-
-    commit_message = f"release {next_version}"
-    git.add_files(*files_to_commit)
-    git.commit(f"chore: {commit_message}{fmt.format_commit_message(log)}")
-    git.annotated_tag(setup.curr_tag, commit_message)
-
-    if gh_links.is_active:
-        draft_url = gh_links.draft_a_release(log, setup, git).draft_url
-        if draft_url:
-            rt.message("-- Visit draft at", draft_url, level=env.Msg.ALWAYS)
-
-    print()
-
-    print(project_version, "->", next_version)

proj_flow/plugins/sign/win32.py

@@ -1,191 +0,0 @@
-# Copyright (c) 2025 Marcin Zdun
-# This code is licensed under MIT license (see LICENSE for details)
-
-"""
-The **proj_flow.plugins.sign.win32** provides code signing with SignTool
-from Windows SDKs.
-"""
-
-import base64
-import json
-import os
-import platform
-import struct
-import subprocess
-import sys
-import winreg
-from typing import Iterable, List, NamedTuple, Optional, Tuple
-
-from proj_flow.api.env import Runtime
-
-ENV_KEY = "SIGN_TOKEN"
-
-Version = Tuple[int, int, int]
-
-machine = {"ARM64": "arm64", "AMD64": "x64", "X86": "x86"}.get(
-    platform.machine(), "x86"
-)
-
-
-def find_sign_tool(rt: Runtime) -> Optional[str]:
-    with winreg.OpenKeyEx(
-        winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\Microsoft\Windows Kits\Installed Roots"
-    ) as kits:
-        try:
-            kits_root = winreg.QueryValueEx(kits, "KitsRoot10")[0]
-        except FileNotFoundError:
-            rt.message("sign/win32: No KitsRoot10 value")
-            return None
-
-        versions: List[Tuple[Version, str]] = []
-        try:
-            index = 0
-            while True:
-                ver_str = winreg.EnumKey(kits, index)
-                ver = tuple(int(chunk) for chunk in ver_str.split("."))
-                index += 1
-                versions.append((ver, ver_str))
-        except OSError:
-            pass
-    versions.sort()
-    versions.reverse()
-    rt.message(
-        "sign/win32: Regarding versions:", ", ".join(version[1] for version in versions)
-    )
-    for _, version in versions:
-        # C:\Program Files (x86)\Windows Kits\10\bin\10.0.22621.0\x64\signtool.exe
-        sign_tool = os.path.join(kits_root, "bin", version, machine, "signtool.exe")
-        if os.path.isfile(sign_tool):
-            rt.message("sign/win32: using:", sign_tool)
-            return sign_tool
-    return None
-
-
-class Key(NamedTuple):
-    token: str
-    secret: bytes
-
-
-def _get_key_from_contents(key: str, rt: Runtime):
-    try:
-        obj = json.loads(key)
-    except json.decoder.JSONDecodeError:
-        rt.message("sign/win32: the signature is not a valid JSON document")
-        return None
-
-    if not isinstance(obj, dict):
-        rt.message("sign/win32: the signature is missing required fields")
-        return None
-
-    token = obj.get("token")
-    secret = obj.get("secret")
-    if not isinstance(token, str) or not isinstance(secret, str):
-        rt.message("sign/win32: the signature is missing required fields")
-        return None
-
-    return Key(
-        base64.b64decode(token).decode("UTF-8"),
-        base64.b64decode(secret),
-    )
-
-
-def get_key(rt: Runtime) -> Optional[Key]:
-    rt.message(f"sign/win32: trying ${ENV_KEY}")
-    env = os.environ.get(ENV_KEY)
-    if env:
-        key = _get_key_from_contents(env, rt)
-        if key is not None:
-            return key
-    local_signature = os.path.join(".", "signature.key")
-    home_signature = os.path.join(os.path.expanduser("~"), "signature.key")
-    for filename in [local_signature, home_signature]:
-        rt.message(f"sign/win32: trying {filename}")
-        if os.path.isfile(filename):
-            with open(filename, encoding="UTF-8") as file:
-                result = file.read().strip()
-                key = _get_key_from_contents(result, rt)
-                if key is not None:
-                    return key
-
-    rt.message("sign/win32: no key set up")
-
-    return None
-
-
-def is_active(os_name: str, rt: Runtime):
-    if os_name != "windows":
-        return False
-    key = get_key(rt)
-    return (
-        key is not None
-        and key.token is not None
-        and key.secret is not None
-        and find_sign_tool(rt) is not None
-    )
-
-
-_IMAGE_DOS_HEADER = "HHHHHHHHHHHHHH8sHH20sI"
-_IMAGE_NT_HEADERS_Signature = "H"
-_IMAGE_DOS_HEADER_size = struct.calcsize(_IMAGE_DOS_HEADER)
-_IMAGE_NT_HEADERS_Signature_size = struct.calcsize(_IMAGE_NT_HEADERS_Signature)
-_MZ = 23117
-_PE = 17744
-
-
-def is_pe_exec(path: str):
-    with open(path, "rb") as exe:
-        mz_header = exe.read(_IMAGE_DOS_HEADER_size)
-        dos_header = struct.unpack(_IMAGE_DOS_HEADER, mz_header)
-        if dos_header[0] != _MZ:
-            return False
-
-        PE_offset = dos_header[-1]
-        if PE_offset < _IMAGE_DOS_HEADER_size:
-            return False
-
-        if PE_offset > _IMAGE_DOS_HEADER_size:
-            exe.read(PE_offset - _IMAGE_DOS_HEADER_size)
-
-        pe_header = exe.read(_IMAGE_NT_HEADERS_Signature_size)
-        signature = struct.unpack(_IMAGE_NT_HEADERS_Signature, pe_header)[0]
-        return signature == _PE
-
-
-def sign(files: Iterable[str], rt: Runtime):
-    key = get_key(rt)
-
-    if key is None or key.token is None or key.secret is None:
-        print("proj-flow: sign: the key is missing", file=sys.stderr)
-        return 1
-
-    sign_tool = find_sign_tool(rt)
-    if sign_tool is None:
-        print("proj-flow: sign: signtool.exe not found", file=sys.stderr)
-        sys.exit(0)
-
-    with open("temp.pfx", "wb") as pfx:
-        pfx.write(key.secret)
-
-    args = [
-        sign_tool,
-        "sign",
-        "/f",
-        "temp.pfx",
-        "/p",
-        key.token,
-        "/tr",
-        "http://timestamp.digicert.com",
-        "/fd",
-        "sha256",
-        "/td",
-        "sha256",
-        *files,
-    ]
-
-    result = 1
-    try:
-        result = subprocess.run(args, shell=False).returncode
-    finally:
-        os.remove("temp.pfx")
-
-    return result

proj_flow/plugins/store/__init__.py

@@ -1,11 +0,0 @@
-# Copyright (c) 2025 Marcin Zdun
-# This code is licensed under MIT license (see LICENSE for details)
-
-"""
-The **proj_flow.plugins.store** provides ``"Store"``, ``"StoreTests"`` and
-``"StorePackages"`` steps.
-"""
-
-from . import store_both, store_packages, store_tests
-
-__all__ = ["store_both", "store_tests", "store_packages"]

proj_flow/plugins/store/store_both.py

@@ -1,22 +0,0 @@
-# Copyright (c) 2025 Marcin Zdun
-# This code is licensed under MIT license (see LICENSE for details)
-
-"""
-The **proj_flow.plugins.store** provides ``"Store"`` step.
-"""
-
-from proj_flow.api import step
-
-from .store_packages import StorePackages
-from .store_tests import StoreTests
-
-
-@step.register
-class StoreBoth(step.SerialStep):
-    """Stores all artifacts created for ``preset`` config value."""
-
-    name = "Store"
-
-    def __init__(self):
-        super().__init__()
-        self.children = [StoreTests(), StorePackages()]

proj_flow/plugins/store/store_tests.py

@@ -1,21 +0,0 @@
-# Copyright (c) 2025 Marcin Zdun
-# This code is licensed under MIT license (see LICENSE for details)
-
-"""
-The **proj_flow.plugins.store** provides ``"StoreTests"`` step.
-"""
-
-from proj_flow.api import env, step
-
-
-@step.register
-class StoreTests(step.Step):
-    """Stores test results gathered during tests for ``preset`` config value."""
-
-    name = "StoreTests"
-    runs_after = ["Test"]
-
-    def run(self, config: env.Config, rt: env.Runtime) -> int:
-        return rt.cp(
-            f"build/{config.preset}/test-results", "build/artifacts/test-results"
-        )