fastconstmap 0.7.0__tar.gz → 0.8.0__tar.gz

{fastconstmap-0.7.0/fastconstmap.egg-info → fastconstmap-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastconstmap
-Version: 0.7.0
+Version: 0.8.0
 Summary: Fast, immutable, compact map from strings to uint64 (binary fuse filter).
 Author-email: Daniel Lemire <daniel@lemire.me>
 License: Apache-2.0

{fastconstmap-0.7.0 → fastconstmap-0.8.0}/fastconstmap/__init__.py

@@ -21,4 +21,4 @@ copy — see ``serialized_size``, ``write_into`` and ``from_buffer``.
 from ._fastconstmap import ConstMap, VerifiedConstMap
 
 __all__ = ["ConstMap", "VerifiedConstMap"]
-__version__ = "0.7.0"
+__version__ = "0.8.0"

{fastconstmap-0.7.0 → fastconstmap-0.8.0/fastconstmap.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastconstmap
-Version: 0.7.0
+Version: 0.8.0
 Summary: Fast, immutable, compact map from strings to uint64 (binary fuse filter).
 Author-email: Daniel Lemire <daniel@lemire.me>
 License: Apache-2.0

{fastconstmap-0.7.0 → fastconstmap-0.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fastconstmap"
-version = "0.7.0"
+version = "0.8.0"
 description = "Fast, immutable, compact map from strings to uint64 (binary fuse filter)."
 readme = "README.md"
 license = { text = "Apache-2.0" }

{fastconstmap-0.7.0 → fastconstmap-0.8.0}/src/constmap.c

@@ -416,6 +416,7 @@ int fcm_constmap_new(fcm_constmap_t *out,
     out->segment_count        = params.segment_count;
     out->segment_count_length = params.segment_count_length;
     out->data_len             = params.array_len;
+    out->n                    = size;
     out->data                 = data;
     data = NULL;  /* ownership transferred */
 
@@ -497,6 +498,7 @@ int fcm_verified_constmap_new(fcm_verified_constmap_t *out,
     out->segment_count        = params.segment_count;
     out->segment_count_length = params.segment_count_length;
     out->data_len             = params.array_len;
+    out->n                    = size;
     out->data                 = data;
     out->checks               = checks;
     data   = NULL;
@@ -631,7 +633,7 @@ int fcm_constmap_write(const fcm_constmap_t *cm, void *buf) {
     fcm_write_u32(p, cm->segment_length); p += 4;
     fcm_write_u32(p, cm->segment_count);  p += 4;
     fcm_write_u32(p, cm->data_len);       p += 4;
-    fcm_write_u32(p, 0);                  p += 4;  /* reserved padding */
+    fcm_write_u32(p, cm->n);              p += 4;  /* original key count (was reserved) */
     for (uint32_t i = 0; i < cm->data_len; i++) {
         fcm_write_u64(p, cm->data[i]); p += 8;
     }
@@ -652,6 +654,7 @@ int fcm_constmap_read(fcm_constmap_t *out, const void *buf, size_t buf_len) {
     uint32_t segment_length  = fcm_read_u32(p + 16);
     uint32_t segment_count   = fcm_read_u32(p + 20);
     uint32_t data_len        = fcm_read_u32(p + 24);
+    uint32_t n               = fcm_read_u32(p + 28);  /* original key count */
 
     size_t expected = FCM_HEADER_SIZE + (size_t)data_len * 8u + FCM_TRAILER_SIZE;
     if (buf_len < expected) return FCM_E_SHORT_BUFFER;
@@ -675,6 +678,7 @@ int fcm_constmap_read(fcm_constmap_t *out, const void *buf, size_t buf_len) {
     out->segment_count        = segment_count;
     out->segment_count_length = segment_count * segment_length;
     out->data_len             = data_len;
+    out->n                    = n;
     out->data                 = data;
     return FCM_OK;
 }
@@ -691,7 +695,7 @@ int fcm_verified_constmap_write(const fcm_verified_constmap_t *vm, void *buf) {
     fcm_write_u32(p, vm->segment_length); p += 4;
     fcm_write_u32(p, vm->segment_count);  p += 4;
     fcm_write_u32(p, vm->data_len);       p += 4;
-    fcm_write_u32(p, 0);                  p += 4;  /* reserved padding */
+    fcm_write_u32(p, vm->n);              p += 4;  /* original key count (was reserved) */
     for (uint32_t i = 0; i < vm->data_len; i++) {
         fcm_write_u64(p, vm->data[i]); p += 8;
     }
@@ -715,6 +719,7 @@ int fcm_verified_constmap_read(fcm_verified_constmap_t *out, const void *buf, si
     uint32_t segment_length  = fcm_read_u32(p + 16);
     uint32_t segment_count   = fcm_read_u32(p + 20);
     uint32_t data_len        = fcm_read_u32(p + 24);
+    uint32_t n               = fcm_read_u32(p + 28);  /* original key count */
 
     size_t expected = FCM_HEADER_SIZE + (size_t)data_len * 16u + FCM_TRAILER_SIZE;
     if (buf_len < expected) return FCM_E_SHORT_BUFFER;
@@ -744,6 +749,7 @@ int fcm_verified_constmap_read(fcm_verified_constmap_t *out, const void *buf, si
     out->segment_count        = segment_count;
     out->segment_count_length = segment_count * segment_length;
     out->data_len             = data_len;
+    out->n                    = n;
     out->data                 = data;
     out->checks               = checks;
     return FCM_OK;
@@ -785,6 +791,7 @@ int fcm_constmap_view(fcm_constmap_t *out, const void *buf, size_t buf_len) {
     out->segment_count        = fcm_read_u32(p + 20);
     out->segment_count_length = out->segment_count * segment_length;
     out->data_len             = data_len;
+    out->n                    = fcm_read_u32(p + 28);  /* original key count */
     /* Borrowed pointer into `buf`; the integer round-trip launders away the
      * source const-ness. Lookups only read this array. */
     out->data = (uint64_t *)(uintptr_t)dp;
@@ -819,6 +826,7 @@ int fcm_verified_constmap_view(fcm_verified_constmap_t *out, const void *buf, si
     out->segment_count        = fcm_read_u32(p + 20);
     out->segment_count_length = out->segment_count * segment_length;
     out->data_len             = data_len;
+    out->n                    = fcm_read_u32(p + 28);  /* original key count */
     out->data   = (uint64_t *)(uintptr_t)dp;
     out->checks = (uint64_t *)(uintptr_t)cp;
     return FCM_OK;

{fastconstmap-0.7.0 → fastconstmap-0.8.0}/src/constmap.h

@@ -36,6 +36,7 @@ typedef struct fcm_constmap {
     uint32_t  segment_count;
     uint32_t  segment_count_length;
     uint32_t  data_len;
+    uint32_t  n;          /* original number of inserted keys */
     uint64_t *data;
 } fcm_constmap_t;
 
@@ -46,6 +47,7 @@ typedef struct fcm_verified_constmap {
     uint32_t  segment_count;
     uint32_t  segment_count_length;
     uint32_t  data_len;
+    uint32_t  n;          /* original number of inserted keys */
     uint64_t *data;
     uint64_t *checks;
 } fcm_verified_constmap_t;

{fastconstmap-0.7.0 → fastconstmap-0.8.0}/src/fastconstmap_module.c

@@ -290,10 +290,7 @@ fail:
 }
 
 static Py_ssize_t PyConstMap_length(PyConstMap *self) {
-    /* The ConstMap doesn't actually retain the original size, only data_len.
-     * The Python wrapper stores it separately if needed; here we report 0
-     * since we don't track it (Map is anonymous). */
-    return (Py_ssize_t)self->cm.data_len;
+    return (Py_ssize_t)self->cm.n;
 }
 
 static PyObject *PyConstMap_subscript(PyConstMap *self, PyObject *key) {
@@ -661,7 +658,7 @@ fail:
 }
 
 static Py_ssize_t PyVerifiedConstMap_length(PyVerifiedConstMap *self) {
-    return (Py_ssize_t)self->vm.data_len;
+    return (Py_ssize_t)self->vm.n;
 }
 
 static PyObject *PyVerifiedConstMap_serialize(PyVerifiedConstMap *self, PyObject *Py_UNUSED(ignored)) {

{fastconstmap-0.7.0 → fastconstmap-0.8.0}/tests/test_constmap.py

@@ -23,6 +23,19 @@ def test_empty():
     assert len(m) == 0
 
 
+def test_len():
+    d = {"apple": 100, "banana": 200, "cherry": 300}
+    m = ConstMap(d)
+    assert len(m) == 3
+
+
+def test_len_after_serialization():
+    d = {"a": 1, "b": 2, "c": 3, "d": 4}
+    m = ConstMap(d)
+    m2 = ConstMap.from_bytes(m.to_bytes())
+    assert len(m2) == 4
+
+
 def test_single_key():
     m = ConstMap({"only": 42})
     assert m["only"] == 42
@@ -148,6 +161,19 @@ def test_verified_basic():
         assert vm[k] == v
 
 
+def test_verified_len():
+    d = {"apple": 100, "banana": 200, "cherry": 300}
+    vm = VerifiedConstMap(d)
+    assert len(vm) == 3
+
+
+def test_verified_len_after_serialization():
+    d = {"a": 1, "b": 2, "c": 3, "d": 4}
+    vm = VerifiedConstMap(d)
+    vm2 = VerifiedConstMap.from_bytes(vm.to_bytes())
+    assert len(vm2) == 4
+
+
 def test_verified_missing_raises():
     vm = VerifiedConstMap({"a": 1, "b": 2})
     with pytest.raises(KeyError):