scons-xo-exts-lib 1.4.0__tar.gz

scons_xo_exts_lib-1.4.0/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: scons-xo-exts-lib
+Version: 1.4.0
+Summary: Scons extensions library by XGQT.
+Author-email: Maciej Barć <xgqt@xgqt.org>
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Classifier: Environment :: Console
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Dist: scons>=4.8.1
+Project-URL: Home, https://gitlab.com/xgqt/xgqt-python-lib-scons-xo-exts/
+
+# SCons X.O Exts
+
+SCons extensions
+
+## About
+
+Extensions for SCons, includes Python libraries and builders.
+
+## Repository
+
+Upstream repository is <https://gitlab.com/xgqt/xgqt-python-lib-scons-xo-exts/>.
+
+## Package
+
+Download from PYPI: <https://pypi.org/project/scons-xo-exts-lib/>.
+
+## License
+
+### Code
+
+Code in this project is licensed under the MPL, version 2.0.
+
+    This Source Code Form is subject to the terms of the Mozilla Public
+    License, v. 2.0. If a copy of the MPL was not distributed with this
+    file, You can obtain one at http://mozilla.org/MPL/2.0/.
+

scons_xo_exts_lib-1.4.0/README.md

@@ -0,0 +1,25 @@
+# SCons X.O Exts
+
+SCons extensions
+
+## About
+
+Extensions for SCons, includes Python libraries and builders.
+
+## Repository
+
+Upstream repository is <https://gitlab.com/xgqt/xgqt-python-lib-scons-xo-exts/>.
+
+## Package
+
+Download from PYPI: <https://pypi.org/project/scons-xo-exts-lib/>.
+
+## License
+
+### Code
+
+Code in this project is licensed under the MPL, version 2.0.
+
+    This Source Code Form is subject to the terms of the Mozilla Public
+    License, v. 2.0. If a copy of the MPL was not distributed with this
+    file, You can obtain one at http://mozilla.org/MPL/2.0/.

scons_xo_exts_lib-1.4.0/pyproject.toml

@@ -0,0 +1,28 @@
+[project]
+name = "scons-xo-exts-lib"
+dynamic = [
+    "description",
+    "version",
+]
+authors = [
+    {name = "Maciej Barć", email = "xgqt@xgqt.org"},
+]
+readme = "README.md"
+classifiers = [
+    "Environment :: Console",
+    "Operating System :: POSIX",
+    "Programming Language :: Python :: 3 :: Only",
+]
+requires-python = ">=3.12"
+dependencies = [
+    "scons>=4.8.1",
+]
+
+[project.urls]
+Home = "https://gitlab.com/xgqt/xgqt-python-lib-scons-xo-exts/"
+
+[build-system]
+build-backend = "flit_core.buildapi"
+requires = [
+    "flit_core >=3.2,<4",
+]

scons_xo_exts_lib-1.4.0/src/scons_xo_exts_lib/Actions/Uv.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python
+
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+import os
+
+from SCons.Script import Environment
+
+from ..GenericExtensions import execute_command
+
+
+def uv_venv_action(target, source, env):
+    if os.path.exists(".venv"):
+        return
+    else:
+        execute_command(env, "${UV_EXE} venv")
+
+
+def uv_sync_action(target, source, env):
+    execute_command(env, "${UV_EXE} sync --all-packages")
+
+
+def uv_pip(env, cmd):
+    execute_command(env, "${UV_EXE} pip " + cmd)
+
+
+def uv_pip_freeze_action(target, source, env):
+    output_file = str(target[0])
+
+    uv_pip(env, f"freeze --exclude-editable > {output_file}")
+
+
+def uv_build_pkg_action(target, source, env):
+    if source and isinstance(source, list):
+        pkgs = []
+
+        for a_source in source:
+            a_source_str = str(a_source)
+
+            if "pyproject.toml" in a_source_str:
+                pkg_dir = os.path.dirname(a_source_str)
+
+                pkgs.append(pkg_dir)
+
+        for pkg in pkgs:
+            if pkg:
+                execute_command(env, "${UV_EXE} build " + pkg)
+    else:
+        execute_command(env, "${UV_EXE} build --all-packages")
+
+
+def uv_pytest_action(target, source, env):
+    pytest_exec_flags = env.get("PYTEST_FLAGS", "--capture=no")
+
+    execute_command(env, f"${{UV_EXE}} run -- pytest {pytest_exec_flags}")

scons_xo_exts_lib-1.4.0/src/scons_xo_exts_lib/Actions/__init__.py

@@ -0,0 +1 @@
+#!/usr/bin/env python

scons_xo_exts_lib-1.4.0/src/scons_xo_exts_lib/BuildSupport/Make.py

@@ -0,0 +1,18 @@
+#!/usr/bin/env python
+
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+from typing import List
+
+from SCons.Script import Environment
+
+from .GenericExtensions import execute_command
+
+
+def execute_make(env: Environment, args: List[str]) -> None:
+    make_cmd = "make" + " ".join(args)
+
+    execute_command(env, make_cmd)

scons_xo_exts_lib-1.4.0/src/scons_xo_exts_lib/BuildSupport/NodeMangling.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+import os
+import re
+
+
+def get_first_node(nodes):
+    if isinstance(nodes, list):
+        return nodes[0]
+
+    return nodes
+
+
+def get_first_directory(nodes):
+    node = get_first_node(nodes=nodes)
+    path = node.abspath
+
+    if os.path.isdir(path):
+        return path
+
+    return os.path.dirname(path)
+
+
+def regex_find_node(regex, nodes):
+    for node in nodes:
+        if re.match(pattern=regex, string=str(node.abspath)):
+            return node
+
+    raise RuntimeError("No file was matched using the specified regex")

scons_xo_exts_lib-1.4.0/src/scons_xo_exts_lib/BuildSupport/__init__.py

@@ -0,0 +1 @@
+#!/usr/bin/env python

scons_xo_exts_lib-1.4.0/src/scons_xo_exts_lib/Builders/__init__.py

@@ -0,0 +1 @@
+#!/usr/bin/env python

scons_xo_exts_lib-1.4.0/src/scons_xo_exts_lib/Builders/bazel.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python
+
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+import subprocess
+
+from SCons.Script import Builder
+
+
+def bazel_action(target, source, env):
+    bazel_pkgs = " ".join(str(s) for s in source)
+
+    bazel_exe = env.get("BAZEL_EXE", "bazelisk")
+    bazel_flags = env.get("BAZEL_FLAGS", "")
+
+    cmd = f"{bazel_exe} build {bazel_flags} {bazel_pkgs}"
+    print(cmd)
+
+    result = subprocess.run(
+        args=cmd,
+        capture_output=False,
+        check=False,
+        shell=True,
+    )
+
+    return result.returncode
+
+
+def generate(env):
+    bazel_binary_builder = Builder(action=bazel_action)
+
+    env.Append(BUILDERS={"BazelBinary": bazel_binary_builder})
+
+
+def exists(env):
+    return env.Detect("bazel")

scons_xo_exts_lib-1.4.0/src/scons_xo_exts_lib/Builders/cmake.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python
+
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+import subprocess
+
+from SCons.Script import Builder
+
+
+def cmake_action(target, source, env):
+    cmake_targets = " ".join(str(t) for t in target)
+
+    cmake_exe = env.get("CMAKE_EXE", "cmake")
+    cmake_flags = env.get("CMAKE_FLAGS", "")
+
+    cmd = f"{cmake_exe} {cmake_flags} {cmake_targets}"
+    print(cmd)
+
+    result = subprocess.run(
+        args=cmd,
+        capture_output=False,
+        check=False,
+        shell=True,
+    )
+
+    return result.returncode
+
+
+def generate(env):
+    cmake_binary_builder = Builder(action=cmake_action)
+
+    env.Append(BUILDERS={"CmakeBinary": cmake_binary_builder})
+
+
+def exists(env):
+    return env.Detect("cmake")

scons_xo_exts_lib-1.4.0/src/scons_xo_exts_lib/Builders/dotnet.py

@@ -0,0 +1,304 @@
+#!/usr/bin/env python
+
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+
+import os
+import platform
+import subprocess
+
+from typing import List
+
+from SCons.Script import Builder
+from SCons.Script import Environment
+
+from scons_xo_exts_lib.BuildSupport import NodeMangling
+
+
+def _dotnet_get_dotnet_exe(env: Environment) -> str:
+    dotnet_exe = env.get("DOTNET_EXE")
+
+    if dotnet_exe:
+        return dotnet_exe
+
+    try:
+        return os.path.join(env["DOTNET_ROOT"], "dotnet")
+    except KeyError:
+        return "dotnet"
+
+
+def _dotnet_get_project(source) -> str:
+    regex = ".*\\.(cs|fs|vb|)proj$"
+
+    try:
+        node = NodeMangling.regex_find_node(regex=regex, nodes=source)
+
+        return str(node.abspath)
+    except Exception as exception:
+        raise RuntimeError("No dotnet project file found", exception)
+
+
+def _dotnet_command(env: Environment, source, args: List[str]) -> None:
+    project_file = _dotnet_get_project(source=source)
+    source_directory = os.path.dirname(project_file)
+
+    extra_variables = {
+        "DOTNET_CLI_TELEMETRY_OPTOUT": "1",
+        "DOTNET_NOLOGO": "1",
+        "DOTNET_SKIP_FIRST_TIME_EXPERIENCE": "1",
+        "MSBUILDTERMINALLOGGER": "off",
+    }
+
+    subprocess_env = env.Clone()["ENV"]
+    subprocess_env.update(extra_variables)
+
+    dotnet_exe = _dotnet_get_dotnet_exe(env=env)
+
+    cmd = [dotnet_exe] + args
+    print(cmd)
+
+    result = subprocess.run(
+        args=cmd,
+        capture_output=False,
+        check=False,
+        cwd=source_directory,
+        env=subprocess_env,
+    )
+
+    if result.returncode == 0:
+        return
+
+    raise RuntimeError("Dotnet command failed")
+
+
+def _dotnet_detect_rid() -> str:
+    """
+    Returns a dotnet runtime identifier string in the format "{os}-{arch}".
+
+    OS values: linux, linux-musl, windows, osx
+    Arch values: x64, x86, arm, arm64
+    """
+
+    os_name = "unknownos"
+    os_arch = "unknownarch"
+
+    py_os_name = platform.system().lower()
+    py_os_arch = platform.machine().lower()
+
+    match py_os_name:
+        case "linux":
+            if platform.libc_ver()[0] == "glibc":
+                os_name = "linux"
+            else:
+                os_name = "linux-musl"
+        case "darwin":
+            os_name = "osx"
+        case "windows":
+            os_name = "win"
+        case _:
+            os_name = py_os_name
+
+    match py_os_arch:
+        case "x86_64" | "amd64":
+            os_arch = "x64"
+        case "i386" | "i686":
+            os_arch = "x86"
+        case "aarch64":
+            os_arch = "arm64"
+        case _:
+            os_arch = py_os_arch
+
+    return f"{os_name}-{os_arch}"
+
+
+def _dotnet_get_rid(env: Environment) -> str:
+    key = "DOTNET_RUNTIME"
+
+    if key in env:
+        return env[key]
+
+    return _dotnet_detect_rid()
+
+
+def _dotnet_get_configuration(env: Environment) -> str:
+    key = "DOTNET_CONFIGURATION"
+
+    if key in env:
+        return env[key]
+
+    return "Release"
+
+
+def _dotnet_restore(env: Environment, source) -> None:
+    runtime = _dotnet_get_rid(env=env)
+
+    _dotnet_command(
+        env=env,
+        source=source,
+        args=[
+            "restore",
+            "--force-evaluate",
+            f"--runtime={runtime}",
+        ],
+    )
+
+
+def _dotnet_blazor_restore(env: Environment, source) -> None:
+    _dotnet_command(
+        env=env,
+        source=source,
+        args=[
+            "restore",
+            "--force-evaluate",
+        ],
+    )
+
+
+def _dotnet_build(env: Environment, source) -> None:
+    runtime = _dotnet_get_rid(env=env)
+    configuration = _dotnet_get_configuration(env=env)
+
+    _dotnet_command(
+        env=env,
+        source=source,
+        args=[
+            "build",
+            "--no-restore",
+            f"--runtime={runtime}",
+            f"--configuration={configuration}",
+        ],
+    )
+
+
+def _dotnet_blazor_build(env: Environment, source) -> None:
+    configuration = _dotnet_get_configuration(env=env)
+
+    _dotnet_command(
+        env=env,
+        source=source,
+        args=[
+            "build",
+            "--no-restore",
+            f"--configuration={configuration}",
+        ],
+    )
+
+
+def _dotnet_compile(*args, **kwargs) -> None:
+    _dotnet_restore(*args, **kwargs)
+    _dotnet_build(*args, **kwargs)
+
+
+def _dotnet_blazor_compile(*args, **kwargs) -> None:
+    _dotnet_blazor_restore(*args, **kwargs)
+    _dotnet_blazor_build(*args, **kwargs)
+
+
+def _dotnet_pack(env: Environment, source, target) -> None:
+    runtime = _dotnet_get_rid(env=env)
+    configuration = _dotnet_get_configuration(env=env)
+
+    target_directory = NodeMangling.get_first_directory(nodes=target)
+
+    _dotnet_command(
+        env=env,
+        source=source,
+        args=[
+            "pack",
+            "--no-restore",
+            f"--runtime={runtime}",
+            f"--configuration={configuration}",
+            f"--output={target_directory}",
+        ],
+    )
+
+
+def _dotnet_compile_binary(env: Environment, source, target) -> None:
+    runtime = _dotnet_get_rid(env=env)
+    configuration = _dotnet_get_configuration(env=env)
+
+    target_directory = NodeMangling.get_first_directory(nodes=target)
+
+    _dotnet_command(
+        env=env,
+        source=source,
+        args=[
+            "publish",
+            "--no-restore",
+            "--self-contained",
+            "-p:PublishSingleFile=true",
+            f"--runtime={runtime}",
+            f"--configuration={configuration}",
+            f"--output={target_directory}",
+        ],
+    )
+
+
+def _dotnet_blazor_compile_binary(env: Environment, source, target) -> None:
+    configuration = _dotnet_get_configuration(env=env)
+
+    # Assume we have "target/wwwroot/index.html" as "target".
+    # We have to 1st resolve "wwwroot" path and then resolve it's parent path.
+    wwwroot_directory = NodeMangling.get_first_directory(nodes=target)
+    target_directory = os.path.dirname(wwwroot_directory)
+
+    _dotnet_command(
+        env=env,
+        source=source,
+        args=[
+            "publish",
+            "--no-restore",
+            f"--configuration={configuration}",
+            f"--output={target_directory}",
+        ],
+    )
+
+
+def dotnet_package_build_action(target, source, env: Environment) -> int:
+    try:
+        _dotnet_compile(env=env, source=source)
+        _dotnet_pack(env=env, source=source, target=target)
+    except RuntimeError:
+        return 1
+
+    return 0
+
+
+def dotnet_binary_build_action(target, source, env) -> int:
+    try:
+        _dotnet_compile(env=env, source=source)
+        _dotnet_compile_binary(env=env, source=source, target=target)
+    except RuntimeError:
+        return 1
+
+    return 0
+
+
+def dotnet_blazor_binary_build_action(target, source, env) -> int:
+    try:
+        _dotnet_blazor_compile(env=env, source=source)
+        _dotnet_blazor_compile_binary(env=env, source=source, target=target)
+    except RuntimeError:
+        return 1
+
+    return 0
+
+
+def generate(env: Environment) -> None:
+    dotnet_package_builder = Builder(action=dotnet_package_build_action)
+    dotnet_binary_builder = Builder(action=dotnet_binary_build_action)
+    dotnet_blazor_binary_builder = Builder(action=dotnet_blazor_binary_build_action)
+
+    env.Append(
+        BUILDERS={
+            "DotnetPackage": dotnet_package_builder,
+            "DotnetBinary": dotnet_binary_builder,
+            "DotnetBlazorBinary": dotnet_blazor_binary_builder,
+        }
+    )
+
+
+def exists(env: Environment):
+    return env.Detect("dotnet")