python-gitea 0.11.3__tar.gz → 0.11.5__tar.gz

{python_gitea-0.11.3 → python_gitea-0.11.5}/.github/workflows/codeql.yml

@@ -22,13 +22,13 @@ jobs:
               uses: actions/checkout@d23441a48e516b6c34aea4fa41551a30e30af803 # v6
 
             - name: Initialize CodeQL
-              uses: github/codeql-action/init@cdf488f595d80d6e07e03d4674febd5ab45fa938 # v4
+              uses: github/codeql-action/init@b96794f015dfd88f77b49b1c93e0fa7110f94c63 # v4
               with:
                   languages: python
                   queries: security-and-quality
 
             - name: Autobuild
-              uses: github/codeql-action/autobuild@cdf488f595d80d6e07e03d4674febd5ab45fa938 # v4
+              uses: github/codeql-action/autobuild@b96794f015dfd88f77b49b1c93e0fa7110f94c63 # v4
 
             - name: Perform CodeQL Analysis
-              uses: github/codeql-action/analyze@cdf488f595d80d6e07e03d4674febd5ab45fa938 # v4
+              uses: github/codeql-action/analyze@b96794f015dfd88f77b49b1c93e0fa7110f94c63 # v4

{python_gitea-0.11.3 → python_gitea-0.11.5}/.github/workflows/scheduled_release.yml

@@ -31,7 +31,7 @@ jobs:
 
             - name: Check for new commits
               id: check_commits
-              uses: isaac-cf-wong/detect-git-changes-action@604bb375bf2cef3116a2505f30cc6c5965a8fcba # v0.0.18
+              uses: isaac-cf-wong/detect-git-changes-action@10d1e3ac7c5ee0997d7b370e9929cacac9c87013 # v0.0.19
               with:
                   use-latest-tag: true
 

{python_gitea-0.11.3 → python_gitea-0.11.5}/.github/workflows/support_floor_update.yml

@@ -22,7 +22,7 @@ jobs:
 
             - name: Apply support policy (spec0, from pyproject tool table)
               id: policy
-              uses: isaac-cf-wong/dependency-support-policy-action@ffc9ff06cb39b2dc14680bff5f9bc84c0ad838b6 # v0.2.7
+              uses: isaac-cf-wong/dependency-support-policy-action@3831b000a448af639c88b8529d7057778edbc6ae # v0.2.8
               with:
                   mode: update
 

{python_gitea-0.11.3 → python_gitea-0.11.5}/.pre-commit-config.yaml

@@ -16,7 +16,7 @@ repos:
           - id: check-json
 
     - repo: https://github.com/astral-sh/ruff-pre-commit
-      rev: v0.16.6
+      rev: v0.16.7
       hooks:
           - id: ruff
             args: [--fix, --config=pyproject.toml]
@@ -28,7 +28,7 @@ repos:
           - id: taplo-format
 
     - repo: https://github.com/crate-ci/typos
-      rev: v1.50.1
+      rev: v1.50.2
       hooks:
           - id: typos
             args: []
@@ -52,7 +52,7 @@ repos:
           - id: actionlint
 
     - repo: https://github.com/astral-sh/uv-pre-commit
-      rev: 0.12.10
+      rev: 0.12.15
       hooks:
           # Update the uv lockfile
           - id: uv-lock

{python_gitea-0.11.3 → python_gitea-0.11.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: python-gitea
-Version: 0.11.3
+Version: 0.11.5
 Summary: A Python package for interacting with the Gitea API, offering a simple interface to access repositories, users, organizations, issues, and more for automation and data management.
 Project-URL: Documentation, https://isaac-cf-wong.github.io/python-gitea
 Project-URL: Source, https://github.com/isaac-cf-wong/python-gitea

{python_gitea-0.11.3 → python_gitea-0.11.5}/docs/user-guide/cli.md

@@ -722,6 +722,15 @@ or its comments changed. An issue that dropped out of what is being watched -
 closed, deleted, or moved off the board - is reported as `gone`. An issue that
 changed in more than one way is reported once per way.
 
+An issue seen for the first time is one of those: it is reported as `new`, and
+what it already carries - its assignees, its labels, and the comments already on
+it - is reported alongside as added. That matters for a comment written between
+an issue being opened and the next run: reporting only `new` would fold it into
+the baseline the same run records, so no later run would have anything left to
+compare it against and it would never be reported at all. It also means a
+consumer that reacts to `comments` and not to `new` still hears about it. A
+scope seen for the first time is still silent - see the cache below.
+
 Comments are compared by a stable hash of each comment rather than by counting
 them, so a comment edited in place is reported, and a comment added while
 another was deleted is two movements rather than none.

{python_gitea-0.11.3 → python_gitea-0.11.5}/docs/user-guide/python-api.md

@@ -397,6 +397,12 @@ for change in detect_changes(current, scope_snapshots(state, SCOPE)):
 save_scopes("watch-state.json", {SCOPE: current})
 ```
 
+Baselining applies to a scope and not to an issue. An issue the recorded scope
+has not seen is compared against an empty snapshot, so `detect_changes` reports
+`new` for it and then reports the assignees, labels and comments it already
+carries as added - which is what keeps a comment written before the issue was
+first seen from being folded into the baseline and never reported.
+
 `issue_snapshot` reduces an issue to the fields the comparison reads,
 `comment_hash` identifies a comment stably across re-fetches - by the author's
 ID rather than their login, so renaming a user does not look like every comment

{python_gitea-0.11.3 → python_gitea-0.11.5}/pyproject.toml

@@ -29,7 +29,7 @@ dependencies = [
 
 [dependency-groups]
 dev = [
-  "ruff>=0.16.6",
+  "ruff>=0.16.7",
   # The mutation runner, in the environment `uv run` resolves, so that
   # `uv run mutmut run` reaches the same interpreter as `uv run pytest` and finds
   # the pytest plugins the suite's own options need. Run from a tool environment

{python_gitea-0.11.3 → python_gitea-0.11.5}/src/gitea/watch/changes.py

@@ -13,6 +13,12 @@ comparison needs nothing from the previous run except the hashes it recorded.
 same value, and an edited one does not, which is what makes an edit show up as a
 change rather than disappear.
 
+A comment is reported whether or not the issue carrying it was already known.
+An issue seen for the first time is compared against an empty snapshot rather
+than passed over, so a comment that was already on it is an addition and not a
+baseline - what it costs to pass over is a comment nobody is ever told about,
+since the run that passed over it also recorded it.
+
 `updated_at` is recorded but is not itself compared. Gitea bumps it for every
 edit, including ones a watch has nothing to say about, so comparing it would
 report a body reworded as indistinguishable from a comment added. The
@@ -271,6 +277,17 @@ def detect_changes(
     An issue that changed in more than one way contributes one record per way,
     as a digest reads better naming each change than one line naming three.
 
+    An issue the recorded scope has not seen is one of those: it contributes the
+    `new` record naming it, and then the same records everything else
+    contributes, taken against the empty snapshot it is being compared to - so
+    the assignees, labels and comments it already carries are reported as added.
+    Reporting only `new` would make them baseline, which loses a comment written
+    between an issue being opened and the run that first saw it, and loses it
+    permanently: the run that swallowed it records it and the next one has
+    nothing left to compare against. It matters most to a consumer that reacts
+    to a kind rather than to an issue - one acting on `comments` and not on
+    `new` would never learn the comment was there.
+
     Args:
         current: The snapshot of each issue in the scope now, keyed by
             `issue_key`.
@@ -293,7 +310,14 @@ def detect_changes(
         before = previous.get(key)
         if before is None:
             changes.append(_change(snapshot, "new", "new issue", [], []))
-            continue
+            # An issue first seen here is compared against an empty snapshot
+            # rather than skipped, so what it already carries is reported as
+            # added. Skipping it would make the comments an issue was opened
+            # with - or the ones written before the run that first saw it -
+            # baseline instead of a change, and they would never be reported:
+            # the one record that mentioned the issue would be `new`, which a
+            # consumer filtering on the kinds it acts on may not act on at all.
+            before = {}
 
         for field, kind in _FIELD_KINDS:
             added, removed = _delta(before.get(field, []), snapshot.get(field, []))

{python_gitea-0.11.3 → python_gitea-0.11.5}/tests/cli/test_cli_contract.py

@@ -36,6 +36,7 @@ from typer.main import get_command
 from typer.testing import CliRunner
 
 from gitea.cli.main import app
+from gitea.watch.changes import comment_hash
 from gitea.watch.state import STATE_FILE_ENV
 from tests.cli.envelope import parse_envelope
 from tests.cli.tree import leaf_commands
@@ -293,13 +294,21 @@ BOARD_ROUTES = (
 WATCH_SCOPE = "repo:o/r"
 
 
-def _change(issue: dict[str, Any], kind: str, detail: str) -> dict[str, Any]:
+def _change(
+    issue: dict[str, Any],
+    kind: str,
+    detail: str,
+    added: list[str] | None = None,
+    removed: list[str] | None = None,
+) -> dict[str, Any]:
     """Build the change record a watch reports for one issue.
 
     Args:
         issue: The issue the change is on.
         kind: What changed.
         detail: The change, as the human digest phrases it.
+        added: What appeared, for a kind that has something to add.
+        removed: What went away, for a kind that has something to remove.
 
     Returns:
         The change record, including the scope the command adds.
@@ -312,8 +321,8 @@ def _change(issue: dict[str, Any], kind: str, detail: str) -> dict[str, Any]:
         "title": issue["title"],
         "repository": "o/r",
         "detail": detail,
-        "added": [],
-        "removed": [],
+        "added": added or [],
+        "removed": removed or [],
         "scope": WATCH_SCOPE,
     }
 
@@ -622,7 +631,15 @@ CONTRACTS = (
         # under test is the second one, which meets a different issue.
         warmup=(("/comments", [COMMENT]), ("", [ISSUE])),
         routes=(("/comments", [COMMENT]), ("", [OTHER_ISSUE])),
-        data=[_change(OTHER_ISSUE, "new", "new issue"), _change(ISSUE, "gone", "no longer listed")],
+        # The issue that appeared is reported twice: once as the issue itself,
+        # and once for the comment that was already on it when it was first
+        # seen, which a consumer acting on comments would otherwise never hear
+        # about.
+        data=[
+            _change(OTHER_ISSUE, "new", "new issue"),
+            _change(OTHER_ISSUE, "comments", "1 new", added=[comment_hash(COMMENT)]),
+            _change(ISSUE, "gone", "no longer listed"),
+        ],
         metadata=(
             "status_code",
             "scopes",
@@ -642,8 +659,9 @@ CONTRACTS = (
         routes=(("/comments", [COMMENT]), ("", [OTHER_ISSUE])),
         # What was recorded, not what changed: the command commits the baseline
         # rather than reporting the difference. `change_count` is how far it
-        # moved - the issue that appeared and the one that went away.
-        data=[{"scope": WATCH_SCOPE, "issue_count": 1, "change_count": 2, "baselined": False}],
+        # moved - the issue that appeared, the comment it already carried, and
+        # the issue that went away.
+        data=[{"scope": WATCH_SCOPE, "issue_count": 1, "change_count": 3, "baselined": False}],
         metadata=(
             "status_code",
             "scopes",

{python_gitea-0.11.3 → python_gitea-0.11.5}/tests/cli/watch/test_cli_watch_list.py

@@ -137,6 +137,72 @@ class TestReportedChanges:
 
         assert result.stdout == "my-org/my-repo#16 new: new issue · Ship the release\n"
 
+    def test_a_comment_written_before_an_issue_was_first_seen_is_reported(self, tmp_path: Path) -> None:
+        """A comment already on an issue the run first meets has to be reported.
+
+        This is the window a comment can fall into and never come out of: it is
+        written after the issue is opened and before the run that first records
+        the issue. Reporting only `new` makes the comment part of the baseline,
+        and the same run writes that baseline down, so no later run has anything
+        left to compare it against - the comment is consumed without ever having
+        been reported, and a consumer that reacts to comments rather than to new
+        issues is never told about it.
+        """
+        state_path = tmp_path / "watch-state.json"
+        run(*watch(state_path), client=make_client([ISSUE], comments={15: [COMMENT]}))
+
+        # The issue arrives already carrying the comment, as one commented on
+        # between two ticks does.
+        result = run(
+            *watch(state_path, output="json"),
+            client=make_client([ISSUE, OTHER_ISSUE], comments={15: [COMMENT], 16: [COMMENT]}),
+        )
+
+        assert result.exit_code == 0
+        reported = [change for change in parse_envelope(result.stdout)["data"] if change["kind"] == "comments"]
+        assert [change["number"] for change in reported] == [16]
+        assert reported[0]["added"] == [comment_hash(COMMENT)]
+        assert reported[0]["removed"] == []
+
+    def test_the_new_issue_carrying_the_comment_is_still_reported_as_new(self, tmp_path: Path) -> None:
+        """The comment record is additional to `new`, not a replacement for it."""
+        state_path = tmp_path / "watch-state.json"
+        run(*watch(state_path), client=make_client([ISSUE]))
+
+        result = run(*watch(state_path), client=make_client([ISSUE, OTHER_ISSUE], comments={16: [COMMENT]}))
+
+        assert result.stdout.splitlines() == [
+            "my-org/my-repo#16 new: new issue · Ship the release",
+            "my-org/my-repo#16 comments: 1 new · Ship the release",
+        ]
+
+    def test_a_comment_on_a_first_seen_issue_is_reported_once(self, tmp_path: Path) -> None:
+        """Reporting it on first sight must not make every later run report it again."""
+        state_path = tmp_path / "watch-state.json"
+        run(*watch(state_path), client=make_client([ISSUE]))
+        run(*watch(state_path), client=make_client([ISSUE, OTHER_ISSUE], comments={16: [COMMENT]}))
+
+        result = run(*watch(state_path), client=make_client([ISSUE, OTHER_ISSUE], comments={16: [COMMENT]}))
+
+        assert result.stdout == ""
+
+    def test_the_comment_is_reported_whatever_board_the_issue_is_on(self, tmp_path: Path) -> None:
+        """Nothing here gates a comment on the issue being on a project board.
+
+        A repository scope watches the open issues of the repository, on a board
+        or not, and the issue in this suite carries no `projects` at all - so a
+        gate of that shape would have to be added here to break this. A consumer
+        that applies one of its own is free to, but a comment it never hears
+        about cannot be gated on anything.
+        """
+        state_path = tmp_path / "watch-state.json"
+        run(*watch(state_path), client=make_client([ISSUE]))
+        unboarded = {**OTHER_ISSUE, "projects": []}
+
+        result = run(*watch(state_path), client=make_client([ISSUE, unboarded], comments={16: [COMMENT]}))
+
+        assert "my-org/my-repo#16 comments: 1 new · Ship the release" in result.stdout.splitlines()
+
     def test_an_assignee_change_is_reported(self, tmp_path: Path) -> None:
         """Handing an issue over should reach the digest."""
         state_path = tmp_path / "watch-state.json"

{python_gitea-0.11.3 → python_gitea-0.11.5}/tests/watch/test_watch_changes.py

@@ -258,7 +258,7 @@ class TestDetectChanges:
 
     def test_an_issue_absent_from_the_cache_is_new(self) -> None:
         """An issue a recorded scope has not seen should be reported as new."""
-        changes = detect_changes({"1854": snapshot()}, {})
+        changes = detect_changes({"1854": snapshot(assignees=[], labels=[], comment_hashes=[])}, {})
 
         assert [change["kind"] for change in changes] == ["new"]
         assert changes[0]["detail"] == "new issue"
@@ -267,9 +267,56 @@ class TestDetectChanges:
         assert changes[0]["added"] == []
         assert changes[0]["removed"] == []
 
+    def test_a_comment_already_on_an_issue_first_seen_is_reported(self) -> None:
+        """A comment written before the run that first saw the issue is a change.
+
+        Reporting only `new` would make it baseline, and the run reporting that
+        also records it, so nothing would ever report it: a consumer acting on
+        `comments` rather than on `new` - because a comment is worth reacting to
+        wherever the issue sits - would never learn the comment was there.
+        """
+        changes = detect_changes({"1854": snapshot(assignees=[], labels=[])}, {})
+
+        assert [change["kind"] for change in changes] == ["new", "comments"]
+        assert changes[1]["added"] == [comment_hash(COMMENT)]
+        assert changes[1]["removed"] == []
+        assert changes[1]["detail"] == "1 new"
+        assert changes[1]["number"] == 15
+
+    def test_an_issue_first_seen_reports_the_fields_it_already_carries(self) -> None:
+        """Its assignees and labels are additions against an empty snapshot."""
+        changes = detect_changes({"1854": snapshot(comment_hashes=[])}, {})
+
+        assert [change["kind"] for change in changes] == ["new", "assignees", "labels"]
+        assert changes[1]["added"] == ["alice", "bob"]
+        assert changes[1]["removed"] == []
+        assert changes[2]["added"] == ["bug", "docs"]
+        assert changes[2]["removed"] == []
+
+    def test_an_issue_first_seen_still_reports_new_before_what_it_carries(self) -> None:
+        """The `new` record stays, and stays first, so a consumer keyed on it is unaffected."""
+        changes = detect_changes({"1854": snapshot()}, {})
+
+        assert [change["kind"] for change in changes] == ["new", "assignees", "labels", "comments"]
+        assert changes[0]["detail"] == "new issue"
+        assert changes[0]["added"] == []
+        assert changes[0]["removed"] == []
+
+    def test_an_issue_first_seen_is_reported_once(self) -> None:
+        """The run that reports it also records it, so the next run is quiet."""
+        current = {"1854": snapshot()}
+
+        assert detect_changes(current, {}) != []
+        # The run that reported recorded these same snapshots, and they are what
+        # the next run compares against.
+        assert detect_changes(current, {key: dict(value) for key, value in current.items()}) == []
+
     def test_every_new_issue_is_reported_not_only_the_first(self) -> None:
         """Two issues opened between runs are two changes."""
-        current = {"1854": snapshot(), "1900": snapshot(issue_id=1900, number=16)}
+        current = {
+            "1854": snapshot(assignees=[], labels=[], comment_hashes=[]),
+            "1900": snapshot(issue_id=1900, number=16, assignees=[], labels=[], comment_hashes=[]),
+        }
 
         changes = detect_changes(current, {})
 
@@ -368,7 +415,10 @@ class TestDetectChanges:
     def test_a_change_record_carries_the_same_keys_whatever_the_kind(self) -> None:
         """A consumer should be able to read `added` without asking the kind first."""
         changes = detect_changes(
-            {"1854": snapshot(assignees=["alice"]), "1855": snapshot(issue_id=1855, number=16)},
+            {
+                "1854": snapshot(assignees=["alice"]),
+                "1855": snapshot(issue_id=1855, number=16, assignees=[], labels=[], comment_hashes=[]),
+            },
             {"1854": snapshot(), "1900": snapshot(issue_id=1900, number=17)},
         )