pymake

commit 02d5f992b24639a2fa9ade4d49cc4f1cfd7c5531
parent 2dfbf1fea450d17f8a3da8e67f248ff9f7b6548f
Author: gracefu <81774659+gracefuu@users.noreply.github.com>
Date:   Wed, 16 Apr 2025 00:37:06 +0800

I hate closures

Diffstat:
M
make.py
 | 
48
++++++++++++++++++++++++++++++------------------

1 file changed, 30 insertions(+), 18 deletions(-)
diff --git a/make.py b/make.py
@@ -191,15 +191,21 @@ class Rules:
             args.append(self.eval_task_key(arg) if isinstance(arg, tuple) else arg)
         return rule(*args)
 
-    def rule(self, rule_fn: NiceRuleFn) -> Rule:
-        @self.register
-        @self.hash_cache
-        @Rule.new
-        @functools.wraps(rule_fn)
-        def wrapped(fetch, task_key, store, *args):
-            return rule_fn(fetch, *args)
+    @staticmethod
+    def nice_rule_fn_to_rule_fn(nice_rule_fn, fetch, task_key, store, *args):
+        return nice_rule_fn(fetch, *args)
 
-        return wrapped
+    def rule(self, rule_fn: NiceRuleFn) -> Rule:
+        return self.register(
+            self.hash_cache(
+                Rule.new(
+                    functools.update_wrapper(
+                        functools.partial(Rules.nice_rule_fn_to_rule_fn, rule_fn),
+                        rule_fn,
+                    )
+                )
+            )
+        )
 
     def register(self, rule: Rule) -> Rule:
         self.rules[rule.rule_key] = rule
@@ -221,6 +227,12 @@ class Rules:
         )
         return rule
 
+    @staticmethod
+    async def track_fetch(fetch: Fetch, new_inputs: list, task: Task):
+        result = await fetch(task)
+        new_inputs.append((task.task_key, make_hash(result)))
+        return result
+
     async def hash_cache_fn(
         self,
         inner_rule_fn: RuleFn,
@@ -252,12 +264,12 @@ class Rules:
 
         new_inputs = []
 
-        async def track_fetch(task: Task):
-            result = await fetch(task)
-            new_inputs.append((task.task_key, make_hash(result)))
-            return result
-
-        new_value = await inner_rule_fn(track_fetch, task_key, store, *args)
+        new_value = await inner_rule_fn(
+            functools.partial(Rules.track_fetch, fetch, new_inputs),
+            task_key,
+            store,
+            *args,
+        )
         store.key_info[task_key].append((new_inputs, new_value))
         return new_value
 
@@ -358,21 +370,21 @@ class SuspendingScheduler:
 
 
 class Build:
-    __slots__ = "_store", "_fetch"
+    __slots__ = "_store", "_scheduler"
 
     def __init__(self, filename, rules=_rules):
         self._store = Store(filename, rules)
-        self._fetch = SuspendingScheduler(self._store)
+        self._scheduler = SuspendingScheduler(self._store)
 
     async def __call__(self, task: Task):
         await self.build(task)
         await self.wait()
 
     def wait(self):
-        return self._fetch.wait()
+        return self._scheduler.wait()
 
     def build(self, task: Task):
-        return self._fetch.build(task)
+        return self._scheduler.build(task)
 
     def __enter__(self):
         self._store.__enter__()