gitcode-api 1.2.13__py3-none-any.whl → 1.2.15__py3-none-any.whl

gitcode_api/__init__.py

@@ -9,6 +9,7 @@ from ._exceptions import (
     GitCodeError,
     GitCodeHTTPStatusError,
 )
+from .utils import as_dict
 
 __version__ = (Path(__file__).parent / "version.txt").read_text().strip()
 
@@ -20,4 +21,5 @@ __all__ = [
     "GitCodeConfigurationError",
     "GitCodeError",
     "GitCodeHTTPStatusError",
+    "as_dict",
 ]

gitcode_api/_models.py

@@ -9,7 +9,6 @@ from typing import (
     Mapping,
     MutableMapping,
     Optional,
-    TypedDict,
     TypeVar,
     Union,
     get_args,
@@ -136,60 +135,6 @@ def as_model_list(data: List[Mapping[str, Any]], model_type: type[ModelT]) -> Li
     return [as_model(item, model_type) for item in data]
 
 
-class RepositoryCreateParams(TypedDict, total=False):
-    """Typed fields accepted by repository creation endpoints."""
-
-    name: str
-    description: str
-    has_issues: bool
-    has_wiki: bool
-    auto_init: bool
-    gitignore_template: str
-    license_template: str
-    path: str
-    private: bool
-    public: int
-    default_branch: str
-    homepage: str
-    can_comment: bool
-
-
-class IssueCreateParams(TypedDict, total=False):
-    """Typed fields accepted by issue creation endpoints."""
-
-    title: str
-    body: str
-    assignee: str
-    labels: List[str]
-    milestone: Union[int, str]
-
-
-class PullRequestCreateParams(TypedDict, total=False):
-    """Typed fields accepted by pull request creation endpoints."""
-
-    title: str
-    body: str
-    head: str
-    base: str
-    assignees: List[str]
-    testers: List[str]
-    labels: List[str]
-    draft: bool
-
-
-class WebhookCreateParams(TypedDict, total=False):
-    """Typed fields accepted by webhook creation endpoints."""
-
-    url: str
-    encryption_type: int
-    password: str
-    push_events: bool
-    tag_push_events: bool
-    issues_events: bool
-    note_events: bool
-    merge_requests_events: bool
-
-
 @dataclass(init=False)
 class UserRef(APIObject):
     """Compact user payload embedded in other responses.
@@ -513,6 +458,8 @@ class Repository(APIObject):
     :vartype relation: Optional[str]
     :ivar members: Members returned in the repository payload.
     :vartype members: Optional[List[str]]
+    :ivar parent: Upstream source repository information
+    :vartype parent: Optional[Dict[str, Any]]
     :ivar permission: Permission summary for this object.
     :vartype permission: Optional[RepositoryPermission]
     :ivar enterprise: Enterprise associated with the repository.
@@ -566,6 +513,7 @@ class Repository(APIObject):
     status: Optional[str] = None
     relation: Optional[str] = None
     members: Optional[List[str]] = None
+    parent: Optional[Dict[str, Any]] = None
     permission: Optional[RepositoryPermission] = None
     enterprise: Optional[Union[EnterpriseRef, str]] = None
     issue_template_source: Optional[str] = None
@@ -760,6 +708,31 @@ class ContentObject(APIObject):
     _links: Optional[ContentLinks] = None
 
 
+@dataclass(init=False)
+class RepositoryGitCodeTemplate(APIObject):
+    """Metadata for a ``.gitcode`` issue or pull request template file.
+
+    Returned by :meth:`~gitcode_api.resources.collaboration.IssuesResource.list_templates`
+    and :meth:`~gitcode_api.resources.collaboration.PullsResource.list_templates`. Use
+    :meth:`~gitcode_api.resources.collaboration.IssuesResource.get_template` or
+    :meth:`~gitcode_api.resources.collaboration.PullsResource.get_template` to load the body.
+
+    :ivar path: Repository-relative path (under ``.gitcode/``).
+    :vartype path: Optional[str]
+    :ivar sha: Object SHA for the file.
+    :vartype sha: Optional[str]
+    :ivar template_owner: Owner path of the repository the template was resolved from.
+    :vartype template_owner: Optional[str]
+    :ivar template_repo: Repository name the template was resolved from.
+    :vartype template_repo: Optional[str]
+    """
+
+    path: Optional[str] = None
+    sha: Optional[str] = None
+    template_owner: Optional[str] = None
+    template_repo: Optional[str] = None
+
+
 @dataclass(init=False)
 class CommitIdentity(APIObject):
     """Commit author/committer identity.

gitcode_api/llm/jiuwen.py

@@ -9,7 +9,7 @@ from gitcode_api._base_client import DEFAULT_BASE_URL
 from ._tool import TOOL_DESCRIPTION, TOOL_NAME, TOOL_PARAMETERS, GitCodeLLMTool
 
 if TYPE_CHECKING:
-    from openjiuwen.core.foundation.tool import LocalFunction
+    from openjiuwen.core.foundation.tool import LocalFunction  # type: ignore[import-untyped]
 
 
 def _missing_openjiuwen_error() -> ImportError:

gitcode_api/llm/openai.py

@@ -75,6 +75,7 @@ class GitCodeOpenAITool(GitCodeLLMTool):
         return self.tool
 
     async def __async_call__(self, *args, **kwargs) -> str:
+        """Invoke the configured async tool callable."""
         result = await super().__async_call__(*args, **kwargs)
         return json.dumps(result, ensure_ascii=False, indent=self.indent)
 

gitcode_api/resources/_shared.py

@@ -1,11 +1,317 @@
 """Shared resource base classes for the GitCode SDK."""
 
-from typing import Any, Dict, List, Optional, Union
+import re
+from typing import Any, Dict, List, Optional, Pattern, Tuple, Union
 
 from .._base_client import AsyncAPIClient, SyncAPIClient
 from .._base_resource import BaseResource
+from .._exceptions import GitCodeHTTPStatusError
 from .._models import APIObject, ModelT, as_model, as_model_list
 
+GITCODE_ISSUE_TEMPLATE_PATH_RE: Pattern[str] = re.compile(
+    r"\.gitcode/ISSUE_TEMPLATE.*\.(md|markdown|ya?ml)$", re.IGNORECASE
+)
+GITCODE_PULL_REQUEST_TEMPLATE_PATH_RE: Pattern[str] = re.compile(
+    r"\.gitcode/PULL_REQUEST_TEMPLATE.*\.(md|markdown|ya?ml)$", re.IGNORECASE
+)
+
+
+def _parse_parent_owner_repo(repo_obj: Any) -> Optional[Tuple[str, str]]:
+    parent = getattr(repo_obj, "parent", None)
+    if parent is None and hasattr(repo_obj, "get"):
+        parent = repo_obj.get("parent")
+    if not isinstance(parent, dict):
+        return None
+    full = str(parent.get("full_name") or "").strip()
+    if "/" not in full:
+        return None
+    owner_path, name = full.rsplit("/", 1)
+    owner_path, name = owner_path.strip(), name.strip()
+    if not owner_path or not name:
+        return None
+    return owner_path, name
+
+
+def _resolution_sources_sync(client: SyncAPIClient, owner: str, repo: str) -> List[Tuple[str, str]]:
+    """Build ordered repo candidates.
+
+    Starts with ``(owner, repo)`` and ``(owner, ".gitcode")``. For every candidate that is a
+    fork (per ``GET /repos/{owner}/{repo}``), appends that repository's parent main repo and
+    ``(parent_owner, ".gitcode")`` when not already listed (deduplicated, breadth-first).
+    """
+    from .repositories import ReposResource
+
+    sources: List[Tuple[str, str]] = []
+    seen: set[Tuple[str, str]] = set()
+
+    def add(pair: Tuple[str, str]) -> None:
+        if pair not in seen:
+            seen.add(pair)
+            sources.append(pair)
+
+    add((owner, repo))
+    add((owner, ".gitcode"))
+
+    max_candidates = 64
+    index = 0
+    while index < len(sources) and len(sources) < max_candidates:
+        so, sr = sources[index]
+        index += 1
+        try:
+            meta = ReposResource(client).get(owner=so, repo=sr)
+        except GitCodeHTTPStatusError:
+            continue
+        if not getattr(meta, "fork", None):
+            continue
+        parsed = _parse_parent_owner_repo(meta)
+        if not parsed:
+            continue
+        po, pr = parsed
+        add((po, pr))
+        add((po, ".gitcode"))
+
+    return sources
+
+
+async def _resolution_sources_async(client: AsyncAPIClient, owner: str, repo: str) -> List[Tuple[str, str]]:
+    """Async counterpart of :func:`_resolution_sources_sync`."""
+    from .repositories import AsyncReposResource
+
+    sources: List[Tuple[str, str]] = []
+    seen: set[Tuple[str, str]] = set()
+
+    def add(pair: Tuple[str, str]) -> None:
+        if pair not in seen:
+            seen.add(pair)
+            sources.append(pair)
+
+    add((owner, repo))
+    add((owner, ".gitcode"))
+
+    max_candidates = 64
+    index = 0
+    while index < len(sources) and len(sources) < max_candidates:
+        so, sr = sources[index]
+        index += 1
+        try:
+            meta = await AsyncReposResource(client).get(owner=so, repo=sr)
+        except GitCodeHTTPStatusError:
+            continue
+        if not getattr(meta, "fork", None):
+            continue
+        parsed = _parse_parent_owner_repo(meta)
+        if not parsed:
+            continue
+        po, pr = parsed
+        add((po, pr))
+        add((po, ".gitcode"))
+
+    return sources
+
+
+def _walk_dot_gitcode_contents_sync(
+    client: SyncAPIClient,
+    template_owner: str,
+    template_repo: str,
+    path: str,
+    acc: List[Tuple[str, str, str, str]],
+) -> None:
+    try:
+        data = client.request(
+            "GET",
+            client._repo_file_path("contents", path, owner=template_owner, repo=template_repo),
+        )
+    except GitCodeHTTPStatusError as exc:
+        if exc.status_code == 404:
+            return
+        raise
+
+    if isinstance(data, dict):
+        t = (data.get("type") or "").lower()
+        if t == "file":
+            sha = data.get("sha") or ""
+            pth = data.get("path") or path
+            if sha and pth:
+                acc.append((template_owner, template_repo, str(pth), str(sha)))
+            return
+        if t in ("dir", "directory", "tree"):
+            pth = data.get("path") or path
+            _walk_dot_gitcode_contents_sync(client, template_owner, template_repo, pth, acc)
+            return
+        return
+
+    if isinstance(data, list):
+        for item in data:
+            if not isinstance(item, dict):
+                continue
+            t = (item.get("type") or "").lower()
+            pth = item.get("path") or ""
+            if t == "file":
+                sha = item.get("sha") or ""
+                if sha and pth:
+                    acc.append((template_owner, template_repo, str(pth), str(sha)))
+            elif t in ("dir", "directory", "tree") and pth:
+                _walk_dot_gitcode_contents_sync(client, template_owner, template_repo, str(pth), acc)
+
+
+async def _walk_dot_gitcode_contents_async(
+    client: AsyncAPIClient,
+    template_owner: str,
+    template_repo: str,
+    path: str,
+    acc: List[Tuple[str, str, str, str]],
+) -> None:
+    try:
+        data = await client.request(
+            "GET",
+            client._repo_file_path("contents", path, owner=template_owner, repo=template_repo),
+        )
+    except GitCodeHTTPStatusError as exc:
+        if exc.status_code == 404:
+            return
+        raise
+
+    if isinstance(data, dict):
+        t = (data.get("type") or "").lower()
+        if t == "file":
+            sha = data.get("sha") or ""
+            pth = data.get("path") or path
+            if sha and pth:
+                acc.append((template_owner, template_repo, str(pth), str(sha)))
+            return
+        if t in ("dir", "directory", "tree"):
+            pth = data.get("path") or path
+            await _walk_dot_gitcode_contents_async(client, template_owner, template_repo, pth, acc)
+            return
+        return
+
+    if isinstance(data, list):
+        for item in data:
+            if not isinstance(item, dict):
+                continue
+            t = (item.get("type") or "").lower()
+            pth = item.get("path") or ""
+            if t == "file":
+                sha = item.get("sha") or ""
+                if sha and pth:
+                    acc.append((template_owner, template_repo, str(pth), str(sha)))
+            elif t in ("dir", "directory", "tree") and pth:
+                await _walk_dot_gitcode_contents_async(client, template_owner, template_repo, str(pth), acc)
+
+
+def list_gitcode_template_rows_sync(
+    client: SyncAPIClient,
+    owner: str,
+    repo: str,
+    path_pattern: Pattern[str],
+) -> List[Tuple[str, str, str, str]]:
+    """Return ``(template_owner, template_repo, path, sha)`` from the first resolution source with matches."""
+    for so, sr in _resolution_sources_sync(client, owner, repo):
+        acc: List[Tuple[str, str, str, str]] = []
+        try:
+            _walk_dot_gitcode_contents_sync(client, so, sr, ".gitcode", acc)
+        except GitCodeHTTPStatusError:
+            continue
+        rows = [(t_o, t_r, p, s) for t_o, t_r, p, s in acc if path_pattern.match(p)]
+        if rows:
+            return rows
+    return []
+
+
+async def list_gitcode_template_rows_async(
+    client: AsyncAPIClient,
+    owner: str,
+    repo: str,
+    path_pattern: Pattern[str],
+) -> List[Tuple[str, str, str, str]]:
+    for so, sr in await _resolution_sources_async(client, owner, repo):
+        acc: List[Tuple[str, str, str, str]] = []
+        try:
+            await _walk_dot_gitcode_contents_async(client, so, sr, ".gitcode", acc)
+        except GitCodeHTTPStatusError:
+            continue
+        rows = [(t_o, t_r, p, s) for t_o, t_r, p, s in acc if path_pattern.match(p)]
+        if rows:
+            return rows
+    return []
+
+
+def get_gitcode_template_body_sync(
+    client: SyncAPIClient,
+    path: str,
+    path_pattern: Pattern[str],
+    owner: str,
+    repo: str,
+) -> str:
+    """Fetch raw template text from the first resolution source that serves ``path``."""
+    if not path_pattern.match(path):
+        raise GitCodeHTTPStatusError(
+            "Path does not match the expected GitCode template pattern for this resource.",
+            status_code=404,
+            payload=None,
+        )
+    last_error: Optional[GitCodeHTTPStatusError] = None
+    for so, sr in _resolution_sources_sync(client, owner, repo):
+        try:
+            raw = client.request(
+                "GET",
+                client._repo_file_path("raw", path, owner=so, repo=sr),
+                raw=True,
+            )
+        except GitCodeHTTPStatusError as exc:
+            last_error = exc
+            continue
+        if isinstance(raw, bytes):
+            return raw.decode("utf-8")
+        if isinstance(raw, str):
+            return raw
+        return str(raw)
+    if last_error is not None:
+        raise last_error
+    raise GitCodeHTTPStatusError(
+        "No template found for the given path.",
+        status_code=404,
+        payload=None,
+    )
+
+
+async def get_gitcode_template_body_async(
+    client: AsyncAPIClient,
+    path: str,
+    path_pattern: Pattern[str],
+    owner: str,
+    repo: str,
+) -> str:
+    if not path_pattern.match(path):
+        raise GitCodeHTTPStatusError(
+            "Path does not match the expected GitCode template pattern for this resource.",
+            status_code=404,
+            payload=None,
+        )
+    last_error: Optional[GitCodeHTTPStatusError] = None
+    for so, sr in await _resolution_sources_async(client, owner, repo):
+        try:
+            raw = await client.request(
+                "GET",
+                client._repo_file_path("raw", path, owner=so, repo=sr),
+                raw=True,
+            )
+        except GitCodeHTTPStatusError as exc:
+            last_error = exc
+            continue
+        if isinstance(raw, bytes):
+            return raw.decode("utf-8")
+        if isinstance(raw, str):
+            return raw
+        return str(raw)
+    if last_error is not None:
+        raise last_error
+    raise GitCodeHTTPStatusError(
+        "No template found for the given path.",
+        status_code=404,
+        payload=None,
+    )
+
 
 class SyncResource(BaseResource):
     """Base class for synchronous resource groups."""

gitcode_api/resources/collaboration.py

@@ -21,10 +21,20 @@ from .._models import (
     RepoMember,
     RepoMemberPermission,
     RepositoryCollaboratorCheck,
+    RepositoryGitCodeTemplate,
     UserSummary,
     as_model,
 )
-from ._shared import AsyncResource, SyncResource
+from ._shared import (
+    GITCODE_ISSUE_TEMPLATE_PATH_RE,
+    GITCODE_PULL_REQUEST_TEMPLATE_PATH_RE,
+    AsyncResource,
+    SyncResource,
+    get_gitcode_template_body_async,
+    get_gitcode_template_body_sync,
+    list_gitcode_template_rows_async,
+    list_gitcode_template_rows_sync,
+)
 
 
 def _comma_join(values: Optional[List[str]]) -> Optional[str]:
@@ -392,6 +402,62 @@ class IssuesResource(SyncResource):
             params={"page": page, "per_page": per_page},
         )
 
+    def list_templates(
+        self,
+        *,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+    ) -> List[RepositoryGitCodeTemplate]:
+        """List active issue templates under ``.gitcode/`` for this repository.
+
+        Matches Markdown (``.md``, ``.markdown``) and YAML (``.yml`` / ``.yaml``) paths whose
+        names start with ``ISSUE_TEMPLATE`` under ``.gitcode/`` (case-insensitive), including
+        files inside localized directories such as ``.gitcode/ISSUE_TEMPLATE.en/``.
+
+        Resolution tries the repository, then the owner's ``.gitcode`` repository, then any
+        parent main and ``parent/.gitcode`` pairs discovered from forks (each candidate is
+        inspected with ``GET /repos/{owner}/{repo}``; when ``fork`` is true, its parent's repos
+        are appended, deduplicated, and visited in order). The first source with matching
+        templates wins.
+
+        :param owner: Repository owner path. Uses the client default when omitted.
+        :param repo: Repository name. Uses the client default when omitted.
+        :returns: Template metadata entries (paths and SHAs); empty when none match.
+        """
+        resolved_owner, resolved_repo = self._client._resolve_repo_context(owner, repo)
+        rows = list_gitcode_template_rows_sync(
+            self._client, resolved_owner, resolved_repo, GITCODE_ISSUE_TEMPLATE_PATH_RE
+        )
+        return [
+            as_model(
+                {
+                    "path": path,
+                    "sha": sha,
+                    "template_owner": template_owner,
+                    "template_repo": template_repo,
+                },
+                RepositoryGitCodeTemplate,
+            )
+            for template_owner, template_repo, path, sha in rows
+        ]
+
+    def get_template(self, *, path: str, owner: Optional[str] = None, repo: Optional[str] = None) -> str:
+        """Load a single issue template file body from the default branch.
+
+        Uses the same resolution order as :meth:`list_templates`. The path must match the
+        active issue template naming convention (see GitCode ``.gitcode`` documentation).
+
+        :param path: Repository-relative path such as ``.gitcode/ISSUE_TEMPLATE_bug.md`` or
+            ``.gitcode/ISSUE_TEMPLATE/config.yml``.
+        :param owner: Repository owner path. Uses the client default when omitted.
+        :param repo: Repository name. Uses the client default when omitted.
+        :returns: Decoded template file contents (UTF-8).
+        """
+        resolved_owner, resolved_repo = self._client._resolve_repo_context(owner, repo)
+        return get_gitcode_template_body_sync(
+            self._client, path, GITCODE_ISSUE_TEMPLATE_PATH_RE, resolved_owner, resolved_repo
+        )
+
 
 class PullsResource(SyncResource):
     """Synchronous pull request endpoints."""
@@ -987,6 +1053,57 @@ class PullsResource(SyncResource):
             PullRequest,
         )
 
+    def list_templates(
+        self,
+        *,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+    ) -> List[RepositoryGitCodeTemplate]:
+        """List active pull request templates under ``.gitcode/`` for this repository.
+
+        Resolution tries the repository, then the owner's ``.gitcode`` repository, then any
+        parent main and ``parent/.gitcode`` pairs discovered from forks (each candidate is
+        inspected with ``GET /repos/{owner}/{repo}``; when ``fork`` is true, its parent's repos
+        are appended, deduplicated, and visited in order). The first source with matching
+        templates wins.
+
+        :param owner: Repository owner path. Uses the client default when omitted.
+        :param repo: Repository path. Uses the client default when omitted.
+        :returns: Template metadata entries (paths and SHAs); empty when none match.
+        """
+        resolved_owner, resolved_repo = self._client._resolve_repo_context(owner, repo)
+        rows = list_gitcode_template_rows_sync(
+            self._client, resolved_owner, resolved_repo, GITCODE_PULL_REQUEST_TEMPLATE_PATH_RE
+        )
+        return [
+            as_model(
+                {
+                    "path": path,
+                    "sha": sha,
+                    "template_owner": template_owner,
+                    "template_repo": template_repo,
+                },
+                RepositoryGitCodeTemplate,
+            )
+            for template_owner, template_repo, path, sha in rows
+        ]
+
+    def get_template(self, *, path: str, owner: Optional[str] = None, repo: Optional[str] = None) -> str:
+        """Load a single pull request template file body from the default branch.
+
+        Uses the same resolution order as :meth:`list_templates`. The path must match the
+        active pull request template naming convention (see GitCode ``.gitcode`` documentation).
+
+        :param path: Repository-relative path such as ``.gitcode/PULL_REQUEST_TEMPLATE.md``.
+        :param owner: Repository owner path. Uses the client default when omitted.
+        :param repo: Repository path. Uses the client default when omitted.
+        :returns: Decoded template file contents (UTF-8).
+        """
+        resolved_owner, resolved_repo = self._client._resolve_repo_context(owner, repo)
+        return get_gitcode_template_body_sync(
+            self._client, path, GITCODE_PULL_REQUEST_TEMPLATE_PATH_RE, resolved_owner, resolved_repo
+        )
+
 
 class LabelsResource(SyncResource):
     """Synchronous label endpoints."""
@@ -1599,6 +1716,62 @@ class AsyncIssuesResource(AsyncResource):
             params=params,
         )
 
+    async def list_templates(
+        self,
+        *,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+    ) -> List[RepositoryGitCodeTemplate]:
+        """List active issue templates under ``.gitcode/`` for this repository.
+
+        Matches Markdown (``.md``, ``.markdown``) and YAML (``.yml`` / ``.yaml``) paths whose
+        names start with ``ISSUE_TEMPLATE`` under ``.gitcode/`` (case-insensitive), including
+        files inside localized directories such as ``.gitcode/ISSUE_TEMPLATE.en/``.
+
+        Resolution tries the repository, then the owner's ``.gitcode`` repository, then any
+        parent main and ``parent/.gitcode`` pairs discovered from forks (each candidate is
+        inspected with ``GET /repos/{owner}/{repo}``; when ``fork`` is true, its parent's repos
+        are appended, deduplicated, and visited in order). The first source with matching
+        templates wins.
+
+        :param owner: Repository owner path. Uses the client default when omitted.
+        :param repo: Repository name. Uses the client default when omitted.
+        :returns: Template metadata entries (paths and SHAs); empty when none match.
+        """
+        resolved_owner, resolved_repo = self._client._resolve_repo_context(owner, repo)
+        rows = await list_gitcode_template_rows_async(
+            self._client, resolved_owner, resolved_repo, GITCODE_ISSUE_TEMPLATE_PATH_RE
+        )
+        return [
+            as_model(
+                {
+                    "path": path,
+                    "sha": sha,
+                    "template_owner": template_owner,
+                    "template_repo": template_repo,
+                },
+                RepositoryGitCodeTemplate,
+            )
+            for template_owner, template_repo, path, sha in rows
+        ]
+
+    async def get_template(self, *, path: str, owner: Optional[str] = None, repo: Optional[str] = None) -> str:
+        """Load a single issue template file body from the default branch.
+
+        Uses the same resolution order as :meth:`list_templates`. The path must match the
+        active issue template naming convention (see GitCode ``.gitcode`` documentation).
+
+        :param path: Repository-relative path such as ``.gitcode/ISSUE_TEMPLATE_bug.md`` or
+            ``.gitcode/ISSUE_TEMPLATE/config.yml``.
+        :param owner: Repository owner path. Uses the client default when omitted.
+        :param repo: Repository name. Uses the client default when omitted.
+        :returns: Decoded template file contents (UTF-8).
+        """
+        resolved_owner, resolved_repo = self._client._resolve_repo_context(owner, repo)
+        return await get_gitcode_template_body_async(
+            self._client, path, GITCODE_ISSUE_TEMPLATE_PATH_RE, resolved_owner, resolved_repo
+        )
+
 
 class AsyncPullsResource(AsyncResource):
     """Asynchronous pull request endpoints.
@@ -2141,6 +2314,57 @@ class AsyncPullsResource(AsyncResource):
             "GET", self._client._path("enterprises", enterprise, "issues", number, "pull_requests"), PullRequest
         )
 
+    async def list_templates(
+        self,
+        *,
+        owner: Optional[str] = None,
+        repo: Optional[str] = None,
+    ) -> List[RepositoryGitCodeTemplate]:
+        """List active pull request templates under ``.gitcode/`` for this repository.
+
+        Resolution tries the repository, then the owner's ``.gitcode`` repository, then any
+        parent main and ``parent/.gitcode`` pairs discovered from forks (each candidate is
+        inspected with ``GET /repos/{owner}/{repo}``; when ``fork`` is true, its parent's repos
+        are appended, deduplicated, and visited in order). The first source with matching
+        templates wins.
+
+        :param owner: Repository owner path. Uses the client default when omitted.
+        :param repo: Repository path. Uses the client default when omitted.
+        :returns: Template metadata entries (paths and SHAs); empty when none match.
+        """
+        resolved_owner, resolved_repo = self._client._resolve_repo_context(owner, repo)
+        rows = await list_gitcode_template_rows_async(
+            self._client, resolved_owner, resolved_repo, GITCODE_PULL_REQUEST_TEMPLATE_PATH_RE
+        )
+        return [
+            as_model(
+                {
+                    "path": path,
+                    "sha": sha,
+                    "template_owner": template_owner,
+                    "template_repo": template_repo,
+                },
+                RepositoryGitCodeTemplate,
+            )
+            for template_owner, template_repo, path, sha in rows
+        ]
+
+    async def get_template(self, *, path: str, owner: Optional[str] = None, repo: Optional[str] = None) -> str:
+        """Load a single pull request template file body from the default branch.
+
+        Uses the same resolution order as :meth:`list_templates`. The path must match the
+        active pull request template naming convention (see GitCode ``.gitcode`` documentation).
+
+        :param path: Repository-relative path such as ``.gitcode/PULL_REQUEST_TEMPLATE.md``.
+        :param owner: Repository owner path. Uses the client default when omitted.
+        :param repo: Repository path. Uses the client default when omitted.
+        :returns: Decoded template file contents (UTF-8).
+        """
+        resolved_owner, resolved_repo = self._client._resolve_repo_context(owner, repo)
+        return await get_gitcode_template_body_async(
+            self._client, path, GITCODE_PULL_REQUEST_TEMPLATE_PATH_RE, resolved_owner, resolved_repo
+        )
+
 
 class AsyncLabelsResource(AsyncResource):
     """Asynchronous label endpoints.

gitcode_api/utils.py

@@ -0,0 +1,37 @@
+"""Utility helper functions."""
+
+from copy import deepcopy
+from typing import Any, Dict, List, Union, overload
+
+from ._models import APIObject
+
+
+@overload
+def as_dict(data: APIObject, deep_copy: bool = False) -> Dict[str, Any]: ...
+
+
+@overload
+def as_dict(data: List[APIObject], deep_copy: bool = False) -> List[Dict[str, Any]]: ...
+
+
+def as_dict(data: Union[APIObject, List[APIObject]], deep_copy: bool = False) -> Union[Dict, List[Dict]]:
+    """Convert one :class:`~gitcode_api._models.APIObject` to a plain ``dict``, or several to a list of dicts.
+
+    Similar to :func:`dataclasses.asdict`. Input is converted with :meth:`~gitcode_api._models.APIObject.to_dict`.
+    When ``deep_copy`` is true, each mapping is copied with :func:`copy.deepcopy`.
+
+    :param data: A single response model or a list of them.
+    :param deep_copy: When true, return deep-copied dicts.
+    :returns: A dict for a single input, or a list of dicts for a list input.
+    """
+    if isinstance(data, list):
+        items = data
+    else:
+        items = [data]
+    if not all(hasattr(item, "to_dict") for item in items):
+        raise TypeError("Input is not APIObject or list[APIObject]")
+    if deep_copy:
+        out = [deepcopy(item.to_dict()) for item in items]
+    else:
+        out = [item.to_dict() for item in items]
+    return out[0] if len(out) == 1 else out

gitcode_api/version.txt

@@ -1 +1 @@
-1.2.13
+1.2.15

{gitcode_api-1.2.13.dist-info → gitcode_api-1.2.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitcode-api
-Version: 1.2.13
+Version: 1.2.15
 Summary: Easy to use Python SDK for the GitCode REST API. Providing builtin CLI tool, and optional LLM integration (MCP, OpenAI tool, and openJiuwen tool) for agents. Community-maintained.
 Author-email: Hugo Huang <hugo@hugohuang.com>
 License-Expression: MIT
@@ -37,7 +37,7 @@ Dynamic: license-file
 
 # GitCode-API
 
-[![PyPI - Version](https://img.shields.io/pypi/v/gitcode-api?link=https%3A%2F%2Fpypi.org%2Fproject%2Fgitcode-api%2F&uuid=d15040ff268342bca07ad60f812924a7)](https://pypi.org/project/gitcode-api) [![PyPI Downloads](https://static.pepy.tech/personalized-badge/gitcode-api?period=total&units=INTERNATIONAL_SYSTEM&left_color=GRAY&right_color=RED&left_text=downloads&uuid=b7f4a02b5f3e4776bd62a22cc539074b)](https://pepy.tech/projects/gitcode-api) [![CodeFactor](https://www.codefactor.io/repository/github/trenza1ore/gitcode-api/badge)](https://www.codefactor.io/repository/github/trenza1ore/gitcode-api)
+[![PyPI - Version](https://img.shields.io/pypi/v/gitcode-api?link=https%3A%2F%2Fpypi.org%2Fproject%2Fgitcode-api%2F&uuid=1d56ca66edb448b88c30fbfd677b8542)](https://pypi.org/project/gitcode-api) [![PyPI Downloads](https://static.pepy.tech/personalized-badge/gitcode-api?period=total&units=INTERNATIONAL_SYSTEM&left_color=GRAY&right_color=RED&left_text=downloads&uuid=03b2f61f19894ce49501bb9e856b434a)](https://pepy.tech/projects/gitcode-api) [![CodeFactor](https://www.codefactor.io/repository/github/trenza1ore/gitcode-api/badge)](https://www.codefactor.io/repository/github/trenza1ore/gitcode-api)
 [![Install in Cursor](https://img.shields.io/badge/Install_in-Cursor-000000?logoColor=white)](https://cursor.com/en/install-mcp?name=GitCode%20API&config=eyJjb21tYW5kIjoidXZ4IiwiYXJncyI6WyItLWZyb20iLCJnaXRjb2RlLWFwaVttY3BdIiwiZ2l0Y29kZS1hcGkiLCJzZXJ2ZSJdLCJlbnYiOnsiR0lUQ09ERV9BQ0NFU1NfVE9LRU4iOiIke2lucHV0OmdpdGNvZGVfYWNjZXNzX3Rva2VufSJ9LCJpbnB1dHMiOlt7ImlkIjoiZ2l0Y29kZV9hY2Nlc3NfdG9rZW4iLCJ0eXBlIjoicHJvbXB0U3RyaW5nIiwiZGVzY3JpcHRpb24iOiJFbnRlciBHSVRDT0RFX0FDQ0VTU19UT0tFTiIsInBhc3N3b3JkIjp0cnVlfV19) [![Install in VS Code](https://img.shields.io/badge/Install_in-VS_Code-0098FF?logo=visualstudiocode&logoColor=white)](https://vscode.dev/redirect/mcp/install?name=GitCode%20API&config=%7B%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22--from%22%2C%22gitcode-api%5Bmcp%5D%22%2C%22gitcode-api%22%2C%22serve%22%5D%2C%22env%22%3A%7B%22GITCODE_ACCESS_TOKEN%22%3A%22%24%7Binput%3Agitcode_access_token%7D%22%7D%2C%22inputs%22%3A%5B%7B%22id%22%3A%22gitcode_access_token%22%2C%22type%22%3A%22promptString%22%2C%22description%22%3A%22Enter%20GITCODE_ACCESS_TOKEN%22%2C%22password%22%3Atrue%7D%5D%7D)
 [![GitHub Badge](https://img.shields.io/badge/github-repo-blue?logo=github&link=https%3A%2F%2Fgithub.com%2FTrenza1ore%2FGitCode-API)](https://github.com/Trenza1ore/GitCode-API) [![GitCode Badge](https://img.shields.io/badge/gitcode-repo-brown?logo=gitcode&link=https%3A%2F%2Fgitcode.com%2FSushiNinja%2FGitCode-API)](https://gitcode.com/SushiNinja/GitCode-API)
 
@@ -49,6 +49,7 @@ Dynamic: license-file
 
 - Community project for developers who want a practical GitCode Python library.
 - Sync and async clients with a consistent API surface.
+- Convenient methods not offered by REST API directly: such as fetching Issue and PR templates.
 - Resource groups such as `client.repos`, `client.pulls`, and `client.users`.
 - Repository defaults via `owner=` and `repo=` on the client.
 - Sphinx docs plus a mirrored GitCode REST API reference in `docs/`.
@@ -153,6 +154,21 @@ async def main() -> None:
 asyncio.run(main())
 ```
 
+### Convert typed return objects to dicts with `as_dict`
+
+Response values are typed `APIObject` subclasses. For serialization or code that expects built-in `dict`, import `as_dict` from the package root: pass a single model to get a `dict`, or pass a list (for example from `client.pulls.list(...)`) to get `list[dict]`. This mirrors the idea of `dataclasses.asdict` but uses each model’s `to_dict()` method. Use `deep_copy=True` when you need detached deep copies.
+
+```python
+from gitcode_api import GitCode, as_dict
+
+client = GitCode(owner="SushiNinja")
+pulls = client.pulls.list_templates(repo="GitCode-API")
+payload = as_dict(pulls)  # list[dict]
+
+repo = client.repos.get(repo="GitCode-API")
+meta = as_dict(repo)  # dict
+```
+
 ### Context managers
 
 `GitCode` and `AsyncGitCode` (and the lower-level `SyncAPIClient` / `AsyncAPIClient`) support `with` / `async with`. Leaving the block calls `close()` / `await close()` on the underlying client automatically, including a custom `http_client=` you passed in. `close()` also clears the LRU cache used by each resource group's `method_signature(...)` helper (see the [Available Resources](#available-resources) section).
@@ -354,6 +370,8 @@ Runnable examples live in `examples/`:
 
 - `get_current_user.py`
 - `get_repository_overview.py`
+- `get_issue_templates.py`
+- `get_pull_request_templates.py`
 - `list_pull_requests.py`
 - `async_list_branches.py`
 
@@ -362,6 +380,8 @@ Example scripts load shared configuration from `examples/.env` using `python-dot
 ```bash
 uv run python examples/get_current_user.py
 uv run python examples/get_repository_overview.py
+uv run python examples/get_issue_templates.py
+uv run python examples/get_pull_request_templates.py
 uv run python examples/list_pull_requests.py
 uv run python examples/async_list_branches.py
 ```

{gitcode_api-1.2.13.dist-info → gitcode_api-1.2.15.dist-info}/RECORD

@@ -1,29 +1,30 @@
-gitcode_api/__init__.py,sha256=NvLp28D9brVbmv2ROSZ8mxKDuIamE9xeutBKGl9pra8,497
+gitcode_api/__init__.py,sha256=vqRBOTuk4UygSh2y4wZSTiK2FNY8DSqjcSGjC3W0ifg,539
 gitcode_api/__main__.py,sha256=Yd8P4MSNcWFqUTKnUaNibbWX4Vd-MVVNmhPFaohzqcA,137
 gitcode_api/_base_client.py,sha256=PFsTMZJI4p5INjubRa4H4JcybYLGt-B9VkSAfTgpxfI,13280
 gitcode_api/_base_resource.py,sha256=mlKe1b_1AKcqxhptaCpP-AOjKkLNzCbYG-Pkp1HYWrA,2238
 gitcode_api/_cli_banner.py,sha256=3DsoJ2qZ-mWWB4yD-cnxDN_osXzrUKabrA5tbV6752M,978
 gitcode_api/_client.py,sha256=bmZxBHdfshM5Kv_EurHUVu8rsEj0k3Up3ATSIPaFrvc,8258
 gitcode_api/_exceptions.py,sha256=T5N8gBGmPSktDkLP5P_hxbzOHw3W378TzxN1xja40pA,1140
-gitcode_api/_models.py,sha256=7MqQJSEZiXkqcBAKdaKUQN_I61QjkHRIJYIR70tYMWU,110559
+gitcode_api/_models.py,sha256=ip0xgdWao8Z3ATfSaPn3KzG81OXd25RVB1ansOaJaUM,110586
 gitcode_api/cli.py,sha256=Z-X5gK8iI2wCEXqT-igVKpVzO4ZhaRYaxmTbqMbIUx8,18735
 gitcode_api/py.typed,sha256=mDShSrm8qg9qjacQc2F-rI8ATllqP6EdgHuEYxuCXZ0,7
 gitcode_api/run_mcp.py,sha256=3_JOrjg9_yL-0M-H-F8mPgxdVKh7K2ggipu7UHeNCg0,147
-gitcode_api/version.txt,sha256=whaYM0seIwi4VWrB0QQCNCuNPoN_ZfocQx6yM5KCSx0,7
+gitcode_api/utils.py,sha256=51QmPTQPeNsPSGf2IzhwmiEO1H2GkJrp2A7vkzhOOag,1351
+gitcode_api/version.txt,sha256=CR1Vtk3iATNBumC-6iLKE5LhwljWj_KqLo-QHPlyPWM,7
 gitcode_api/llm/__init__.py,sha256=rU75ZlJvTWNVxBLc3QzdfWmSjqVc9z6hfQ8z6jVVKOk,1693
 gitcode_api/llm/_tool.py,sha256=b65iUiHo1H29uA6mFM3WlD0zZlISsENx1tpEqlkiUoA,16239
-gitcode_api/llm/jiuwen.py,sha256=axwAcoG86XkPkN37PTh47Cdzwh3yACUpe4bTjlaAFDc,4244
+gitcode_api/llm/jiuwen.py,sha256=qca2y4544xoRYFOCMbkjiUZZLpJGMcBkK4w5bqs60-4,4276
 gitcode_api/llm/mcp.py,sha256=eeAuEETZ4THw31wbcnQaTlZQJ-9ZolvsejQY630OqHs,5702
-gitcode_api/llm/openai.py,sha256=r8LZi3oK9D80dfiPpv1TpP-PwKUXpAGqgNGE3hOIAaA,3200
+gitcode_api/llm/openai.py,sha256=FSPA0Jv-k4n1Ud92TDfP1TWRlW4FB7smaLwY331nagk,3257
 gitcode_api/resources/__init__.py,sha256=nsCKW0bFDZ5ombJZxLThmO82sOuF7o4OKUMRkAmwbwk,1725
-gitcode_api/resources/_shared.py,sha256=7bCym8bIfs818SiYYrBGI7-ZtiYlxECSDG3RduInu10,5387
+gitcode_api/resources/_shared.py,sha256=07f4Zk_bk6JKjEwubZ6iSd1Lq1rGi7CyWjvcMNMcYpo,15402
 gitcode_api/resources/account.py,sha256=mnc2p7wI-nBnHFNdWPNiHfmZpT6d3RDQC777gewtm4M,38801
-gitcode_api/resources/collaboration.py,sha256=8lyk78GTjVXddiE9fieutsMGovRjteGfTJcAhwLoR0M,101607
+gitcode_api/resources/collaboration.py,sha256=TK0QXG_ymE4vbtHyP3Y-M39oG9zQE44UU5-UnPhF2WM,112388
 gitcode_api/resources/misc.py,sha256=w7bq8rmgKr2ScBKeWZ3EZJmAdylDdPtSPrhi3AQre7w,34747
 gitcode_api/resources/repositories.py,sha256=EAK2znZhEsgVUu-NDEQslSEEYJzvb-kHuh4mW57y6sc,78178
-gitcode_api-1.2.13.dist-info/licenses/LICENSE,sha256=gOACXuWhMu6PJKVLr9RQbxX3HULnZIGNXCaMFJIXhoA,1067
-gitcode_api-1.2.13.dist-info/METADATA,sha256=sqYMb5Au9bBv9TpDu8d6sK29DzIzl2XwsP3Mrllwfng,22335
-gitcode_api-1.2.13.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-gitcode_api-1.2.13.dist-info/entry_points.txt,sha256=dIPylJcgohIE2RRIlt3In2WzcwDK8TOdkL_ReKuij4o,53
-gitcode_api-1.2.13.dist-info/top_level.txt,sha256=gIlg0ptyOUHJT64ajOjWIhRPYgIQnMIvnhhnesw9fxU,12
-gitcode_api-1.2.13.dist-info/RECORD,,
+gitcode_api-1.2.15.dist-info/licenses/LICENSE,sha256=gOACXuWhMu6PJKVLr9RQbxX3HULnZIGNXCaMFJIXhoA,1067
+gitcode_api-1.2.15.dist-info/METADATA,sha256=UpCCoL8teAQTmSRO5LDV7qx6dNV6EzgoIfeVnsoS81s,23323
+gitcode_api-1.2.15.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+gitcode_api-1.2.15.dist-info/entry_points.txt,sha256=dIPylJcgohIE2RRIlt3In2WzcwDK8TOdkL_ReKuij4o,53
+gitcode_api-1.2.15.dist-info/top_level.txt,sha256=gIlg0ptyOUHJT64ajOjWIhRPYgIQnMIvnhhnesw9fxU,12
+gitcode_api-1.2.15.dist-info/RECORD,,