tensorfs 0.3.45__tar.gz → 0.3.46__tar.gz

{tensorfs-0.3.45 → tensorfs-0.3.46}/Cargo.lock

@@ -421,7 +421,7 @@ checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
 
 [[package]]
 name = "tensorfs-core"
-version = "0.3.45"
+version = "0.3.46"
 dependencies = [
  "fs2",
  "libc",
@@ -435,7 +435,7 @@ dependencies = [
 
 [[package]]
 name = "tensorfs-py"
-version = "0.3.45"
+version = "0.3.46"
 dependencies = [
  "pyo3",
  "tensorfs-core",

{tensorfs-0.3.45 → tensorfs-0.3.46}/Cargo.toml

@@ -3,5 +3,5 @@ resolver = "2"
 members = ["crates/tensorfs-core", "crates/tensorfs-py"]
 
 [workspace.package]
-version = "0.3.45"
+version = "0.3.46"
 edition = "2021"

{tensorfs-0.3.45 → tensorfs-0.3.46}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tensorfs
-Version: 0.3.45
+Version: 0.3.46
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Rust

{tensorfs-0.3.45 → tensorfs-0.3.46}/crates/tensorfs-core/src/asset_update.rs

@@ -23,6 +23,9 @@ pub enum Edit {
         source_path: String,
         media_type: String,
     },
+    /// Inherit one already-committed asset from the source checkpoint header.
+    /// The asset declaration and segment ObjectRefs are copied verbatim; no payload is read.
+    Inherit { name: String, source_name: String },
     /// Remove an asset by its exact header name.  Missing names are harmless, making
     /// retries deterministic.
     Drop { name: String },
@@ -72,6 +75,7 @@ pub fn update(
         detail: "asset update source has no CozyTensors header".into(),
     })?;
     let mut header = checkpoint::load_header(store, header_ref)?;
+    let source_assets: BTreeMap<String, Asset> = header.assets.iter().cloned().collect();
     let closure = checkpoint::load_closure(store, &header)?;
 
     let mut assets: BTreeMap<String, Asset> = header.assets.drain(..).collect();
@@ -80,6 +84,13 @@ pub fn update(
             Edit::Drop { name } => {
                 assets.remove(name);
             }
+            Edit::Inherit { name, source_name } => {
+                let asset = source_assets.get(source_name).ok_or_else(|| Refusal {
+                    code: Code::OBJECT_ABSENT,
+                    detail: format!("source asset {source_name:?} is absent"),
+                })?;
+                assets.insert(name.clone(), asset.clone());
+            }
             Edit::Copy {
                 name,
                 source_path,
@@ -129,6 +140,47 @@ pub fn update(
     })
 }
 
+/// Inherit selected runtime assets from one exact source checkpoint into another
+/// metadata-only derived checkpoint. Tensor and asset payloads are never opened.
+pub fn inherit(
+    store: &Store,
+    target_manifest: &ObjectRef,
+    source_manifest: &ObjectRef,
+    names: &[String],
+) -> Result<ResultSnapshot> {
+    let target = checkpoint::load_manifest(store, target_manifest)?;
+    let target_header_ref = target.header().ok_or_else(|| Refusal {
+        code: Code::ATTACHMENT_CARDINALITY,
+        detail: "asset inheritance target has no CozyTensors header".into(),
+    })?;
+    let source = checkpoint::load_manifest(store, source_manifest)?;
+    let source_header_ref = source.header().ok_or_else(|| Refusal {
+        code: Code::ATTACHMENT_CARDINALITY,
+        detail: "asset inheritance source has no CozyTensors header".into(),
+    })?;
+    let mut header = checkpoint::load_header(store, target_header_ref)?;
+    let source_header = checkpoint::load_header(store, source_header_ref)?;
+    let target_closure = checkpoint::load_closure(store, &header)?;
+    let source_assets: BTreeMap<String, Asset> = source_header.assets.into_iter().collect();
+    let mut assets: BTreeMap<String, Asset> = header.assets.drain(..).collect();
+    for name in names {
+        let asset = source_assets.get(name).ok_or_else(|| Refusal {
+            code: Code::OBJECT_ABSENT,
+            detail: format!("source asset {name:?} is absent"),
+        })?;
+        assets.insert(name.clone(), asset.clone());
+    }
+    header.assets = assets.into_iter().collect();
+    header.validate(&target_closure)?;
+    let header_object = checkpoint::put_doc(store, &header)?;
+    let manifest = checkpoint::build_manifest(&header, &header_object, &target_closure)?;
+    let manifest_object = store.put_manifest(&manifest)?.obj;
+    Ok(ResultSnapshot {
+        header: header_object,
+        manifest: manifest_object,
+    })
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -290,4 +342,63 @@ mod tests {
         assert_eq!(one.manifest, two.manifest);
         std::fs::remove_dir_all(root).unwrap();
     }
+
+    #[test]
+    fn inherits_existing_asset_refs_without_payload_reads() {
+        let root = temp();
+        let store = Store::init(&root).unwrap();
+        let spec = registry::seeds().into_iter().next().unwrap().spec;
+        let payload = put(&store, b"tokenizer");
+        let header = Header {
+            configs: vec![],
+            assets: vec![(
+                "tokenizer/vocab.json".into(),
+                Asset {
+                    logical_sha256: payload.sha256.clone(),
+                    logical_length: payload.length,
+                    media_type: "application/json".into(),
+                    segments: vec![payload.clone()],
+                },
+            )],
+            encodings: vec![spec.clone()],
+            components: vec![(
+                "model".into(),
+                vec![(
+                    "w".into(),
+                    Tensor {
+                        dtype: Dtype::U8,
+                        shape: vec![1],
+                        encoding: spec.object_id(),
+                        parts: vec![(
+                            "value".into(),
+                            Part {
+                                dtype: Dtype::U8,
+                                shape: vec![1],
+                                body: Body::Inline(vec![0]),
+                            },
+                        )],
+                    },
+                )],
+            )],
+        };
+        let href = put(&store, &header.canonical_bytes().unwrap());
+        let source = Draft {
+            entries: vec![("model.cozytensors".into(), Entry::CozyTensors(href))],
+        }
+        .seal()
+        .unwrap();
+        let source_ref = store.put_manifest(&source).unwrap().obj;
+        let result = update(
+            &store,
+            &source_ref,
+            &[Edit::Inherit {
+                name: "tokenizer/vocab.json".into(),
+                source_name: "tokenizer/vocab.json".into(),
+            }],
+        )
+        .unwrap();
+        let output = checkpoint::load_header(&store, &result.header).unwrap();
+        assert_eq!(output.assets[0].1.segments, vec![payload]);
+        std::fs::remove_dir_all(root).unwrap();
+    }
 }

{tensorfs-0.3.45 → tensorfs-0.3.46}/crates/tensorfs-py/src/store.rs

@@ -593,18 +593,19 @@ impl PyStore {
 
     /// Rewrite only a CozyTensors header/manifest to add, replace, or drop model assets.
     /// `copies` are `(name, source_path, media_type)` rows selected from the exact source
-    /// manifest; TensorFS reuses their ObjectRefs without reading payload bytes.
-    #[pyo3(signature = (manifest_id, manifest_length, copies=Vec::new(), drops=Vec::new()))]
+    /// manifest; `inherits` are `(name, source_name)` rows copied from the source header.
+    #[pyo3(signature = (manifest_id, manifest_length, copies=Vec::new(), inherits=Vec::new(), drops=Vec::new()))]
     fn update_model_assets<'p>(
         &self,
         py: Python<'p>,
         manifest_id: &str,
         manifest_length: u64,
         copies: Vec<(String, String, String)>,
+        inherits: Vec<(String, String)>,
         drops: Vec<String>,
     ) -> PyResult<Bound<'p, PyDict>> {
         let source = obj_ref(py, manifest_id, manifest_length)?;
-        let mut edits = Vec::with_capacity(copies.len() + drops.len());
+        let mut edits = Vec::with_capacity(copies.len() + inherits.len() + drops.len());
         edits.extend(copies.into_iter().map(|(name, source_path, media_type)| {
             tensorfs_core::asset_update::Edit::Copy {
                 name,
@@ -612,6 +613,9 @@ impl PyStore {
                 media_type,
             }
         }));
+        edits.extend(inherits.into_iter().map(|(name, source_name)| {
+            tensorfs_core::asset_update::Edit::Inherit { name, source_name }
+        }));
         edits.extend(
             drops
                 .into_iter()
@@ -628,6 +632,31 @@ impl PyStore {
         Ok(out)
     }
 
+    /// Inherit selected verified model assets from one checkpoint into another,
+    /// rewriting only the target header and manifest.
+    #[pyo3(signature = (target_manifest_id, target_manifest_length, source_manifest_id, source_manifest_length, names=Vec::new()))]
+    fn inherit_model_assets<'p>(
+        &self,
+        py: Python<'p>,
+        target_manifest_id: &str,
+        target_manifest_length: u64,
+        source_manifest_id: &str,
+        source_manifest_length: u64,
+        names: Vec<String>,
+    ) -> PyResult<Bound<'p, PyDict>> {
+        let target = obj_ref(py, target_manifest_id, target_manifest_length)?;
+        let source = obj_ref(py, source_manifest_id, source_manifest_length)?;
+        let result = py
+            .detach(|| tensorfs_core::asset_update::inherit(&self.store, &target, &source, &names))
+            .or_refuse(py)?;
+        let out = PyDict::new(py);
+        out.set_item("header_id", result.header.id())?;
+        out.set_item("header_length", result.header.length)?;
+        out.set_item("manifest_id", result.manifest.id())?;
+        out.set_item("manifest_length", result.manifest.length)?;
+        Ok(out)
+    }
+
     fn verify_checkpoint_source(
         &self,
         py: Python<'_>,

{tensorfs-0.3.45 → tensorfs-0.3.46}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "tensorfs"
-version = "0.3.45"
+version = "0.3.46"
 description = "TensorFS — canonical tensor artifact substrate"
 requires-python = ">=3.12"
 classifiers = [

{tensorfs-0.3.45 → tensorfs-0.3.46}/python/tensorfs/_ext.pyi

@@ -489,8 +489,17 @@ class Store:
         manifest_id: str,
         manifest_length: int,
         copies: Sequence[tuple[str, str, str]] = ...,
+        inherits: Sequence[tuple[str, str]] = ...,
         drops: Sequence[str] = ...,
     ) -> dict[str, str | int]: ...
+    def inherit_model_assets(
+        self,
+        target_manifest_id: str,
+        target_manifest_length: int,
+        source_manifest_id: str,
+        source_manifest_length: int,
+        names: Sequence[str] = ...,
+    ) -> dict[str, str | int]: ...
     def objects(self) -> list[str]: ...
     def reap_holds(self) -> list[str]: ...