Implement and add python bindings

Author: paraseba

icechunk-python/python/icechunk/_icechunk_python.pyi

@@ -1499,6 +1499,10 @@ class PyRepository:
     async def inspect_snapshot_async(
         self, snapshot_id: str, *, pretty: bool = True
     ) -> str: ...
+    def inspect_manifest(self, manifest_id: str, *, pretty: bool = True) -> str: ...
+    async def inspect_manifest_async(
+        self, manifest_id: str, *, pretty: bool = True
+    ) -> str: ...
 
 class PySession:
     @classmethod

icechunk-python/python/icechunk/repository.py

@@ -1397,3 +1397,11 @@ async def inspect_snapshot_async(
         self, snapshot_id: str, *, pretty: bool = True
     ) -> str:
         return await self._repository.inspect_snapshot_async(snapshot_id, pretty=pretty)
+
+    def inspect_manifest(self, manifest_id: str, *, pretty: bool = True) -> str:
+        return self._repository.inspect_manifest(manifest_id, pretty=pretty)
+
+    async def inspect_manifest_async(
+        self, manifest_id: str, *, pretty: bool = True
+    ) -> str:
+        return await self._repository.inspect_manifest_async(manifest_id, pretty=pretty)

icechunk-python/src/repository.rs

@@ -13,11 +13,11 @@ use icechunk::{
     Repository,
     config::Credentials,
     format::{
-        SnapshotId,
+        ManifestId, SnapshotId,
         snapshot::{ManifestFileInfo, SnapshotInfo, SnapshotProperties},
         transaction_log::Diff,
     },
-    inspect::snapshot_json,
+    inspect::{manifest_json, snapshot_json},
     ops::{
         gc::{ExpiredRefAction, GCConfig, GCSummary, expire, garbage_collect},
         manifests::rewrite_manifests,
@@ -1660,6 +1660,42 @@ impl PyRepository {
             Ok(res)
         })
     }
+
+    #[pyo3(signature = (manifest_id, *, pretty = true))]
+    fn inspect_manifest(&self, manifest_id: String, pretty: bool) -> PyResult<String> {
+        let result = pyo3_async_runtimes::tokio::get_runtime()
+            .block_on(async move {
+                let lock = self.0.read().await;
+                let manifest = ManifestId::try_from(manifest_id.as_str())
+                    .map_err(|e| RepositoryErrorKind::Other(e.to_string()))?;
+                let res = manifest_json(lock.asset_manager(), &manifest, pretty).await?;
+                Ok(res)
+            })
+            .map_err(PyIcechunkStoreError::RepositoryError)?;
+        Ok(result)
+    }
+
+    #[pyo3(signature = (manifest_id, *, pretty = true))]
+    fn inspect_manifest_async<'py>(
+        &self,
+        py: Python<'py>,
+        manifest_id: String,
+        pretty: bool,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        let repository = self.0.clone();
+        pyo3_async_runtimes::tokio::future_into_py(py, async move {
+            let lock = repository.read().await;
+            let manifest = ManifestId::try_from(manifest_id.as_str())
+                .map_err(|e| {
+                    RepositoryError::from(RepositoryErrorKind::Other(e.to_string()))
+                })
+                .map_err(PyIcechunkStoreError::RepositoryError)?;
+            let res = manifest_json(lock.asset_manager(), &manifest, pretty)
+                .await
+                .map_err(PyIcechunkStoreError::RepositoryError)?;
+            Ok(res)
+        })
+    }
 }
 
 fn map_credentials(

icechunk-python/tests/test_inspect.py

@@ -33,3 +33,39 @@ async def test_inspect_snapshot_async() -> None:
     assert pretty["id"] == snap
     assert pretty_str != non_pretty_str
     assert pretty == non_pretty
+
+
+def test_inspect_manifest() -> None:
+    repo = ic.Repository.open(
+        storage=ic.local_filesystem_storage("./tests/data/test-repo")
+    )
+    snap = next(repo.ancestry(branch="main")).id
+    snap_info = json.loads(repo.inspect_snapshot(snap, pretty=True))
+    man_id = snap_info["manifests"][0]["id"]
+    pretty_str = repo.inspect_manifest(man_id, pretty=True)
+    non_pretty_str = repo.inspect_manifest(man_id, pretty=False)
+
+    pretty = json.loads(pretty_str)
+    non_pretty = json.loads(non_pretty_str)
+
+    assert pretty["id"] == man_id
+    assert pretty_str != non_pretty_str
+    assert pretty == non_pretty
+
+
+async def test_inspect_manifest_async() -> None:
+    repo = ic.Repository.open(
+        storage=ic.local_filesystem_storage("./tests/data/test-repo")
+    )
+    snap = next(repo.ancestry(branch="main")).id
+    snap_info = json.loads(await repo.inspect_snapshot_async(snap, pretty=True))
+    man_id = snap_info["manifests"][0]["id"]
+    pretty_str = await repo.inspect_manifest_async(man_id, pretty=True)
+    non_pretty_str = await repo.inspect_manifest_async(man_id, pretty=False)
+
+    pretty = json.loads(pretty_str)
+    non_pretty = json.loads(non_pretty_str)
+
+    assert pretty["id"] == man_id
+    assert pretty_str != non_pretty_str
+    assert pretty == non_pretty

icechunk/src/format/manifest.rs

@@ -470,6 +470,15 @@ impl Manifest {
             array_manifest.refs().iter().map(|r| ref_to_payload(r))
         })
     }
+
+    pub fn nodes(&self) -> impl Iterator<Item = NodeId> + '_ {
+        self.root().arrays().iter().map(|array_manifest| array_manifest.node_id().into())
+    }
+
+    pub fn node_refs(&self, node: &NodeId) -> Option<usize> {
+        let manifest = self.root();
+        lookup_node(manifest, node).map(|am| am.refs().len())
+    }
 }
 
 fn lookup_node<'a>(

icechunk/src/inspect.rs

@@ -5,8 +5,8 @@ use serde::{Deserialize, Serialize};
 use crate::{
     asset_manager::AssetManager,
     format::{
-        ManifestId, SnapshotId,
-        manifest::ManifestRef,
+        IcechunkFormatError, ManifestId, SnapshotId,
+        manifest::{Manifest, ManifestRef},
         snapshot::{
             ManifestFileInfo, NodeData, NodeSnapshot, NodeType, SnapshotProperties,
         },
@@ -94,20 +94,45 @@ struct SnapshotInfoInspect {
 #[derive(Debug, Serialize, Deserialize)]
 struct ArrayManifestInspect {
     node_id: String,
-    num_chunks: u64,
+    num_chunk_refs: u64,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
 struct ManifestInfoInspect {
     id: String,
+    size_bytes: u64,
+    total_chunk_refs: u64,
     arrays: Vec<ArrayManifestInspect>,
 }
 
+impl TryFrom<&Manifest> for ManifestInfoInspect {
+    type Error = IcechunkFormatError;
+
+    fn try_from(value: &Manifest) -> Result<Self, Self::Error> {
+        let arrays = value
+            .nodes()
+            .filter_map(|node_id| {
+                value.node_refs(&node_id).map(|num_chunk_refs| ArrayManifestInspect {
+                    node_id: node_id.to_string(),
+                    num_chunk_refs: num_chunk_refs as u64,
+                })
+            })
+            .collect();
+        Ok(Self {
+            id: value.id().to_string(),
+            size_bytes: value.bytes().len() as u64,
+            total_chunk_refs: value.len() as u64,
+            arrays,
+        })
+    }
+}
+
 async fn inspect_manifest(
     asset_manager: &AssetManager,
     id: &ManifestId,
 ) -> RepositoryResult<ManifestInfoInspect> {
-    todo!()
+    let manifest = asset_manager.fetch_manifest_unknown_size(id).await?;
+    Ok(manifest.as_ref().try_into()?)
 }
 
 pub async fn manifest_json(