fix: Confusion with Overriding input After Snakemake Modularization

Hocnonsense · Hocnonsense · commit 08e28ba34c23 · 2025-08-28T21:01:42.000+08:00
1. use name to map dependence
2. restrict cases when rule can be overwritten
diff --git a/src/snakemake/modules.py b/src/snakemake/modules.py
@@ -177,7 +177,6 @@ def __init__(
             self.allow_rule_overwrite = parent_modifier.allow_rule_overwrite
             self.path_modifier = parent_modifier.path_modifier
             self.replace_wrapper_tag = parent_modifier.replace_wrapper_tag
-            self.namespace = parent_modifier.namespace
             self.wildcard_constraints = parent_modifier.wildcard_constraints
             self.rules = parent_modifier.rules
             self.rule_proxies = parent_modifier.rule_proxies
@@ -193,6 +192,7 @@ def __init__(
             self.globals["checkpoints"] = self.globals[
                 "checkpoints"
             ].spawn_new_namespace()
+            self.globals["__name__"] = namespace
 
         self.workflow = workflow
         self.base_snakefile = base_snakefile
diff --git a/src/snakemake/rules.py b/src/snakemake/rules.py
@@ -12,6 +12,7 @@
 from pathlib import Path
 from itertools import chain
 from functools import partial
+from typing import Union
 
 try:
     import re._constants as sre_constants
@@ -74,7 +75,7 @@
 
 
 class Rule(RuleInterface):
-    def __init__(self, name, workflow, lineno=None, snakefile=None):
+    def __init__(self, name: str, workflow, lineno=None, snakefile=None):
         """
         Create a rule
 
@@ -124,7 +125,7 @@ def __init__(self, name, workflow, lineno=None, snakefile=None):
         self.log_modifier = None
         self.benchmark_modifier = None
         self.ruleinfo = None
-        self.module_globals = None
+        self.module_globals: dict
 
     @property
     def name(self):
@@ -462,7 +463,7 @@ def _set_inoutput_item(self, item, output=False, name=None, mark_ancient=False):
 
             rule_dependency = None
             if isinstance(item, _IOFile) and item.rule and item in item.rule.output:
-                rule_dependency = item.rule
+                rule_dependency = item.rule.name
 
             if output:
                 path_modifier = self.output_modifier
@@ -895,20 +896,23 @@ def handle_incomplete_checkpoint(exception):
             )
 
         if self.dependencies:
-            dependencies = {
+            rule_depends = {
                 f: self.dependencies[f_]
                 for f, f_ in mapping.items()
                 if f_ in self.dependencies
             }
             if None in self.dependencies:
-                dependencies[None] = self.dependencies[None]
+                rule_depends[None] = self.dependencies[None]
+            job_depends = {
+                f: self.workflow.get_rule(d) for f, d in rule_depends.items()
+            }
         else:
-            dependencies = self.dependencies
+            job_depends = {}
 
         for f in input:
             f.check()
 
-        return input, mapping, dependencies, incomplete
+        return input, mapping, job_depends, incomplete
 
     @classmethod
     def _is_deriving_function(cls, func):
diff --git a/src/snakemake/workflow.py b/src/snakemake/workflow.py
@@ -174,7 +174,7 @@ def __post_init__(self):
         self.global_resources["_cores"] = self.resource_settings.cores
         self.global_resources["_nodes"] = self.resource_settings.nodes
 
-        self._rules = OrderedDict()
+        self._rules: OrderedDict[str, Rule] = OrderedDict()
         self.default_target = None
         self._workdir_init = os.path.abspath(os.curdir)
         self._ruleorder = Ruleorder()
@@ -634,24 +634,34 @@ def add_rule(
         checkpoint=False,
         allow_overwrite=False,
     ):
+        """Add a rule.
+        Check if the rule can be overwritten.
+
+        > Specific rules may even be modified before using them,
+        >  via a final with: followed by a block that lists items to overwrite.
+        >  This modification can be performed after a general import,
+        >  and will overwrite any unmodified import of the same rule.
         """
-        Add a rule.
-        """
-        is_overwrite = self.is_rule(name)
-        if not allow_overwrite and is_overwrite:
-            raise CreateRuleException(
-                f"The name {name} is already used by another rule",
-                lineno=lineno,
-                snakefile=snakefile,
+        if self.is_rule(name):
+            is_overwrite = allow_overwrite and (
+                self.get_rule(name).module_globals["__name__"]
+                == self.modifier.namespace
             )
+            if not is_overwrite:
+                raise CreateRuleException(
+                    f"The name {name} is already used by another rule",
+                    lineno=lineno,
+                    snakefile=snakefile,
+                )
+        else:
+            is_overwrite = False
+            self.rule_count += 1
+            if not self.default_target:
+                self.default_target = name
         rule = Rule(name, self, lineno=lineno, snakefile=snakefile)
         self._rules[rule.name] = rule
         self.modifier.rules.add(rule)
-        if not is_overwrite:
-            self.rule_count += 1
-        if not self.default_target:
-            self.default_target = rule.name
-        return name
+        return is_overwrite
 
     def is_rule(self, name):
         """
@@ -1766,7 +1776,7 @@ def decorate(ruleinfo):
         orig_name = name
         name = self.modifier.modify_rulename(name)
 
-        name = self.add_rule(
+        is_overwrite = self.add_rule(
             name,
             lineno,
             snakefile,
@@ -1776,6 +1786,8 @@ def decorate(ruleinfo):
         rule = self.get_rule(name)
         rule.is_checkpoint = checkpoint
         rule.module_globals = self.modifier.globals
+        if is_overwrite:
+            rule.module_globals["__name__"] = None
 
         def decorate(ruleinfo):  # type: ignore[no-redef]
             nonlocal name
@@ -1789,10 +1801,9 @@ def decorate(ruleinfo):  # type: ignore[no-redef]
                     **ruleinfo.wildcard_constraints[1],
                 )
             if ruleinfo.name:
-                rule.name = ruleinfo.name
                 del self._rules[name]
-                self._rules[ruleinfo.name] = rule
-                name = rule.name
+                name = rule.name = ruleinfo.name
+                self._rules[name] = rule
             if ruleinfo.input:
                 rule.input_modifier = ruleinfo.input.modifier
                 rule.set_input(*ruleinfo.input.paths, **ruleinfo.input.kwpaths)
diff --git a/tests/test_modules_all/Snakefile b/tests/test_modules_all/Snakefile
@@ -15,6 +15,8 @@ module test:
 
 use rule * from test as test_*
 
+use rule a from test as test_* with:
+    input: "config/config.yaml"
 
 rule all:
     input:
diff --git a/tests/test_modules_all/module-test/Snakefile b/tests/test_modules_all/module-test/Snakefile
@@ -6,6 +6,7 @@ def some_func():
 
 
 rule a:
+    input: "not exist"
     output:
         temp("results/a/{name}.out"),
     shell:
