Files that changed from the base of the PR and between c98b2e7 and 84f4e79.

• snakemake/cli.py (3 hunks)
• snakemake/rules.py (5 hunks)
• snakemake/settings/types.py (2 hunks)

snakemake/rules.py (2)

275-283: LGTM: Input handling properly integrates ancient file marking.

The implementation correctly retrieves ancient file settings from the workflow configuration and properly passes the mark_ancient flag to the underlying item processing.

---

490-491: LGTM: Ancient flag is properly applied to input items.

The implementation correctly applies the ancient flag to input items when specified, maintaining consistency with the existing codebase while adding the new functionality.

Files that changed from the base of the PR and between 84f4e79 and 120a602.

• snakemake/cli.py (4 hunks)
• snakemake/rules.py (5 hunks)
• snakemake/settings/types.py (2 hunks)

• snakemake/rules.py

snakemake/settings/types.py (1)

6-6: Skipping comment about unused List import.

A previous review already correctly identified the unused List import issue.

🧰 Tools

🪛 Ruff

6-6: typing.List imported but unused

Remove unused import: typing.List

(F401)

snakemake/cli.py (2)

760-771: LGTM: CLI argument is well-defined.

The --consider-ancient argument is properly implemented with:

• Clear help text explaining purpose and usage
• Appropriate default value and parser function
• Consistent style with other similar arguments

---

2032-2032: LGTM: Proper integration with workflow settings.

The consider_ancient parameter is correctly added to the WorkflowSettings constructor call.

Files that changed from the base of the PR and between 120a602 and c97e319.

• snakemake/cli.py (4 hunks)
• snakemake/rules.py (5 hunks)
• snakemake/settings/types.py (2 hunks)
• tests/test_ancient_cli/Snakefile (1 hunks)
• tests/test_ancient_cli/expected-results/1 (1 hunks)
• tests/test_ancient_cli/expected-results/2 (1 hunks)
• tests/test_ancient_cli/expected-results/3 (1 hunks)
• tests/test_ancient_cli/expected-results/4 (1 hunks)
• tests/tests.py (1 hunks)

• tests/test_ancient_cli/expected-results/1
• tests/test_ancient_cli/expected-results/2
• tests/test_ancient_cli/expected-results/3
• tests/test_ancient_cli/expected-results/4

• snakemake/settings/types.py

tests/test_ancient_cli/Snakefile (4)

1-3: Clever test setup for validating ancient file behavior.

The initialization creates output files before input files with a time delay, which is an excellent test pattern for validating the --consider-ancient functionality. This ensures that input files (1,3) are newer than output files (2,4), which would typically trigger a rebuild without the ancient marking.

---

5-9: LGTM! Clear target definition.

The rule correctly specifies the final targets that correspond to the outputs of rules A and B.

---

18-24: LGTM! Well-structured rule definition.

The rule correctly uses named inputs and properly defines the file operation.

---

1-24: Verify test function implementation.

This Snakefile provides good coverage for the --consider-ancient feature, but let's ensure there's proper test function implementation.

✅ Verification successful

Test implementation is properly in place

The test function test_ancient_cli is implemented in tests/tests.py and correctly executes the Snakefile with the --consider-ancient flag, validating the functionality through the provided test case.

🏁 Scripts executed

The following scripts were executed for the analysis:

Script:

#!/bin/bash
# Search for corresponding test function
echo "Searching for test_ancient_cli function in test files..."
rg -l "def test_ancient_cli" tests/

Length of output: 160

---

Script:

#!/bin/bash
# Let's try a broader search to find test files and their content in the test_ancient_cli directory
echo "Searching for test files in test_ancient_cli directory..."
fd . tests/test_ancient_cli/ -t f -x cat {}

# Also search for any test functions that might be related to ancient functionality
echo -e "\nSearching for test functions related to ancient..."
rg "def test.*ancient" tests/

Length of output: 687

---

Script:

#!/bin/bash
# Let's check the parent directory structure and any test files that might contain the tests
echo "Checking parent directory structure..."
ls -la tests/test_ancient_cli/

# Let's also check for any pytest files in the parent directory
echo -e "\nChecking for test files in parent directory..."
ls -la tests/

# Search for any conftest.py that might contain the test implementation
echo -e "\nSearching for conftest.py files..."
fd conftest.py tests/

Length of output: 24879

---

Script:

#!/bin/bash
# Let's check the content of common.py and conftest.py as they might contain the test implementation
echo "Checking common.py for test implementation..."
cat tests/common.py

echo -e "\nChecking conftest.py for test implementation..."
cat tests/conftest.py

# Also check tests.py as it might contain the test implementation
echo -e "\nChecking tests.py for test implementation..."
rg "def test.*ancient" tests/tests.py

Length of output: 18997

---

Script:

#!/bin/bash
# Let's check the implementation of the ancient test functions in tests.py
echo "Checking test_ancient_cli implementation in tests.py..."
rg "def test_ancient_cli" tests/tests.py -A 20

Length of output: 594

snakemake/rules.py (4)

275-285: LGTM: Well-structured implementation of ancient file marking

The implementation correctly retrieves and applies the "consider_ancient" settings from workflow settings, handling both positional and keyword arguments appropriately.

---

410-410: LGTM: Clean implementation of ancient flag setting

The mark_ancient parameter is well integrated into the method, and the ancient flag is set at the appropriate point in the execution flow.

Also applies to: 492-493

---

473-475: LGTM: Proper handling of dependencies and temp files

The code correctly manages rule dependencies and implements conditional temp file marking based on workflow settings.

Also applies to: 478-480

---

275-285: Verify the ancient flag handling across the codebase

Let's verify the consistency of ancient flag handling and its usage across the codebase.

Also applies to: 410-410, 492-493

✅ Verification successful

Ancient flag handling is properly integrated and consistent across the codebase

The verification shows that the ancient flag implementation is well-integrated:

• The mark_ancient parameter in _set_inoutput_item is used consistently for both positional and keyword inputs
• Ancient flag handling is properly implemented in:
  • CLI parsing via --consider-ancient argument
  • Workflow settings via WorkflowSettings.consider_ancient
  • DAG execution logic in dag.py that correctly handles ancient files
  • IO system with proper is_ancient property checks
• Documentation in docs/snakefiles/rules.rst accurately describes the behavior
• Tests exist to verify the functionality (test_ancient, test_ancient_cli, test_ancient_dag)

🏁 Scripts executed

The following scripts were executed for the analysis:

Script:

#!/bin/bash
# Description: Verify the usage and handling of ancient flags

# Test 1: Check for other occurrences of ancient flag handling
echo "Checking for ancient flag handling..."
rg "ancient" -A 3 -B 3

# Test 2: Check for potential mark_ancient parameter usage
echo "Checking for mark_ancient parameter usage..."
ast-grep --pattern 'mark_ancient'

Length of output: 12876

snakemake/cli.py (2)

776-787: LGTM! Well-documented CLI argument.

The argument definition is clear, follows the established pattern, and includes comprehensive help text that explains both the functionality and its practical use case.

---

2048-2048: LGTM! Proper integration with workflow settings.

The consider_ancient parameter is correctly integrated into the WorkflowSettings constructor.

684-687: Enhance explanation with specific examples.

The explanation of consistency checks is comprehensive, but could be more helpful with specific examples of each case (e.g., what constitutes a "semantic level" change).

Consider adding examples like:

 This is based on file modification dates (input files may not be newer than output files of the same job), as well as execution metadata like the used software stack (e.g. conda env or container image), the non-file parameters, the set of input files, and the code of the rule.
+For example:
+- If you update a conda environment specification, Snakemake will rerun affected jobs
+- If you modify a rule's parameters, Snakemake will rerun that rule's jobs
+- If you change the set of input files, Snakemake will rerun the affected jobs

701-707: Add a note about wildcard support in CLI example.

The CLI usage example is clear, but it would be helpful to mention if wildcards are supported in the rule name or input specification.

Consider adding:

 This will mark the file ``inputfile.txt`` as ancient for the rule ``myrule``.
+Note that both rule names and input names support wildcards, e.g., ``snakemake --consider-ancient "align_*=*.fastq"``.

Files that changed from the base of the PR and between 1ad5627 and 42fad41.

• docs/project_info/faq.rst (1 hunks)
• snakemake/profiles.py (1 hunks)

688-726: Consider enhancing the example with multiple input scenarios

While the documentation effectively explains how to mark input files as ancient both via CLI and workflow profiles, it could be more comprehensive by including:

1. An example with multiple input files
2. A note about the impact on downstream rules

Consider adding this additional example:

    rule myrule:
        input:
            foo="inputfile.txt",
+           bar="another.txt"
        output:
            "outputfile.txt"
        shell:
            "somecommand {input.foo} {input.bar} > {output}"

And the corresponding CLI example:

    $ snakemake --consider-ancient myrule=foo,bar

And profile example:

    consider-ancient:
-       myrule: foo
+       myrule: [foo, bar]

Files that changed from the base of the PR and between 42fad41 and 9f2f4fb.

• docs/project_info/faq.rst (1 hunks)
• snakemake/cli.py (4 hunks)