small-cache 0.0.1__tar.gz → 0.0.3__tar.gz

{small_cache-0.0.1 → small_cache-0.0.3}/.github/workflows/pip.yml

@@ -14,9 +14,9 @@ jobs:
         python-version: ["3.11", "3.12"]
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
 
-    - uses: actions/setup-python@v5
+    - uses: actions/setup-python@v6
       with:
         python-version: ${{ matrix.python-version }}
 

{small_cache-0.0.1 → small_cache-0.0.3}/.github/workflows/wheels.yml

@@ -11,7 +11,7 @@ jobs:
     name: Build SDist
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
       with:
         submodules: true
 
@@ -21,7 +21,7 @@ jobs:
     - name: Check metadata
       run: pipx run twine check dist/*
 
-    - uses: actions/upload-artifact@v4
+    - uses: actions/upload-artifact@v5
       with:
         name: dist-sdist
         path: dist/*.tar.gz
@@ -36,18 +36,18 @@ jobs:
         os: [ubuntu-latest, macos-latest, windows-latest]
 
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v6
       with:
         submodules: true
 
-    - uses: pypa/cibuildwheel@v3.0
+    - uses: pypa/cibuildwheel@v3.3
 
     - name: Verify clean directory
       run: git diff --exit-code
       shell: bash
 
     - name: Upload wheels
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v5
       with:
         path: wheelhouse/*.whl
         name: dist-${{ matrix.os }}
@@ -59,8 +59,8 @@ jobs:
     if: github.event_name == 'release' && github.event.action == 'published'
 
     steps:
-    - uses: actions/setup-python@v5
-    - uses: actions/download-artifact@v4
+    - uses: actions/setup-python@v6
+    - uses: actions/download-artifact@v6
       with:
         path: dist
         pattern: dist-*

{small_cache-0.0.1 → small_cache-0.0.3}/CMakeLists.txt

@@ -66,7 +66,7 @@ include(FetchContent)
 FetchContent_Declare(
         glaze
         GIT_REPOSITORY https://github.com/stephenberry/glaze.git
-        GIT_TAG main
+        GIT_TAG v6.1.0
         GIT_SHALLOW TRUE
 )
 
@@ -75,7 +75,7 @@ FetchContent_MakeAvailable(glaze)
 FetchContent_Declare(
         tsl_sparse_map
         GIT_REPOSITORY https://github.com/Tessil/sparse-map
-        GIT_TAG master
+        GIT_TAG v0.7.0
         GIT_SHALLOW TRUE
 )
 FetchContent_MakeAvailable(tsl_sparse_map)
@@ -83,7 +83,7 @@ FetchContent_MakeAvailable(tsl_sparse_map)
 FetchContent_Declare(
         absl
         GIT_REPOSITORY https://github.com/abseil/abseil-cpp.git
-        GIT_TAG master
+        GIT_TAG 20250814.1
         GIT_SHALLOW TRUE
         OVERRIDE_FIND_PACKAGE TRUE
         EXCLUDE_FROM_ALL
@@ -92,14 +92,14 @@ FetchContent_Declare(
 find_package(
         absl
         REQUIRED
-        COMPONENTS flat_hash_map hash
+        COMPONENTS flat_hash_map flat_hash_set hash
 )
 
 Set(FETCHCONTENT_QUIET FALSE)
 FetchContent_Declare(
         Boost
         URL https://github.com/boostorg/boost/releases/download/boost-1.88.0/boost-1.88.0-cmake.7z
-        GIT_TAG "boost-1.88.0"
+        GIT_TAG "boost-1.89.0"
         USES_TERMINAL_DOWNLOAD TRUE
         GIT_PROGRESS TRUE
         DOWNLOAD_NO_EXTRACT FALSE

{small_cache-0.0.1 → small_cache-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: small-cache
-Version: 0.0.1
+Version: 0.0.3
 Summary: Small cache
 Author: kam1k4dze
 Classifier: License :: OSI Approved :: BSD License

{small_cache-0.0.1 → small_cache-0.0.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "small-cache"
-version = "0.0.1"
+version = "0.0.3"
 description = "Small cache"
 readme = "README.md"
 requires-python = ">=3.11"

{small_cache-0.0.1 → small_cache-0.0.3}/src/small_cache.cpp

@@ -8,6 +8,7 @@
 #include <tsl/sparse_map.h>
 #include <absl/hash/hash.h>
 #include <absl/container/flat_hash_map.h>
+#include <absl/container/flat_hash_set.h>
 #include <boost/flyweight.hpp>
 #include <optional>
 #include <algorithm>
@@ -55,7 +56,7 @@ class SmallCache {
     using str = std::string;
     using strVec = std::vector<str>;
     using fwStr = boost::flyweight<str>;
-    using strVecUPtr = std::unique_ptr<std::vector<fwStr> >;
+    using strVecUPtr = std::unique_ptr<std::vector<fwStr>>;
 
     using AttributeValue = std::variant<std::monostate, double, bool, fwStr, strVecUPtr>;
     using pyAttrValue = std::variant<std::monostate, bool, double, str, strVec>;
@@ -109,7 +110,7 @@ public:
             return (attrs_flags[w] >> b) & 1u;
         }
 
-        [[nodiscard]] std::optional<std::reference_wrapper<AttributeValue> > getValue(size_t idx) noexcept {
+        [[nodiscard]] std::optional<std::reference_wrapper<AttributeValue>> getValue(size_t idx) noexcept {
             if (!hasIdx(idx))
                 return std::nullopt;
 
@@ -130,7 +131,7 @@ public:
             return value.size() > pos ? std::optional{std::ref(value[pos])} : std::nullopt; // just-in-case
         }
 
-        [[nodiscard]] std::optional<std::reference_wrapper<const AttributeValue> > getValue(size_t idx) const noexcept {
+        [[nodiscard]] std::optional<std::reference_wrapper<const AttributeValue>> getValue(size_t idx) const noexcept {
             if (auto ref = const_cast<MarkedItem *>(this)->getValue(idx))
                 return std::cref(ref->get());
             return std::nullopt;
@@ -142,7 +143,7 @@ public:
         item.attrs_flags.fill(0);
 
         // build a slot for each possible attr index
-        std::vector<std::optional<AttributeValue> > slots(attrMap.size());
+        std::vector<std::optional<AttributeValue>> slots(attrMap.size());
 
         // 1) collect into slots[] by index
         for (auto &[name, pyVal]: attrs) {
@@ -185,29 +186,29 @@ public:
 
     static AttributeValue convert_value(const json::AttributeValue &src) {
         return std::visit(overloaded{
-                              [](bool b) -> AttributeValue { return b; },
-                              [](double d) -> AttributeValue { return d; },
-                              [](const str &s) -> AttributeValue {
-                                  // if (s.empty()) return std::monostate{};
-                                  return fwStr{s};
-                              },
-
-                              [](const std::vector<glz::raw_json> &json_vec) -> AttributeValue {
-                                  auto out = std::make_unique<std::vector<fwStr> >();
-                                  out->reserve(json_vec.size());
-                                  for (auto &r: json_vec)
-                                      if (!r.str.empty())
-                                          out->emplace_back(r.str);
-                                  // if (out->empty()) {
-                                  //     return std::monostate{};
-                                  // }
-                                  out->shrink_to_fit();
-                                  return out;
-                              },
-                              [](const std::optional<glz::raw_json> &o) -> AttributeValue {
-                                  // if (!o.has_value() || o->str.empty()) return std::monostate{};
-                                  return fwStr{o->str};
-                              },
+                                  [](bool b) -> AttributeValue { return b; },
+                                  [](double d) -> AttributeValue { return d; },
+                                  [](const str &s) -> AttributeValue {
+                                      // if (s.empty()) return std::monostate{};
+                                      return fwStr{s};
+                                  },
+
+                                  [](const std::vector<glz::raw_json> &json_vec) -> AttributeValue {
+                                      auto out = std::make_unique<std::vector<fwStr>>();
+                                      out->reserve(json_vec.size());
+                                      for (auto &r: json_vec)
+                                          if (!r.str.empty())
+                                              out->emplace_back(r.str);
+                                      // if (out->empty()) {
+                                      //     return std::monostate{};
+                                      // }
+                                      out->shrink_to_fit();
+                                      return out;
+                                  },
+                                  [](const std::optional<glz::raw_json> &o) -> AttributeValue {
+                                      // if (!o.has_value() || o->str.empty()) return std::monostate{};
+                                      return fwStr{o->str};
+                                  },
 
                           },
                           src);
@@ -216,17 +217,17 @@ public:
 
     static pyAttrValue convert_valueJ(const json::AttributeValue &src) {
         return std::visit(overloaded{
-                              [](std::monostate b) -> pyAttrValue { return b; },
-                              [](bool b) -> pyAttrValue { return b; },
-                              [](double d) -> pyAttrValue { return d; },
-                              [](const str &s) -> pyAttrValue { return s; },
-                              [](const std::vector<glz::raw_json> &json_vec) -> pyAttrValue {
-                                  return json_vec | std::views::transform([](const glz::raw_json &j) -> str {
-                                             return j.str;
-                                         }) |
-                                         std::ranges::to<strVec>();
-                              },
-                              [](const std::optional<glz::raw_json> &o) -> pyAttrValue { return o ? o->str : ""; },
+                                  [](std::monostate b) -> pyAttrValue { return b; },
+                                  [](bool b) -> pyAttrValue { return b; },
+                                  [](double d) -> pyAttrValue { return d; },
+                                  [](const str &s) -> pyAttrValue { return s; },
+                                  [](const std::vector<glz::raw_json> &json_vec) -> pyAttrValue {
+                                      return json_vec | std::views::transform([](const glz::raw_json &j) -> str {
+                                                 return j.str;
+                                             }) |
+                                             std::ranges::to<strVec>();
+                                  },
+                                  [](const std::optional<glz::raw_json> &o) -> pyAttrValue { return o ? o->str : ""; },
 
                           },
                           src);
@@ -234,54 +235,54 @@ public:
 
     static pyAttrValue convert_value(const AttributeValue &src) {
         return std::visit(overloaded{
-                              [](std::monostate b) -> pyAttrValue { return b; },
-                              [](bool b) -> pyAttrValue { return b; },
-                              [](double d) -> pyAttrValue { return d; },
-                              [](const fwStr &s) -> pyAttrValue { return s; },
-                              [](const strVecUPtr &fw_vec) -> pyAttrValue {
-                                  return *fw_vec | std::views::transform([](const fwStr &s) -> str { return s; }) |
-                                         std::ranges::to<strVec>();
-                              },
+                                  [](std::monostate b) -> pyAttrValue { return b; },
+                                  [](bool b) -> pyAttrValue { return b; },
+                                  [](double d) -> pyAttrValue { return d; },
+                                  [](const fwStr &s) -> pyAttrValue { return s; },
+                                  [](const strVecUPtr &fw_vec) -> pyAttrValue {
+                                      return *fw_vec | std::views::transform([](const fwStr &s) -> str { return s; }) |
+                                             std::ranges::to<strVec>();
+                                  },
                           },
                           src);
     }
 
     static AttributeValue convert_value(const pyAttrValue &src) {
         return std::visit(overloaded{
-                              [](std::monostate b) -> AttributeValue { return b; },
-                              [](bool b) -> AttributeValue { return b; },
-                              [](double d) -> AttributeValue { return d; },
-                              [](const str &s) -> AttributeValue { return fwStr{s}; },
-                              [](const strVec &vec) -> AttributeValue {
-                                  auto out = std::make_unique<std::vector<fwStr> >();
-                                  out->reserve(vec.size());
-                                  for (auto &r: vec) {
-                                      out->emplace_back(r);
-                                  }
-                                  out->shrink_to_fit();
-                                  return out;
-                              },
+                                  [](std::monostate b) -> AttributeValue { return b; },
+                                  [](bool b) -> AttributeValue { return b; },
+                                  [](double d) -> AttributeValue { return d; },
+                                  [](const str &s) -> AttributeValue { return fwStr{s}; },
+                                  [](const strVec &vec) -> AttributeValue {
+                                      auto out = std::make_unique<std::vector<fwStr>>();
+                                      out->reserve(vec.size());
+                                      for (auto &r: vec) {
+                                          out->emplace_back(r);
+                                      }
+                                      out->shrink_to_fit();
+                                      return out;
+                                  },
                           },
                           src);
     }
 
     static str to_string(const pyAttrValue &src) {
         return std::visit(overloaded{
-                              [](std::monostate) -> str { return "null"; },
-                              [](bool b) -> str { return b ? "true" : "false"; },
-                              [](double d) -> str { return std::to_string(d); },
-                              [](const str &s) -> str { return s; },
-
-                              [](const strVec &vecptr) -> str {
-                                  str out = "[";
-
-                                  for (auto &r: vecptr) {
-                                      out.append(r);
-                                      out.append(",");
-                                  }
-                                  out.append("]");
-                                  return out;
-                              },
+                                  [](std::monostate) -> str { return "null"; },
+                                  [](bool b) -> str { return b ? "true" : "false"; },
+                                  [](double d) -> str { return std::to_string(d); },
+                                  [](const str &s) -> str { return s; },
+
+                                  [](const strVec &vecptr) -> str {
+                                      str out = "[";
+
+                                      for (auto &r: vecptr) {
+                                          out.append(r);
+                                          out.append(",");
+                                      }
+                                      out.append("]");
+                                      return out;
+                                  },
                           },
                           src);
     }
@@ -295,7 +296,7 @@ public:
         increaseIteratorVersion();
     }
 
-    std::vector<pyAttrValue> get(const str &id, const strVec &attributes) {
+    std::vector<pyAttrValue> get_one(const str &id, const strVec &attributes) {
         if (attributes.empty()) {
             return {};
         }
@@ -311,41 +312,49 @@ public:
                            return {};
                        return convert_value(*attr_value);
                    }) |
-                   std::ranges::to<std::vector<pyAttrValue> >();
+                   std::ranges::to<std::vector<pyAttrValue>>();
         }
         return {};
     }
 
-
-    struct getAllResponse {
+    struct getManyResponse {
         uint64_t iterator_version{};
         uint64_t iterator{};
-        std::vector<std::pair<str, std::vector<pyAttrValue> > > result{};
+        std::vector<std::pair<str, std::vector<pyAttrValue>>> result{};
     };
 
-    str get_all(const strVec &attributes, uint64_t per_iteration = 10000, uint64_t iterator_version = 0,
-                           uint64_t iterator = 0) {
+    str get_many(const strVec &ids, const strVec &attributes, uint64_t per_iteration = 10000,
+                 uint64_t iterator_version = 0, uint64_t iterator = 0) {
         if (transactionOpened)
-            throw std::runtime_error("Can't get all when transaction is opened");
+            throw std::runtime_error("Can't get many when transaction is opened");
         if (iterator && iterator_version == 0) {
             throw std::runtime_error("Invalid iterator version");
         }
         if (iterator && iterator_version != this->iterator_version)
             throw std::runtime_error("Iterator already invalidated");
-        getAllResponse resp{};
-        std::vector<str> keys = cache | std::views::keys | std::ranges::to<std::vector>();
+        getManyResponse resp{};
+        std::vector<str> keys;
+        if (ids.empty()) {
+            keys = cache | std::views::keys | std::ranges::to<std::vector>();
+            std::ranges::sort(keys);
+        } else {
+            absl::flat_hash_set<str> set_of_ids(ids.begin(), ids.end());
+            keys = cache | std::views::keys |
+                   std::views::filter([&](const auto &key) { return set_of_ids.contains(key); }) |
+                   std::ranges::to<std::vector>();
+        }
         std::ranges::sort(keys);
 
-        uint64_t start = iterator;
-        uint64_t available = keys.size() > start ? keys.size() - start : 0;
-        uint64_t to_take = std::min<uint64_t>(available, per_iteration);
+        const uint64_t start = iterator;
+        const uint64_t available = keys.size() > start ? keys.size() - start : 0;
+        const uint64_t to_take = std::min<uint64_t>(available, per_iteration);
 
         resp.result.reserve(to_take);
 
         auto i = iterator;
         while (i < iterator + per_iteration && i < keys.size()) {
             const auto &key = keys[i];
-            resp.result.emplace_back(key, get(key, attributes));
+            resp.result.emplace_back(key, get_one(key, attributes));
             i++;
         }
         resp.iterator_version = this->iterator_version;
@@ -354,7 +363,7 @@ public:
     }
 
 
-    void begin_transaction(uint64_t estimated_number_of_items = 0) {
+    void begin_transaction(uint64_t estimated_number_of_items = 0, bool remove_old_items = true) {
         if (transactionOpened) {
             throw std::runtime_error("Transaction already open");
         }
@@ -364,6 +373,7 @@ public:
         }
         oldCacheSize = cache.size();
         transactionOpened = true;
+        transactionShouldRemoveOldItems = remove_old_items;
     }
 
     void end_transaction() {
@@ -375,11 +385,16 @@ public:
                 it.value().isNew = false;
                 ++it;
             } else {
-                it = cache.erase(it);
+                if (transactionShouldRemoveOldItems) {
+                    it = cache.erase(it);
+                } else {
+                    ++it;
+                }
             }
         }
         increaseIteratorVersion();
         transactionOpened = false;
+        transactionShouldRemoveOldItems = true;
     }
 
     size_t load_page(const str &json_text) {
@@ -408,11 +423,12 @@ public:
     }
 
     tsl::sparse_map<str, MarkedItem> cache;
-    absl::flat_hash_map<str, uint8_t, absl::Hash<str> > attrMap;
+    absl::flat_hash_map<str, uint8_t, absl::Hash<str>> attrMap;
     strVec attrIdx;
     const uint8_t numberOfAttributes;
     size_t oldCacheSize = 0;
     bool transactionOpened = false;
+    bool transactionShouldRemoveOldItems = true;
     uint64_t iterator_version = 1; // for get_all()
 };
 
@@ -421,11 +437,13 @@ NB_MODULE(_small_cache_impl, m) {
     nb::class_<SmallCache> cache(m, "SmallCache");
     cache
             .def(nb::init<std::vector<std::string> >(), nb::arg("attribute_names"))
-            .def("begin_transaction", &SmallCache::begin_transaction, nb::arg("estimated_number_of_items") = 0)
+            .def("begin_transaction", &SmallCache::begin_transaction,
+                 nb::arg("estimated_number_of_items") = 0,
+                 nb::arg("remove_old_items") = true)
             .def("end_transaction", &SmallCache::end_transaction)
             .def("add", &SmallCache::add_item, nb::arg("item_id"), nb::arg("attributes"))
-            .def("get", &SmallCache::get, nb::arg("id"), nb::arg("attributes"))
-            .def("get_all", &SmallCache::get_all, nb::arg("attributes"), nb::arg("per_iteration") = 10000,
+            .def("get_one", &SmallCache::get_one, nb::arg("id"), nb::arg("attributes"))
+            .def("get_many", &SmallCache::get_many, nb::arg("ids"), nb::arg("attributes"), nb::arg("per_iteration") = 10000,
                  nb::arg("iterator_version") = 0,
                  nb::arg("iterator") = 0)
             .def("load_page", &SmallCache::load_page, nb::arg("json_text"));