hubvault.server.serde

Response-serialization helpers for hubvault.server.

This module converts public hubvault dataclasses into JSON-compatible payloads for the HTTP API. The conversion is explicit so the remote client can reconstruct the same public model classes without relying on FastAPI internals.

The module contains:

encode_repo_info() - Serialize repository metadata
encode_repo_entry() - Serialize file and folder entries
encode_git_refs() - Serialize branch and tag refs
encode_git_commit_info() - Serialize commit-list entries
encode_commit_file_version_info() - Serialize one commit diff file side
encode_commit_change_info() - Serialize one commit diff entry
encode_commit_detail_info() - Serialize one commit detail payload
encode_reflog_entry() - Serialize reflog entries
encode_commit_info() - Serialize write-commit metadata
encode_merge_result() - Serialize structured merge results
encode_verify_report() - Serialize repository verification reports
encode_storage_summary() - Serialize lightweight storage summary
encode_storage_overview() - Serialize repository storage analysis
encode_gc_report() - Serialize storage reclamation reports
encode_squash_report() - Serialize history-squash reports
build_snapshot_plan_payload() - Build the remote snapshot manifest

encode_last_commit_info

hubvault.server.serde.encode_last_commit_info(value: LastCommitInfo | None) → dict | None[source]

Serialize optional last-commit metadata.

Parameters:: value (Optional[LastCommitInfo]) – Last-commit metadata, if available
Returns:: JSON-compatible last-commit payload or None
Return type:: Optional[dict]

encode_blob_security_info

hubvault.server.serde.encode_blob_security_info(value: BlobSecurityInfo | None) → dict | None[source]

Serialize optional blob-security metadata.

Parameters:: value (Optional[BlobSecurityInfo]) – Blob-security metadata, if available
Returns:: JSON-compatible security payload or None
Return type:: Optional[dict]

encode_blob_lfs_info

hubvault.server.serde.encode_blob_lfs_info(value: BlobLfsInfo | None) → dict | None[source]

Serialize optional large-file metadata.

Parameters:: value (Optional[BlobLfsInfo]) – Large-file metadata, if available
Returns:: JSON-compatible LFS payload or None
Return type:: Optional[dict]

encode_repo_info

hubvault.server.serde.encode_repo_info(value: RepoInfo) → dict[source]

Serialize repository metadata.

Parameters:: value (RepoInfo) – Repository metadata model
Returns:: JSON-compatible repository metadata
Return type:: dict

encode_repo_entry

hubvault.server.serde.encode_repo_entry(value) → dict[source]

Serialize one repository file or folder entry.

Parameters:: value (Union[RepoFile, RepoFolder]) – Repository entry model
Returns:: JSON-compatible entry payload with an entry_type discriminator
Return type:: dict
Raises:: TypeError – Raised when value is not a supported entry model.

encode_repo_entries

hubvault.server.serde.encode_repo_entries(values: Iterable[object]) → List[dict][source]

Serialize repository file and folder entries.

Parameters:: values (Iterable[object]) – Repository entry models
Returns:: JSON-compatible entry payloads
Return type:: List[dict]

encode_git_commit_info

hubvault.server.serde.encode_git_commit_info(value: GitCommitInfo) → dict[source]

Serialize one commit-list entry.

Parameters:: value (GitCommitInfo) – Commit-list entry model
Returns:: JSON-compatible commit payload
Return type:: dict

encode_git_commit_list

hubvault.server.serde.encode_git_commit_list(values: Iterable[GitCommitInfo]) → List[dict][source]

Serialize commit-list entries.

Parameters:: values (Iterable[GitCommitInfo]) – Commit-list entry models
Returns:: JSON-compatible commit payloads
Return type:: List[dict]

encode_commit_file_version_info

hubvault.server.serde.encode_commit_file_version_info(value: CommitFileVersionInfo | None) → dict | None[source]

Serialize one optional commit-diff file-side entry.

Parameters:: value (Optional[CommitFileVersionInfo]) – Commit-diff file-side metadata, if available
Returns:: JSON-compatible file-side payload or None
Return type:: Optional[dict]

encode_commit_change_info

hubvault.server.serde.encode_commit_change_info(value: CommitChangeInfo) → dict[source]

Serialize one file-level commit change entry.

Parameters:: value (CommitChangeInfo) – File-level commit change metadata
Returns:: JSON-compatible commit change payload
Return type:: dict

encode_commit_detail_info

hubvault.server.serde.encode_commit_detail_info(value: CommitDetailInfo) → dict[source]

Serialize one commit-detail payload.

Parameters:: value (CommitDetailInfo) – Commit detail metadata
Returns:: JSON-compatible commit detail payload
Return type:: dict

encode_commit_info

hubvault.server.serde.encode_commit_info(value: CommitInfo) → dict[source]

Serialize one write-commit result.

Parameters:: value (CommitInfo) – Commit metadata returned by a write API
Returns:: JSON-compatible commit payload
Return type:: dict

encode_merge_conflict

hubvault.server.serde.encode_merge_conflict(value: MergeConflict) → dict[source]

Serialize one structured merge conflict.

Parameters:: value (MergeConflict) – Merge conflict model
Returns:: JSON-compatible conflict payload
Return type:: dict

encode_merge_result

hubvault.server.serde.encode_merge_result(value: MergeResult) → dict[source]

Serialize one structured merge result.

Parameters:: value (MergeResult) – Merge result model
Returns:: JSON-compatible merge payload
Return type:: dict

encode_git_ref_info

hubvault.server.serde.encode_git_ref_info(value: GitRefInfo) → dict[source]

Serialize one git reference entry.

Parameters:: value (GitRefInfo) – Git reference entry model
Returns:: JSON-compatible ref payload
Return type:: dict

encode_git_refs

hubvault.server.serde.encode_git_refs(value: GitRefs) → dict[source]

Serialize branch and tag reference metadata.

Parameters:: value (GitRefs) – Git refs model
Returns:: JSON-compatible refs payload
Return type:: dict

encode_reflog_entry

hubvault.server.serde.encode_reflog_entry(value: ReflogEntry) → dict[source]

Serialize one reflog entry.

Parameters:: value (ReflogEntry) – Reflog entry model
Returns:: JSON-compatible reflog payload
Return type:: dict

encode_reflog_entries

hubvault.server.serde.encode_reflog_entries(values: Iterable[ReflogEntry]) → List[dict][source]

Serialize reflog entries.

Parameters:: values (Iterable[ReflogEntry]) – Reflog entry models
Returns:: JSON-compatible reflog payloads
Return type:: List[dict]

encode_verify_report

hubvault.server.serde.encode_verify_report(value: VerifyReport) → dict[source]

Serialize one repository verification report.

Parameters:: value (VerifyReport) – Verification report model
Returns:: JSON-compatible verification payload
Return type:: dict

encode_storage_section_info

hubvault.server.serde.encode_storage_section_info(value: StorageSectionInfo) → dict[source]

Serialize one storage section analysis entry.

Parameters:: value (StorageSectionInfo) – Storage section analysis model
Returns:: JSON-compatible storage section payload
Return type:: dict

encode_storage_summary

hubvault.server.serde.encode_storage_summary(value: Mapping[str, object]) → dict[source]

Serialize one lightweight storage-summary payload.

Parameters:: value (Mapping[str, object]) – Lightweight storage summary mapping
Returns:: JSON-compatible storage summary payload
Return type:: dict

encode_storage_overview

hubvault.server.serde.encode_storage_overview(value: StorageOverview) → dict[source]

Serialize repository-wide storage analysis.

Parameters:: value (StorageOverview) – Storage analysis model
Returns:: JSON-compatible storage overview payload
Return type:: dict

encode_gc_report

hubvault.server.serde.encode_gc_report(value: GcReport) → dict[source]

Serialize one garbage-collection report.

Parameters:: value (GcReport) – GC report model
Returns:: JSON-compatible GC payload
Return type:: dict

encode_squash_report

hubvault.server.serde.encode_squash_report(value: SquashReport) → dict[source]

Serialize one history-squash report.

Parameters:: value (SquashReport) – Squash report model
Returns:: JSON-compatible squash payload
Return type:: dict

build_snapshot_plan_payload

hubvault.server.serde.build_snapshot_plan_payload(*, revision: str, resolved_revision: str, head: str | None, files: Iterable[dict], allow_patterns: Iterable[str], ignore_patterns: Iterable[str]) → dict[source]

Build the remote-consumable snapshot manifest.

Parameters:

revision (str) – Requested revision string
resolved_revision (str) – Immutable revision used for file downloads
head (Optional[str]) – Resolved commit OID, if available
files (Iterable[dict]) – File manifest entries
allow_patterns (Iterable[str]) – Normalized allowlist patterns
ignore_patterns (Iterable[str]) – Normalized ignore patterns

Returns:

JSON-compatible snapshot manifest

Return type:

dict

build_meta_service_payload

hubvault.server.serde.build_meta_service_payload(*, service, version, mode, repo_path, ui_enabled, default_branch, head, auth) → dict[source]

Build the /api/v1/meta/service response body.

Parameters:

service (str) – Service title
version (str) – Service version string
mode (str) – Active server mode
repo_path (str) – Repository root path
ui_enabled (bool) – Whether the frontend UI is enabled
default_branch (str) – Repository default branch
head (Optional[str]) – Current repository head OID
auth (dict) – Authentication summary payload

Returns:

JSON-compatible service payload

Return type:

dict

build_whoami_payload

hubvault.server.serde.build_whoami_payload(*, access, can_write) → dict[source]

Build the /api/v1/meta/whoami response body.

Parameters:

access (str) – Resolved access level
can_write (bool) – Whether the caller may mutate repository state

Returns:

JSON-compatible caller summary

Return type:

dict