cppmake 127.0.13__py3-none-any.whl → 127.0.16__py3-none-any.whl

cppmakelib/unit/module.py

@@ -0,0 +1,69 @@
+from cppmakelib.compiler.all       import compiler
+from cppmakelib.executor.operation import when_all
+from cppmakelib.executor.scheduler import scheduler
+from cppmakelib.system.all         import system
+from cppmakelib.unit.code          import Code
+from cppmakelib.unit.precompiled   import Precompiled
+from cppmakelib.utility.algorithm  import recursive_collect
+from cppmakelib.utility.decorator  import member, once, relocatable, syncable, unique
+from cppmakelib.utility.filesystem import path
+import typing
+
+class Module(Code):
+    def           __new__         (cls: ..., file: path) -> Module     : ...
+    async def    __anew__         (cls: ..., file: path) -> Module     : ...
+    def           __init__        (self,     file: path) -> None       : ...
+    async def    __ainit__        (self,     file: path) -> None       : ...
+    def             precompile    (self)                 -> Precompiled: ...
+    async def async_precompile    (self)                 -> Precompiled: ...
+    def             is_precompiled(self)                 -> bool       : ...
+    async def async_is_precompiled(self)                 -> bool       : ...
+    name            : str
+    precompiled_file: path
+    object_file     : path
+    diagnostic_file : path
+    import_modules  : list[Module]
+
+    
+
+@member(Module)
+@relocatable
+@syncable
+@unique
+async def __ainit__(self: Module, file: path) -> None:
+    await super(Module, self).__ainit__(file)
+    self.name             = await self.context_package.unit_status_logger.async_get_module_name(module=self)
+    self.precompiled_file = f'{self.context_package.build_module_dir}/{self.name.replace(':', '-')}{compiler.precompiled_suffix}'
+    self.object_file      = f'{self.context_package.build_module_dir}/{self.name.replace(':', '-')}{system.object_suffix}'
+    self.diagnostic_file  = f'{self.context_package.build_module_dir}/{self.name.replace(':', '.')}{compiler.diagnostic_suffix}'
+    self.import_modules   = await when_all([Module.__anew__(Module, file) for file in await self.context_package.unit_status_logger.async_get_module_imports(module=self)])
+
+@member(Module)
+@syncable
+@once
+async def async_precompile(self: Module) -> Precompiled:
+    if not await self.async_is_precompiled():
+        await when_all([module.async_precompile() for module in self.import_modules])
+        await self.async_preprocess()
+        async with scheduler.schedule():
+            await compiler.async_precompile(
+                module_file     =self.file,
+                precompiled_file=self.precompiled_file,
+                object_file     =self.object_file,
+                compile_flags   =self.compile_flags,
+                define_macros   =self.define_macros,
+                include_dirs    =[self.context_package.build_header_dir] + recursive_collect(self.context_package, next=lambda package: package.require_packages, collect=lambda package: package.install_include_dir),
+                import_dirs     =[self.context_package.build_module_dir] + recursive_collect(self.context_package, next=lambda package: package.require_packages, collect=lambda package: package.install_import_dir),
+                diagnostic_file =self.diagnostic_file,
+            )
+        self.context_package.unit_status_logger.set_module_precompiled(module=self, precompiled=True)
+    return Precompiled(self.precompiled_file)
+
+@member(Module)
+@syncable
+@once
+async def async_is_precompiled(self: Module) -> bool:
+    return all(await when_all([module.async_is_precompiled() for module in self.import_modules ])) and \
+           await self.async_is_preprocessed()                                                      and \
+           self.context_package.unit_status_logger.get_module_precompiled(module=self)
+

cppmakelib/unit/object.py

@@ -0,0 +1,71 @@
+from cppmakelib.compiler.all       import compiler
+from cppmakelib.unit.binary        import Binary
+from cppmakelib.unit.dynamic       import Dynamic
+from cppmakelib.unit.executable    import Executable
+from cppmakelib.utility.algorithm  import recursive_collect
+from cppmakelib.utility.decorator  import member, once, syncable, unique
+from cppmakelib.utility.filesystem import iterate_dir, path
+
+class Object(Binary):
+    def           __new__    (cls,  file: path) -> Object    : ...
+    def           __init__   (self, file: path) -> None      : ...
+    def             share    (self)             -> Dynamic   : ...
+    async def async_share    (self)             -> Dynamic   : ...
+    def             is_shared(self)             -> bool      : ...
+    async def async_is_shared(self)             -> bool      : ...
+    def             link     (self)             -> Executable: ...
+    async def async_link     (self)             -> Executable: ...
+    def             is_linked(self)             -> bool      : ...
+    async def async_is_linked(self)             -> bool      : ...
+    static_file    : path
+    dynamic_file   : path
+    executable_file: path
+    lib_objects    : list[Object]
+
+
+
+@member(Object)
+@unique
+def __init__(self: Object, file: path) -> None:
+    super(Object, self).__init__(file)
+    self.lib_objects = [Object(file) for file in self.context_package.unit_status_logger.get_object_libs(object=self)]
+
+@member(Object)
+@syncable
+@once
+async def async_share(self: Object) -> Dynamic:
+    await compiler.async_share(
+        object_file =self.file,
+        dynamic_file=self.dynamic_file,
+        link_flags  =self.link_flags,
+        lib_files   =recursive_collect(self,                 next=lambda object : object.lib_objects,       collect=lambda object : object.file) +
+                     recursive_collect(self.context_package, next=lambda package: package.require_packages, collect=lambda package: [file for file in iterate_dir(package.install_lib_dir)], flatten=True)
+    )
+    return Dynamic(self.dynamic_file)
+
+@member(Object)
+@syncable
+@once
+async def async_is_shared(self: Object) -> bool:
+    return self.context_package.unit_status_logger.get_object_shared(object=self)
+
+@member(Object)
+@syncable
+@once
+async def async_link(self: Object) -> Executable:
+    await compiler.async_link(
+        object_file    =self.file,
+        executable_file=self.executable_file,
+        link_flags     =self.link_flags,
+        lib_files      =recursive_collect(self,                 next=lambda object : object.lib_objects,       collect=lambda object : object.file) +
+                        recursive_collect(self.context_package, next=lambda package: package.require_packages, collect=lambda package: [file for file in iterate_dir(package.install_lib_dir)], flatten=True)
+    )
+    return Executable(self.executable_file)
+
+# 1. Module.compile() -> Precompiled, Object, 需要Module(...).precompile()[0].install(), [0]来的莫名其妙, 返回struct更是莫名其妙
+# 2. Module.compile() -> Precompiled, Precompiled.xxx() -> Object, 想不出xxx名字
+# 3. Module.compile() -> Precompiled, 而Object直接link Precompiled本身, 不知道gcc/msvc如何支持, 且降低性能, Module需要预链接为.o的
+# 4. Module.compile() -> Precompield (+ implicit Object), 可以Module(...).precompile().install, 这里Object的属性如何？
+
+# 1. Object构造时传入所有依赖, 外部接口丑
+# 2. Object由unit_status_logger记录来源于哪里，module/source->object反向记录, 需要提前Module.__anew__, 内部逻辑丑

cppmakelib/unit/package.py

@@ -0,0 +1,87 @@
+from cppmakelib.basic.config          import config
+from cppmakelib.basic.context         import context
+from cppmakelib.executor.operation    import when_all
+from cppmakelib.executor.scheduler    import scheduler
+from cppmakelib.logger.unit_status    import UnitStatusLogger
+from cppmakelib.utility.decorator     import member, once, syncable, unique
+from cppmakelib.utility.filesystem    import path
+from cppmakelib.utility.import_       import import_module
+import types
+import typing
+
+class Package:
+    def           __new__   (cls,  dir: path) -> Package: ...
+    def           __init__  (self, dir: path) -> None   : ...
+    def             build   (self)            -> None   : ...
+    async def async_build   (self)            -> None   : ...
+    def             is_built(self)            -> bool   : ...
+    async def async_is_built(self)            -> bool   : ...
+    # ========
+    name               : str
+    dir                : path
+    # ========
+    search_header_dir  : path # redefinable in cppmake.py
+    search_module_dir  : path # redefinable in cppmake.py
+    # ========
+    build_dir          : path
+    build_cache_dir    : path
+    build_code_dir     : path
+    build_header_dir   : path
+    build_module_dir   : path
+    build_source_dir   : path
+    # ========
+    install_dir        : path
+    install_bin_dir    : path
+    install_import_dir : path
+    install_include_dir: path
+    install_lib_dir    : path
+    # ========
+    compile_flags      : list[str]      # redefinable in cppmake.py
+    link_flags         : list[str]      # redefinable in cppmake.py
+    define_macros      : dict[str, str] # redefinable in cppmake.py
+    # ========
+    require_packages   : list[Package]
+    # ========
+    unit_status_logger : UnitStatusLogger
+    # ========
+    cppmake_file       : path
+    cppmake            : types.ModuleType
+    # ========
+    
+
+@member(Package)
+@unique
+def __init__(self: Package, dir: path) -> None:
+    self.dir                 = dir
+    self.search_header_dir   = f'{self.dir}/header'
+    self.search_module_dir   = f'{self.dir}/module'
+    self.build_dir           = f'binary/{config.type}/{self.name}/build'
+    self.build_cache_dir     = f'binary/{config.type}/{self.name}/build/cache'
+    self.build_code_dir      = f'binary/{config.type}/{self.name}/build/code'
+    self.build_header_dir    = f'binary/{config.type}/{self.name}/build/header'
+    self.build_module_dir    = f'binary/{config.type}/{self.name}/build/module'
+    self.build_source_dir    = f'binary/{config.type}/{self.name}/build/source'
+    self.install_dir         = f'binary/{config.type}/{self.name}/install'
+    self.install_bin_dir     = f'binary/{config.type}/{self.name}/install/bin'
+    self.install_import_dir  = f'binary/{config.type}/{self.name}/install/import'
+    self.install_include_dir = f'binary/{config.type}/{self.name}/install/include'
+    self.install_lib_dir     = f'binary/{config.type}/{self.name}/install/lib'
+    self.compile_flags       = []
+    self.link_flags          = []
+    self.define_macros       = {}
+    self.require_packages    = []
+    self.unit_status_logger  = UnitStatusLogger(build_cache_dir=self.build_cache_dir)
+    self.cppmake_file        = f'{self.dir}/cppmake.py'
+    with context.switch(package=self):
+        self.cppmake = import_module(file=self.cppmake_file, globals={'self': self})
+
+
+@member(Package)
+@syncable
+@once
+async def async_build(self: Package) -> None:
+    await when_all([package.async_build() for package in self.require_packages])
+    async with scheduler.schedule(scheduler.max):
+        with context.switch(package=self):
+            # lazy-print(f'build package {self.name}')
+            self.cppmake.build() if hasattr(self.cppmake, 'build') else None

cppmakelib/unit/precompiled.py

@@ -0,0 +1,6 @@
+from cppmakelib.unit.binary        import Binary
+from cppmakelib.utility.filesystem import path
+
+class Precompiled(Binary):
+    def __new__ (cls,  file: path) -> Precompiled: ...
+    def __init__(self, file: path) -> None       : ...

cppmakelib/unit/preparsed.py

@@ -0,0 +1,6 @@
+from cppmakelib.unit.binary        import Binary
+from cppmakelib.utility.filesystem import path
+
+class Preparsed(Binary):
+    def __new__ (cls,  file: path) -> Preparsed: ...
+    def __init__(self, file: path) -> None     : ...

cppmakelib/unit/preprocessed.py

@@ -0,0 +1,3 @@
+from cppmakelib.utility.filesystem import path
+
+Preprocessed = path

cppmakelib/unit/source.py

@@ -0,0 +1,64 @@
+from cppmakelib.compiler.all       import compiler
+from cppmakelib.executor.operation import when_all
+from cppmakelib.executor.scheduler import scheduler
+from cppmakelib.system.all         import system
+from cppmakelib.unit.code          import Code
+from cppmakelib.unit.module        import Module
+from cppmakelib.unit.object        import Object
+from cppmakelib.utility.algorithm  import recursive_collect
+from cppmakelib.utility.decorator  import member, once, relocatable, syncable, unique
+from cppmakelib.utility.filesystem import path
+
+class Source(Code):
+    def           __new__      (cls: ..., file: path) -> Source: ...
+    async def    __anew__      (cls: ..., file: path) -> Source: ...
+    def           __init__     (self,     file: path) -> None  : ...
+    async def    __ainit__     (self,     file: path) -> None  : ...
+    def             compile    (self)                 -> Object: ...
+    async def async_compile    (self)                 -> Object: ...
+    def             is_compiled(self)                 -> bool  : ...
+    async def async_is_compiled(self)                 -> bool  : ...
+    name           : str
+    object_file    : path
+    diagnostic_file: path
+    import_modules : list[Module]
+
+
+
+@member(Source)
+@relocatable
+@syncable
+@unique
+async def __ainit__(self: Source, file: path) -> None:
+    await super(Source, self).__ainit__(file)
+    self.object_file     = f'{self.context_package.build_source_dir}/{self.name}{system.object_suffix}'
+    self.diagnostic_file = f'{self.context_package.build_source_dir}/{self.name}{system.executable_suffix}'
+    self.import_modules  = await when_all([Module.__anew__(Module, file) for file in await self.context_package.unit_status_logger.async_get_source_imports(source=self)])
+
+@member(Source)
+@syncable
+@once
+async def async_compile(self: Source) -> Object:
+    if not await self.async_is_compiled():
+        await when_all([module.async_precompile() for module in self.import_modules ])
+        await self.async_preprocess()
+        async with scheduler.schedule():
+            await compiler.async_compile(
+                source_file    =self.file,
+                object_file    =self.object_file,
+                compile_flags  =self.compile_flags,
+                define_macros  =self.define_macros,
+                include_dirs   =[self.context_package.build_header_dir] + recursive_collect(self.context_package, next=lambda package: package.require_packages, collect=lambda package: package.install_include_dir),
+                import_dirs    =[self.context_package.build_module_dir] + recursive_collect(self.context_package, next=lambda package: package.require_packages, collect=lambda package: package.install_import_dir),                    
+                diagnostic_file=self.diagnostic_file,
+            )
+        self.context_package.unit_status_logger.set_source_compiled(source=self, compiled=True)
+    return Object(self.object_file)
+
+@member(Source)
+@syncable
+@once
+async def async_is_compiled(self: Source) -> bool:
+    return all(await when_all([module.async_is_precompiled() for module in self.import_modules ])) and \
+           await self.async_is_preprocessed()                                                      and \
+           self.context_package.unit_status_logger.get_source_compiled(source=self)

cppmakelib/utility/algorithm.py

@@ -0,0 +1,44 @@
+import typing
+
+def recursive_collect[T, U, R](node: U, next: typing.Callable[[U | T], list[T]], collect: typing.Callable[[U | T], R | list[R] | None], flatten: bool = False) -> list[R]: ...
+
+if typing.TYPE_CHECKING:
+    @typing.overload
+    def recursive_collect[T, U, R](node: U, next: typing.Callable[[U | T], list[T]], collect: typing.Callable[[T], R | None], *, flatten: typing.Literal[False] = False) -> list[R]: ...
+    @typing.overload
+    def recursive_collect[T, U, R](node: U, next: typing.Callable[[U | T], list[T]], collect: typing.Callable[[T], list[R]],  *, flatten: typing.Literal[True])          -> list[R]: ...
+
+
+
+# Our goal is to make the caller more pretty (with the algorithm itself to be maybe dirty).
+# Feel free to overwrite the implemention when we need something new from it.
+
+def recursive_collect[T, U, R](
+    node   : U, 
+    next   : typing.Callable[[U | T], list[T]], 
+    collect: typing.Callable[[T], R | list[R] | None], 
+    flatten: bool = False
+) -> list[R]:
+   return _recursive_collect_impl(node, next, collect, flatten, True, set(), list())
+
+def _recursive_collect_impl[T, U, R](
+    node     : U | T, 
+    next     : typing.Callable[[U | T], list[T]], 
+    collect  : typing.Callable[[T], R | list[R] | None], 
+    flatten  : bool,
+    root     : bool,
+    visited  : set[T],
+    collected: list[R]
+) -> list[R]:
+    if node not in visited:
+        if not root:
+            visited |= {typing.cast(T, node)}
+            value = collect(typing.cast(T, node))
+            if value is not None and value not in collected:
+                if not flatten:
+                    collected += [typing.cast(R, value)]
+                else:
+                    collected += typing.cast(list[R], value)
+        for subnode in next(node):
+            _recursive_collect_impl(subnode, next, collect, flatten, True, visited, collected)
+    return collected

cppmakelib/utility/color.py

@@ -0,0 +1,14 @@
+def red(str):
+    return f'\033[31m{str}\033[39m'
+
+def green(str):
+    return f'\033[32m{str}\033[39m'
+
+def yellow(str):
+    return f'\033[33m{str}\033[39m'
+
+def blue(str):
+    return f'\033[34m{str}\033[39m'
+
+def bold(str):
+    return f'\033[1m{str}\033[22m'

cppmakelib/utility/decorator.py

@@ -0,0 +1,120 @@
+from cppmakelib.basic.context      import context
+from cppmakelib.executor.operation import sync_wait
+from cppmakelib.utility.filesystem import path, relative_path
+import asyncio
+import functools
+import inspect
+import threading
+import typing
+
+def implement  [**Ts, R](func: typing.Callable[Ts, R])                                                            -> typing.Callable[Ts, R]                                                           : ...
+def member              (cls: type)                                                                               -> typing.Callable[[typing.Callable[..., typing.Any]], None]                        : ...
+def once       [S, R]   (func: typing.Callable[[S], typing.Coroutine[typing.Any, typing.Any, R]])                 -> typing.Callable[[S], typing.Coroutine[typing.Any, typing.Any, R]]                : ...
+def relocatable[S, R]   (func: typing.Callable[[S, path], R])                                                     -> typing.Callable[[S, path], R]                                                    : ...
+def syncable   [**Ts, R](func: typing.Callable[Ts, typing.Coroutine[typing.Any, typing.Any, R]])                  -> typing.Callable[Ts, typing.Coroutine[typing.Any, typing.Any, R]]                 : ...
+def unique     [S]      (func: typing.Callable[[S, path], None | typing.Coroutine[typing.Any, typing.Any, None]]) -> typing.Callable[[S, path], None | typing.Coroutine[typing.Any, typing.Any, None]]: ...
+
+if typing.TYPE_CHECKING:
+    @typing.overload
+    def unique[S](func: typing.Callable[[S, path],                                          None ]) -> typing.Callable[[S, path],                                          None ]: ...
+    @typing.overload
+    def unique[S](func: typing.Callable[[S, path], typing.Coroutine[typing.Any, typing.Any, None]]) -> typing.Callable[[S, path], typing.Coroutine[typing.Any, typing.Any, None]]: ...
+
+# Every project has its own kind of shit mountain,
+# and the main difference lies in where those mountains are placed.
+# Some pile them up in plain sight, fully transparent to users
+# (for example, C++ templates, which exposes every bit of the mess
+# from their inner implementations but gains 'zero-cost abstraction'),
+# while others prefer to hide them deep in a corner where no one can ever reach 
+# (for example, the Python GIL).
+#
+# Here, in this project, we've gathered and neatly buried
+# all our shit in the file below. :)
+
+def implement[**Ts, R](func: typing.Callable[Ts, R]) -> typing.Callable[Ts, R]:
+    if inspect.isfunction(func):
+        return func
+    elif isinstance(func, _MultiFunc):
+        for subfunc in func.functions:
+            setattr(inspect.getmodule(subfunc), subfunc.__name__, subfunc)
+        return typing.cast(_MultiFunc[Ts, R], func)
+    else:
+        assert False
+
+def member(cls: type) -> typing.Callable[[typing.Callable[..., typing.Any]], None]:
+    def memberizer(func: typing.Callable[..., typing.Any]) -> None:
+        if inspect.isfunction(func):
+            setattr(cls, func.__name__, func)
+        elif isinstance(func, _MultiFunc):
+            for subfunc in func.functions:
+                setattr(cls, subfunc.__name__, subfunc)
+        else:
+            assert False
+    return memberizer
+
+def once[S, R](func: typing.Callable[[S], typing.Coroutine[typing.Any, typing.Any, R]]) -> typing.Callable[[S], typing.Coroutine[typing.Any, typing.Any, R]]:
+    async def once_func(self: S) -> R:
+        if not hasattr      (self, f'_once_{func.__name__}'):
+            setattr         (self, f'_once_{func.__name__}', asyncio.create_task(func(self)))
+        return await getattr(self, f'_once_{func.__name__}')
+    once_func.__name__ = func.__name__
+    return once_func
+
+def relocatable[S, R](func: typing.Callable[[S, path], R]) -> typing.Callable[[S, path], R]:
+    def relocatable_func(self: S, path: path) -> R:
+        relocated_path = relative_path(from_path='.', to_path=f'{context.package.dir}/{path}')
+        return func(self, relocated_path)
+    relocatable_func.__name__ = func.__name__
+    return relocatable_func
+
+def syncable[**Ts, R](func: typing.Callable[Ts, typing.Coroutine[typing.Any, typing.Any, R]]) -> typing.Callable[Ts, typing.Coroutine[typing.Any, typing.Any, R]]:
+    if inspect.isfunction(func):
+        assert func.__name__.startswith('async_') or func.__name__.startswith('__a')
+        def sync_func(*args: Ts.args, **kwargs: Ts.kwargs) -> R:
+            return sync_wait(func(*args, **kwargs))
+        sync_func.__name__ = func.__name__.removeprefix('async_') if func.__name__.startswith('async_') else func.__name__.replace('__a', '__')
+        return _MultiFunc(func, sync_func)
+    elif isinstance(func, _MultiFunc):
+        return _MultiFunc[Ts, typing.Coroutine[typing.Any, typing.Any, R]](*[syncable(subfunc) for subfunc in func.functions])
+    else:
+        assert False
+
+def unique[S](func: typing.Callable[[S, path], None | typing.Coroutine[typing.Any, typing.Any, None]]) -> typing.Callable[[S, path], None | typing.Coroutine[typing.Any, typing.Any, None]]:
+    if inspect.isfunction(func) and not inspect.iscoroutinefunction(func):
+        assert func.__name__ == '__init__'
+        def unique_func(cls: type, path: path):
+            if not hasattr        (cls, f'_unique'):
+                setattr           (cls, f'_unique', {})
+            if path not in getattr(cls, f'_unique').keys():
+                getattr           (cls, f'_unique')[path] = super(cls, cls).__new__(cls)
+            return getattr        (cls, f'_unique')[path]
+        unique_func.__name__ = '__new__'
+        return _MultiFunc(func, unique_func)
+    elif inspect.iscoroutinefunction(func):
+        assert func.__name__ == '__ainit__'
+        async def unique_func(cls: type, path: path):
+            if not hasattr        (cls, f'_unique'):
+                setattr           (cls, f'_unique', {})
+            if path not in getattr(cls, f'_unique').keys():
+                getattr           (cls, f'_unique')[path] = super(cls, cls).__new__(cls)
+            await getattr         (cls, f'_unique')[path].__ainit__(path)
+            return getattr        (cls, f'_unique')[path]
+        unique_func.__name__  = '__anew__'
+        return _MultiFunc(func, unique_func)
+    elif isinstance(func, _MultiFunc):
+        return _MultiFunc(*[unique(subfunc) for subfunc in func.functions])
+    else:
+        assert False
+
+class _MultiFunc[**Ts, R]:
+    def __init__ (self, first: typing.Callable[Ts, R], *other: ...) -> None: ...
+    def __call__ (self, *args: Ts.args, **kwargs: Ts.kwargs)        -> R   : ...
+    functions: tuple[typing.Callable[Ts, R], ...]
+
+@member(_MultiFunc)
+def __init__[**Ts, R](self: _MultiFunc[Ts, R], first: typing.Callable[Ts, R], *other: ...) -> None:
+    self.functions = (first, *other)
+
+@member(_MultiFunc)
+def __call__[**Ts, R](self: _MultiFunc[Ts, R], *args: Ts.args, **kwargs: Ts.kwargs) -> R:
+    return self.functions[0](*args, **kwargs)

cppmakelib/utility/filesystem.py

@@ -0,0 +1,71 @@
+from cppmakelib.utility.time import time
+import os
+import shutil
+import typing
+
+path = str
+
+def absolute_path     (path     : path)                -> path                 : ...
+def copy_dir          (from_dir : path, to_dir : path) -> None                 : ...
+def copy_file         (from_file: path, to_file: path) -> None                 : ...
+def create_dir        (dir      : path)                -> None                 : ...
+def create_file       (file     : path)                -> None                 : ...
+def iterate_dir       (dir      : path)                -> typing.Iterable[path]: ...
+def exist_dir         (dir      : path)                -> bool                 : ...
+def exist_file        (file     : path)                -> bool                 : ...
+def modified_time_file(file     : path)                -> time                 : ...
+def parent_dir        (path     : path)                -> path                 : ...
+def relative_path     (from_path: path, to_path: path) -> path                 : ...
+def remove_dir        (dir      : path)                -> None                 : ...
+def remove_file       (file     : path)                -> None                 : ...
+def root_dir          (path     : path)                -> path                 : ...
+
+
+
+def absolute_path(path: path) -> path:
+    return os.path.abspath(path)
+
+def copy_dir(from_dir: path, to_dir: path) -> None:
+    shutil.copytree(from_dir, to_dir, dirs_exist_ok=True)
+
+def copy_file(from_file: path, to_file: path) -> None:
+    shutil.copyfile(from_file, to_file)
+
+def create_dir(dir: path) -> None:
+    os.makedirs(dir, exist_ok=True)
+
+def create_file(file: path) -> None:
+    create_dir(parent_dir(file))
+    open(file, 'w')
+
+def iterate_dir(dir: path) -> typing.Iterable[path]:
+    for root, _, filenames in os.walk(dir):
+        for filename in filenames:
+            yield f'{path(root)}/{filename}'
+
+def exist_dir(dir: path) -> bool:
+    return os.path.isdir(dir)
+
+def exist_file(file: path) -> bool:
+    return os.path.isfile(file)
+        
+def modified_time_file(file: path) -> time:
+    return os.stat(file).st_mtime_ns
+
+def parent_dir(self: path) -> path:
+    return os.path.dirname(self)
+
+def relative_path(from_path: path, to_path: path) -> path:
+    return os.path.relpath(to_path, from_path)
+
+def remove_dir(dir: path) -> None:
+    shutil.rmtree(dir, ignore_errors=True)
+
+def remove_file(file: path) -> None:
+    try:
+        os.remove(file)
+    except FileNotFoundError:
+        pass
+        
+def root_dir(path: path) -> path:
+    return os.path.splitroot(path)[0]

cppmakelib/utility/import_.py

@@ -0,0 +1,21 @@
+from cppmakelib.error.config       import ConfigError
+from cppmakelib.utility.filesystem import path
+import importlib.util
+import types
+import typing
+
+def import_module(file: path, globals: dict[str, typing.Any] = {}) -> types.ModuleType: ...
+
+
+
+def import_module(file: path, globals: dict[str, typing.Any] = {}) -> types.ModuleType:
+    try:
+        spec = importlib.util.spec_from_file_location(name=file, location=file)
+    except FileNotFoundError as error:
+        raise ConfigError(f'cppmake.py is not found') from error
+    if spec is None or spec.loader is None:
+        raise ConfigError(f'cppmake.py is not loaded (with file = {file})')
+    module = importlib.util.module_from_spec(spec)
+    module.__dict__.update(globals)
+    spec.loader.exec_module(module)
+    return module

cppmakelib/utility/remote/client.py

@@ -0,0 +1,2 @@
+class Client:
+    def 

cppmakelib/utility/remote/protocol.py

@@ -0,0 +1,32 @@
+from cppmakelib.utility.filesystemimport path
+from cppmakelib.utility.decorator import member
+
+class Protocol:
+    async def async_send_file   (self, file: path): ...
+    async def async_receive_file(self, file: path): ...
+    def relocate_client(self, file: path) -> str : ...
+    def relocate_server(self, file: str ) -> path: ...
+    
+    class _Datagram:
+        ...
+    async def _async_send_datagram(self, datagram: _Datagram) -> None    : ...
+    async def _async_send_datagram(self)                     -> _Datagram: ...
+
+
+
+@member(Protocol)
+async def async_send_file(self: Protocol, file: path):
+    with open(self.relocate_client(file), 'rb') as reader:
+        content = reader.read()
+    datagram = Protocol._Datagram({Protocol._Datagram{
+        "file"   : self.reloate_client(file),
+        "content": content
+    })
+    await self._async_send_datagram(datagram)
+
+@member(Protocol)
+async def async_receive_file(self: Protocol, file: path):
+    datagram = await self._async_receive_datagram()
+    with open(self.relocate_server(file), 'wb') as writer:
+        writer.write(bytes)
+

cppmakelib/utility/remote/remote.py

@@ -0,0 +1,43 @@
+from cppmakelib.compiler.all      import compiler
+from cppmakelib.utility.filesystemimport path
+from cppmakelib.utility.decorator import member
+
+class RemoteCompiler:
+    def __init__(self, protocol: Protocol): ...
+    def preprocess(): ...
+    def precompile(): ...
+    def compile   (): ...
+    def link      (): ...
+
+class DistributedCompiler:
+    def __init__(self, local_compiler: ..., remote_compilers: list[...]): ...
+    def preprocess(): ...
+    def precompile(): ...
+    def compile   (): ...
+    def link      (): ...
+
+local_compiler   = compiler
+remote_compilers = [RemoteCompiler(compiler) for compiler in config.remote_compilers]
+compiler         = DistributeCompiler(local_compiler, remote_compilers)
+
+
+
+@member(RemoteCompiler)
+def preprocess(self: RemoteCompiler):
+    return local_compiler.preprocess()
+
+@member(RemoteCompiler)
+def precompile(
+    self            : RemoteCompiler,
+    module_file     : path,
+    precompiled_file: path, 
+    object_file     : path, 
+    compiler_flags  : list[str],
+    define_macros   : dict[str, str],
+    include_dirs    : list[path],
+    import_dirs     : list[path]
+) -> None:
+    await when_all(self.protocol.async_send_file(file) for file in recursive_collect(import_files...))
+    await self.protocol.async_send_command(precompile, module_file, precompiled_file, object_file, ...)
+    await self.protocol.async_receive_file(object_file)
+