PyProd 0.2.0.post1__py3-none-any.whl → 0.3.0__py3-none-any.whl

pyprod/prod.py

@@ -33,7 +33,7 @@ class NoRuleToMakeTargetError(Exception):
     pass
 
 
-class InvalidRuleError(Exception):
+class RuleError(Exception):
     pass
 
 
@@ -109,13 +109,11 @@ def glob(path, dir="."):
 
 def rule_to_re(rule):
     if not isinstance(rule, (str, Path)):
-        raise InvalidRuleError(rule)
+        raise RuleError(rule)
 
     srule = str(rule)
     srule = translate(srule)
     srule = replace_pattern(srule, "(?P<stem>.*)", maxreplace=1)
-    if isinstance(rule, Path):
-        return Path(srule)
     return srule
 
 
@@ -132,38 +130,97 @@ def replace_pattern(rule, replaceto, *, maxreplace=None):
             if maxreplace is not None:
                 if n > maxreplace:
                     # contains multiple '%'
-                    raise InvalidRuleError(s_rule)
+                    raise RuleError(f"{s_rule} contains multiple '%'")
+
             return replaceto
 
     s_rule = re.sub("%%|%", f, s_rule)
-    if isinstance(rule, Path):
-        return Path(s_rule)
     return s_rule
 
 
-@dataclass
+def _check_pattern_count(pattern):
+    """Counts number of '%' in the pattern"""
+    matches = re.finditer(r"%%|%", pattern)
+    num = len([m for m in matches if len(m[0]) == 1])
+    if num > 1:
+        raise RuleError(f"{pattern}: Multiple '%' is not allowed")
+    return num
+
+
+def _check_pattern(pattern):
+    matches = re.finditer(r"%%|%", pattern)
+    singles = [m for m in matches if len(m[0]) == 1]
+    if len(singles) > 1:
+        raise RuleError(f"{pattern}: Multiple '%' is not allowed")
+    if not len(singles):
+        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:
-    targets: list
-    pattern: str | None
-    depends: list
-    uses: list | None
-    builder: str | None
-
-    orig_targets: list = field(init=False)
-    orig_depends: list = field(init=False)
-    orig_uses: list = field(init=False)
-
-    def __post_init__(self):
-        self.orig_targets = self.targets
-        self.orig_depends = self.depends
-        self.orig_uses = self.uses
-
-        self.targets = [rule_to_re(r) for r in flatten(self.targets)]
-        self.depends = list(flatten(self.depends))
-        if self.pattern:
-            self.pattern = rule_to_re(self.pattern)
-        if self.uses:
-            self.uses = list(flatten(self.uses))
+    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)
+
+        self.first_target = None
+        for target in flatten(targets or ()):
+            target = str(target)
+            if not target:
+                continue
+
+            if "*" in target:
+                continue
+
+            if _check_pattern_count(target) == 0:
+                # not contain one %
+                self.first_target = target
+                break
+
+        if pattern:
+            pattern = _strip_dot(pattern)
+            if _check_pattern_count(pattern) != 1:
+                raise RuleError(f"{pattern}: Pattern should contain a '%'")
+
+            self.pattern = rule_to_re(pattern)
+        else:
+            self.pattern = None
+
+        self.depends = []
+        for depend in flatten(depends or ()):
+            depend = 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)
+            _check_pattern_count(use)
+            _check_wildcard(use)
+            use = _strip_dot(use)
+            self.uses.append(use)
+
+        self.builder = builder
 
     def __call__(self, f):
         self.builder = f
@@ -211,12 +268,15 @@ class Rules:
                         stem = d
                     elif dep.pattern:
                         m = re.fullmatch(str(dep.pattern), name)
-                        d = m.groupdict().get("stem", None)
-                        if d is not None:
-                            stem = d
+                        if m:
+                            stem = m.groupdict().get("stem", None)
 
-                    depends = [replace_pattern(r, stem) for r in dep.depends]
-                    uses = [replace_pattern(r, stem) for r in dep.uses]
+                    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]
+                    else:
+                        depends = dep.depends[:]
+                        uses = dep.uses[:]
 
                     yield depends, uses, dep
                     break
@@ -237,14 +297,8 @@ class Rules:
 
     def select_first_target(self):
         for dep in self.rules:
-            for target in dep.orig_targets:
-                s_target = str(target)
-                # pattern?
-                matches = re.finditer(r"%%|%", s_target)
-                if any((len(m[0]) == 1) for m in matches):
-                    # has %
-                    continue
-                return target
+            if dep.first_target:
+                return dep.first_target
 
     def select_builder(self, name):
         for depends, uses, dep in self.iter_rule(name):
@@ -356,6 +410,30 @@ class Envs:
         return os.environ.get(name, default=default)
 
 
+def read(filename):
+    with open(filename, "r") as f:
+        return f.read()
+
+
+def write(filename, s, append=False):
+    mode = "a" if append else "w"
+    with open(filename, mode) as f:
+        f.write(s)
+
+
+def quote(s):
+    return shlex.quote(str(s))
+
+
+def squote(*s):
+    ret = [shlex.quote(str(x)) for x in flatten(s)]
+    return ret
+
+
+def makedirs(path):
+    os.makedirs(path, exist_ok=True)
+
+
 class Prod:
     def __init__(self, modulefile, njobs=1, params=None):
         self.modulefile = Path(modulefile)
@@ -372,18 +450,25 @@ class Prod:
 
     def get_module_globals(self):
         globals = {
+            "capture": capture,
+            "check": self.checkers.check,
+            "environ": Envs(),
+            "glob": glob,
+            "makedirs": makedirs,
+            "os": os,
+            "params": self.params,
             "pip": pip,
+            "quote": quote,
+            "q": quote,
+            "squote": squote,
+            "sq": squote,
+            "read": read,
             "rule": self.rules.rule,
-            "check": self.checkers.check,
-            "Path": Path,
             "run": run,
-            "capture": capture,
-            "glob": glob,
-            "MAX_TS": MAX_TS,
-            "environ": Envs(),
             "shutil": shutil,
-            "quote": shlex.quote,
-            "params": self.params,
+            "write": write,
+            "MAX_TS": MAX_TS,
+            "Path": Path,
         }
         return globals
 
@@ -432,13 +517,13 @@ class Prod:
             if isinstance(obj, str | Path):
                 builds.append(obj)
             elif isinstance(obj, Rule):
-                raise InvalidRuleError(obj)
+                raise RuleError(obj)
             elif callable(obj):
                 self.built += 1
                 task = asyncio.create_task(self.run_in_executor(obj))
                 waitings.append(task)
             else:
-                raise InvalidRuleError(obj)
+                raise RuleError(obj)
 
         await self.build(builds)
         await asyncio.gather(*waitings)
@@ -497,11 +582,11 @@ class Prod:
         return Exists(name, True, ret)
 
     async def run(self, name):  # -> Any | int:
-        s_name = str(name)
+        name = str(name)
 
-        self.rules.build_tree(s_name)
-        deps, uses = self.rules.get_dep_names(s_name)
-        selected = self.rules.select_builder(s_name)
+        self.rules.build_tree(name)
+        deps, uses = self.rules.get_dep_names(name)
+        selected = self.rules.select_builder(name)
         if selected:
             build_deps, build_uses, builder = selected
             deps = deps + build_deps
@@ -513,19 +598,19 @@ class Prod:
         if uses:
             await self.build(uses)
 
-        exists = await self.is_exists(s_name)
+        exists = await self.is_exists(name)
 
         if not exists.exists:
-            logger.debug("%r does not exists", str(s_name))
+            logger.debug("%r does not exists", name)
         elif (ts >= MAX_TS) or (exists.ts < ts):
-            logger.debug("%r should be updated", str(s_name))
+            logger.debug("%r should be updated", name)
         else:
-            logger.debug("%r already exists", str(s_name))
+            logger.debug("%r already exists", name)
 
         if not exists.exists and not selected:
-            raise NoRuleToMakeTargetError(s_name)
+            raise NoRuleToMakeTargetError(name)
         elif selected and ((not exists.exists) or (ts >= MAX_TS) or (exists.ts < ts)):
-            logger.warning("building: %r", s_name)
+            logger.warning("building: %r", name)
             await self.run_in_executor(builder.builder, name, *build_deps)
             self.built += 1
             return MAX_TS

{pyprod-0.2.0.post1.dist-info → pyprod-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyProd
-Version: 0.2.0.post1
+Version: 0.3.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.3.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=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,,

pyprod-0.2.0.post1.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=poLehE5Gs_vEZvKrSdMicF016tQeaMMAnFc76ssPQQY,14586
-pyprod/utils.py,sha256=oiiUkSbeqTazbtJ6gz7ZKqG1OvAeV-nV9u_3Y0DCOOM,401
-pyprod/venv.py,sha256=_riw56YQvUOSd55u_1m9ElsqPdjM5qVvIZP6dr9Fzt4,1051
-pyprod-0.2.0.post1.dist-info/METADATA,sha256=WnpzS2zWCnRZxR9cHjrfkI7yUd742pp5idOzdNyJ7Fk,2483
-pyprod-0.2.0.post1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pyprod-0.2.0.post1.dist-info/entry_points.txt,sha256=zFycf8BYSMRDTiI0jftmcvtkf9XM4MZ4BL3JaIer_ZM,44
-pyprod-0.2.0.post1.dist-info/licenses/LICENSE,sha256=OtPgwnlLrsVEYPnTraun5AqftAT5vUv4rIan-qYj7nE,1071
-pyprod-0.2.0.post1.dist-info/RECORD,,