PyProd 0.6.0__tar.gz → 0.8.0__tar.gz

{pyprod-0.6.0 → pyprod-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyProd
-Version: 0.6.0
+Version: 0.8.0
 Summary: PyProd: More Makeable than Make
 Project-URL: Homepage, https://github.com/atsuoishimoto/pyprod
 Project-URL: Documentation, https://pyprod.readthedocs.io/en/latest/

{pyprod-0.6.0 → pyprod-0.8.0}/docs/releasenotes.rst

@@ -1,6 +1,17 @@
 Release Notes
 ================
 
+0.8.0 (2025-4-15)
+-----------------------------
+
+- Allow functions in the ``depends`` and ``uses``.
+
+
+0.7.0 (2025-4-6)
+-----------------------------
+
+- Allow wildcard in the ``depends``.
+
 0.6.0 (2025-4-6)
 -----------------------------
 

pyprod-0.8.0/src/pyprod/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.8.0"

{pyprod-0.6.0 → pyprod-0.8.0}/src/pyprod/prod.py

@@ -17,7 +17,9 @@ from dataclasses import dataclass, field
 from fnmatch import fnmatch, translate
 from functools import wraps
 from pathlib import Path
+
 import dateutil.parser
+
 import pyprod
 
 from .utils import flatten, unique_list
@@ -164,7 +166,7 @@ def _check_pattern(pattern):
 
 def _check_wildcard(path):
     if "*" in path:
-        raise RuleError(f"{path}: '*' directory is not allowed")
+        raise RuleError(f"{path}: '*' is not allowed")
 
 
 def _name_to_str(name):
@@ -183,6 +185,25 @@ def _name_to_str(name):
     return name
 
 
+def _expand_glob(name):
+    if not isinstance(name, (str, Path)):
+        return name
+
+    if "*" not in str(name):
+        return name
+
+    # split path to support absolute path
+    p = Path(name)
+    parts = p.parts
+    for i, part in enumerate(parts):
+        if "*" in part:
+            root = Path(*parts[:i])
+            rest = "/".join(parts[i:])
+            break
+
+    return list(root.glob(rest))
+
+
 class Rule:
     def __init__(self, targets, pattern=None, depends=(), uses=(), builder=None):
         self.targets = []
@@ -219,9 +240,9 @@ class Rule:
             if not depend:
                 continue
 
-            depend = _name_to_str(depend)
-            _check_pattern_count(depend)
-            _check_wildcard(depend)
+            if not callable(depend):
+                depend = _name_to_str(depend)
+                _check_pattern_count(depend)
             self.depends.append(depend)
 
         self.uses = []
@@ -229,9 +250,10 @@ class Rule:
             if not use:
                 continue
 
-            use = _name_to_str(use)
-            _check_pattern_count(use)
-            _check_wildcard(use)
+            if not callable(use):
+                use = _name_to_str(use)
+                _check_pattern_count(use)
+                _check_wildcard(use)
             self.uses.append(use)
 
         self.builder = builder
@@ -345,13 +367,30 @@ class Rules:
                         if m:
                             stem = m.groupdict().get("stem", None)
 
+                    depends = []
+                    for d in dep.depends:
+                        if callable(d):
+                            ret = flatten([d(name, stem)], ignore_none=True)
+                            depends.extend(ret)
+                        else:
+                            depends.append(d)
+
+                    uses = []
+                    for u in dep.uses:
+                        if callable(u):
+                            ret = flatten([u(name, stem)], ignore_none=True)
+                            uses.extend(ret)
+                        else:
+                            uses.append(u)
+
                     if stem is not None:
-                        depends = [replace_pattern(r, stem) for r in dep.depends]
-                        uses = [replace_pattern(r, stem) for r in dep.uses]
+                        depends = [replace_pattern(r, stem) for r in depends]
+                        uses = [replace_pattern(r, stem) for r in uses]
                     else:
                         depends = dep.depends[:]
                         uses = dep.uses[:]
 
+                    depends = list(flatten(_expand_glob(depend) for depend in depends))
                     yield depends, uses, dep
                     break
 

{pyprod-0.6.0 → pyprod-0.8.0}/tests/test_prod.py

@@ -1,3 +1,4 @@
+import json
 import os
 from contextlib import contextmanager
 from pathlib import Path
@@ -95,7 +96,7 @@ def build_app(target, a, b):
     Path(target).write_text(f"{target}, {a}, {b}")
 """
 
-    Path(tmp_path / "Prodfile.py").write_text(src)
+    (tmp_path / "Prodfile.py").write_text(src)
 
     with chdir(tmp_path):
         p = prod.Prod("Prodfile.py", 4)
@@ -108,6 +109,99 @@ def build_app(target, a, b):
     assert (tmp_path / "b.c").read_text() == "b.c"
 
 
+@pytest.mark.asyncio
+async def test_dep_glob(tmp_path):
+    src = """
+@rule(targets=("%.o"), depends=Path("deps/%/*/dep"))
+def build(target, *deps):
+    assert isinstance(target, str)
+    p = Path(target)
+    assert set(deps) == {Path("deps/aaa/bbb/dep"), Path("deps/aaa/ccc/dep")}
+    p.write_text(repr([str(p) for p in deps]))
+"""
+
+    (tmp_path / "Prodfile.py").write_text(src)
+
+    (tmp_path / "deps/aaa/bbb/").mkdir(parents=True, exist_ok=True)
+    (tmp_path / "deps/aaa/bbb/dep").write_text("1")
+
+    (tmp_path / "deps/aaa/ccc/").mkdir(parents=True, exist_ok=True)
+    (tmp_path / "deps/aaa/ccc/dep").write_text("2")
+
+    (tmp_path / "deps/aaa/ddd/").mkdir(parents=True, exist_ok=True)
+
+    with chdir(tmp_path):
+        p = prod.Prod("Prodfile.py")
+        await p.start(["aaa.o"])
+        print((tmp_path / "aaa.o").read_text())
+
+
+@pytest.mark.asyncio
+async def test_dep_glob_no_match(tmp_path):
+    src = """
+@rule(targets=("%.o"), depends=Path("deps/%/*/dep"))
+def build(target, *deps):
+    assert isinstance(target, str)
+    p = Path(target)
+    p.write_text(str(target)+"-"+str(deps))
+"""
+
+    (tmp_path / "Prodfile.py").write_text(src)
+    with chdir(tmp_path):
+        p = prod.Prod("Prodfile.py")
+        await p.start(["aaa.o"])
+        assert (tmp_path / "aaa.o").read_text() == "aaa.o-()"
+
+
+@pytest.mark.asyncio
+async def test_dep_callable(tmp_path):
+    src = """
+def dep1(target, stem):
+    return target+".dep", stem
+
+@rule(targets=("%.o"), depends=dep1)
+def build(target, *deps):
+    print(">>>>>>>>>>>>>>>>>", target, deps)
+    assert deps == ("aaa.o.dep", "aaa")
+"""
+
+    (tmp_path / "Prodfile.py").write_text(src)
+    (tmp_path / "aaa.o.dep").write_text("1")
+    (tmp_path / "aaa").write_text("2")
+
+    with chdir(tmp_path):
+        p = prod.Prod("Prodfile.py")
+        await p.start(["aaa.o"])
+
+
+@pytest.mark.asyncio
+async def test_uses_callable(tmp_path):
+    src = """
+def call1(target, stem):
+    return "call1-name"
+
+def call2(target, stem):
+    return "call2-name"
+
+@rule(targets=("%.o"), uses=(call1, call2))
+def build(target, *deps):
+    print(">>>>>>>>>>>>>>>>>", target, deps)
+"""
+
+    (tmp_path / "Prodfile.py").write_text(src)
+    (tmp_path / "call1-name").write_text("1")
+
+    with chdir(tmp_path):
+        p = prod.Prod("Prodfile.py")
+        with pytest.raises(prod.NoRuleToMakeTargetError):
+            await p.start(["aaa.o"])
+
+    (tmp_path / "call2-name").write_text("2")
+    with chdir(tmp_path):
+        p = prod.Prod("Prodfile.py")
+        await p.start(["aaa.o"])
+
+
 @pytest.mark.asyncio
 async def test_preserve_pathobj(tmp_path):
     src = """

{pyprod-0.6.0 → pyprod-0.8.0}/tests/test_rule.py

@@ -126,9 +126,6 @@ def test_validate_depends():
     with pytest.raises(prod.RuleError):
         prod.Rule("a.%", None, "%.%", "")
 
-    with pytest.raises(prod.RuleError):
-        prod.Rule("a.%", None, "*/x.y", "")
-
     prod.Rule("a.b", None, "x.y", "")
 
 

pyprod-0.6.0/src/pyprod/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.6.0"