tensorfs 0.1.2__tar.gz → 0.2.0__tar.gz

{tensorfs-0.1.2 → tensorfs-0.2.0}/Cargo.lock

@@ -249,7 +249,7 @@ checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
 
 [[package]]
 name = "tensorfs-core"
-version = "0.1.2"
+version = "0.2.0"
 dependencies = [
  "fs2",
  "minicbor",
@@ -258,7 +258,7 @@ dependencies = [
 
 [[package]]
 name = "tensorfs-py"
-version = "0.1.2"
+version = "0.2.0"
 dependencies = [
  "pyo3",
  "tensorfs-core",

{tensorfs-0.1.2 → tensorfs-0.2.0}/Cargo.toml

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

{tensorfs-0.1.2 → tensorfs-0.2.0}/PKG-INFO

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

{tensorfs-0.1.2 → tensorfs-0.2.0}/crates/tensorfs-core/src/bin/tfs/ckpt.rs

@@ -14,7 +14,7 @@ use std::time::Instant;
 use tensorfs_core::checkpoint::{self as ck, build_manifest};
 use tensorfs_core::dtype::Dtype;
 use tensorfs_core::header::{Asset, Body, Closure, Header, Located, Part, Tensor};
-use tensorfs_core::ids::{ConfigRef, ObjectRef};
+use tensorfs_core::ids::ObjectRef;
 use tensorfs_core::limits;
 use tensorfs_core::registry;
 use tensorfs_core::relation::Carrier;
@@ -262,8 +262,7 @@ pub fn cmd_write(root: &Path, f: &Flags) -> ExitCode {
     };
     let items = plan(blocks, scale, encoding);
 
-    // The closure first: spec objects and config objects are ordinary CAS objects, and the
-    // header commits them BY REFERENCE.
+    // The encoding closure first. Construction configs are canonical bytes inside the header.
     let mut aliases: Vec<&'static str> = items.iter().map(|i| i.alias).collect();
     aliases.sort_unstable();
     aliases.dedup();
@@ -278,28 +277,19 @@ pub fn cmd_write(root: &Path, f: &Flags) -> ExitCode {
 
     // --no-configs is the TENSORS-ONLY shape: one header plus its closure, zero sibling
     // assets. The manifest id derives once from the virtual tree.
-    let mut cfg_refs: Vec<(String, ConfigRef)> = Vec::new();
+    let mut inline_configs = Vec::new();
     let cfgs = if flag_on(f, "no-configs") {
         Vec::new()
     } else {
         configs()
     };
     for (name, bytes) in cfgs {
-        let put = ok!(store.put_stream(
-            &mut &bytes[..],
-            Some(&ObjectRef::of(bytes)),
-            &Default::default()
-        ));
-        cfg_refs.push((
+        inline_configs.push((
             name.to_string(),
-            ConfigRef {
-                sha256: put.obj.sha256,
-                length: put.obj.length,
-                media_type: "application/json".to_string(),
-            },
+            ok!(tensorfs_core::header::canonical_config("config", bytes)),
         ));
     }
-    cfg_refs.sort_by(|a, b| a.0.cmp(&b.0));
+    inline_configs.sort_by(|a, b| a.0.cmp(&b.0));
     let asset_bytes = b"<pad>0</pad>\n<pad>1</pad>\n";
     let asset_object = ok!(store.put_stream(
         &mut &asset_bytes[..],
@@ -358,7 +348,7 @@ pub fn cmd_write(root: &Path, f: &Flags) -> ExitCode {
     let write_s = t0.elapsed().as_secs_f64();
 
     let header = Header {
-        configs: cfg_refs,
+        configs: inline_configs,
         assets,
         encodings,
         components: comps,
@@ -377,7 +367,7 @@ pub fn cmd_write(root: &Path, f: &Flags) -> ExitCode {
     println!("checkpoint written to {}", root.display());
     println!("  header_digest   {}", href.id());
     println!("  manifest_id     {}", sref.id());
-    println!("  topology_digest {}", header.topology_digest());
+    println!("  tensor_schema_digest {}", header.tensor_schema_digest());
     println!(
         "  components {}  tensors {}  parts {}  segments {}  inline {}",
         header.components.len(),
@@ -549,17 +539,8 @@ pub fn cmd_info(root: &Path, hex: &str) -> ExitCode {
     let (store, href) = opened!(root, hex);
     let header = ok!(ck::load_header(&store, &href));
     println!("header {} ({} B)", href.id(), href.length);
-    let digests = ok!(ck::digests(&store, &header));
-    println!("topology_digest {}", digests.topology_digest);
-    println!("shape_digest    {}", digests.shape_digest);
-    if let Some(config) = &digests.config_digest {
-        println!("config_digest   {config}");
-    }
     for (name, c) in &header.configs {
-        println!(
-            "config {name:<14} sha256:{} {} B {}",
-            c.sha256, c.length, c.media_type
-        );
+        println!("config {name:<14} {} inline B", c.len());
     }
     for r in &header.encodings {
         println!("encoding {} (inlined)", r.object_id());
@@ -863,7 +844,7 @@ pub fn cmd_size(n: usize) -> ExitCode {
     println!(
         "  encode {encode_ms:.1} ms   strict parse {parse_ms:.1} ms   validate {validate_ms:.1} ms"
     );
-    println!("  topology_digest {}", parsed.topology_digest());
+    println!("  tensor_schema_digest {}", parsed.tensor_schema_digest());
     println!("  peak RSS {:.1} MiB", rss_kb("VmHWM") as f64 / 1024.0);
     ExitCode::SUCCESS
 }
@@ -879,10 +860,10 @@ mod tests {
     use super::*;
 
     static NEXT_ROOT: AtomicU64 = AtomicU64::new(0);
-    const SCALED_TOPOLOGY: &str =
-        "sha256:b0bcb1d36deae42e880632817730172f6f6a14f2177bae0ea953cba2a64b0ccf";
-    const FULL_TOPOLOGY: &str =
-        "sha256:20568368a293a7d7fa7ab76d7dfece5c04616d3ff85f9e36656949eda35579d4";
+    const SCALED_SCHEMA: &str =
+        "sha256:b4cce0c745fe5bb0535827572791c37195c982e21b5d5fe9b30a9b2446bc8ea2";
+    const FULL_SCHEMA: &str =
+        "sha256:61e69d1fcc565583e90560cf0282f42a18d3cc65462a6a17eee5f69c64b0a6ba";
     const MIXED_BLOCK_ORDER: [&str; 5] = [
         "blocks.0.attn1.to_q.weight",
         "blocks.0.attn1.to_out.0.weight",
@@ -1017,7 +998,7 @@ mod tests {
             .iter()
             .all(|item| item.alias == "plain/1"));
         let full_plain = plan(12, 1, PlanEncoding::Plain);
-        let topology = tensorfs_core::header::topology_value(full_plain.iter().map(|item| {
+        let schema = tensorfs_core::header::tensor_schema_value(full_plain.iter().map(|item| {
             (
                 item.comp,
                 item.key.as_str(),
@@ -1026,8 +1007,8 @@ mod tests {
             )
         }));
         assert_eq!(
-            tensorfs_core::header::topology_digest_of(&topology),
-            FULL_TOPOLOGY
+            tensorfs_core::header::tensor_schema_digest_of(&schema),
+            FULL_SCHEMA
         );
     }
 
@@ -1063,7 +1044,7 @@ mod tests {
         assert_eq!(ids, closure_ids);
         assert!(ids.contains(&registry_seed("plain/1").spec.object_id()));
         assert_eq!(component_keys(&header, "unet"), MIXED_BLOCK_ORDER);
-        assert_eq!(header.topology_digest(), SCALED_TOPOLOGY);
+        assert_eq!(header.tensor_schema_digest(), SCALED_SCHEMA);
     }
 
     #[test]
@@ -1090,7 +1071,7 @@ mod tests {
             .tensors()
             .all(|(_, _, tensor)| tensor.parts.len() == 1 && tensor.parts[0].0 == "value"));
         assert_eq!(component_keys(&header, "unet"), PLAIN_BLOCK_ORDER);
-        assert_eq!(header.topology_digest(), SCALED_TOPOLOGY);
+        assert_eq!(header.tensor_schema_digest(), SCALED_SCHEMA);
         assert_eq!(cmd_read(&root.0, &href.sha256, &flags), ExitCode::SUCCESS);
     }
 }

{tensorfs-0.1.2 → tensorfs-0.2.0}/crates/tensorfs-core/src/bin/tfs/ingest.rs

@@ -29,8 +29,8 @@ use tensorfs_core::canon::{self, as_arr, as_str, Fields, Value};
 use tensorfs_core::checkpoint as ck;
 use tensorfs_core::dtype::Dtype;
 use tensorfs_core::err::Code;
-use tensorfs_core::header::topology_digest_of;
-use tensorfs_core::ids::{ConfigRef, ObjectRef, Plain};
+use tensorfs_core::header::tensor_schema_digest_of;
+use tensorfs_core::ids::{ObjectRef, Plain};
 use tensorfs_core::ingest::carrier::{self, SourceHeader};
 use tensorfs_core::ingest::convert::{self, Class, Effect, Rekey, Source, Target};
 use tensorfs_core::ingest::fingerprint::{
@@ -42,7 +42,6 @@ use tensorfs_core::ingest::stamp::{self, Stamp};
 use tensorfs_core::ingest::transaction::{self as tx};
 use tensorfs_core::ingest::{Evidence, IngestProfile, IngestSubject, IngestVerificationReceipt};
 use tensorfs_core::limits;
-use tensorfs_core::manifest::{Draft, Entry};
 use tensorfs_core::registry;
 use tensorfs_core::store::{Progress, Store};
 
@@ -340,7 +339,7 @@ pub fn cmd_inspect(f: &Flags) -> ExitCode {
         println!("  dtypes       {}", dt.join(" · "));
         println!("  declared     {} B of tensor bytes", h.declared_bytes());
         println!("  keyset       {}", fp.keyset_digest);
-        println!("  topology     {}", fp.topology_digest);
+        println!("  tensor schema {}", fp.tensor_schema_digest);
         println!("  source       {}", source_core::source_digest(&h, &raw));
         if !stamps.is_empty() {
             for (k, v) in &stamps {
@@ -436,7 +435,7 @@ pub fn cmd_bank(dialect: &str, converter: &str, f: &Flags) -> ExitCode {
             dialect: dialect.to_string(),
             component: component.clone(),
             converter: converter.to_string(),
-            topology_digest: fp.topology_digest.clone(),
+            tensor_schema_digest: fp.tensor_schema_digest.clone(),
             logical_keys: fp.logical_keys as u64,
             provenance: Provenance {
                 kind: REAL.to_string(),
@@ -454,7 +453,7 @@ pub fn cmd_bank(dialect: &str, converter: &str, f: &Flags) -> ExitCode {
         });
         println!(
             "banked {component}  {}  {}",
-            fp.keyset_digest, fp.topology_digest
+            fp.keyset_digest, fp.tensor_schema_digest
         );
         reviewed.push((component.clone(), fp.keyset_digest));
     }
@@ -991,8 +990,8 @@ fn print_plan(p: &Prepared) {
         Err(e) => println!("declared     REFUSED {}: {}", e.code.as_str(), e.detail),
     }
     println!(
-        "topology     {}",
-        topology_digest_of(&source_core::plan_topology(pl))
+        "tensor schema {}",
+        tensor_schema_digest_of(&source_core::plan_tensor_schema(pl))
     );
     println!(
         "cost         {} B of headers read, {} tensor bytes read",
@@ -1291,8 +1290,8 @@ pub fn cmd_worker(root: &Path, target: &str, f: &Flags) -> ExitCode {
     // The root goes down FIRST. From this line on the session is reapable whatever happens.
     let (mut ingest_root, _operation_writer) = ok!(tx::open_root(&store, &session, &tenant));
 
-    // Configs are sidecar bytes the header commits BY REFERENCE.
-    let mut configs: Vec<(String, ConfigRef)> = Vec::new();
+    // Configs become canonical JSON bytes inside the CozyTensors header.
+    let mut configs = Vec::new();
     for (k, v) in f.iter() {
         if k != "config" {
             continue;
@@ -1311,19 +1310,9 @@ pub fn cmd_worker(root: &Path, target: &str, f: &Flags) -> ExitCode {
                 return ExitCode::FAILURE;
             }
         };
-        let put = ok!(store.put_stream_held(
-            &mut bytes.as_slice(),
-            Some(&ObjectRef::of(&bytes)),
-            &Default::default(),
-            Some(&session),
-        ));
         configs.push((
             name.to_string(),
-            ConfigRef {
-                sha256: put.obj.sha256,
-                length: put.obj.length,
-                media_type: "application/json".to_string(),
-            },
+            ok!(tensorfs_core::header::canonical_config("config", &bytes)),
         ));
     }
     configs.sort_by(|a, b| a.0.cmp(&b.0));
@@ -1333,7 +1322,7 @@ pub fn cmd_worker(root: &Path, target: &str, f: &Flags) -> ExitCode {
     let golden = ok!(source_core::golden_suite(p.conv));
     println!("golden       {golden} cases reassembled bit-for-bit");
 
-    let predicted = topology_digest_of(&source_core::plan_topology(&p.plan));
+    let predicted = tensor_schema_digest_of(&source_core::plan_tensor_schema(&p.plan));
     // Qualification fixtures are build data, not model-store objects.
     for (_, seed) in &p.seeds {
         if let Some(v) = &seed.vectors {
@@ -1348,11 +1337,11 @@ pub fn cmd_worker(root: &Path, target: &str, f: &Flags) -> ExitCode {
         &configs,
         &session,
     ));
-    let got = out.header.topology_digest();
+    let got = out.header.tensor_schema_digest();
     if got != predicted {
         eprintln!(
-            "REFUSED TOPOLOGY_MISMATCH: the plan predicted {predicted} and the written \
-             header projects {got} — the preview and the run disagree"
+            "REFUSED TOPOLOGY_MISMATCH: the plan predicted tensor schema {predicted} and \
+             the written header projects {got} — the preview and the run disagree"
         );
         return ExitCode::FAILURE;
     }
@@ -1401,7 +1390,7 @@ pub fn cmd_worker(root: &Path, target: &str, f: &Flags) -> ExitCode {
         source_dialect: p.conv.dialect.to_string(),
         converter_build: build.clone(),
         converter_recipe: recipe.clone(),
-        expected_topology_digest: predicted.clone(),
+        expected_tensor_schema_digest: predicted.clone(),
         allowed_encodings: {
             let mut v: Vec<ObjectRef> = p.seeds.iter().map(|(_, s)| s.spec.object_ref()).collect();
             v.sort_by(|a, b| a.sha256.cmp(&b.sha256));
@@ -1414,15 +1403,6 @@ pub fn cmd_worker(root: &Path, target: &str, f: &Flags) -> ExitCode {
     ok!(profile.validate(&registry::platform_digests()));
     let profile_ref = profile.object_ref();
 
-    let mut manifest = Draft::of(&out.manifest);
-    manifest.entries.push((
-        "evidence/converter-recipe".to_string(),
-        Entry::File(recipe.clone()),
-    ));
-    manifest.entries.sort_by(|left, right| left.0.cmp(&right.0));
-    out.manifest = ok!(manifest.seal());
-    out.manifest_ref = ok!(store.put_manifest_held(&out.manifest, Some(&session))).obj;
-
     let subject = IngestSubject {
         profile: profile_ref,
         tenant: tenant.clone(),
@@ -1521,7 +1501,7 @@ pub fn cmd_worker(root: &Path, target: &str, f: &Flags) -> ExitCode {
     println!("candidate    header {}", out.header_ref.id());
     println!("candidate    manifest {}", out.manifest_ref.id());
     println!("stamp        {}", stamp_ref.id());
-    println!("  topology   {}", stamped.stamp.topology_digest);
+    println!("  tensor schema {}", stamped.stamp.tensor_schema_digest);
     println!("  candidates {}", stamped.stamp.candidate_set);
     println!("  golden     {}", stamped.stamp.golden);
     println!("receipt      {}", receipt_ref.id());
@@ -1685,7 +1665,7 @@ pub fn cmd_install(
     let receipt = ok!(IngestVerificationReceipt::parse(&rb));
     let subject = ok!(IngestSubject::parse(&sb));
     let stamp_doc = ok!(Stamp::parse(&tb));
-    let profile = ok!(IngestProfile::parse(&pb));
+    let _profile = ok!(IngestProfile::parse(&pb));
     let snap = ok!(ck::load_manifest(&store, &receipt.manifest));
     let header = ok!(ck::load_header(&store, &receipt.header));
     let repo = ok!(tensorfs_core::repository::RepositoryName::new(org, name));
@@ -1704,12 +1684,9 @@ pub fn cmd_install(
             manifest: &snap,
             header: &header,
             stamp: &stamp_doc,
-            profile: &profile,
             repo,
             version,
             lane,
-            source_uri: flag(flags, "source-uri"),
-            declared_license: flag(flags, "declared-license"),
             observed_repository: flag(flags, "observed"),
         },
     ));
@@ -1906,7 +1883,9 @@ pub fn cmd_restamp(root: &Path, session: &str, flags: &Flags) -> ExitCode {
     let plant = flag(flags, "plant").unwrap_or("");
     match plant {
         "" => {}
-        "topology" => profile.expected_topology_digest = tensorfs_core::ids::object_id(b"other"),
+        "tensor-schema" => {
+            profile.expected_tensor_schema_digest = tensorfs_core::ids::object_id(b"other")
+        }
         "candidate" => {
             subject.candidates.pop();
         }
@@ -1936,7 +1915,7 @@ pub fn cmd_restamp(root: &Path, session: &str, flags: &Flags) -> ExitCode {
         // any of its contents are read. This plant proves that binding on its own.
         "profile-bytes" => profile.max_tensors += 1,
         "structure" => {
-            // One tensor's logical shape moved: the header no longer projects the topology
+            // One tensor's logical shape moved: the header no longer projects the tensor schema
             // the profile pinned, and the manifest no longer describes what is in the store.
             if let Some((_, ts)) = out.header.components.first_mut() {
                 if let Some((_, t)) = ts.first_mut() {
@@ -1957,7 +1936,7 @@ pub fn cmd_restamp(root: &Path, session: &str, flags: &Flags) -> ExitCode {
     // `profile-bytes` plant is the one that deliberately does not, and proves the binding.
     if matches!(
         plant,
-        "topology" | "encoding" | "quota-tensors" | "quota-bytes"
+        "tensor-schema" | "encoding" | "quota-tensors" | "quota-bytes"
     ) {
         subject.profile = profile.object_ref();
     }
@@ -1977,7 +1956,7 @@ pub fn cmd_restamp(root: &Path, session: &str, flags: &Flags) -> ExitCode {
         }
     ));
     println!("restamped    {}", stamped.stamp.object_id());
-    println!("  topology   {}", stamped.stamp.topology_digest);
+    println!("  tensor schema {}", stamped.stamp.tensor_schema_digest);
     println!("  candidates {}", stamped.stamp.candidate_set);
     println!("receipt      {}", stamped.receipt.object_id());
     if stamped.receipt.object_id() == receipt.object_id() {

{tensorfs-0.1.2 → tensorfs-0.2.0}/crates/tensorfs-core/src/bin/tfs/layout.rs

@@ -77,8 +77,7 @@ pub fn cmd_topology(root: &Path, hex: &str, flags: &Flags) -> ExitCode {
     emit(&code, flags);
     println!("contract     {}", code.contract);
     println!("tensors      {}", code.count());
-    println!("topology     {}", code.topology_digest());
-    println!("shape        {}", code.shape_digest());
+    println!("tensor schema {}", code.tensor_schema_digest());
     ExitCode::SUCCESS
 }
 
@@ -170,16 +169,6 @@ pub fn cmd_fit(code_p: &Path, root: &Path, header_arg: &str, flags: &Flags) -> E
     println!("fit          {}", verdict.code());
     println!("detail       {}", verdict.text());
     println!("custody      {}", custody.name());
-    println!(
-        "shape        code {} / checkpoint {} — {}",
-        &code.shape_digest()[7..19],
-        &header.shape_digest()[7..19],
-        if code.shape_digest() == header.shape_digest() {
-            "the fit index HITS"
-        } else {
-            "index miss; the answer is the walk above"
-        }
-    );
     if let Fit::Ok { ignored, .. } = &verdict {
         for key in ignored {
             println!("ignored      {key}");
@@ -404,7 +393,7 @@ pub fn cmd_import(rows_p: &Path, flags: &Flags) -> ExitCode {
     println!("  logical    REAL — keys/dtypes/shapes/roles off pinned upstream header bytes");
     println!("  parts      PLACEHOLDER object ids: no weight bytes transit this machine");
     println!("header       {}", ok!(header.object_id()));
-    println!("topology     {}", header.topology_digest());
+    println!("tensor schema {}", header.tensor_schema_digest());
     println!("code         {}", code.object_id());
     for (id, s) in &closure.specs {
         println!(
@@ -518,7 +507,7 @@ fn emit_bytes(bytes: &[u8], flags: &Flags) {
 ///
 /// `--json` prints ONE object and nothing else -- the surface a program should read; the
 /// human print below is for people. It is TOTAL: `satisfied`, `depth`, `details`,
-/// `encodings`, `report` and the four `topology_*` index keys are present on every answer.
+/// `encodings` and `report` are present on every answer.
 /// `encodings` is the set the CHECKPOINT carries, and it is here because "these bytes can
 /// be read" and "some card has a qualified implementation for them" are two independent
 /// questions; the second is `tfs capability`, and a caller cannot ask it without knowing
@@ -572,26 +561,6 @@ pub fn cmd_check(code_p: &Path, header_p: &Path, flags: &Flags) -> ExitCode {
     }
 
     println!("custody      {}", custody.name());
-    println!(
-        "topology     required {} / present {} — {}",
-        &report.topology_required[7..19],
-        &report.topology_present[7..19],
-        if report.topology_required == report.topology_present {
-            "the fast-path index HITS (an index, never the decision)"
-        } else {
-            "index miss; the decision is the document comparison below"
-        }
-    );
-    println!(
-        "shape        required {} / present {} — {}",
-        &report.shape_required[7..19],
-        &report.shape_present[7..19],
-        if report.shape_required == report.shape_present {
-            "same shapes, so any difference is dtype or encoding alone (a search bucket)"
-        } else {
-            "different shapes: a different model, not a different packaging"
-        }
-    );
     if out.mismatches.is_empty() {
         println!("verdict      Satisfied");
     } else {