fix: address review - record-after-success, stable GitHub anchor, lazy logger import

Addresses the Qodo review on PR The-PR-Agent#2424:

- GitHub publish_inline_comments now records fingerprints only after a publish
  path runs without raising, tracks within-batch duplicates in a local set, and
  skips dedup on the disable_fallback re-publish. Previously the store was
  populated before create_review succeeded, so a 422 fallback retry could be
  wrongly skipped and silently drop a comment.
- GitHub fingerprints are anchored on (path, content) instead of the diff
  position, which shifts as the PR gains commits; this keeps the fingerprint
  stable across runs (the persistent behaviour the feature is about).
- inline_comment_dedup imports get_logger lazily inside the failure path, so the
  module no longer imports pr_agent.log at import time and can be imported
  standalone without the pre-existing log/config circular-import fragility. The
  test no longer needs an import-order workaround.
- isort-format the new multi-line imports in both providers.

The broad except in InlineCommentStore.load() is kept deliberately (fail-open:
dedup must never break comment publishing), matching existing provider patterns.

Author: IsmaelMartinez

pr_agent/algo/inline_comment_dedup.py

@@ -35,8 +35,6 @@
 import re
 from typing import Iterator, Optional
 
-from pr_agent.log import get_logger
-
 BODY_MARKER_RE = re.compile(r"<!-- pr-agent-dedup: ([a-f0-9]{12}) -->")
 CODE_MARKER_RE = re.compile(r"<!-- pr-agent-dedup-code: ([a-f0-9]{12}) -->")
 
@@ -126,6 +124,7 @@ def load(self) -> set:
                     for match in marker_re.finditer(body or ""):
                         self._keys.add(match.group(1))
         except Exception as e:
+            from pr_agent.log import get_logger
             get_logger().info(
                 f"Persistent inline comments: could not load existing comments, "
                 f"within-run dedup only. error={e}"

pr_agent/git_providers/github_provider.py

@@ -18,8 +18,8 @@
 from ..algo.file_filter import filter_ignored
 from ..algo.git_patch_processing import extract_hunk_headers
 from ..algo.inline_comment_dedup import (body_fingerprint, build_markers,
-                                         code_fingerprint, get_inline_comment_store,
-                                         inline_comment_line)
+                                         code_fingerprint,
+                                         get_inline_comment_store)
 from ..algo.language_handler import is_valid_file
 from ..algo.types import EDIT_TYPE
 from ..algo.utils import (PRReviewHeader, Range, clip_tokens,
@@ -419,25 +419,36 @@ def create_inline_comment(self, body: str, relevant_file: str, relevant_line_in_
         return dict(body=body, path=path, position=position) if subject_type == "LINE" else {}
 
     def publish_inline_comments(self, comments: list[dict], disable_fallback: bool = False):
-        if get_settings().get("config.persistent_inline_comments", False):
+        store = None
+        pending_fingerprints = []
+        # Dedup only on the top-level call. A fallback re-publish passes
+        # disable_fallback=True; it must not re-filter, or it could drop a
+        # comment that has not actually been posted yet.
+        if not disable_fallback and get_settings().get("config.persistent_inline_comments", False):
             store = get_inline_comment_store(self)
+            local_seen = set()
             deduped = []
             for comment in comments:
                 if not comment:
                     deduped.append(comment)
                     continue
                 path = comment.get("path", "")
-                line = inline_comment_line(comment)
                 body = comment.get("body", "")
-                body_fp = body_fingerprint(path, line, body)
-                code_fp = code_fingerprint(path, line, body)
-                if store.seen(body_fp) or store.seen(code_fp):
+                # GitHub committable comments are anchored by diff position, which
+                # shifts as the PR gains commits; anchor the fingerprint on the file
+                # path and comment content instead so it stays stable across runs.
+                body_fp = body_fingerprint(path, None, body)
+                code_fp = code_fingerprint(path, None, body)
+                if (store.seen(body_fp) or store.seen(code_fp)
+                        or body_fp in local_seen or (code_fp and code_fp in local_seen)):
                     continue
                 marked = dict(comment)
                 marked["body"] = f"{body}\n\n{build_markers(body_fp, code_fp)}"
                 deduped.append(marked)
-                store.add(body_fp)
-                store.add(code_fp)
+                local_seen.add(body_fp)
+                if code_fp:
+                    local_seen.add(code_fp)
+                pending_fingerprints.append((body_fp, code_fp))
             if not any(deduped):
                 get_logger().info("Persistent inline comments: all suggestions already posted; nothing to publish")
                 return
@@ -459,6 +470,13 @@ def publish_inline_comments(self, comments: list[dict], disable_fallback: bool =
                 get_logger().error(f"Failed to publish inline code comments fallback, error: {e}")
                 raise e    
 
+        # Record fingerprints only after a publish path has run without raising,
+        # so a failed publish does not block a retry of the same comment this run.
+        if store is not None:
+            for body_fp, code_fp in pending_fingerprints:
+                store.add(body_fp)
+                store.add(code_fp)
+    
     def get_review_thread_comments(self, comment_id: int) -> list[dict]:
         """
         Retrieves all comments in the same thread as the given comment.

pr_agent/git_providers/gitlab_provider.py

@@ -15,7 +15,8 @@
 from ..algo.file_filter import filter_ignored
 from ..algo.git_patch_processing import decode_if_bytes
 from ..algo.inline_comment_dedup import (body_fingerprint, build_markers,
-                                         code_fingerprint, get_inline_comment_store)
+                                         code_fingerprint,
+                                         get_inline_comment_store)
 from ..algo.language_handler import is_valid_file
 from ..algo.utils import (clip_tokens,
                           find_line_number_of_relevant_line_in_file,

tests/unittest/test_inline_comment_dedup.py

@@ -1,11 +1,8 @@
 from unittest.mock import MagicMock, patch
 
-# Import a provider module first: it pulls in pr_agent.log via its transitive
-# imports before config load, avoiding the partially-initialised-module
-# circular import that triggers when pr_agent.log is the first pr_agent import.
+from pr_agent.algo import inline_comment_dedup as d
 from pr_agent.git_providers.github_provider import GithubProvider
 from pr_agent.git_providers.gitlab_provider import GitLabProvider
-from pr_agent.algo import inline_comment_dedup as d
 
 
 # --------------------------------------------------------------------------- #
@@ -106,7 +103,7 @@ def _patch_flag(value):
 
 
 def test_github_filters_seen_and_marks_new():
-    seen_fp = d.body_fingerprint("a.py", 10, "old body")
+    seen_fp = d.body_fingerprint("a.py", None, "old body")
     p = _gh_provider([f"old body\n\n<!-- pr-agent-dedup: {seen_fp} -->"])
     gs = _patch_flag(True)
     try:
@@ -123,7 +120,7 @@ def test_github_filters_seen_and_marks_new():
 
 
 def test_github_all_duplicates_skips_publish():
-    seen_fp = d.body_fingerprint("a.py", 10, "old body")
+    seen_fp = d.body_fingerprint("a.py", None, "old body")
     p = _gh_provider([f"old body\n\n<!-- pr-agent-dedup: {seen_fp} -->"])
     gs = _patch_flag(True)
     try:
@@ -241,7 +238,7 @@ def test_github_code_fingerprint_or_match_across_runs():
     # existing comment carries ONLY a code marker; a new comment with different
     # prose but the same suggestion block must be dropped via the code fp even
     # though its body fingerprint differs.
-    code_fp = d.code_fingerprint("a.py", 10, "p\n```suggestion\nx = 1\n```")
+    code_fp = d.code_fingerprint("a.py", None, "p\n```suggestion\nx = 1\n```")
     p = _gh_provider([f"earlier wording\n\n<!-- pr-agent-dedup-code: {code_fp} -->"])
     gs = _patch_flag(True)
     try: