PyProd 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

pyprod/main.py

@@ -14,6 +14,13 @@ parser = argparse.ArgumentParser(
     description="""PyProd - More makable than make""",
 )
 
+parser.add_argument(
+    "-C",
+    "--directory",
+    dest="directory",
+    help="Change to DIRECTORY before performing any operations",
+)
+
 parser.add_argument(
     "-f", "--file", help="Use FILE as the Prodfile (default: 'PRODFILE.py')"
 )
@@ -27,12 +34,8 @@ parser.add_argument(
 )
 
 parser.add_argument(
-    "-C",
-    "--directory",
-    dest="directory",
-    help="Change to DIRECTORY before performing any operations",
+    "-r", "--rebuild", dest="rebuild", action="store_true", help="Rebuild all"
 )
-
 parser.add_argument(
     "-v",
     dest="verbose",
@@ -55,8 +58,13 @@ def print_exc(e):
             logger.exception("Terminated by exception")
 
 
+def init_args(args=None):
+    args = pyprod.args = parser.parse_args(args)
+    return args
+
+
 def main():
-    args = pyprod.args = parser.parse_args()
+    args = init_args()
     pyprod.verbose = args.verbose
     chdir = args.directory
     if chdir:
@@ -89,6 +97,7 @@ def main():
 
     params = {}
     targets = []
+
     for target in args.targets:
         if "=" in target:
             name, value = target.split("=", 1)
@@ -107,7 +116,10 @@ def main():
                 sys.exit("No default target")
             targets = [target]
 
-        ret = asyncio.run(prod.start(targets))
+        ret = 0
+        for target in targets:
+            ret += asyncio.run(prod.start([target]))
+
         if not ret:
             print(f"Nothing to be done for {targets}")
 

pyprod/prod.py

@@ -37,6 +37,10 @@ class RuleError(Exception):
     pass
 
 
+class TargetError(Exception):
+    pass
+
+
 class HandledExceptionError(Exception):
     pass
 
@@ -109,7 +113,7 @@ def glob(path, dir="."):
 
 def rule_to_re(rule):
     if not isinstance(rule, (str, Path)):
-        raise RuleError(rule)
+        raise TypeError(f"str or Path required: {rule}")
 
     srule = str(rule)
     srule = translate(srule)
@@ -156,47 +160,48 @@ def _check_pattern(pattern):
         raise RuleError(f"{pattern}: Pattern should contain a '%'.")
 
 
-def _strip_dot(path):
-    if not path:
-        return path
-    path = Path(path)  # ./aaa/ -> aaa
-    parts = path.parts
-    if ".." in parts:
-        raise RuleError(f"{path}: '..' directory is not allowed")
-    return str(path)
-
-
 def _check_wildcard(path):
     if "*" in path:
         raise RuleError(f"{path}: '*' directory is not allowed")
 
 
-class Rule:
-    def __init__(self, targets, pattern, depends, uses, builder=None):
-        self.targets = []
-        for target in flatten(targets or ()):
-            target = str(target)
-            _check_pattern_count(target)
-            target = _strip_dot(target)
-            target = rule_to_re(target)
-            self.targets.append(target)
+def _name_to_str(name):
+    match name:
+        case Task():
+            return name.name
+        case _TaskFunc():
+            return name.name
+        case Path():
+            return str(name)
+        case str():
+            return name
 
-        self.first_target = None
-        for target in flatten(targets or ()):
-            target = str(target)
-            if not target:
-                continue
+    return name
 
-            if "*" in target:
-                continue
 
-            if _check_pattern_count(target) == 0:
-                # not contain one %
-                self.first_target = target
-                break
+class Rule:
+    def __init__(self, targets, pattern=None, depends=(), uses=(), builder=None):
+        self.targets = []
+        self.first_target = None
+        if targets:
+            for target in flatten(targets):
+                if not target:
+                    continue
+                target = str(target)
+                if not target:
+                    continue
+
+                if not self.first_target:
+                    if "*" not in target:
+                        if _check_pattern_count(target) == 0:
+                            # not contain one %
+                            self.first_target = target
+
+                target = rule_to_re(target)
+                self.targets.append(target)
 
         if pattern:
-            pattern = _strip_dot(pattern)
+            pattern = str(pattern)
             if _check_pattern_count(pattern) != 1:
                 raise RuleError(f"{pattern}: Pattern should contain a '%'")
 
@@ -206,18 +211,16 @@ class Rule:
 
         self.depends = []
         for depend in flatten(depends or ()):
-            depend = str(depend)
+            depend = _name_to_str(depend)
             _check_pattern_count(depend)
             _check_wildcard(depend)
-            depend = _strip_dot(depend)
             self.depends.append(depend)
 
         self.uses = []
         for use in flatten(uses or ()):
-            use = str(use)
+            use = _name_to_str(use)
             _check_pattern_count(use)
             _check_wildcard(use)
-            use = _strip_dot(use)
             self.uses.append(use)
 
         self.builder = builder
@@ -227,6 +230,49 @@ class Rule:
         return f
 
 
+class _TaskFunc:
+    def __init__(self, f, name):
+        self.f = f
+        self.name = name
+
+    def __call__(self, *args, **kwargs):
+        return self.f(*args, **kwargs)
+
+
+def default_builder(self, *args, **kwargs):
+    # default builder
+    pass
+
+
+class Task(Rule):
+    def __init__(self, name, depends, uses, func=None):
+        super().__init__((), pattern=None, depends=depends, uses=uses, builder=func)
+        self.name = _name_to_str(name)
+        if name:
+            self.targets = [name]
+            self.first_target = self.name
+        if func:
+            self._set_funcname(func)
+        if not self.builder:
+            self.builder = default_builder
+
+    def _set_funcname(self, f):
+        if not self.name:
+            if not f.__name__ or f.__name__ == "<lambda>":
+                raise RuleError(
+                    "Task function should have a name. Use @task(name='name')"
+                )
+            self.name = f.__name__
+            self.targets = [f.__name__]
+
+        self.first_target = self.name
+
+    def __call__(self, f):
+        self.builder = f
+        self._set_funcname(f)
+        return _TaskFunc(f, self.name)
+
+
 class Rules:
     def __init__(self):
         self.rules = []
@@ -234,40 +280,52 @@ class Rules:
         self._detect_loop = set()
         self.frozen = False
 
-    def add_rule(self, targets, pattern, depends, uses, builder):
+    def add_rule(self, targets, pattern=None, depends=(), uses=(), builder=None):
+        if builder:
+            if not callable(builder):
+                raise ValueError(f"{builder} is not callable")
+
         if self.frozen:
             raise RuntimeError("No new rule can be added after initialization")
 
-        dep = Rule(
-            targets,
-            pattern,
-            depends,
-            uses,
-            builder,
-        )
+        dep = Rule(targets, pattern, depends, uses, builder)
         self.rules.append(dep)
         return dep
 
-    def rule(self, target, pattern=None, depends=(), uses=()):
-        if (not isinstance(depends, Collection)) or isinstance(depends, str):
-            depends = [depends]
-        if (not isinstance(uses, Collection)) or isinstance(uses, str):
-            uses = [uses]
-        dep = self.add_rule([target], pattern, depends, uses, None)
+    def add_task(self, name=None, depends=(), uses=(), func=None):
+        if self.frozen:
+            raise RuntimeError("No new rule can be added after initialization")
+        dep = Task(name, depends, uses, func)
+        self.rules.append(dep)
+        return dep
+
+    def rule(self, targets, *, pattern=None, depends=(), uses=()):
+        if not targets:
+            raise ValueError("No target specified")
+
+        dep = self.add_rule([targets], pattern, depends, uses, None)
+        return dep
+
+    def task(self, func=None, *, name=None, depends=(), uses=()):
+        if func:
+            if not callable(func):
+                raise ValueError(f"{func} is not callable")
+
+        dep = self.add_task(name, depends, uses, func)
         return dep
 
     def iter_rule(self, name):
-        name = str(name)
+        name = _name_to_str(name)
         for dep in self.rules:
             for target in dep.targets:
-                m = re.fullmatch(str(target), name)
+                m = re.fullmatch(target, name)
                 if m:
                     stem = None
                     d = m.groupdict().get("stem", None)
                     if d is not None:
                         stem = d
                     elif dep.pattern:
-                        m = re.fullmatch(str(dep.pattern), name)
+                        m = re.fullmatch(dep.pattern, name)
                         if m:
                             stem = m.groupdict().get("stem", None)
 
@@ -282,7 +340,6 @@ class Rules:
                     break
 
     def get_dep_names(self, name):
-        assert name
         ret_depends = []
         ret_uses = []
 
@@ -307,11 +364,13 @@ class Rules:
             return depends, uses, dep
 
     def build_tree(self, name, lv=1):
+        assert name
         self.frozen = True
 
-        name = str(name)
+        name = _name_to_str(name)
         if name in self._detect_loop:
-            raise CircularReferenceError(name)
+            raise CircularReferenceError(f"Circular reference detected: {name}")
+
         self._detect_loop.add(name)
         try:
             if name in self.tree:
@@ -326,7 +385,7 @@ class Rules:
                 depends.extend(build_uses)
 
             depends = unique_list(depends)
-            self.tree[name].update(str(d) for d in depends)
+            self.tree[name].update(depends)
             for dep in depends:
                 self.build_tree(dep, lv=lv + 1)
 
@@ -339,17 +398,19 @@ class Checkers:
         self.checkers = []
 
     def get_checker(self, name):
+        name = _name_to_str(name)
         for targets, f in self.checkers:
             for target in targets:
-                if fnmatch(name, str(target)):
+                if fnmatch(name, target):
                     return f
 
-    def add_check(self, target, f):
-        self.checkers.append((list(t for t in flatten(target)), f))
+    def add_check(self, targets, f):
+        targets = list(map(_name_to_str, flatten(targets or ())))
+        self.checkers.append((targets, f))
 
-    def check(self, target):
+    def check(self, targets):
         def deco(f):
-            self.add_check(target, f)
+            self.add_check(targets, f)
             return f
 
         return deco
@@ -421,22 +482,27 @@ def write(filename, s, append=False):
         f.write(s)
 
 
-def quote(s):
-    return shlex.quote(str(s))
-
-
-def squote(*s):
+def quote(*s):
     ret = [shlex.quote(str(x)) for x in flatten(s)]
     return ret
 
 
+def squote(s):
+    s = " ".join(str(e) for e in flatten(s))
+    return shlex.quote(s)
+
+
 def makedirs(path):
     os.makedirs(path, exist_ok=True)
 
 
 class Prod:
     def __init__(self, modulefile, njobs=1, params=None):
-        self.modulefile = Path(modulefile)
+        if modulefile:
+            self.modulefile = Path(modulefile)
+        else:
+            self.modulefile = None
+
         self.rules = Rules()
         self.checkers = Checkers()
         if njobs > 1:
@@ -445,11 +511,14 @@ class Prod:
             self.executor = None
         self.params = Params(params)
         self.buildings = {}
-        self.module = self.load_pyprodfile(self.modulefile)
+        self.module = None
+        if self.modulefile:
+            self.module = self.load_pyprodfile(self.modulefile)
         self.built = 0  # number of build execused
 
     def get_module_globals(self):
         globals = {
+            "build": self.build,
             "capture": capture,
             "check": self.checkers.check,
             "environ": Envs(),
@@ -466,6 +535,7 @@ class Prod:
             "rule": self.rules.rule,
             "run": run,
             "shutil": shutil,
+            "task": self.rules.task,
             "write": write,
             "MAX_TS": MAX_TS,
             "Path": Path,
@@ -489,47 +559,28 @@ class Prod:
     async def run_in_executor(self, func, *args, **kwargs):
         if self.executor:
             loop = asyncio.get_running_loop()
-            return await loop.run_in_executor(
+            ret = await loop.run_in_executor(
                 self.executor, lambda: func(*args, **kwargs)
             )
         else:
-            return func(*args, **kwargs)
+            ret = func(*args, **kwargs)
+
+        return ret
 
     def get_default_target(self):
         return self.rules.select_first_target()
 
     async def start(self, deps):
+        self.loop = asyncio.get_running_loop()
         self.built = 0
-        names = []
-        for name in deps:
-            if isinstance(name, str):
-                value = getattr(self.module, name, None)
-                if value:
-                    names.append(value)
-                else:
-                    names.append(name)
-            else:
-                names.append(name)
-
-        builds = []
-        waitings = []
-        for obj in flatten(names):
-            if isinstance(obj, str | Path):
-                builds.append(obj)
-            elif isinstance(obj, Rule):
-                raise RuleError(obj)
-            elif callable(obj):
-                self.built += 1
-                task = asyncio.create_task(self.run_in_executor(obj))
-                waitings.append(task)
-            else:
-                raise RuleError(obj)
+        self.deps = deps[:]
+        while self.deps:
+            dep = self.deps.pop(0)
+            await self.schedule([dep])
 
-        await self.build(builds)
-        await asyncio.gather(*waitings)
         return self.built
 
-    async def build(self, deps):
+    async def schedule(self, deps):
         tasks = []
         waits = []
         for dep in deps:
@@ -581,9 +632,11 @@ class Prod:
             ret = MAX_TS
         return Exists(name, True, ret)
 
-    async def run(self, name):  # -> Any | int:
-        name = str(name)
+    def build(self, *deps):
+        self.deps[0:0] = [_name_to_str(name) for name in flatten(deps)]
 
+    async def run(self, name):  # -> Any | int:
+        name = _name_to_str(name)
         self.rules.build_tree(name)
         deps, uses = self.rules.get_dep_names(name)
         selected = self.rules.select_builder(name)
@@ -594,9 +647,14 @@ class Prod:
 
         ts = 0
         if deps:
-            ts = await self.build(deps)
+            ts = await self.schedule(deps)
         if uses:
-            await self.build(uses)
+            await self.schedule(uses)
+
+        if selected and isinstance(builder, Task):
+            self.built += 1
+            await self.run_in_executor(builder.builder, *build_deps)
+            return MAX_TS
 
         exists = await self.is_exists(name)
 
@@ -608,8 +666,14 @@ class Prod:
             logger.debug("%r already exists", name)
 
         if not exists.exists and not selected:
-            raise NoRuleToMakeTargetError(name)
-        elif selected and ((not exists.exists) or (ts >= MAX_TS) or (exists.ts < ts)):
+            raise NoRuleToMakeTargetError(f"No rule to make target: {name}")
+
+        elif selected and (
+            (not exists.exists)
+            or (ts >= MAX_TS)
+            or (exists.ts < ts)
+            or pyprod.args.rebuild
+        ):
             logger.warning("building: %r", name)
             await self.run_in_executor(builder.builder, name, *build_deps)
             self.built += 1

pyprod/utils.py

@@ -1,8 +1,8 @@
-from collections.abc import Iterable, Sequence
+from collections.abc import Iterable
 
 
 def flatten(seq):
-    if isinstance(seq, str) or (not isinstance(seq, Sequence)):
+    if isinstance(seq, str) or (not isinstance(seq, Iterable)):
         yield seq
         return
 

pyprod/venv.py

@@ -11,15 +11,15 @@ import pyprod
 from .utils import flatten
 
 THREADID = threading.get_ident()
-pyprodenv = ".pyprod"
 venvdir = None
 
-PYPRODVENV = ".pyprod"
+PYPRODVENV = "pyprod"
 
 
 def makevenv(conffile):
     global venvdir
-    venvdir = Path(".") / f".{conffile.name}{PYPRODVENV}"
+    major, minor = sys.version_info[:2]
+    venvdir = Path(".") / f".{conffile.name}.{major}.{minor}.{PYPRODVENV}"
     if not venvdir.is_dir():
         venv.main([str(venvdir)])
 

{pyprod-0.3.0.dist-info → pyprod-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyProd
-Version: 0.3.0
+Version: 0.4.0
 Summary: PyProd: More Makeable than Make
 Project-URL: Homepage, https://github.com/atsuoishimoto/pyprod
 Project-URL: Documentation, https://pyprod.readthedocs.io/en/latest/
@@ -17,7 +17,7 @@ Description-Content-Type: text/x-rst
 PyProd - More Makeable than Make
 =================================
 
-PyProd is a Python script that can be used as an alternative to Makefile. By leveraging Python's versatility, it enables you to define build rules and dependencies programmatically, allowing for dynamic configurations, integration with existing Python libraries, and custom build logic not easily achievable with traditional Makefiles. For detailed documentation, please refer to the `official documentation <https://pyprod.readthedocs.io/en/latest/>`_.
+PyProd is a Python script that can be used as an alternative to Makefile. By leveraging Python's versatility, it enables you to define build rules and dependencies programmatically, allowing for dynamic configurations, integration with existing Python libraries, and custom build logic not easily achievable with traditional Makefiles. For detailed documentation, please refer to the `official documentation <https://pyprod.readthedocs.io/en/stable/>`_.
 
 
 Features
@@ -42,22 +42,26 @@ With PyProd, a traditional Makefile for C can be expressed as a Python script li
 .. code-block:: python
 
     CC = "gcc"
-    CFLAGS = "-I."
+    CFLAGS = "-c -I."
     DEPS = "hello.h"
     OBJS = "hello.o main.o".split()
+    EXE = "hello.exe"
 
     @rule("%.o", depends=("%.c", DEPS))
     def compile(target, src, *deps):
-        run(CC, "-c -o", target, src, CFLAGS)
+        run(CC, "-o", target, src, CFLAGS)
 
-    @rule("hello.exe", depends=OBJS)
+    @rule(EXE, depends=OBJS)
     def link(target, *objs):
         run(CC, "-o", target, objs)
 
+    @task
     def clean():
         run("rm -f", OBJS, "hello.exe")
 
-    all = "hello.exe"
+    @task
+    def rebuild():
+        build(clean, EXE)
 
 
 To run the build script, simply execute:
@@ -67,6 +71,8 @@ To run the build script, simply execute:
     $ cd project
     $ pyprod
 
+Other examples can be found in the `samples <https://github.com/atsuoishimoto/pyprod/tree/main/samples>`_ directory.
+
 License
 -------
 PyProd is licensed under the MIT License. See the `LICENSE <LICENSE>`_ file for more details.

pyprod-0.4.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+pyprod/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyprod/__main__.py,sha256=Vdhw8YA1K3wPMlbJQYL5WqvRzAKVeZ16mZQFO9VRmCo,62
+pyprod/main.py,sha256=w8xm7Dz4eXF6D6FhZuxlPfU24KpnXciJLuAMT6_y3zI,2808
+pyprod/prod.py,sha256=Vu376JyNqiieCMy8jVvBml3TAf32Pq4XxSdpC4bBdgY,18424
+pyprod/utils.py,sha256=hvqeZhXyVAsHAdPUG6LhBOs2dMVXuDUWBYiIPBcsoKw,391
+pyprod/venv.py,sha256=lRTYxvtX876FQ9-bTYmsOHYV3nuMkKHO5hTLog0iHro,1085
+pyprod-0.4.0.dist-info/METADATA,sha256=zkpPbp07U627hgqWE6yDYGe_dZEDQTCiE3FidIfQ5mM,2652
+pyprod-0.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pyprod-0.4.0.dist-info/entry_points.txt,sha256=zFycf8BYSMRDTiI0jftmcvtkf9XM4MZ4BL3JaIer_ZM,44
+pyprod-0.4.0.dist-info/licenses/LICENSE,sha256=OtPgwnlLrsVEYPnTraun5AqftAT5vUv4rIan-qYj7nE,1071
+pyprod-0.4.0.dist-info/RECORD,,

pyprod-0.3.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-pyprod/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyprod/__main__.py,sha256=Vdhw8YA1K3wPMlbJQYL5WqvRzAKVeZ16mZQFO9VRmCo,62
-pyprod/main.py,sha256=nS0mcLy3Ix7ydnX1Pu5g7ceLzhh6DndwJWO5sjO_qWg,2580
-pyprod/prod.py,sha256=r2e-JSHiTw2SOcv-tYFx4aRpVkQbOb5j9vEVrjT0meE,16694
-pyprod/utils.py,sha256=oiiUkSbeqTazbtJ6gz7ZKqG1OvAeV-nV9u_3Y0DCOOM,401
-pyprod/venv.py,sha256=_riw56YQvUOSd55u_1m9ElsqPdjM5qVvIZP6dr9Fzt4,1051
-pyprod-0.3.0.dist-info/METADATA,sha256=t9TMYeBveYE1LFZNpcYJAtOdUo7gPARFHmIZ9p0bnag,2477
-pyprod-0.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pyprod-0.3.0.dist-info/entry_points.txt,sha256=zFycf8BYSMRDTiI0jftmcvtkf9XM4MZ4BL3JaIer_ZM,44
-pyprod-0.3.0.dist-info/licenses/LICENSE,sha256=OtPgwnlLrsVEYPnTraun5AqftAT5vUv4rIan-qYj7nE,1071
-pyprod-0.3.0.dist-info/RECORD,,