snakefmt 2.0.2__tar.gz → 2.0.3__tar.gz

{snakefmt-2.0.2 → snakefmt-2.0.3}/CHANGELOG.md

@@ -6,6 +6,13 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 
+## [2.0.3](https://github.com/snakemake/snakefmt/compare/v2.0.2...v2.0.3) (2026-06-25)
+
+
+### Bug Fixes
+
+* skip fmt-directive and indent processing for inline comments ([#305](https://github.com/snakemake/snakefmt/issues/305)) ([#307](https://github.com/snakemake/snakefmt/issues/307)) ([d3a06b2](https://github.com/snakemake/snakefmt/commit/d3a06b27cfb8e1995871dcef37201e65c353527d))
+
 ## [2.0.2](https://github.com/snakemake/snakefmt/compare/v2.0.1...v2.0.2) (2026-06-11)
 
 

{snakefmt-2.0.2 → snakefmt-2.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snakefmt
-Version: 2.0.2
+Version: 2.0.3
 Summary: The uncompromising Snakemake code formatter
 Project-URL: Homepage, https://github.com/snakemake/snakefmt
 Project-URL: Repository, https://github.com/snakemake/snakefmt

{snakefmt-2.0.2 → snakefmt-2.0.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "snakefmt"
-version = "2.0.2"
+version = "2.0.3"
 description = "The uncompromising Snakemake code formatter"
 authors = [
     { name = "Michael Hall", email = "mhaldini@icloud.com" },

{snakefmt-2.0.2 → snakefmt-2.0.3}/snakefmt/formatter.py

@@ -80,6 +80,34 @@ def indent_docstring(docstring: str, target_indent: int) -> str:
     return textwrap.indent(docstring, TAB * target_indent)
 
 
+def align_strings(string: str, target_indent: int) -> str:
+    """
+    Takes an ensemble of strings and indents/reindents it
+    """
+    used_indent = TAB * target_indent
+    split_string = split_code_string(string)
+    if len(split_string) == 1:
+        return textwrap.indent(split_string[0], used_indent)
+
+    # First, masks all multi-line strings
+    mask_string = "`~!@#$%^&*|?"
+    while mask_string in string:
+        mask_string += mask_string
+    mask_string = f'"""{mask_string}"""'
+    fakewrap = textwrap.indent(
+        "".join(mask_string if i % 2 else s for i, s in enumerate(split_string)),
+        used_indent,
+    )
+    split_code = fakewrap.split(mask_string)
+
+    # After indenting, we put those strings back exactly as they were
+    indented = "".join(
+        s.replace("\t", TAB) if i % 2 else split_code[i // 2]
+        for i, s in enumerate(split_string)
+    )
+    return indented
+
+
 class Formatter(Parser):
     def __init__(
         self,
@@ -136,7 +164,7 @@ class Formatter(Parser):
                     # string, so indent the whole docstring directly. See issue #303.
                     formatted = indent_docstring(formatted, self.keyword_indent)
                 else:
-                    formatted = self.align_strings(formatted, self.keyword_indent)
+                    formatted = align_strings(formatted, self.keyword_indent)
         else:
             # Invalid python syntax, eg lone 'else:' between two rules, can occur.
             # Below constructs valid code statements and formats them.
@@ -400,33 +428,6 @@ class Formatter(Parser):
             fmted = textwrap.dedent(s)
         return fmted
 
-    def align_strings(self, string: str, target_indent: int) -> str:
-        """
-        Takes an ensemble of strings and indents/reindents it
-        """
-        used_indent = TAB * target_indent
-        split_string = split_code_string(string)
-        if len(split_string) == 1:
-            return textwrap.indent(split_string[0], used_indent)
-
-        # First, masks all multi-line strings
-        mask_string = "`~!@#$%^&*|?"
-        while mask_string in string:
-            mask_string += mask_string
-        mask_string = f'"""{mask_string}"""'
-        fakewrap = textwrap.indent(
-            "".join(mask_string if i % 2 else s for i, s in enumerate(split_string)),
-            used_indent,
-        )
-        split_code = fakewrap.split(mask_string)
-
-        # After indenting, we put those strings back exactly as they were
-        indented = "".join(
-            s.replace("\t", TAB) if i % 2 else split_code[i // 2]
-            for i, s in enumerate(split_string)
-        )
-        return indented
-
     def format_param(
         self,
         parameter: Parameter,
@@ -498,7 +499,7 @@ class Formatter(Parser):
             else:
                 val = content
 
-        val = self.align_strings(val, target_indent)
+        val = align_strings(val, target_indent)
 
         result = ""
         if not inline_formatting:

{snakefmt-2.0.2 → snakefmt-2.0.3}/snakefmt/parser/parser.py

@@ -756,41 +756,62 @@ class Parser(ABC):
                     token, block_indent, self.cur_indent, buffer, True, pythonable
                 )
             elif token.type == tokenize.COMMENT:
-                fmt_dir = FMT_DIRECTIVE.from_token(token)
-                if (
-                    fmt_dir
-                    and col_nb(token) == 0
-                    and not (fmt_dir.disable and "next" in fmt_dir.modifiers)
-                ):
-                    # col-0 comments report cur_indent=0 to trigger context_exit;
-                    # fmt directives at other columns report actual cur_indent.
-                    return Status(token, block_indent, 0, buffer, False, pythonable)
-                # Comments arrive in the token stream *before* any following
-                # INDENT/DEDENT tokens, so self.cur_indent still reflects the
-                # previous (potentially higher) level.  Delegate to
-                # _determine_comment_indent which peeks ahead and applies the
-                # two snapping rules.
-                effective_indent = self._determine_comment_indent(token)
-                self.syntax.cur_indent = effective_indent
-                if effective_indent < max(self.keyword_indent, self.block_indent):
-                    return Status(
-                        token, block_indent, effective_indent, buffer, False, pythonable
-                    )
-                # `# fmt: off[next]` always needs parser-level handling.
-                # Plain `# fmt: off` is parser-level only in global context; in other
-                # Python contexts it is handled by Black.
-                if (
-                    fmt_dir
-                    and fmt_dir.disable
-                    and (
-                        "next" in fmt_dir.modifiers
-                        or "sort" in fmt_dir.modifiers
-                        or (not fmt_dir.modifiers and self.in_global_context)
-                    )
-                ):
-                    return Status(
-                        token, block_indent, effective_indent, buffer, False, pythonable
-                    )
+                is_inline = (
+                    prev_token is not None
+                    and prev_token.type
+                    not in {
+                        tokenize.NL,
+                        tokenize.NEWLINE,
+                        tokenize.INDENT,
+                        tokenize.DEDENT,
+                    }
+                    and prev_token.end[0] == token.start[0]
+                )
+                if not is_inline:
+                    fmt_dir = FMT_DIRECTIVE.from_token(token)
+                    if (
+                        fmt_dir
+                        and col_nb(token) == 0
+                        and not (fmt_dir.disable and "next" in fmt_dir.modifiers)
+                    ):
+                        # col-0 comments report cur_indent=0 to trigger context_exit;
+                        # fmt directives at other columns report actual cur_indent.
+                        return Status(token, block_indent, 0, buffer, False, pythonable)
+                    # Comments arrive in the token stream *before* any following
+                    # INDENT/DEDENT tokens, so self.cur_indent still reflects the
+                    # previous (potentially higher) level.  Delegate to
+                    # _determine_comment_indent which peeks ahead and applies the
+                    # two snapping rules.
+                    effective_indent = self._determine_comment_indent(token)
+                    self.syntax.cur_indent = effective_indent
+                    if effective_indent < max(self.keyword_indent, self.block_indent):
+                        return Status(
+                            token,
+                            block_indent,
+                            effective_indent,
+                            buffer,
+                            False,
+                            pythonable,
+                        )
+                    # Plain `# fmt: off` is parser-level only in global context;
+                    # in other Python contexts it is handled by Black.
+                    if (
+                        fmt_dir
+                        and fmt_dir.disable
+                        and (
+                            "next" in fmt_dir.modifiers
+                            or "sort" in fmt_dir.modifiers
+                            or (not fmt_dir.modifiers and self.in_global_context)
+                        )
+                    ):
+                        return Status(
+                            token,
+                            block_indent,
+                            effective_indent,
+                            buffer,
+                            False,
+                            pythonable,
+                        )
 
             elif is_newline(token):
                 self.queriable, newline = True, True

{snakefmt-2.0.2 → snakefmt-2.0.3}/tests/test_formatter.py

@@ -12,6 +12,7 @@ import black.parsing
 import pytest
 
 from snakefmt.exceptions import InvalidPython
+from snakefmt.formatter import align_strings
 from snakefmt.parser.grammar import SingleParam, SnakeGlobal
 from snakefmt.parser.syntax import COMMENT_SPACING
 from snakefmt.types import TAB
@@ -1070,6 +1071,27 @@ rule a:
         formatter = setup_formatter(snakecode)
         assert formatter.get_formatted() == expected
 
+    def test_multiline_docstring_with_same_line_comment_inside_rule(self):
+        """Closing quote with same-line comment is formatted correctly"""
+        snakecode = (
+            "rule test:\n"
+            f'{TAB * 1}"""\n'
+            f"{TAB * 1}Comment\n"
+            f'{TAB * 1}""" # comment\n'
+            f"{TAB * 1}input:\n"
+            f'{TAB * 2}"test.txt",\n'
+        )
+        expected = (
+            "rule test:\n"
+            f'{TAB * 1}"""\n'
+            f"{TAB * 1}Comment\n"
+            f'{TAB * 1}"""  # comment\n'
+            f"{TAB * 1}input:\n"
+            f'{TAB * 2}"test.txt",\n'
+        )
+        formatter = setup_formatter(snakecode)
+        assert formatter.get_formatted() == expected
+
     def test_collapsing_docstring_inside_rule_keeps_black_normalisation(self):
         """Black still collapses a single-line docstring; indentation is preserved"""
         snakecode = (
@@ -2273,6 +2295,24 @@ class TestDocstringHelpers:
         assert indent_docstring(docstring, 1) == expected
 
 
+class TestAlignStrings:
+    """Unit tests for the align_strings helper function."""
+
+    def test_align_strings_single_line(self):
+        assert align_strings("param = 1", 1) == f"{TAB * 1}param = 1"
+        assert align_strings("param = 1", 2) == f"{TAB * 2}param = 1"
+
+    def test_align_strings_multiline_code(self):
+        code = "a = 1\nb = 2"
+        expected = f"{TAB * 1}a = 1\n{TAB * 1}b = 2"
+        assert align_strings(code, 1) == expected
+
+    def test_align_strings_preserves_triple_quoted_strings(self):
+        code = 'x = """\nline1\nline2\n"""'
+        expected = f'{TAB * 1}x = """\nline1\nline2\n"""'
+        assert align_strings(code, 1) == expected
+
+
 class TestFmtOffOn:
     """Tests for # fmt: off / # fmt: on directives."""
 

{snakefmt-2.0.2 → snakefmt-2.0.3}/uv.lock

@@ -1019,7 +1019,7 @@ wheels = [
 
 [[package]]
 name = "snakefmt"
-version = "2.0.2"
+version = "2.0.3"
 source = { editable = "." }
 dependencies = [
     { name = "black" },