gitcode-api 1.2.12__py3-none-any.whl → 1.2.14__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.
@@ -2171,6 +2144,23 @@ class RepoMemberPermission(APIObject):
     permission: Optional[str] = None
 
 
+@dataclass(init=False)
+class ReleaseAsset(APIObject):
+    """Asset metadata embedded in release payloads.
+
+    :ivar browser_download_url: Browser download URL for this asset.
+    :vartype browser_download_url: Optional[str]
+    :ivar name: Asset file name.
+    :vartype name: Optional[str]
+    :ivar type: Asset media type.
+    :vartype type: Optional[str]
+    """
+
+    browser_download_url: Optional[str] = None
+    name: Optional[str] = None
+    type: Optional[str] = None
+
+
 @dataclass(init=False)
 class Release(APIObject):
     """Release payload.
@@ -2179,6 +2169,10 @@ class Release(APIObject):
     :vartype id: Optional[Union[int, str]]
     :ivar tag_name: Tag name.
     :vartype tag_name: Optional[str]
+    :ivar target_commitish: Branch or commit SHA targeted by the release tag.
+    :vartype target_commitish: Optional[str]
+    :ivar prerelease: Whether this release is a pre-release.
+    :vartype prerelease: Optional[bool]
     :ivar name: Display name.
     :vartype name: Optional[str]
     :ivar body: Body text of the object.
@@ -2191,16 +2185,38 @@ class Release(APIObject):
     :vartype published_at: Optional[str]
     :ivar html_url: Web URL for this object.
     :vartype html_url: Optional[str]
+    :ivar assets: Release source packages and uploaded attachments.
+    :vartype assets: Optional[List[ReleaseAsset]]
+    :ivar release_status: Release status, for example ``pre`` or ``latest``.
+    :vartype release_status: Optional[str]
     """
 
     id: Optional[Union[int, str]] = None
     tag_name: Optional[str] = None
+    target_commitish: Optional[str] = None
+    prerelease: Optional[bool] = None
     name: Optional[str] = None
     body: Optional[str] = None
     author: Optional[UserRef] = None
     created_at: Optional[str] = None
     published_at: Optional[str] = None
     html_url: Optional[str] = None
+    assets: Optional[List[ReleaseAsset]] = None
+    release_status: Optional[str] = None
+
+
+@dataclass(init=False)
+class ReleaseUploadURL(APIObject):
+    """Pre-signed release attachment upload target.
+
+    :ivar url: Pre-signed object storage URL for uploading with ``PUT``.
+    :vartype url: Optional[str]
+    :ivar headers: Headers to send unchanged with the upload request.
+    :vartype headers: Optional[Dict[str, str]]
+    """
+
+    url: Optional[str] = None
+    headers: Optional[Dict[str, str]] = None
 
 
 @dataclass(init=False)

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."""