pjdev-gitlab 5.0.0__py3-none-any.whl

pjdev_gitlab/config_service.py

@@ -0,0 +1,49 @@
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from pjdev_gitlab.models import Config, ProjectId
+
+__ctx: Dict[str, Any] = {}
+
+
+def get_config() -> Config:
+    if "config" not in __ctx:
+        raise RuntimeError("pjdev_gitlab is not initialized -- call config_service.init() first")
+    return __ctx["config"]
+
+
+def init(
+    env_path: Optional[Path] = None,
+    token: Optional[str] = None,
+    gitlab_url: Optional[str] = None,
+    default_project_id: Optional[ProjectId] = None,
+    output_path: Optional[Path] = None,
+    http_retry_max_count: Optional[int] = None,
+    http_retry_delay_seconds: Optional[int] = None,
+    request_timeout_seconds: Optional[float] = None,
+) -> None:
+    if env_path is not None:
+        Config.model_config = {**Config.model_config, "env_file": env_path}
+
+    kwargs: Dict[str, Any] = {}
+    if token is not None:
+        kwargs["token"] = token
+    if gitlab_url is not None:
+        kwargs["gitlab_url"] = gitlab_url
+    if default_project_id is not None:
+        kwargs["default_project_id"] = default_project_id
+    if output_path is not None:
+        kwargs["output_path"] = output_path
+    if http_retry_max_count is not None:
+        kwargs["http_retry_max_count"] = http_retry_max_count
+    if http_retry_delay_seconds is not None:
+        kwargs["http_retry_delay_seconds"] = http_retry_delay_seconds
+    if request_timeout_seconds is not None:
+        kwargs["request_timeout_seconds"] = request_timeout_seconds
+
+    config = Config(**kwargs)
+
+    if config.output_path is None and env_path is not None:
+        config.output_path = env_path.parent / "output"
+
+    __ctx["config"] = config

pjdev_gitlab/issues_service.py

@@ -0,0 +1,430 @@
+import re
+from collections import Counter
+from pathlib import Path
+from typing import Any, Dict, List, Literal, Optional
+
+from httpx import AsyncClient
+from loguru import logger
+
+from pjdev_gitlab.api_utilities import (
+    async_retry_http,
+    encode_path_segment,
+    http_client,
+    paginate,
+    upload_to_project,
+)
+from pjdev_gitlab.models import (
+    Discussion,
+    Issue,
+    IssueState,
+    IssueType,
+    Iteration,
+    Milestone,
+    Note,
+    ProjectId,
+    StateEvent,
+)
+
+_IGNORE_4XX = [400, 401, 403, 404]
+_IMG_PATTERN = re.compile(r'<img[^>]*src="([^"]+)"[^>]*>', re.IGNORECASE)
+
+
+def _project_url(project_id: ProjectId) -> str:
+    return f"/projects/{encode_path_segment(project_id)}"
+
+
+async def _replace_image_paths_with_uploads(
+    project_id: ProjectId,
+    description: str,
+    image_paths: List[Path],
+    client: AsyncClient,
+) -> str:
+    """Upload local images and rewrite ``<img src=...>`` references in the description.
+
+    Images are matched positionally to ``<img>`` tags (first tag -> first path, etc.).
+    Images without a corresponding tag are appended to the end of the description.
+    Mirrors the pattern in keystone-gitlab.
+    """
+    matches = _IMG_PATTERN.findall(description)
+    rewritten = description
+
+    for index, image_path in enumerate(image_paths):
+        upload = await upload_to_project(project_id, image_path, client=client)
+        markdown = upload.get("markdown") or upload.get("url", "")
+        if index < len(matches):
+            rewritten = _IMG_PATTERN.sub(markdown, rewritten, count=1)
+        else:
+            rewritten = f"{rewritten}\n\n{markdown}"
+
+    return rewritten
+
+
+@async_retry_http(status_codes_to_ignore=_IGNORE_4XX)
+async def search_issues(
+    project_id: ProjectId,
+    *,
+    state: Optional[IssueState] = None,
+    labels: Optional[List[str]] = None,
+    milestone: Optional[str] = None,
+    iteration_id: Optional[int] = None,
+    search: Optional[str] = None,
+    assignee_id: Optional[int] = None,
+    author_id: Optional[int] = None,
+    created_after: Optional[str] = None,
+    created_before: Optional[str] = None,
+    issue_type: Optional[IssueType] = None,
+    extra_params: Optional[Dict[str, Any]] = None,
+    paginate_results: bool = True,
+    page_size: int = 100,
+    client: Optional[AsyncClient] = None,
+) -> List[Issue]:
+    params: Dict[str, Any] = {}
+    if state is not None:
+        params["state"] = state.value
+    if labels:
+        params["labels"] = ",".join(labels)
+    if milestone is not None:
+        params["milestone"] = milestone
+    if iteration_id is not None:
+        params["iteration_id"] = iteration_id
+    if search is not None:
+        params["search"] = search
+    if assignee_id is not None:
+        params["assignee_id"] = assignee_id
+    if author_id is not None:
+        params["author_id"] = author_id
+    if created_after is not None:
+        params["created_after"] = created_after
+    if created_before is not None:
+        params["created_before"] = created_before
+    if issue_type is not None:
+        params["issue_type"] = issue_type.value
+    if extra_params:
+        params.update(extra_params)
+
+    url = f"{_project_url(project_id)}/issues"
+
+    async def _exec(_client: AsyncClient) -> List[Issue]:
+        if paginate_results:
+            rows = await paginate(_client, url, params=params, page_size=page_size)
+        else:
+            params["per_page"] = page_size
+            r = await _client.get(url, params=params)
+            r.raise_for_status()
+            rows = r.json()
+        return [Issue.model_validate(row) for row in rows]
+
+    if client is None:
+        async with http_client() as _client:
+            return await _exec(_client)
+    return await _exec(client)
+
+
+@async_retry_http(status_codes_to_ignore=_IGNORE_4XX)
+async def get_issue(
+    project_id: ProjectId,
+    issue_iid: int,
+    client: Optional[AsyncClient] = None,
+) -> Issue:
+    url = f"{_project_url(project_id)}/issues/{issue_iid}"
+
+    async def _exec(_client: AsyncClient) -> Issue:
+        r = await _client.get(url)
+        r.raise_for_status()
+        return Issue.model_validate(r.json())
+
+    if client is None:
+        async with http_client() as _client:
+            return await _exec(_client)
+    return await _exec(client)
+
+
+@async_retry_http(status_codes_to_ignore=_IGNORE_4XX)
+async def create_issue(
+    project_id: ProjectId,
+    title: str,
+    description: str = "",
+    *,
+    labels: Optional[List[str]] = None,
+    assignee_ids: Optional[List[int]] = None,
+    milestone_id: Optional[int] = None,
+    iteration_id: Optional[int] = None,
+    issue_type: Optional[IssueType] = None,
+    image_paths: Optional[List[Path]] = None,
+    confidential: Optional[bool] = None,
+    client: Optional[AsyncClient] = None,
+) -> Issue:
+    """Create an issue. Optionally uploads ``image_paths`` first and splices their
+    markdown into the description (replacing ``<img>`` tags positionally).
+
+    Quick actions like ``/label ~bug`` or ``/assign @me`` embedded in the
+    description are interpreted server-side by GitLab.
+    """
+    url = f"{_project_url(project_id)}/issues"
+
+    async def _exec(_client: AsyncClient) -> Issue:
+        final_description = description
+        if image_paths:
+            final_description = await _replace_image_paths_with_uploads(
+                project_id, description, image_paths, _client
+            )
+
+        payload: Dict[str, Any] = {"title": title, "description": final_description}
+        if labels:
+            payload["labels"] = ",".join(labels)
+        if assignee_ids:
+            payload["assignee_ids"] = assignee_ids
+        if milestone_id is not None:
+            payload["milestone_id"] = milestone_id
+        if iteration_id is not None:
+            payload["iteration_id"] = iteration_id
+        if issue_type is not None:
+            payload["issue_type"] = issue_type.value
+        if confidential is not None:
+            payload["confidential"] = confidential
+
+        r = await _client.post(url, json=payload)
+        r.raise_for_status()
+        issue = Issue.model_validate(r.json())
+        logger.info(f"Created issue !{issue.iid} in project {project_id}")
+        return issue
+
+    if client is None:
+        async with http_client() as _client:
+            return await _exec(_client)
+    return await _exec(client)
+
+
+@async_retry_http(status_codes_to_ignore=_IGNORE_4XX)
+async def comment_on_issue(
+    project_id: ProjectId,
+    issue_iid: int,
+    body: str,
+    *,
+    image_paths: Optional[List[Path]] = None,
+    client: Optional[AsyncClient] = None,
+) -> Note:
+    """Add a single (non-threaded) note to an issue.
+
+    Quick actions in ``body`` (e.g. ``/close``, ``/label ~bug``) are processed by GitLab.
+    Use ``start_issue_discussion`` instead when you want a threaded reply.
+    """
+    url = f"{_project_url(project_id)}/issues/{issue_iid}/notes"
+
+    async def _exec(_client: AsyncClient) -> Note:
+        final_body = body
+        if image_paths:
+            final_body = await _replace_image_paths_with_uploads(
+                project_id, body, image_paths, _client
+            )
+        r = await _client.post(url, json={"body": final_body})
+        r.raise_for_status()
+        return Note.model_validate(r.json())
+
+    if client is None:
+        async with http_client() as _client:
+            return await _exec(_client)
+    return await _exec(client)
+
+
+@async_retry_http(status_codes_to_ignore=_IGNORE_4XX)
+async def start_issue_discussion(
+    project_id: ProjectId,
+    issue_iid: int,
+    body: str,
+    client: Optional[AsyncClient] = None,
+) -> Discussion:
+    url = f"{_project_url(project_id)}/issues/{issue_iid}/discussions"
+
+    async def _exec(_client: AsyncClient) -> Discussion:
+        r = await _client.post(url, json={"body": body})
+        r.raise_for_status()
+        return Discussion.model_validate(r.json())
+
+    if client is None:
+        async with http_client() as _client:
+            return await _exec(_client)
+    return await _exec(client)
+
+
+@async_retry_http(status_codes_to_ignore=_IGNORE_4XX)
+async def set_issue_state(
+    project_id: ProjectId,
+    issue_iid: int,
+    state_event: StateEvent,
+    client: Optional[AsyncClient] = None,
+) -> Issue:
+    url = f"{_project_url(project_id)}/issues/{issue_iid}"
+
+    async def _exec(_client: AsyncClient) -> Issue:
+        r = await _client.put(url, json={"state_event": state_event.value})
+        r.raise_for_status()
+        return Issue.model_validate(r.json())
+
+    if client is None:
+        async with http_client() as _client:
+            return await _exec(_client)
+    return await _exec(client)
+
+
+@async_retry_http(status_codes_to_ignore=_IGNORE_4XX)
+async def set_issue_labels(
+    project_id: ProjectId,
+    issue_iid: int,
+    labels: List[str],
+    *,
+    mode: Literal["replace", "add", "remove"] = "replace",
+    client: Optional[AsyncClient] = None,
+) -> Issue:
+    url = f"{_project_url(project_id)}/issues/{issue_iid}"
+    label_csv = ",".join(labels)
+    if mode == "replace":
+        payload = {"labels": label_csv}
+    elif mode == "add":
+        payload = {"add_labels": label_csv}
+    else:
+        payload = {"remove_labels": label_csv}
+
+    async def _exec(_client: AsyncClient) -> Issue:
+        r = await _client.put(url, json=payload)
+        r.raise_for_status()
+        return Issue.model_validate(r.json())
+
+    if client is None:
+        async with http_client() as _client:
+            return await _exec(_client)
+    return await _exec(client)
+
+
+@async_retry_http(status_codes_to_ignore=_IGNORE_4XX)
+async def set_issue_iteration(
+    project_id: ProjectId,
+    issue_iid: int,
+    iteration_id: int,
+    client: Optional[AsyncClient] = None,
+) -> Issue:
+    url = f"{_project_url(project_id)}/issues/{issue_iid}"
+
+    async def _exec(_client: AsyncClient) -> Issue:
+        r = await _client.put(url, json={"iteration_id": iteration_id})
+        r.raise_for_status()
+        return Issue.model_validate(r.json())
+
+    if client is None:
+        async with http_client() as _client:
+            return await _exec(_client)
+    return await _exec(client)
+
+
+@async_retry_http(status_codes_to_ignore=_IGNORE_4XX)
+async def set_issue_milestone(
+    project_id: ProjectId,
+    issue_iid: int,
+    milestone_id: int,
+    client: Optional[AsyncClient] = None,
+) -> Issue:
+    url = f"{_project_url(project_id)}/issues/{issue_iid}"
+
+    async def _exec(_client: AsyncClient) -> Issue:
+        r = await _client.put(url, json={"milestone_id": milestone_id})
+        r.raise_for_status()
+        return Issue.model_validate(r.json())
+
+    if client is None:
+        async with http_client() as _client:
+            return await _exec(_client)
+    return await _exec(client)
+
+
+@async_retry_http(status_codes_to_ignore=_IGNORE_4XX)
+async def list_iterations(
+    group_id: ProjectId,
+    *,
+    state: Optional[str] = None,
+    page_size: int = 100,
+    client: Optional[AsyncClient] = None,
+) -> List[Iteration]:
+    url = f"/groups/{encode_path_segment(group_id)}/iterations"
+    params: Dict[str, Any] = {}
+    if state is not None:
+        params["state"] = state
+
+    async def _exec(_client: AsyncClient) -> List[Iteration]:
+        rows = await paginate(_client, url, params=params, page_size=page_size)
+        return [Iteration.model_validate(row) for row in rows]
+
+    if client is None:
+        async with http_client() as _client:
+            return await _exec(_client)
+    return await _exec(client)
+
+
+@async_retry_http(status_codes_to_ignore=_IGNORE_4XX)
+async def list_milestones(
+    project_id: ProjectId,
+    *,
+    state: Optional[str] = None,
+    page_size: int = 100,
+    client: Optional[AsyncClient] = None,
+) -> List[Milestone]:
+    url = f"{_project_url(project_id)}/milestones"
+    params: Dict[str, Any] = {}
+    if state is not None:
+        params["state"] = state
+
+    async def _exec(_client: AsyncClient) -> List[Milestone]:
+        rows = await paginate(_client, url, params=params, page_size=page_size)
+        return [Milestone.model_validate(row) for row in rows]
+
+    if client is None:
+        async with http_client() as _client:
+            return await _exec(_client)
+    return await _exec(client)
+
+
+_GROUP_BY = Literal["state", "label", "author", "assignee", "iteration", "milestone"]
+
+
+async def aggregate_issues(
+    project_id: ProjectId,
+    group_by: _GROUP_BY,
+    *,
+    state: Optional[IssueState] = None,
+    labels: Optional[List[str]] = None,
+    created_after: Optional[str] = None,
+    created_before: Optional[str] = None,
+    client: Optional[AsyncClient] = None,
+) -> Dict[str, int]:
+    """Return a count-by-bucket aggregation of issues matching the given filters.
+
+    For ``label``, each label of each issue is counted separately (an issue with
+    two labels contributes 1 to each bucket).
+    """
+    issues = await search_issues(
+        project_id,
+        state=state,
+        labels=labels,
+        created_after=created_after,
+        created_before=created_before,
+        client=client,
+    )
+    counter: Counter[str] = Counter()
+    for issue in issues:
+        if group_by == "state":
+            counter[issue.state.value] += 1
+        elif group_by == "label":
+            for label in issue.labels:
+                counter[label] += 1
+        elif group_by == "author":
+            counter[issue.author.username if issue.author else "unknown"] += 1
+        elif group_by == "assignee":
+            if not issue.assignees:
+                counter["unassigned"] += 1
+            else:
+                for assignee in issue.assignees:
+                    counter[assignee.username] += 1
+        elif group_by == "iteration":
+            counter[issue.iteration.title or str(issue.iteration.id) if issue.iteration else "none"] += 1
+        elif group_by == "milestone":
+            counter[issue.milestone.title if issue.milestone else "none"] += 1
+    return dict(counter)