xai-review 0.25.0__py3-none-any.whl → 0.27.0__py3-none-any.whl

ai_review/libs/constants/vcs_provider.py

@@ -4,3 +4,4 @@ from enum import StrEnum
 class VCSProvider(StrEnum):
     GITHUB = "GITHUB"
     GITLAB = "GITLAB"
+    BITBUCKET = "BITBUCKET"

ai_review/libs/http/paginate.py

@@ -0,0 +1,43 @@
+from typing import Awaitable, Callable, TypeVar
+
+from httpx import Response
+from pydantic import BaseModel
+
+from ai_review.libs.logger import get_logger
+
+T = TypeVar("T", bound=BaseModel)
+
+logger = get_logger("PAGINATE")
+
+
+async def paginate(
+        fetch_page: Callable[[int], Awaitable[Response]],
+        extract_items: Callable[[Response], list[T]],
+        has_next_page: Callable[[Response], bool],
+        max_pages: int | None = None,
+) -> list[T]:
+    page = 1
+    items: list[T] = []
+
+    while True:
+        response = await fetch_page(page)
+
+        try:
+            extracted = extract_items(response)
+        except Exception as error:
+            logger.error(f"Failed to extract items on {page=}")
+            raise RuntimeError(f"Failed to extract items on {page=}") from error
+
+        logger.debug(f"Page {page}: extracted {len(extracted)} items (total={len(items) + len(extracted)})")
+        items.extend(extracted)
+
+        if not has_next_page(response):
+            logger.debug(f"Pagination finished after {page} page(s), total items={len(items)}")
+            break
+
+        page += 1
+        if max_pages and (page > max_pages):
+            logger.error(f"Pagination exceeded {max_pages=}")
+            raise RuntimeError(f"Pagination exceeded {max_pages=}")
+
+    return items

ai_review/services/vcs/bitbucket/client.py

@@ -0,0 +1,185 @@
+from ai_review.clients.bitbucket.client import get_bitbucket_http_client
+from ai_review.clients.bitbucket.pr.schema.comments import (
+    BitbucketCommentInlineSchema,
+    BitbucketCommentContentSchema,
+    BitbucketCreatePRCommentRequestSchema,
+)
+from ai_review.config import settings
+from ai_review.libs.logger import get_logger
+from ai_review.services.vcs.types import (
+    VCSClientProtocol,
+    UserSchema,
+    BranchRefSchema,
+    ReviewInfoSchema,
+    ReviewCommentSchema,
+)
+
+logger = get_logger("BITBUCKET_VCS_CLIENT")
+
+
+class BitbucketVCSClient(VCSClientProtocol):
+    def __init__(self):
+        self.http_client = get_bitbucket_http_client()
+        self.workspace = settings.vcs.pipeline.workspace
+        self.repo_slug = settings.vcs.pipeline.repo_slug
+        self.pull_request_id = settings.vcs.pipeline.pull_request_id
+
+    async def get_review_info(self) -> ReviewInfoSchema:
+        try:
+            pr = await self.http_client.pr.get_pull_request(
+                workspace=self.workspace,
+                repo_slug=self.repo_slug,
+                pull_request_id=self.pull_request_id,
+            )
+            files = await self.http_client.pr.get_files(
+                workspace=self.workspace,
+                repo_slug=self.repo_slug,
+                pull_request_id=self.pull_request_id,
+            )
+
+            logger.info(f"Fetched PR info for {self.workspace}/{self.repo_slug}#{self.pull_request_id}")
+
+            return ReviewInfoSchema(
+                id=pr.id,
+                title=pr.title,
+                description=pr.description or "",
+                author=UserSchema(
+                    id=pr.author.uuid,
+                    name=pr.author.display_name,
+                    username=pr.author.nickname,
+                ),
+                labels=[],
+                base_sha=pr.destination.commit.hash,
+                head_sha=pr.source.commit.hash,
+                assignees=[
+                    UserSchema(
+                        id=user.uuid,
+                        name=user.display_name,
+                        username=user.nickname,
+                    )
+                    for user in pr.participants
+                ],
+                reviewers=[
+                    UserSchema(
+                        id=user.uuid,
+                        name=user.display_name,
+                        username=user.nickname,
+                    )
+                    for user in pr.reviewers
+                ],
+                source_branch=BranchRefSchema(
+                    ref=pr.source.branch.name,
+                    sha=pr.source.commit.hash,
+                ),
+                target_branch=BranchRefSchema(
+                    ref=pr.destination.branch.name,
+                    sha=pr.destination.commit.hash,
+                ),
+                changed_files=[
+                    file.new.path if file.new else file.old.path
+                    for file in files.values
+                ],
+            )
+        except Exception as error:
+            logger.exception(
+                f"Failed to fetch PR info {self.workspace}/{self.repo_slug}#{self.pull_request_id}: {error}"
+            )
+            return ReviewInfoSchema()
+
+    async def get_general_comments(self) -> list[ReviewCommentSchema]:
+        try:
+            response = await self.http_client.pr.get_comments(
+                workspace=self.workspace,
+                repo_slug=self.repo_slug,
+                pull_request_id=self.pull_request_id,
+            )
+            logger.info(f"Fetched general comments for {self.workspace}/{self.repo_slug}#{self.pull_request_id}")
+
+            return [
+                ReviewCommentSchema(id=comment.id, body=comment.content.raw)
+                for comment in response.values
+                if comment.inline is None
+            ]
+        except Exception as error:
+            logger.exception(
+                f"Failed to fetch general comments for "
+                f"{self.workspace}/{self.repo_slug}#{self.pull_request_id}: {error}"
+            )
+            return []
+
+    async def get_inline_comments(self) -> list[ReviewCommentSchema]:
+        try:
+            response = await self.http_client.pr.get_comments(
+                workspace=self.workspace,
+                repo_slug=self.repo_slug,
+                pull_request_id=self.pull_request_id,
+            )
+            logger.info(f"Fetched inline comments for {self.workspace}/{self.repo_slug}#{self.pull_request_id}")
+
+            return [
+                ReviewCommentSchema(
+                    id=comment.id,
+                    body=comment.content.raw,
+                    file=comment.inline.path,
+                    line=comment.inline.to_line,
+                )
+                for comment in response.values
+                if comment.inline is not None
+            ]
+        except Exception as error:
+            logger.exception(
+                f"Failed to fetch inline comments for "
+                f"{self.workspace}/{self.repo_slug}#{self.pull_request_id}: {error}"
+            )
+            return []
+
+    async def create_general_comment(self, message: str) -> None:
+        try:
+            logger.info(
+                f"Posting general comment to PR {self.workspace}/{self.repo_slug}#{self.pull_request_id}: {message}"
+            )
+            request = BitbucketCreatePRCommentRequestSchema(
+                content=BitbucketCommentContentSchema(raw=message)
+            )
+            await self.http_client.pr.create_comment(
+                workspace=self.workspace,
+                repo_slug=self.repo_slug,
+                pull_request_id=self.pull_request_id,
+                request=request,
+            )
+            logger.info(
+                f"Created general comment in PR {self.workspace}/{self.repo_slug}#{self.pull_request_id}"
+            )
+        except Exception as error:
+            logger.exception(
+                f"Failed to create general comment in PR "
+                f"{self.workspace}/{self.repo_slug}#{self.pull_request_id}: {error}"
+            )
+            raise
+
+    async def create_inline_comment(self, file: str, line: int, message: str) -> None:
+        try:
+            logger.info(
+                f"Posting inline comment in {self.workspace}/{self.repo_slug}#{self.pull_request_id} "
+                f"at {file}:{line}: {message}"
+            )
+            request = BitbucketCreatePRCommentRequestSchema(
+                content=BitbucketCommentContentSchema(raw=message),
+                inline=BitbucketCommentInlineSchema(path=file, to_line=line),
+            )
+            await self.http_client.pr.create_comment(
+                workspace=self.workspace,
+                repo_slug=self.repo_slug,
+                pull_request_id=self.pull_request_id,
+                request=request,
+            )
+            logger.info(
+                f"Created inline comment in {self.workspace}/{self.repo_slug}#{self.pull_request_id} "
+                f"at {file}:{line}"
+            )
+        except Exception as error:
+            logger.exception(
+                f"Failed to create inline comment in {self.workspace}/{self.repo_slug}#{self.pull_request_id} "
+                f"at {file}:{line}: {error}"
+            )
+            raise

ai_review/services/vcs/factory.py

@@ -1,5 +1,6 @@
 from ai_review.config import settings
 from ai_review.libs.constants.vcs_provider import VCSProvider
+from ai_review.services.vcs.bitbucket.client import BitbucketVCSClient
 from ai_review.services.vcs.github.client import GitHubVCSClient
 from ai_review.services.vcs.gitlab.client import GitLabVCSClient
 from ai_review.services.vcs.types import VCSClientProtocol
@@ -11,5 +12,7 @@ def get_vcs_client() -> VCSClientProtocol:
             return GitLabVCSClient()
         case VCSProvider.GITHUB:
             return GitHubVCSClient()
+        case VCSProvider.BITBUCKET:
+            return BitbucketVCSClient()
         case _:
             raise ValueError(f"Unsupported VCS provider: {settings.vcs.provider}")

ai_review/tests/fixtures/clients/bitbucket.py

@@ -0,0 +1,204 @@
+import pytest
+from pydantic import HttpUrl, SecretStr
+
+from ai_review.clients.bitbucket.pr.schema.comments import (
+    BitbucketPRCommentSchema,
+    BitbucketCommentContentSchema,
+    BitbucketCommentInlineSchema,
+    BitbucketGetPRCommentsResponseSchema,
+    BitbucketCreatePRCommentRequestSchema,
+    BitbucketCreatePRCommentResponseSchema,
+)
+from ai_review.clients.bitbucket.pr.schema.files import (
+    BitbucketGetPRFilesResponseSchema,
+    BitbucketPRFileSchema,
+    BitbucketPRFilePathSchema,
+)
+from ai_review.clients.bitbucket.pr.schema.pull_request import (
+    BitbucketUserSchema,
+    BitbucketBranchSchema,
+    BitbucketCommitSchema,
+    BitbucketRepositorySchema,
+    BitbucketPRLocationSchema,
+    BitbucketGetPRResponseSchema,
+)
+from ai_review.clients.bitbucket.pr.types import BitbucketPullRequestsHTTPClientProtocol
+from ai_review.config import settings
+from ai_review.libs.config.vcs.base import BitbucketVCSConfig
+from ai_review.libs.config.vcs.bitbucket import BitbucketPipelineConfig, BitbucketHTTPClientConfig
+from ai_review.libs.constants.vcs_provider import VCSProvider
+from ai_review.services.vcs.bitbucket.client import BitbucketVCSClient
+
+
+class FakeBitbucketPullRequestsHTTPClient(BitbucketPullRequestsHTTPClientProtocol):
+    def __init__(self):
+        self.calls: list[tuple[str, dict]] = []
+
+    async def get_pull_request(
+            self,
+            workspace: str,
+            repo_slug: str,
+            pull_request_id: str
+    ) -> BitbucketGetPRResponseSchema:
+        self.calls.append(
+            (
+                "get_pull_request",
+                {"workspace": workspace, "repo_slug": repo_slug, "pull_request_id": pull_request_id}
+            )
+        )
+        return BitbucketGetPRResponseSchema(
+            id=1,
+            title="Fake Bitbucket PR",
+            description="This is a fake PR for testing",
+            state="OPEN",
+            author=BitbucketUserSchema(uuid="u1", display_name="Tester", nickname="tester"),
+            source=BitbucketPRLocationSchema(
+                commit=BitbucketCommitSchema(hash="def456"),
+                branch=BitbucketBranchSchema(name="feature/test"),
+                repository=BitbucketRepositorySchema(uuid="r1", full_name="workspace/repo"),
+            ),
+            destination=BitbucketPRLocationSchema(
+                commit=BitbucketCommitSchema(hash="abc123"),
+                branch=BitbucketBranchSchema(name="main"),
+                repository=BitbucketRepositorySchema(uuid="r1", full_name="workspace/repo"),
+            ),
+            reviewers=[BitbucketUserSchema(uuid="u2", display_name="Reviewer", nickname="reviewer")],
+            participants=[BitbucketUserSchema(uuid="u3", display_name="Participant", nickname="participant")],
+        )
+
+    async def get_files(
+            self,
+            workspace: str,
+            repo_slug: str,
+            pull_request_id: str
+    ) -> BitbucketGetPRFilesResponseSchema:
+        self.calls.append(
+            (
+                "get_files",
+                {"workspace": workspace, "repo_slug": repo_slug, "pull_request_id": pull_request_id}
+            )
+        )
+        return BitbucketGetPRFilesResponseSchema(
+            size=2,
+            page=1,
+            pagelen=100,
+            next=None,
+            values=[
+                BitbucketPRFileSchema(
+                    new=BitbucketPRFilePathSchema(path="app/main.py"),
+                    old=None,
+                    status="modified",
+                    lines_added=10,
+                    lines_removed=2,
+                ),
+                BitbucketPRFileSchema(
+                    new=BitbucketPRFilePathSchema(path="utils/helper.py"),
+                    old=None,
+                    status="added",
+                    lines_added=5,
+                    lines_removed=0,
+                ),
+            ],
+        )
+
+    async def get_comments(
+            self,
+            workspace: str,
+            repo_slug: str,
+            pull_request_id: str
+    ) -> BitbucketGetPRCommentsResponseSchema:
+        self.calls.append(
+            (
+                "get_comments",
+                {"workspace": workspace, "repo_slug": repo_slug, "pull_request_id": pull_request_id}
+            )
+        )
+        return BitbucketGetPRCommentsResponseSchema(
+            size=2,
+            page=1,
+            next=None,
+            values=[
+                BitbucketPRCommentSchema(
+                    id=1,
+                    inline=None,
+                    content=BitbucketCommentContentSchema(raw="General comment"),
+                ),
+                BitbucketPRCommentSchema(
+                    id=2,
+                    inline=BitbucketCommentInlineSchema(path="file.py", to_line=5),
+                    content=BitbucketCommentContentSchema(raw="Inline comment"),
+                ),
+            ],
+            pagelen=100,
+        )
+
+    async def create_comment(
+            self,
+            workspace: str,
+            repo_slug: str,
+            pull_request_id: str,
+            request: BitbucketCreatePRCommentRequestSchema
+    ) -> BitbucketCreatePRCommentResponseSchema:
+        self.calls.append(
+            (
+                "create_comment",
+                {
+                    "workspace": workspace,
+                    "repo_slug": repo_slug,
+                    "pull_request_id": pull_request_id,
+                    **request.model_dump(by_alias=True)
+                }
+            )
+        )
+        return BitbucketCreatePRCommentResponseSchema(
+            id=10,
+            content=request.content,
+            inline=request.inline,
+        )
+
+
+class FakeBitbucketHTTPClient:
+    def __init__(self, pull_requests_client: BitbucketPullRequestsHTTPClientProtocol):
+        self.pr = pull_requests_client
+
+
+@pytest.fixture
+def fake_bitbucket_pull_requests_http_client() -> FakeBitbucketPullRequestsHTTPClient:
+    return FakeBitbucketPullRequestsHTTPClient()
+
+
+@pytest.fixture
+def fake_bitbucket_http_client(
+        fake_bitbucket_pull_requests_http_client: FakeBitbucketPullRequestsHTTPClient
+) -> FakeBitbucketHTTPClient:
+    return FakeBitbucketHTTPClient(pull_requests_client=fake_bitbucket_pull_requests_http_client)
+
+
+@pytest.fixture
+def bitbucket_vcs_client(
+        monkeypatch: pytest.MonkeyPatch,
+        fake_bitbucket_http_client: FakeBitbucketHTTPClient
+) -> BitbucketVCSClient:
+    monkeypatch.setattr(
+        "ai_review.services.vcs.bitbucket.client.get_bitbucket_http_client",
+        lambda: fake_bitbucket_http_client,
+    )
+    return BitbucketVCSClient()
+
+
+@pytest.fixture
+def bitbucket_http_client_config(monkeypatch: pytest.MonkeyPatch):
+    fake_config = BitbucketVCSConfig(
+        provider=VCSProvider.BITBUCKET,
+        pipeline=BitbucketPipelineConfig(
+            workspace="workspace",
+            repo_slug="repo",
+            pull_request_id="123",
+        ),
+        http_client=BitbucketHTTPClientConfig(
+            timeout=10,
+            api_url=HttpUrl("https://api.bitbucket.org/2.0"),
+            api_token=SecretStr("fake-token"),
+        )
+    )
+    monkeypatch.setattr(settings, "vcs", fake_config)

ai_review/tests/suites/clients/bitbucket/test_client.py

@@ -0,0 +1,14 @@
+import pytest
+from httpx import AsyncClient
+
+from ai_review.clients.bitbucket.client import get_bitbucket_http_client, BitbucketHTTPClient
+from ai_review.clients.bitbucket.pr.client import BitbucketPullRequestsHTTPClient
+
+
+@pytest.mark.usefixtures("bitbucket_http_client_config")
+def test_get_bitbucket_http_client_builds_ok():
+    bitbucket_http_client = get_bitbucket_http_client()
+
+    assert isinstance(bitbucket_http_client, BitbucketHTTPClient)
+    assert isinstance(bitbucket_http_client.pr, BitbucketPullRequestsHTTPClient)
+    assert isinstance(bitbucket_http_client.pr.client, AsyncClient)

ai_review/tests/suites/clients/bitbucket/test_tools.py

@@ -0,0 +1,31 @@
+from httpx import Response, Request
+
+from ai_review.clients.bitbucket.tools import bitbucket_has_next_page
+
+
+def make_response(data: dict) -> Response:
+    return Response(
+        json=data,
+        request=Request("GET", "http://bitbucket.test"),
+        status_code=200,
+    )
+
+
+def test_bitbucket_has_next_page_true():
+    resp = make_response({"next": "https://api.bitbucket.org/2.0/repositories/test/repo?page=2"})
+    assert bitbucket_has_next_page(resp) is True
+
+
+def test_bitbucket_has_next_page_false_none():
+    resp = make_response({"next": None})
+    assert bitbucket_has_next_page(resp) is False
+
+
+def test_bitbucket_has_next_page_false_missing():
+    resp = make_response({})
+    assert bitbucket_has_next_page(resp) is False
+
+
+def test_bitbucket_has_next_page_false_empty_string():
+    resp = make_response({"next": ""})
+    assert bitbucket_has_next_page(resp) is False

ai_review/tests/suites/clients/github/test_tools.py

@@ -0,0 +1,31 @@
+from httpx import Response, Request
+
+from ai_review.clients.github.tools import github_has_next_page
+
+
+def make_response(headers: dict) -> Response:
+    return Response(
+        request=Request("GET", "http://test"),
+        headers=headers,
+        status_code=200,
+    )
+
+
+def test_github_has_next_page_true():
+    response = make_response({
+        "Link": '<https://api.github.com/resource?page=2>; rel="next", '
+                '<https://api.github.com/resource?page=5>; rel="last"'
+    })
+    assert github_has_next_page(response) is True
+
+
+def test_github_has_next_page_false_no_next():
+    response = make_response({
+        "Link": '<https://api.github.com/resource?page=5>; rel="last"'
+    })
+    assert github_has_next_page(response) is False
+
+
+def test_github_has_next_page_false_no_header():
+    resp = make_response({})
+    assert github_has_next_page(resp) is False

ai_review/tests/suites/clients/gitlab/test_tools.py

@@ -0,0 +1,26 @@
+from httpx import Response, Request
+
+from ai_review.clients.gitlab.tools import gitlab_has_next_page
+
+
+def make_response(headers: dict) -> Response:
+    return Response(
+        request=Request("GET", "http://gitlab.test"),
+        headers=headers,
+        status_code=200,
+    )
+
+
+def test_gitlab_has_next_page_true():
+    resp = make_response({"X-Next-Page": "2"})
+    assert gitlab_has_next_page(resp) is True
+
+
+def test_gitlab_has_next_page_false_empty():
+    resp = make_response({"X-Next-Page": ""})
+    assert gitlab_has_next_page(resp) is False
+
+
+def test_gitlab_has_next_page_false_missing():
+    resp = make_response({})
+    assert gitlab_has_next_page(resp) is False

ai_review/tests/suites/libs/http/test_paginate.py

@@ -0,0 +1,95 @@
+import pytest
+from httpx import Response, Request
+from pydantic import BaseModel
+
+from ai_review.libs.http.paginate import paginate
+
+
+class DummySchema(BaseModel):
+    value: int
+
+
+def make_response(data: dict) -> Response:
+    return Response(
+        json=data,
+        request=Request("GET", "http://test"),
+        status_code=200,
+    )
+
+
+@pytest.mark.asyncio
+async def test_single_page():
+    async def fetch_page(_: int) -> Response:
+        return make_response({"items": [1, 2, 3]})
+
+    def extract_items(response: Response) -> list[DummySchema]:
+        return [DummySchema(value=value) for value in response.json()["items"]]
+
+    def has_next_page(_: Response) -> bool:
+        return False
+
+    items = await paginate(fetch_page, extract_items, has_next_page)
+    assert len(items) == 3
+    assert [item.value for item in items] == [1, 2, 3]
+
+
+@pytest.mark.asyncio
+async def test_multiple_pages():
+    async def fetch_page(page: int) -> Response:
+        return make_response({"items": [page]})
+
+    def extract_items(response: Response):
+        return [DummySchema(value=value) for value in response.json()["items"]]
+
+    def has_next_page(response: Response) -> bool:
+        return response.json()["items"][0] < 3
+
+    items = await paginate(fetch_page, extract_items, has_next_page)
+    assert [item.value for item in items] == [1, 2, 3]
+
+
+@pytest.mark.asyncio
+async def test_extract_items_error():
+    async def fetch_page(_: int) -> Response:
+        return make_response({"items": [1]})
+
+    def extract_items(_: Response):
+        raise ValueError("bad json")
+
+    def has_next_page(_: Response) -> bool:
+        return False
+
+    with pytest.raises(RuntimeError) as exc:
+        await paginate(fetch_page, extract_items, has_next_page)
+    assert "Failed to extract items" in str(exc.value)
+
+
+@pytest.mark.asyncio
+async def test_max_pages_exceeded():
+    async def fetch_page(page: int) -> Response:
+        return make_response({"items": [page]})
+
+    def extract_items(response: Response):
+        return [DummySchema(value=value) for value in response.json()["items"]]
+
+    def has_next_page(_: Response) -> bool:
+        return True
+
+    with pytest.raises(RuntimeError) as exc:
+        await paginate(fetch_page, extract_items, has_next_page, max_pages=2)
+    assert "Pagination exceeded" in str(exc.value)
+
+
+@pytest.mark.asyncio
+async def test_empty_items():
+    async def fetch_page(_: int) -> Response:
+        return make_response({"items": []})
+
+    def extract_items(_: Response):
+        return []
+
+    def has_next_page(_: Response) -> bool:
+        return False
+
+    result = await paginate(fetch_page, extract_items, has_next_page)
+    assert result == []