powermake 1.0.0__tar.gz

powermake-1.0.0/.gitignore

@@ -0,0 +1,3 @@
+.vscode
+__pycache__
+build

powermake-1.0.0/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.3
+Name: powermake
+Version: 1.0.0
+Summary: Yet another makefile tool. This one is meant to be super fast, super easy and crossplatform while leaving full power to the user at any time.
+Project-URL: Homepage, https://github.com/mactul/powermake
+Project-URL: Issues, https://github.com/mactul/powermake/issues
+Author: Macéo Tuloup
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+
+# PowerMake
+
+## What is PowerMake ?
+
+Powermake is an utility to compile C/C++ code, just like Make, Ninja, cmake or xmake.
+
+His goal is to give full power to the user, while being cross-platform, easier to use than Make and faster than Ninja.
+
+## For which project is PowerMake suitable ?
+
+PowerMake was specifically designed for all the complex projects that have very complicated compilation steps, with a lot of pre-built tasks and which need to be compiled on multiple operating systems with different options.
+
+## Advantages of PowerMake
+
+- Extremely fast:
+  - PowerMake is approximately 2x faster than Ninja, at least on relatively small projects
+      - With a project that has 10 000 lines of C:
+        - Ninja takes 1.484 seconds
+        - PowerMake takes 0.649 seconds
+
+- Cross-Platform:
+  - PowerMake is able to detect the compiler installed on your machine and give you an abstraction of the compiler syntax.
+    - This currently works well with GCC/G++/Clang/Clang++/MSVC, but other compilers will be add.
+  - Because it's written in python it works in almost all machine and you can always write the compilation instructions for your machine and for your compiler.
+
+- Gives you complete control of what you are doing. Nothing is hidden and any behavior can be overwritten.
+
+## Disadvantages of PowerMake
+
+- PowerMake is very young so it changes a lot at each version and you may have to write some features by yourself (the whole point of PowerMake is that you can write missing features).
+
+- Because PowerMake gives you full control, the tool can't really now what's you are doing during the compilation step. For example, if we want to import dependencies from another PowerMake, the only thing we can do for you is running the PowerMake where it stands and scanning his output directory. This works well but has some limitations...
+
+## Philosophy
+
+All other Make-like utilities that I know parse a file to understand directives from it.
+
+PowerMake does the opposite. You write a python script, you do whatever you like in this script and you call PowerMake functions to help you compiling your code.  
+This gives you a complete control; you can retrieve files from the web, read an write files, even train a Neural Network if you want and at any time you can use Powermake functions to help you in your compilation journey.
+
+## Installation
+
+Documentation in coming...
+
+## Quick Example
+
+This example compile all `.c` and `.cpp` files that are recursively in the same folder as the python script and generate an executable named `program_test`
+
+**Warning !** PowerMake calculate all paths from his own location, not the location where it is run.  
+For example, `python ./folder/makefile.py` will do the same as `cd ./folder && python ./makefile.py`
+
+```py
+import powermake
+
+
+def on_build(config: powermake.Config):
+
+    files = powermake.get_files("**/*.c", "**/*.cpp")
+
+    objects = powermake.compile_files(config, files)
+
+    print(powermake.link_files(config, objects))
+
+
+powermake.run("program_test", build_callback=on_build)
+```
+
+## Documentation
+
+Documentation in coming...

powermake-1.0.0/README.md

@@ -0,0 +1,70 @@
+# PowerMake
+
+## What is PowerMake ?
+
+Powermake is an utility to compile C/C++ code, just like Make, Ninja, cmake or xmake.
+
+His goal is to give full power to the user, while being cross-platform, easier to use than Make and faster than Ninja.
+
+## For which project is PowerMake suitable ?
+
+PowerMake was specifically designed for all the complex projects that have very complicated compilation steps, with a lot of pre-built tasks and which need to be compiled on multiple operating systems with different options.
+
+## Advantages of PowerMake
+
+- Extremely fast:
+  - PowerMake is approximately 2x faster than Ninja, at least on relatively small projects
+      - With a project that has 10 000 lines of C:
+        - Ninja takes 1.484 seconds
+        - PowerMake takes 0.649 seconds
+
+- Cross-Platform:
+  - PowerMake is able to detect the compiler installed on your machine and give you an abstraction of the compiler syntax.
+    - This currently works well with GCC/G++/Clang/Clang++/MSVC, but other compilers will be add.
+  - Because it's written in python it works in almost all machine and you can always write the compilation instructions for your machine and for your compiler.
+
+- Gives you complete control of what you are doing. Nothing is hidden and any behavior can be overwritten.
+
+## Disadvantages of PowerMake
+
+- PowerMake is very young so it changes a lot at each version and you may have to write some features by yourself (the whole point of PowerMake is that you can write missing features).
+
+- Because PowerMake gives you full control, the tool can't really now what's you are doing during the compilation step. For example, if we want to import dependencies from another PowerMake, the only thing we can do for you is running the PowerMake where it stands and scanning his output directory. This works well but has some limitations...
+
+## Philosophy
+
+All other Make-like utilities that I know parse a file to understand directives from it.
+
+PowerMake does the opposite. You write a python script, you do whatever you like in this script and you call PowerMake functions to help you compiling your code.  
+This gives you a complete control; you can retrieve files from the web, read an write files, even train a Neural Network if you want and at any time you can use Powermake functions to help you in your compilation journey.
+
+## Installation
+
+Documentation in coming...
+
+## Quick Example
+
+This example compile all `.c` and `.cpp` files that are recursively in the same folder as the python script and generate an executable named `program_test`
+
+**Warning !** PowerMake calculate all paths from his own location, not the location where it is run.  
+For example, `python ./folder/makefile.py` will do the same as `cd ./folder && python ./makefile.py`
+
+```py
+import powermake
+
+
+def on_build(config: powermake.Config):
+
+    files = powermake.get_files("**/*.c", "**/*.cpp")
+
+    objects = powermake.compile_files(config, files)
+
+    print(powermake.link_files(config, objects))
+
+
+powermake.run("program_test", build_callback=on_build)
+```
+
+## Documentation
+
+Documentation in coming...

powermake-1.0.0/powermake/__init__.py

@@ -0,0 +1,285 @@
+import os
+import sys
+import glob
+import fnmatch
+import subprocess
+import importlib.util
+import __main__ as __makefile__
+from threading import Lock
+from concurrent.futures import ThreadPoolExecutor
+
+from .config import Config
+from .operation import Operation, needs_update
+from .args_parser import run, default_on_clean, default_on_install
+
+
+os.chdir(os.path.dirname(os.path.realpath(__makefile__.__file__)))
+
+
+def import_module(module_name: str, module_path: str = None):
+    """Import a custom module from a path
+
+    Args:
+        module_name (str): The name of the module once it will be imported
+        module_path (str, optional): The path of the module, if None, it takes the module_name as a path.
+
+    Returns:
+        module: an module object, that you can use as a namespace
+    """
+    spec = importlib.util.spec_from_file_location(module_name, module_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+
+    return module
+
+
+def get_files(*patterns: str) -> set[str]:
+    """Return all files on the disk that matches one of the patterns given
+
+    Supported patterns are `*`, like `./*.c` and `**/` like `./**/*.c` to search all .c recursively, starting at `./`
+
+    Warning: `**.c` will not return all .c recursively, you have to use `**/*.c` for that.
+
+    Args:
+        patterns (str): As many patterns as you want to include
+
+    Returns:
+        set[str]: A set (unordered list) of files. You can use the methods `add` and `update` to add files to this set.
+    """
+    files = set()
+    for pattern in patterns:
+        files.update(glob.glob(pattern, recursive=True))
+    return files
+
+
+def filter_files(files: set[str], *patterns: str) -> set[str]:
+    """Create a copy of the set `files` with all elements that matches `pattern` removed.
+
+    This function will equally works if `files` is an iterable but will always returns a set.
+
+    Args:
+        files (set[str]): The set of files to filter
+        patterns (str): As many patterns as you want to exclude
+
+    Returns:
+        set[str]: the filtered set
+    """
+    output = set()
+    for file in files:
+        for pattern in patterns:
+            if not fnmatch.fnmatch(file, pattern):
+                output.add(file)
+    return output
+
+
+def file_in_files_set(file: str, files_set: set[str]) -> bool:
+    for f in files_set:
+        if os.path.samefile(f, file):
+            return True
+    return False
+
+
+def compile_files(config: Config, files: set[str], force: bool = None) -> set[str]:
+    """Compile each C/C++ file in the `files` set according to the compiler and options stored in `config`
+
+    The compilation is parallelized with `config.nb_jobs` threads
+
+    This function will equally works if `files` is an iterable but will always returns a set.
+
+    Args:
+        config (Config): A powermake.Config object, containing all directives for the compilation. Either the one given to the build_callback or a modified copy.
+        files (set[str]): A set of files that ends by .c, .cpp, .cc or .C to compile in .o (or the specified compiler equivalent extension)
+        force (bool, optional): Whether the function should verify if a file needs to be recompiled or if it should recompile everything.  
+            If not specified, this parameter takes the value of config.rebuild
+
+    Raises:
+        RuntimeError: if no compiler is found
+        ValueError: if `files` contains a file that doesn't ends with .c, .cpp, .cc or .C
+
+    Returns:
+        set[str]: A set of object filepaths generated by by the compilation
+    """
+    generated_objects: set[str] = set()
+    operations: set[Operation] = set()
+
+    if force is None:
+        force = config.rebuild
+
+    if config.single_file is not None:
+        if file_in_files_set(config.single_file, files):
+            files = {config.single_file}
+        else:
+            return set()
+
+    for file in files:
+        output_file = os.path.normpath(config.obj_build_directory + "/" + file.replace("..", "__") + config.c_compiler.obj_extension)
+        os.makedirs(os.path.dirname(output_file), exist_ok=True)
+
+        if config.c_compiler is not None:
+            c_args = config.c_compiler.format_args(config.defines, config.additional_includedirs, config.c_flags + config.c_cpp_flags)
+        else:
+            c_args = None
+
+        if config.cpp_compiler is not None:
+            cpp_args = config.cpp_compiler.format_args(config.defines, config.additional_includedirs, config.cpp_flags + config.c_cpp_flags)
+        else:
+            cpp_args = None
+
+        if file.endswith(".c"):
+            if config.c_compiler is None:
+                raise RuntimeError("No C compiler has been specified and the default config didn't find any")
+            command = config.c_compiler.basic_compile_command(output_file, file, c_args)
+        elif file.endswith((".cpp", ".cc", ".C")):
+            if config.cpp_compiler is None:
+                raise RuntimeError("No C++ compiler has been specified and the default config didn't find any")
+            command = config.cpp_compiler.basic_compile_command(output_file, file, cpp_args)
+        else:
+            raise ValueError("The file extension %s can't be compiled", (os.path.splitext(file)[1], ))
+        operations.add(Operation(output_file, [file], config, command))
+
+    if config.single_file is not None:
+        (op, ) = operations
+        op.execute(force)
+        exit(0)
+
+    print_lock = Lock()
+    with ThreadPoolExecutor(max_workers=config.nb_jobs) as executor:
+        generated_objects = set(executor.map(lambda op: op.execute(force, print_lock), operations))
+
+        if False in generated_objects:
+            generated_objects = False
+
+    return generated_objects
+
+
+def archive_files(config: Config, object_files: set[str], archive_name: str = None, force: bool = None) -> str:
+    """Create a static library from A set of object files.
+
+    Args:
+        config (Config): A powermake.Config object, containing all directives for the compilation. Either the one given to the build_callback or a modified copy.
+        object_files (set[str]): A set of object files, potentially the set generated by `compile_files`
+        archive_name (str, optional): The name of the static library you want to create, minus the extension. If None, it will be lib{config.target_name}
+        force (bool, optional): Whether the function should verify if the static library needs to be re-archived or if it should re-archive in any case.  
+            If not specified, this parameter takes the value of config.rebuild
+
+    Raises:
+        RuntimeError: if no archiver is found
+
+    Returns:
+        str: the path of the archive generated
+    """
+    if force is None:
+        force = config.rebuild
+
+    if archive_name is None:
+        archive_name = "lib"+config.target_name
+
+    if config.archiver is None:
+        raise RuntimeError("No archiver has been specified and the default config didn't find any")
+    output_file = os.path.normpath(config.lib_build_directory + "/" + archive_name + config.archiver.static_lib_extension)
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+    command = config.archiver.basic_archive_command(output_file, object_files)
+    return Operation(output_file, object_files, config, command).execute(force=force)
+
+
+def link_files(config: Config, object_files: set[str], archives: list[str] = [], executable_name: str = None, force: bool = None) -> str:
+    """Create an executable from a list of object files and a list of archive files.
+
+    Args:
+        config (Config): A powermake.Config object, containing all directives for the compilation. Either the one given to the build_callback or a modified copy.
+        object_files (set[str]): A set of object files, potentially the set generated by `compile_files`
+        archives (list[str]): A set of static libraries filepaths
+        executable_name (str, optional): The name of the executable you want to create, minus the extension. If None, it will be config.target_name
+        force (bool, optional): Whether the function should verify if the executable needs to be re-linked or if it should re-link in any case.  
+            If not specified, this parameter takes the value of config.rebuild
+
+    Raises:
+        RuntimeError: if no linker is found
+
+    Returns:
+        str: the path of the executable generated
+    """
+    if force is None:
+        force = config.rebuild
+
+    if executable_name is None:
+        executable_name = config.target_name
+
+    if config.linker is None:
+        raise RuntimeError("No linker has been specified and the default config didn't find any")
+    output_file = os.path.normpath(config.exe_build_directory + "/" + executable_name + config.linker.exe_extension)
+    os.makedirs(os.path.dirname(output_file), exist_ok=True)
+    command = config.linker.basic_link_command(output_file, object_files, archives)
+    return Operation(output_file, object_files.union(archives), config, command).execute(force=force)
+
+
+def delete_files_from_disk(*filepaths: str) -> None:
+    """Delete a set of filepaths from the disk and ignore them if they don't exists
+    """
+    for filepath in filepaths:
+        try:
+            os.remove(filepath)
+        except OSError:
+            pass
+
+
+def run_another_powermake(config: Config, path: str, debug: bool = None, rebuild: bool = None, verbosity: int = None, nb_jobs: int = None) -> list[str]:
+    """Run a powermake from another directory and returns a list of path to all libraries generated
+
+    Args:
+        config (Config): A powermake.Config object, containing all directives for the compilation. Either the one given to the build_callback or a modified copy.
+        path (str): The path of the powermake to run
+        debug (bool, optional): Whether the other powermake should be run in debug mode.  
+            If not specified, this parameter takes the value of config.debug
+        rebuild (bool, optional): Whether the other powermake should be run in rebuild mode.  
+            If not specified, this parameter takes the value of config.rebuild
+        verbosity (int, optional): With which verbosity level the other powermake should be run.  
+            If not specified, this parameter takes the value of config.verbosity
+        nb_jobs (int, optional): With how many threads the other powermake should be run.  
+            If not specified, this parameter takes the value of config.nb_jobs
+
+    Raises:
+        RuntimeError: if the other powermake fails
+
+    Returns:
+        list[str]: A list of path to all libraries generated
+    """
+    if debug is None:
+        debug = config.debug
+    if rebuild is None:
+        rebuild = config.rebuild
+    if verbosity is None:
+        verbosity = config.verbosity
+    if nb_jobs is None:
+        nb_jobs = config.nb_jobs
+
+    command = [sys.executable, path, "--get-lib-build-folder", "-j", str(nb_jobs)]
+    if verbosity == 0:
+        command.append("-q")
+    elif verbosity >= 2:
+        command.append("-v")
+
+    if rebuild:
+        command.append("-r")
+
+    if debug:
+        command.append("-d")
+
+    if config.verbosity >= 1:
+        print("Running", path)
+    if config.verbosity >= 2:
+        print(command)
+
+    try:
+        output = subprocess.check_output(command, encoding="utf-8").splitlines()
+    except OSError:
+        raise RuntimeError(f"Failed to run powermake {path}")
+
+    if verbosity != 0:
+        for line in output[:-1]:
+            print(line)
+
+    path = output[-1]
+    if path != "":
+        return [os.path.join(path, file) for file in os.listdir(path)]
+    return None

powermake-1.0.0/powermake/architecture.py

@@ -0,0 +1,33 @@
+# - applexros: arm64 armv7 armv7s i386 x86_64
+# - windows: x86 x64 arm64
+# - appletvos: arm64 armv7 armv7s i386 x86_64
+# - cross: i386 x86_64 arm arm64 mips mips64 riscv riscv64 loong64 s390x ppc ppc64 sh4
+# - mingw: i386 x86_64 arm arm64
+# - msys: i386 x86_64
+# - linux: i386 x86_64 armv7 armv7s arm64-v8a mips mips64 mipsel mips64el loong64
+# - harmony: armeabi-v7a arm64-v8a x86 x86_64
+# - watchos: armv7k i386
+# - wasm: wasm32 wasm64
+# - iphoneos: arm64 x86_64
+# - haiku: i386 x86_64
+# - bsd: i386 x86_64
+# - android: armeabi armeabi-v7a arm64-v8a x86 x86_64 mips mip64
+# - macosx: x86_64 arm64
+# - cygwin: i386 x86_64
+
+
+def simplify_architecture(architecture: str) -> str:
+    arch = architecture.lower()
+    if arch in ["x86", "x32", "80x86", "8086", "80386", "i286", "i386", "i486", "i586", "i686", "i786", "amd386", "am386", "amd486", "am486", "amd-k5", "amd-k6", "amd-k7"]:
+        return "x86"
+
+    if arch in ["x86_64", "x86-64", "x64", "amd64", "intel64"]:
+        return "x64"
+
+    if arch in ["arm32", "arm", "armv6", "armv6-m", "armv7a", "armv7s", "armv7m", "armv7r", "armv7-a", "armv7-m", "armv7-r", "armeabi", "armeabi-v7a"]:
+        return "arm32"
+
+    if arch in ["arm64", "armv8-a", "armv8.2-a", "armv8.3-a", "armv8-m", "armv8-r"]:
+        return "arm64"
+
+    return None

powermake-1.0.0/powermake/archivers.py

@@ -0,0 +1,68 @@
+import abc
+
+from .tools import Tool
+
+
+class Archiver(Tool, abc.ABC):
+    static_lib_extension = None
+
+    def __init__(self, path):
+        Tool.__init__(self, path)
+
+    @abc.abstractmethod
+    def basic_archive_command(self, outputfile: str, inputfiles: set[str], args: list[str] = []) -> list[str]:
+        return []
+
+
+class ArchiverGNU(Archiver):
+    type = "gnu"
+    static_lib_extension = ".a"
+
+    def __init__(self, path: str = "ar"):
+        super().__init__(path)
+
+    def basic_archive_command(self, outputfile: str, inputfiles: set[str], args: list[str] = []) -> list[str]:
+        return [self.path, "-cr", outputfile, *inputfiles, *args]
+
+
+class ArchiverAR(ArchiverGNU):
+    type = "ar"
+
+    def __init__(self, path: str = "ar"):
+        super().__init__(path)
+
+
+class ArchiverLLVM_AR(ArchiverGNU):
+    type = "llvm-ar"
+
+    def __init__(self, path: str = "llvm-ar"):
+        super().__init__(path)
+
+
+class ArchiverMSVC(Archiver):
+    type = "msvc"
+    static_lib_extension = ".lib"
+
+    def __init__(self, path: str = "lib"):
+        super().__init__(path)
+
+    def basic_archive_command(self, outputfile: str, inputfiles: set[str], args: list[str] = []) -> list[str]:
+        return [self.path, "/nologo", *args, "/out:"+outputfile, *inputfiles]
+
+
+_archiver_types: dict[str, Archiver] = {
+    "gnu": ArchiverGNU,
+    "ar": ArchiverAR,
+    "llvm-ar": ArchiverAR,
+    "msvc": ArchiverMSVC
+}
+
+
+def GenericArchiver(archiver_type: str) -> Archiver:
+    if archiver_type not in _archiver_types:
+        return None
+    return _archiver_types[archiver_type]
+
+
+def get_all_archiver_types() -> set[str]:
+    return _archiver_types.keys()