small-cache 0.0.1__tar.gz

small_cache-0.0.1/.github/dependabot.yml

@@ -0,0 +1,11 @@
+version: 2
+updates:
+  # Maintain dependencies for GitHub Actions
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    groups:
+      actions:
+        patterns:
+          - "*"

small_cache-0.0.1/.github/workflows/pip.yml

@@ -0,0 +1,35 @@
+name: Pip
+
+on:
+  workflow_dispatch:
+
+jobs:
+  build:
+    name: Build with Pip
+    runs-on: ${{ matrix.platform }}
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [windows-latest, macos-latest, ubuntu-latest]
+        python-version: ["3.11", "3.12"]
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+
+    - name: Set min macOS version
+      if: runner.os == 'Linux'
+      run: |
+        echo "CC=clang" >> $GITHUB_ENV
+        echo "CXX=clang++" >> $GITHUB_ENV
+
+    - name: Build and install
+      run: |
+        python -m pip install pytest
+        pip install --verbose .
+
+    - name: Test
+      run: python -m pytest

small_cache-0.0.1/.github/workflows/wheels.yml

@@ -0,0 +1,72 @@
+name: Wheels
+
+on:
+  workflow_dispatch:
+  release:
+    types:
+      - published
+
+jobs:
+  build_sdist:
+    name: Build SDist
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        submodules: true
+
+    - name: Build SDist
+      run: pipx run build --sdist
+
+    - name: Check metadata
+      run: pipx run twine check dist/*
+
+    - uses: actions/upload-artifact@v4
+      with:
+        name: dist-sdist
+        path: dist/*.tar.gz
+
+
+  build_wheels:
+    name: Wheels on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        submodules: true
+
+    - uses: pypa/cibuildwheel@v3.0
+
+    - name: Verify clean directory
+      run: git diff --exit-code
+      shell: bash
+
+    - name: Upload wheels
+      uses: actions/upload-artifact@v4
+      with:
+        path: wheelhouse/*.whl
+        name: dist-${{ matrix.os }}
+
+  upload_all:
+    name: Upload if release
+    needs: [build_wheels, build_sdist]
+    runs-on: ubuntu-latest
+    if: github.event_name == 'release' && github.event.action == 'published'
+
+    steps:
+    - uses: actions/setup-python@v5
+    - uses: actions/download-artifact@v4
+      with:
+        path: dist
+        pattern: dist-*
+        merge-multiple: true
+
+    - uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        user: __token__
+        password: ${{ secrets.pypi_password }}

small_cache-0.0.1/.gitignore

@@ -0,0 +1,9 @@
+nanobind_test.egg-info
+_skbuild
+/dist
+__pycache__
+build
+*.pyd
+*.egg-info
+.vscode
+.vs

small_cache-0.0.1/CMakeLists.txt

@@ -0,0 +1,131 @@
+cmake_minimum_required(VERSION 3.15...3.26)
+
+project(small_cache LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 23)
+set(CXX_STANDARD_REQUIRED On)
+set(CMAKE_POLICY_DEFAULT_CMP0069 NEW)
+set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
+set(BUILD_SHARED_LIBS OFF)
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+if (NOT SKBUILD)
+    message(WARNING "\
+  This CMake file is meant to be executed using 'scikit-build'. Running
+  it directly will almost certainly not produce the desired result. If
+  you are a user trying to install this package, please use the command
+  below, which will install all necessary build dependencies, compile
+  the package in an isolated environment, and then install it.
+  =====================================================================
+   $ pip install .
+  =====================================================================
+  If you are a software developer, and this is your own package, then
+  it is usually much more efficient to install the build dependencies
+  in your environment once and use the following command that avoids
+  a costly creation of a new virtual environment at every compilation:
+  =====================================================================
+   $ pip install nanobind scikit-build-core[pyproject]
+   $ pip install --no-build-isolation -ve .
+  =====================================================================
+  You may optionally add -Ceditable.rebuild=true to auto-rebuild when
+  the package is imported. Otherwise, you need to re-run the above
+  after editing C++ files.")
+endif ()
+
+# Try to import all Python components potentially needed by nanobind
+find_package(Python 3.11
+        REQUIRED COMPONENTS Interpreter Development.Module
+        OPTIONAL_COMPONENTS Development.SABIModule)
+
+# Import nanobind through CMake's find_package mechanism
+find_package(nanobind CONFIG REQUIRED)
+
+# We are now ready to compile the actual extension module
+nanobind_add_module(
+        # Name of the extension
+        _small_cache_impl
+
+        # Target the stable ABI for Python 3.12+, which reduces
+        # the number of binary wheels that must be built. This
+        # does nothing on older Python versions
+        STABLE_ABI
+
+        # Build libnanobind statically and merge it into the
+        # extension (which itself remains a shared library)
+        #
+        # If your project builds multiple extensions, you can
+        # replace this flag by NB_SHARED to conserve space by
+        # reusing a shared libnanobind across libraries
+        NB_STATIC
+
+        # Source code goes here
+        src/small_cache.cpp
+)
+
+include(FetchContent)
+FetchContent_Declare(
+        glaze
+        GIT_REPOSITORY https://github.com/stephenberry/glaze.git
+        GIT_TAG main
+        GIT_SHALLOW TRUE
+)
+
+FetchContent_MakeAvailable(glaze)
+
+FetchContent_Declare(
+        tsl_sparse_map
+        GIT_REPOSITORY https://github.com/Tessil/sparse-map
+        GIT_TAG master
+        GIT_SHALLOW TRUE
+)
+FetchContent_MakeAvailable(tsl_sparse_map)
+
+FetchContent_Declare(
+        absl
+        GIT_REPOSITORY https://github.com/abseil/abseil-cpp.git
+        GIT_TAG master
+        GIT_SHALLOW TRUE
+        OVERRIDE_FIND_PACKAGE TRUE
+        EXCLUDE_FROM_ALL
+)
+
+find_package(
+        absl
+        REQUIRED
+        COMPONENTS flat_hash_map 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"
+        USES_TERMINAL_DOWNLOAD TRUE
+        GIT_PROGRESS TRUE
+        DOWNLOAD_NO_EXTRACT FALSE
+        OVERRIDE_FIND_PACKAGE TRUE
+        EXCLUDE_FROM_ALL
+)
+Set(FETCHCONTENT_QUIET TRUE)
+
+find_package(
+        Boost
+        1.88.0
+        EXACT # Minimum or EXACT version e.g. 1.86.0
+        REQUIRED # Fail with error if Boost is not found
+        COMPONENTS flyweight
+)
+
+target_link_libraries(
+        _small_cache_impl
+        PRIVATE
+        glaze::glaze
+        tsl::sparse_map
+        absl::flat_hash_map
+        absl::hash
+        Boost::flyweight
+)
+
+
+# Install directive for scikit-build-core
+install(TARGETS _small_cache_impl LIBRARY DESTINATION small_cache)

small_cache-0.0.1/PKG-INFO

@@ -0,0 +1,70 @@
+Metadata-Version: 2.1
+Name: small-cache
+Version: 0.0.1
+Summary: Small cache
+Author: kam1k4dze
+Classifier: License :: OSI Approved :: BSD License
+Project-URL: Homepage, https://github.com/kam1k4dze/small_cache
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+small_cache
+================
+
+|      CI              | status |
+|----------------------|--------|
+| pip builds           | [![Pip Action Status][actions-pip-badge]][actions-pip-link] |
+| wheels               | [![Wheel Action Status][actions-wheels-badge]][actions-wheels-link] |
+
+[actions-pip-link]:        https://github.com/wjakob/small_cache/actions?query=workflow%3APip
+[actions-pip-badge]:       https://github.com/wjakob/small_cache/workflows/Pip/badge.svg
+[actions-wheels-link]:     https://github.com/wjakob/small_cache/actions?query=workflow%3AWheels
+[actions-wheels-badge]:    https://github.com/wjakob/small_cache/workflows/Wheels/badge.svg
+
+
+This repository contains a tiny project showing how to create C++ bindings
+using [nanobind](https://github.com/wjakob/nanobind) and
+[scikit-build-core](https://scikit-build-core.readthedocs.io/en/latest/index.html). It
+was derived from the corresponding _pybind11_ [example
+project](https://github.com/pybind/scikit_build_example/) developed by
+[@henryiii](https://github.com/henryiii).
+
+Furthermore, the [bazel](https://github.com/wjakob/small_cache/tree/bazel) branch contains an example
+on how to build nanobind bindings extensions with Bazel using the [nanobind-bazel](https://github.com/nicholasjng/nanobind-bazel/) project.
+
+Installation
+------------
+
+1. Clone this repository
+2. Run `pip install ./small_cache`
+
+Afterwards, you should be able to issue the following commands (shown in an
+interactive Python session):
+
+```pycon
+>>> import small_cache
+>>> small_cache.add(1, 2)
+3
+```
+
+CI Examples
+-----------
+
+The `.github/workflows` directory contains two continuous integration workflows
+for GitHub Actions. The first one (`pip`) runs automatically after each commit
+and ensures that packages can be built successfully and that tests pass.
+
+The `wheels` workflow uses
+[cibuildwheel](https://cibuildwheel.readthedocs.io/en/stable/) to automatically
+produce binary wheels for a large variety of platforms. If a `pypi_password`
+token is provided using GitHub Action's _secrets_ feature, this workflow can
+even automatically upload packages on PyPI.
+
+
+License
+-------
+
+_nanobind_ and this example repository are both provided under a BSD-style
+license that can be found in the [LICENSE](./LICENSE) file. By using,
+distributing, or contributing to this project, you agree to the terms and
+conditions of this license.

small_cache-0.0.1/README.md

@@ -0,0 +1,60 @@
+small_cache
+================
+
+|      CI              | status |
+|----------------------|--------|
+| pip builds           | [![Pip Action Status][actions-pip-badge]][actions-pip-link] |
+| wheels               | [![Wheel Action Status][actions-wheels-badge]][actions-wheels-link] |
+
+[actions-pip-link]:        https://github.com/wjakob/small_cache/actions?query=workflow%3APip
+[actions-pip-badge]:       https://github.com/wjakob/small_cache/workflows/Pip/badge.svg
+[actions-wheels-link]:     https://github.com/wjakob/small_cache/actions?query=workflow%3AWheels
+[actions-wheels-badge]:    https://github.com/wjakob/small_cache/workflows/Wheels/badge.svg
+
+
+This repository contains a tiny project showing how to create C++ bindings
+using [nanobind](https://github.com/wjakob/nanobind) and
+[scikit-build-core](https://scikit-build-core.readthedocs.io/en/latest/index.html). It
+was derived from the corresponding _pybind11_ [example
+project](https://github.com/pybind/scikit_build_example/) developed by
+[@henryiii](https://github.com/henryiii).
+
+Furthermore, the [bazel](https://github.com/wjakob/small_cache/tree/bazel) branch contains an example
+on how to build nanobind bindings extensions with Bazel using the [nanobind-bazel](https://github.com/nicholasjng/nanobind-bazel/) project.
+
+Installation
+------------
+
+1. Clone this repository
+2. Run `pip install ./small_cache`
+
+Afterwards, you should be able to issue the following commands (shown in an
+interactive Python session):
+
+```pycon
+>>> import small_cache
+>>> small_cache.add(1, 2)
+3
+```
+
+CI Examples
+-----------
+
+The `.github/workflows` directory contains two continuous integration workflows
+for GitHub Actions. The first one (`pip`) runs automatically after each commit
+and ensures that packages can be built successfully and that tests pass.
+
+The `wheels` workflow uses
+[cibuildwheel](https://cibuildwheel.readthedocs.io/en/stable/) to automatically
+produce binary wheels for a large variety of platforms. If a `pypi_password`
+token is provided using GitHub Action's _secrets_ feature, this workflow can
+even automatically upload packages on PyPI.
+
+
+License
+-------
+
+_nanobind_ and this example repository are both provided under a BSD-style
+license that can be found in the [LICENSE](./LICENSE) file. By using,
+distributing, or contributing to this project, you agree to the terms and
+conditions of this license.

small_cache-0.0.1/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["scikit-build-core >=0.10", "nanobind >=1.3.2"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "small-cache"
+version = "0.0.1"
+description = "Small cache"
+readme = "README.md"
+requires-python = ">=3.11"
+authors = [
+    { name = "kam1k4dze"},
+]
+classifiers = [
+    "License :: OSI Approved :: BSD License",
+]
+
+[project.urls]
+Homepage = "https://github.com/kam1k4dze/small_cache"
+
+
+[tool.scikit-build]
+# Protect the configuration against future changes in scikit-build-core
+minimum-version = "build-system.requires"
+
+# Setuptools-style build caching in a local directory
+build-dir = "build/{wheel_tag}"
+
+# Build stable ABI wheels for CPython 3.12+
+wheel.py-api = "cp312"
+
+[tool.cibuildwheel]
+# Necessary to see build output from the actual compilation
+build-verbosity = 1
+
+archs = ["auto64"]
+
+# Run pytest to ensure that the package was correctly built
+test-command = "pytest {project}/tests"
+test-requires = "pytest"
+
+# Needed for full C++17 support
+[tool.cibuildwheel.macos.environment]
+MACOSX_DEPLOYMENT_TARGET = "10.14"

small_cache-0.0.1/src/small_cache/__init__.py

@@ -0,0 +1 @@
+from ._small_cache_impl import SmallCache, __doc__

small_cache-0.0.1/src/small_cache.cpp

@@ -0,0 +1,437 @@
+#include <nanobind/nanobind.h>
+#include <nanobind/stl/variant.h>
+#include <nanobind/stl/string.h>
+#include <nanobind/stl/vector.h>
+#include <nanobind/stl/pair.h>
+#include <nanobind/stl/optional.h>
+#include <nanobind/stl/unordered_map.h>
+#include <tsl/sparse_map.h>
+#include <absl/hash/hash.h>
+#include <absl/container/flat_hash_map.h>
+#include <boost/flyweight.hpp>
+#include <optional>
+#include <algorithm>
+#include <variant>
+#include <vector>
+#include <string>
+#include <glaze/glaze.hpp>
+
+namespace json {
+    using AttributeValue = std::variant<bool, double, std::string,
+        std::vector<glz::raw_json>,
+        std::optional<glz::raw_json> >;
+
+    struct Attribute {
+        std::string id{};
+        AttributeValue value{};
+    };
+
+    struct Item {
+        std::string id{};
+        std::vector<Attribute> attributes{};
+    };
+
+    struct Pagination {
+        int page{};
+        int pages{};
+    };
+
+    struct Result {
+        int count{};
+        Pagination pagination{};
+        std::vector<Item> data{};
+    };
+
+    struct Response {
+        Result result{};
+    };
+}
+
+
+namespace nb = nanobind;
+using namespace nb::literals;
+
+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 AttributeValue = std::variant<std::monostate, double, bool, fwStr, strVecUPtr>;
+    using pyAttrValue = std::variant<std::monostate, bool, double, str, strVec>;
+
+public:
+    explicit SmallCache(const strVec &attributes) : numberOfAttributes(attributes.size()) {
+        if (attributes.empty()) {
+            throw std::runtime_error("No attributes provided");
+        }
+        if (attributes.size() > 255) {
+            throw std::runtime_error("Too many attributes provided");
+        }
+        attrMap.reserve(attributes.size());
+        attrIdx.reserve(attributes.size());
+        for (size_t idx = 0; idx < attributes.size(); ++idx) {
+            const auto &attr = attributes[idx];
+            attrIdx.emplace_back(attr);
+            attrMap.emplace(attr, idx);
+        }
+    }
+
+    SmallCache(const SmallCache &) = delete;
+
+    SmallCache &operator=(const SmallCache &) = delete;
+
+    struct MarkedItem {
+        bool isNew = true;
+        std::array<uint32_t, 3> attrs_flags{}; // 96 bits total
+        std::vector<AttributeValue> value;
+
+        [[nodiscard]] std::vector<size_t> getIdxs() const {
+            std::vector<size_t> idxs;
+            idxs.reserve(value.size());
+
+            for (size_t w = 0; w < attrs_flags.size(); ++w) {
+                uint32_t bits = attrs_flags[w];
+                while (bits) {
+                    unsigned b = std::countr_zero(bits);
+                    idxs.push_back(w * 32 + b);
+                    bits &= bits - 1; // clear that bit
+                }
+            }
+            return idxs;
+        }
+
+        [[nodiscard]] constexpr bool hasIdx(size_t idx) const noexcept {
+            if (idx >= attrs_flags.size() * 32)
+                return false; // out of range
+            auto w = idx / 32;
+            auto b = idx % 32;
+            return (attrs_flags[w] >> b) & 1u;
+        }
+
+        [[nodiscard]] std::optional<std::reference_wrapper<AttributeValue> > getValue(size_t idx) noexcept {
+            if (!hasIdx(idx))
+                return std::nullopt;
+
+            // count how many bits are set before 'idx'
+            size_t w = idx / 32, b = idx % 32;
+            size_t pos = 0;
+
+            // sum full words
+            for (size_t i = 0; i < w; ++i) {
+                pos += std::popcount(attrs_flags[i]);
+            }
+            // sum lower bits in the same word
+            if (b > 0) {
+                uint32_t mask = (1u << b) - 1;
+                pos += std::popcount(attrs_flags[w] & mask);
+            }
+
+            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 {
+            if (auto ref = const_cast<MarkedItem *>(this)->getValue(idx))
+                return std::cref(ref->get());
+            return std::nullopt;
+        }
+    };
+
+    void setMarkedItem(MarkedItem &item, const std::unordered_map<str, pyAttrValue> &attrs) {
+        item.isNew = true;
+        item.attrs_flags.fill(0);
+
+        // build a slot for each possible attr index
+        std::vector<std::optional<AttributeValue> > slots(attrMap.size());
+
+        // 1) collect into slots[] by index
+        for (auto &[name, pyVal]: attrs) {
+            if (auto it = attrMap.find(name); it != attrMap.end()) {
+                slots[it->second] = convert_value(pyVal);
+            }
+        }
+
+        // 2) reserve exactly as many as we’ll push
+        auto count = std::ranges::count_if(slots, [](auto &o) { return o.has_value(); });
+        item.value.clear();
+        item.value.reserve(count);
+
+        // 3) walk slots in ascending idx order,
+        //    set flags and move values into item.value
+        for (size_t idx = 0; idx < slots.size(); ++idx) {
+            if (auto &opt = slots[idx]; opt) {
+                item.value.push_back(std::move(*opt));
+                auto w = idx / 32;
+                auto b = idx % 32;
+                item.attrs_flags[w] |= (1u << b);
+            }
+        }
+    }
+
+
+    struct getItemResponse {
+        std::vector<pyAttrValue> attribute_values;
+        std::vector<pyAttrValue> attribute_names;
+    };
+
+
+    template<class... Ts>
+    struct overloaded : Ts... {
+        using Ts::operator()...;
+    };
+
+    template<class... Ts>
+    overloaded(Ts...) -> overloaded<Ts...>;
+
+    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};
+                              },
+
+                          },
+                          src);
+    }
+
+
+    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 : ""; },
+
+                          },
+                          src);
+    }
+
+    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>();
+                              },
+                          },
+                          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;
+                              },
+                          },
+                          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;
+                              },
+                          },
+                          src);
+    }
+
+    void add_item(const str &item_id, const std::unordered_map<str, pyAttrValue> &attributes) {
+        if (!transactionOpened) {
+            throw std::runtime_error("Transaction not opened");
+        }
+        auto &marked_attrs = cache[item_id];
+        setMarkedItem(marked_attrs, attributes);
+        increaseIteratorVersion();
+    }
+
+    std::vector<pyAttrValue> get(const str &id, const strVec &attributes) {
+        if (attributes.empty()) {
+            return {};
+        }
+        if (cache.contains(id)) {
+            const auto &item = cache.at(id);
+            return attributes | std::views::transform([this, &item](const auto &attr_name) -> pyAttrValue {
+                       if (!attrMap.contains(attr_name))
+                           // throw std::runtime_error("Attribute " + attr_name + " does not exist in cache");
+                           return {};
+                       const auto attr_idx = attrMap.at(attr_name);
+                       const auto attr_value = item.getValue(attr_idx);
+                       if (!attr_value)
+                           return {};
+                       return convert_value(*attr_value);
+                   }) |
+                   std::ranges::to<std::vector<pyAttrValue> >();
+        }
+        return {};
+    }
+
+
+    struct getAllResponse {
+        uint64_t iterator_version{};
+        uint64_t iterator{};
+        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) {
+        if (transactionOpened)
+            throw std::runtime_error("Can't get all 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>();
+        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);
+
+        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));
+            i++;
+        }
+        resp.iterator_version = this->iterator_version;
+        resp.iterator = i < keys.size() ? i : 0;
+        return glz::write_json(resp).value_or("error"); // TODO don't use json
+    }
+
+
+    void begin_transaction(uint64_t estimated_number_of_items = 0) {
+        if (transactionOpened) {
+            throw std::runtime_error("Transaction already open");
+        }
+        if (estimated_number_of_items != 0) {
+            cache.reserve(estimated_number_of_items);
+            increaseIteratorVersion();
+        }
+        oldCacheSize = cache.size();
+        transactionOpened = true;
+    }
+
+    void end_transaction() {
+        if (!transactionOpened) {
+            throw std::runtime_error("Transaction not opened");
+        }
+        for (auto it = cache.begin(); it != cache.end();) {
+            if (it->second.isNew) {
+                it.value().isNew = false;
+                ++it;
+            } else {
+                it = cache.erase(it);
+            }
+        }
+        increaseIteratorVersion();
+        transactionOpened = false;
+    }
+
+    size_t load_page(const str &json_text) {
+        if (!transactionOpened) {
+            throw std::runtime_error("Transaction not opened");
+        }
+        json::Response resp;
+        if (auto ce = glz::read<glz::opts{.error_on_unknown_keys = false}>(resp, json_text))
+            throw std::runtime_error(glz::format_error(ce, json_text));
+        cache.reserve(resp.result.count);
+        for (auto &item: resp.result.data) {
+            auto &marked_item = cache[item.id];
+            std::unordered_map<str, pyAttrValue> attrs;
+            for (auto &attr: item.attributes)
+                attrs[attr.id] = convert_valueJ(attr.value);
+
+            setMarkedItem(marked_item, attrs);
+        }
+        increaseIteratorVersion();
+        return resp.result.pagination.pages;
+    }
+
+    void increaseIteratorVersion() {
+        iterator_version++;
+        iterator_version++;
+    }
+
+    tsl::sparse_map<str, MarkedItem> cache;
+    absl::flat_hash_map<str, uint8_t, absl::Hash<str> > attrMap;
+    strVec attrIdx;
+    const uint8_t numberOfAttributes;
+    size_t oldCacheSize = 0;
+    bool transactionOpened = false;
+    uint64_t iterator_version = 1; // for get_all()
+};
+
+
+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("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,
+                 nb::arg("iterator_version") = 0,
+                 nb::arg("iterator") = 0)
+            .def("load_page", &SmallCache::load_page, nb::arg("json_text"));
+    // nb::class_<SmallCache::getAllResponse>(cache, "getAllResponse")
+    //         .def(nb::init<>())
+    //         .def_rw("iterator_version", &SmallCache::getAllResponse::iterator_version)
+    //         .def_rw("iterator", &SmallCache::getAllResponse::iterator)
+    //         .def_rw("result", &SmallCache::getAllResponse::result);
+}

small_cache-0.0.1/tests/test_basic.py

@@ -0,0 +1,5 @@
+import small_cache as m
+
+def test_create():
+    m.SmallCache(["test1","2"])
+