pyrex-rocksdb 0.1.4__cp38-cp38-musllinux_1_2_x86_64.whl

pyrex/__init__.py

@@ -0,0 +1,23 @@
+# This makes functions and classes like `PyRocksDB` directly available as `pyrex.PyRocksDB`
+from ._pyrex import *
+
+# Version information (highly recommended)
+try:
+    from importlib.metadata import version, PackageNotFoundError
+except ImportError:  # Python < 3.8
+    from importlib_metadata import version, PackageNotFoundError # pip install importlib_metadata for older Pythons
+
+try:
+    __version__ = version("pyrex-rocksdb") # Use the 'name' from pyproject.toml
+except PackageNotFoundError:
+    # Package is not installed (e.g., running tests in dev mode without editable install)
+    __version__ = "unknown"
+
+
+# Package Docstring 
+"""
+A fast RocksDB wrapper for Python using pybind11.
+
+This package provides high-performance bindings to the RocksDB key-value store,
+allowing seamless interaction from Python applications.
+"""

pyrex/_pyrex.cpp

@@ -0,0 +1,752 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include <memory>
+#include <vector>
+#include <map>
+#include <set>
+#include <string>
+#include <mutex>
+#include <atomic>
+#include <iostream>
+
+#include "rocksdb/db.h"
+#include "rocksdb/options.h"
+#include "rocksdb/status.h"
+#include "rocksdb/slice.h"
+#include "rocksdb/table.h"
+#include "rocksdb/filter_policy.h"
+#include "rocksdb/write_batch.h"
+#include "rocksdb/iterator.h"
+
+namespace py = pybind11;
+
+// --- Custom Exception ---
+class RocksDBException : public std::runtime_error {
+public:
+    explicit RocksDBException(const std::string& msg) : std::runtime_error(msg) {}
+};
+
+// --- Forward Declarations ---
+class PyRocksDB;
+
+// --- PyReadOptions Wrapper ---
+class PyReadOptions {
+public:
+    rocksdb::ReadOptions options_;
+
+    PyReadOptions() = default;
+
+    // Expose properties to Python
+    bool get_fill_cache() const { return options_.fill_cache; }
+    void set_fill_cache(bool value) { options_.fill_cache = value; }
+
+    bool get_verify_checksums() const { return options_.verify_checksums; }
+    void set_verify_checksums(bool value) { options_.verify_checksums = value; }
+};
+
+// --- PyWriteOptions Wrapper ---
+class PyWriteOptions {
+public:
+    rocksdb::WriteOptions options_;
+
+    PyWriteOptions() = default;
+
+    // Expose properties to Python
+    bool get_sync() const { return options_.sync; }
+    void set_sync(bool value) { options_.sync = value; }
+
+    bool get_disable_wal() const { return options_.disableWAL; }
+    void set_disable_wal(bool value) { options_.disableWAL = value; }
+};
+
+
+// --- PyOptions Wrapper ---
+class PyOptions {
+public:
+    rocksdb::Options options_;
+    rocksdb::ColumnFamilyOptions cf_options_;
+
+    PyOptions() {
+        options_.compression = rocksdb::kSnappyCompression;
+        cf_options_.compression = rocksdb::kSnappyCompression;
+    }
+    bool get_create_if_missing() const { return options_.create_if_missing; }
+    void set_create_if_missing(bool value) { options_.create_if_missing = value; }
+    bool get_error_if_exists() const { return options_.error_if_exists; }
+    void set_error_if_exists(bool value) { options_.error_if_exists = value; }
+    int get_max_open_files() const { return options_.max_open_files; }
+    void set_max_open_files(int value) { options_.max_open_files = value; }
+    size_t get_write_buffer_size() const { return options_.write_buffer_size; }
+    void set_write_buffer_size(size_t value) { options_.write_buffer_size = value; }
+    rocksdb::CompressionType get_compression() const { return options_.compression; }
+    void set_compression(rocksdb::CompressionType value) { options_.compression = value; }
+    int get_max_background_jobs() const { return options_.max_background_jobs; }
+    void set_max_background_jobs(int value) { options_.max_background_jobs = value; }
+    void increase_parallelism(int total_threads) { options_.IncreaseParallelism(total_threads); }
+    void optimize_for_small_db() { options_.OptimizeForSmallDb(); }
+    void use_block_based_bloom_filter(double bits_per_key = 10.0) {
+        rocksdb::BlockBasedTableOptions table_options;
+        table_options.filter_policy.reset(rocksdb::NewBloomFilterPolicy(bits_per_key));
+        options_.table_factory.reset(rocksdb::NewBlockBasedTableFactory(table_options));
+        cf_options_.table_factory.reset(rocksdb::NewBlockBasedTableFactory(table_options));
+    }
+    size_t get_cf_write_buffer_size() const { return cf_options_.write_buffer_size; }
+    void set_cf_write_buffer_size(size_t value) { cf_options_.write_buffer_size = value; }
+    rocksdb::CompressionType get_cf_compression() const { return cf_options_.compression; }
+    void set_cf_compression(rocksdb::CompressionType value) { cf_options_.compression = value; }
+};
+
+// --- PyColumnFamilyHandle Wrapper ---
+class PyColumnFamilyHandle {
+public:
+    rocksdb::ColumnFamilyHandle* cf_handle_;
+    std::string name_;
+
+    PyColumnFamilyHandle(rocksdb::ColumnFamilyHandle* handle, const std::string& name)
+        : cf_handle_(handle), name_(name) {
+        if (!cf_handle_) {
+            throw RocksDBException("Invalid ColumnFamilyHandle received.");
+        }
+    }
+    const std::string& get_name() const { return name_; }
+    bool is_valid() const { return cf_handle_ != nullptr; }
+};
+
+// --- PyWriteBatch Wrapper ---
+class PyWriteBatch {
+public:
+    rocksdb::WriteBatch wb_;
+    PyWriteBatch() = default;
+    void put(const py::bytes& key, const py::bytes& value) { wb_.Put(static_cast<std::string>(key), static_cast<std::string>(value)); }
+    void put_cf(PyColumnFamilyHandle& cf, const py::bytes& key, const py::bytes& value) {
+        if (!cf.is_valid()) throw RocksDBException("ColumnFamilyHandle is invalid.");
+        rocksdb::Slice key_slice(static_cast<std::string_view>(key));
+        rocksdb::Slice value_slice(static_cast<std::string_view>(value));
+        wb_.Put(cf.cf_handle_, key_slice, value_slice);
+    }
+    void del(const py::bytes& key) { 
+        rocksdb::Slice key_slice(static_cast<std::string_view>(key));
+        wb_.Delete(key_slice); 
+    }
+    void del_cf(PyColumnFamilyHandle& cf, const py::bytes& key) {
+        if (!cf.is_valid()) throw RocksDBException("ColumnFamilyHandle is invalid.");
+        rocksdb::Slice key_slice(static_cast<std::string_view>(key));
+        wb_.Delete(cf.cf_handle_, key_slice);
+    }
+    void merge(const py::bytes& key, const py::bytes& value) { 
+        rocksdb::Slice key_slice(static_cast<std::string_view>(key));
+        rocksdb::Slice value_slice(static_cast<std::string_view>(value));
+        wb_.Merge(key_slice, value_slice); 
+    }
+    void merge_cf(PyColumnFamilyHandle& cf, const py::bytes& key, const py::bytes& value) {
+        if (!cf.is_valid()) throw RocksDBException("ColumnFamilyHandle is invalid.");
+        rocksdb::Slice key_slice(static_cast<std::string_view>(key));
+        rocksdb::Slice value_slice(static_cast<std::string_view>(value));
+        wb_.Merge(cf.cf_handle_, key_slice, value_slice);
+    }
+    void clear() { wb_.Clear(); }
+};
+
+// --- PyRocksDBIterator Class Declaration ---
+class PyRocksDBIterator {
+private:
+    rocksdb::Iterator* it_raw_ptr_;
+    std::shared_ptr<PyRocksDB> parent_db_ptr_;
+    void check_parent_db_is_open() const;
+
+public:
+    explicit PyRocksDBIterator(rocksdb::Iterator* it, std::shared_ptr<PyRocksDB> parent_db);
+    ~PyRocksDBIterator();
+    bool valid();
+    void seek_to_first();
+    void seek_to_last();
+    void seek(const py::bytes& key);
+    void next();
+    void prev();
+    py::object key();
+    py::object value();
+    void check_status();
+};
+
+// --- PyRocksDB Class (Base) ---
+class PyRocksDB : public std::enable_shared_from_this<PyRocksDB> {
+protected:
+    rocksdb::DB* db_ = nullptr;
+    rocksdb::ColumnFamilyHandle* default_cf_handle_ = nullptr;
+    PyOptions opened_options_;
+    std::string path_;
+    std::map<std::string, std::shared_ptr<PyColumnFamilyHandle>> cf_handles_;
+    std::atomic<bool> is_closed_{false};
+    std::atomic<bool> is_read_only_{false};
+    std::mutex active_iterators_mutex_;
+    std::set<rocksdb::Iterator*> active_rocksdb_iterators_;
+
+    // Default options for read/write operations
+    std::shared_ptr<PyReadOptions> default_read_options_;
+    std::shared_ptr<PyWriteOptions> default_write_options_;
+
+
+    friend class PyRocksDBIterator;
+
+    void check_db_open() const {
+        if (is_closed_ || db_ == nullptr) {
+            throw RocksDBException("Database is not open or has been closed.");
+        }
+    }
+
+    void check_read_only() const {
+        if (is_read_only_.load()) {
+            throw RocksDBException("Cannot perform put/write/delete operation: Database opened in read-only mode.");
+        }
+    }
+
+    rocksdb::ColumnFamilyHandle* get_default_cf_handle() const {
+        auto it = cf_handles_.find(rocksdb::kDefaultColumnFamilyName);
+        if (it == cf_handles_.end() || !it->second->is_valid()) {
+            throw RocksDBException("Default column family handle is not available.");
+        }
+        return it->second->cf_handle_;
+    }
+
+public:
+    // Default constructor for inheritance
+    PyRocksDB() 
+        : default_read_options_(std::make_shared<PyReadOptions>()),
+          default_write_options_(std::make_shared<PyWriteOptions>())
+    {}
+
+    // Public constructor for the simple interface
+    PyRocksDB(const std::string& path, PyOptions* py_options,  bool read_only = false) 
+        : default_read_options_(std::make_shared<PyReadOptions>()),
+          default_write_options_(std::make_shared<PyWriteOptions>())
+    {
+        this->path_ = path;
+        this->is_read_only_.store(read_only);
+        rocksdb::Options options;
+        if (py_options) {
+            options = py_options->options_;
+            this->opened_options_ = *py_options;
+        } else {
+            options.create_if_missing = true;
+            this->opened_options_.options_ = options;
+        }
+
+        rocksdb::Status s;
+        if (read_only) { 
+            s = rocksdb::DB::OpenForReadOnly(options, path, &this->db_);
+        } else {
+            s = rocksdb::DB::Open(options, path, &this->db_);
+        }
+        if (!s.ok()) {
+            throw RocksDBException("Failed to open RocksDB at " + path + ": " + s.ToString());
+        }
+        this->default_cf_handle_ = this->db_->DefaultColumnFamily();
+        this->cf_handles_[rocksdb::kDefaultColumnFamilyName] = std::make_shared<PyColumnFamilyHandle>(this->default_cf_handle_, rocksdb::kDefaultColumnFamilyName);
+    }
+
+    virtual ~PyRocksDB() {
+        close();
+    }
+
+    void close() {
+        if (!is_closed_.exchange(true)) {
+            {
+                std::lock_guard<std::mutex> lock(active_iterators_mutex_);
+                for (rocksdb::Iterator* iter_raw_ptr : active_rocksdb_iterators_) {
+                    delete iter_raw_ptr;
+                }
+                active_rocksdb_iterators_.clear();
+            }
+            for (auto const& [name, handle_ptr] : cf_handles_) {
+                handle_ptr->cf_handle_ = nullptr; 
+            }
+            cf_handles_.clear();
+            if (db_) {
+                delete db_;
+                db_ = nullptr;
+            }
+        }
+    }
+
+    void put(const py::bytes& key, const py::bytes& value, std::shared_ptr<PyWriteOptions> write_options = nullptr) {
+        check_db_open();
+        check_read_only(); 
+        
+        rocksdb::Slice key_slice(static_cast<std::string_view>(key));
+        rocksdb::Slice value_slice(static_cast<std::string_view>(value));
+        
+        const auto& opts = write_options ? write_options->options_ : default_write_options_->options_;
+        rocksdb::Status s = db_->Put(opts, default_cf_handle_, key_slice, value_slice);
+        if (!s.ok()) throw RocksDBException("Put failed: " + s.ToString());
+    }    
+
+    py::object get(const py::bytes& key, std::shared_ptr<PyReadOptions> read_options = nullptr) {
+        check_db_open();
+        std::string value_str;
+        rocksdb::Status s;
+        
+        const auto& opts = read_options ? read_options->options_ : default_read_options_->options_;
+
+        {
+            py::gil_scoped_release release;
+            rocksdb::Slice key_slice(static_cast<std::string_view>(key));
+            s = db_->Get(opts, default_cf_handle_, key_slice, &value_str);
+        }
+        if (s.ok()) return py::bytes(value_str);
+        if (s.IsNotFound()) return py::none();
+        throw RocksDBException("Get failed: " + s.ToString());
+    }
+
+    void del(const py::bytes& key, std::shared_ptr<PyWriteOptions> write_options = nullptr) {
+        check_db_open();
+        check_read_only();
+        rocksdb::Slice key_slice(static_cast<std::string_view>(key));
+        const auto& opts = write_options ? write_options->options_ : default_write_options_->options_;
+        rocksdb::Status s = db_->Delete(opts, default_cf_handle_, key_slice);
+        if (!s.ok()) throw RocksDBException("Delete failed: " + s.ToString());
+    }
+
+    void write(PyWriteBatch& batch, std::shared_ptr<PyWriteOptions> write_options = nullptr) {
+        check_db_open();
+        check_read_only();
+        const auto& opts = write_options ? write_options->options_ : default_write_options_->options_;
+        rocksdb::Status s = db_->Write(opts, &batch.wb_);
+        if (!s.ok()) throw RocksDBException("Write failed: " + s.ToString());
+    }
+
+    std::shared_ptr<PyRocksDBIterator> new_iterator(std::shared_ptr<PyReadOptions> read_options = nullptr) {
+        check_db_open();
+        const auto& opts = read_options ? read_options->options_ : default_read_options_->options_;
+        rocksdb::Iterator* raw_iter = db_->NewIterator(opts, default_cf_handle_);
+        {
+            std::lock_guard<std::mutex> lock(active_iterators_mutex_);
+            active_rocksdb_iterators_.insert(raw_iter);
+        }
+        return std::make_shared<PyRocksDBIterator>(raw_iter, shared_from_this());
+    }
+
+    PyOptions get_options() const { return opened_options_; }
+
+    // Getters and setters for default options
+    std::shared_ptr<PyReadOptions> get_default_read_options() { return default_read_options_; }
+    void set_default_read_options(std::shared_ptr<PyReadOptions> opts) {
+        if (!opts) throw RocksDBException("ReadOptions cannot be None.");
+        default_read_options_ = opts;
+    }
+
+    std::shared_ptr<PyWriteOptions> get_default_write_options() { return default_write_options_; }
+    void set_default_write_options(std::shared_ptr<PyWriteOptions> opts) {
+        if (!opts) throw RocksDBException("WriteOptions cannot be None.");
+        default_write_options_ = opts;
+    }
+};
+
+// --- PyRocksDBExtended Class (Derived) ---
+class PyRocksDBExtended : public PyRocksDB {
+public:
+    // Constructor for the extended interface with CF support
+    PyRocksDBExtended(const std::string& path, PyOptions* py_options, bool read_only = false) {
+        this->path_ = path;
+        this->is_read_only_ = read_only; 
+        rocksdb::Options options;
+        if (py_options) {
+            options = py_options->options_;
+            this->opened_options_ = *py_options;
+        } else {
+            options.create_if_missing = true;
+            this->opened_options_.options_ = options;
+            this->opened_options_.cf_options_.compression = rocksdb::kSnappyCompression;
+        }
+
+        std::vector<std::string> cf_names;
+        rocksdb::Status s = rocksdb::DB::ListColumnFamilies(options, path, &cf_names);
+
+        std::vector<rocksdb::ColumnFamilyDescriptor> cf_descriptors;
+        if (s.IsNotFound() || s.IsIOError()) {
+            if (options.create_if_missing) {
+                cf_descriptors.push_back(rocksdb::ColumnFamilyDescriptor(rocksdb::kDefaultColumnFamilyName, this->opened_options_.cf_options_));
+            } else {
+                throw RocksDBException("Database not found at " + path + " and create_if_missing is false.");
+            }
+        } else if (s.ok()) {
+            for (const auto& name : cf_names) {
+                cf_descriptors.push_back(rocksdb::ColumnFamilyDescriptor(name, this->opened_options_.cf_options_));
+            }
+        } else {
+            throw RocksDBException("Failed to list column families at " + path + ": " + s.ToString());
+        }
+
+        std::vector<rocksdb::ColumnFamilyHandle*> handles;
+        rocksdb::Status s_open;
+
+        if (read_only) { 
+            s_open = rocksdb::DB::OpenForReadOnly(options, path, cf_descriptors, &handles, &this->db_);
+        } else {
+            s_open = rocksdb::DB::Open(options, path, cf_descriptors, &handles, &this->db_);
+        }
+        
+        if (!s_open.ok()) {
+            throw RocksDBException("Failed to open RocksDB at " + path + ": " + s.ToString());
+        }
+
+        for (size_t i = 0; i < handles.size(); ++i) {
+            const std::string& cf_name = cf_descriptors[i].name;
+            this->cf_handles_[cf_name] = std::make_shared<PyColumnFamilyHandle>(handles[i], cf_name);
+            
+            if (cf_name == rocksdb::kDefaultColumnFamilyName) {
+                this->default_cf_handle_ = handles[i];
+            }
+        }
+        
+        if (!this->default_cf_handle_) {
+            throw RocksDBException("Default column family not found after opening.");
+        }
+    }
+
+    void put_cf(PyColumnFamilyHandle& cf, const py::bytes& key, const py::bytes& value, std::shared_ptr<PyWriteOptions> write_options = nullptr) {
+        check_db_open();
+        check_read_only();
+        if (!cf.is_valid()) throw RocksDBException("ColumnFamilyHandle is invalid.");
+        rocksdb::Slice key_slice(static_cast<std::string_view>(key));
+        rocksdb::Slice value_slice(static_cast<std::string_view>(value));
+        const auto& opts = write_options ? write_options->options_ : default_write_options_->options_;
+        rocksdb::Status s = db_->Put(opts, cf.cf_handle_, key_slice, value_slice);
+        if (!s.ok()) throw RocksDBException("put_cf failed: " + s.ToString());
+    }
+
+    py::object get_cf(PyColumnFamilyHandle& cf, const py::bytes& key, std::shared_ptr<PyReadOptions> read_options = nullptr) {
+        check_db_open();
+        if (!cf.is_valid()) throw RocksDBException("ColumnFamilyHandle is invalid.");
+        rocksdb::Slice key_slice(static_cast<std::string_view>(key));
+        std::string value_str;
+        const auto& opts = read_options ? read_options->options_ : default_read_options_->options_;
+        rocksdb::Status s = db_->Get(opts, cf.cf_handle_, key_slice, &value_str);
+        if (s.ok()) return py::bytes(value_str);
+        if (s.IsNotFound()) return py::none();
+        throw RocksDBException("get_cf failed: " + s.ToString());
+    }
+
+    void del_cf(PyColumnFamilyHandle& cf, const py::bytes& key, std::shared_ptr<PyWriteOptions> write_options = nullptr) {
+        check_db_open();
+        check_read_only();
+        if (!cf.is_valid()) throw RocksDBException("ColumnFamilyHandle is invalid.");
+        rocksdb::Slice key_slice(static_cast<std::string_view>(key));
+        const auto& opts = write_options ? write_options->options_ : default_write_options_->options_;
+        rocksdb::Status s = db_->Delete(opts, cf.cf_handle_, key_slice);
+        if (!s.ok()) throw RocksDBException("del_cf failed: " + s.ToString());
+    }
+
+    std::vector<std::string> list_column_families() {
+        check_db_open();
+        std::vector<std::string> names;
+        for (const auto& pair : cf_handles_) {
+            names.push_back(pair.first);
+        }
+        return names;
+    }
+
+    std::shared_ptr<PyColumnFamilyHandle> create_column_family(const std::string& name, PyOptions* cf_py_options) {
+        check_db_open();
+	    check_read_only();
+        if (cf_handles_.count(name)) {
+            throw RocksDBException("Column family '" + name + "' already exists.");
+        }
+        rocksdb::ColumnFamilyOptions cf_opts = cf_py_options ? cf_py_options->cf_options_ : opened_options_.cf_options_;
+        rocksdb::ColumnFamilyHandle* cf_handle;
+        rocksdb::Status s = db_->CreateColumnFamily(cf_opts, name, &cf_handle);
+        if (!s.ok()) throw RocksDBException("Failed to create column family '" + name + "': " + s.ToString());
+        
+        auto new_handle = std::make_shared<PyColumnFamilyHandle>(cf_handle, name);
+        cf_handles_[name] = new_handle;
+        return new_handle;
+    }
+
+    void drop_column_family(PyColumnFamilyHandle& cf_handle) {
+        check_db_open();
+        check_read_only();
+        if (!cf_handle.is_valid()) throw RocksDBException("ColumnFamilyHandle is invalid.");
+        if (cf_handle.get_name() == rocksdb::kDefaultColumnFamilyName) throw RocksDBException("Cannot drop the default column family.");
+
+        rocksdb::ColumnFamilyHandle* raw_handle = cf_handle.cf_handle_;
+        std::string cf_name = cf_handle.get_name();
+
+        rocksdb::Status s = db_->DropColumnFamily(raw_handle);
+        if (!s.ok()) throw RocksDBException("Failed to drop column family '" + cf_name + "': " + s.ToString());
+
+        s = db_->DestroyColumnFamilyHandle(raw_handle);
+        if (!s.ok()) throw RocksDBException("Dropped CF but failed to destroy handle: " + s.ToString());
+
+        cf_handles_.erase(cf_name);
+        cf_handle.cf_handle_ = nullptr;
+    }
+
+    std::shared_ptr<PyColumnFamilyHandle> get_column_family(const std::string& name) {
+        check_db_open();
+        auto it = cf_handles_.find(name);
+        return (it == cf_handles_.end()) ? nullptr : it->second;
+    }
+
+    std::shared_ptr<PyColumnFamilyHandle> get_default_cf() {
+        check_db_open();
+        return get_column_family(rocksdb::kDefaultColumnFamilyName);
+    }
+
+    std::shared_ptr<PyRocksDBIterator> new_cf_iterator(PyColumnFamilyHandle& cf_handle, std::shared_ptr<PyReadOptions> read_options = nullptr) {
+        check_db_open();
+        if (!cf_handle.is_valid()) throw RocksDBException("ColumnFamilyHandle is invalid.");
+        
+        const auto& opts = read_options ? read_options->options_ : default_read_options_->options_;
+        rocksdb::Iterator* raw_iter = db_->NewIterator(opts, cf_handle.cf_handle_);
+        {
+            std::lock_guard<std::mutex> lock(active_iterators_mutex_);
+            active_rocksdb_iterators_.insert(raw_iter);
+        }
+        return std::make_shared<PyRocksDBIterator>(raw_iter, shared_from_this());
+    }
+};
+
+// --- PyRocksDBIterator Method Implementations ---
+PyRocksDBIterator::PyRocksDBIterator(rocksdb::Iterator* it, std::shared_ptr<PyRocksDB> parent_db)
+    : it_raw_ptr_(it), parent_db_ptr_(std::move(parent_db)) {
+    if (!it_raw_ptr_) {
+        throw RocksDBException("Failed to create iterator: null pointer received.");
+    }
+}
+
+PyRocksDBIterator::~PyRocksDBIterator() {
+    if (parent_db_ptr_) {
+        std::lock_guard<std::mutex> lock(parent_db_ptr_->active_iterators_mutex_);
+        if (it_raw_ptr_ && parent_db_ptr_->active_rocksdb_iterators_.count(it_raw_ptr_)) {
+            parent_db_ptr_->active_rocksdb_iterators_.erase(it_raw_ptr_);
+            delete it_raw_ptr_;
+        }
+    }
+    it_raw_ptr_ = nullptr;
+}
+
+void PyRocksDBIterator::check_parent_db_is_open() const {
+    if (!parent_db_ptr_ || parent_db_ptr_->is_closed_.load()) {
+        throw RocksDBException("Database is closed.");
+    }
+}
+
+bool PyRocksDBIterator::valid() { check_parent_db_is_open(); return it_raw_ptr_->Valid(); }
+void PyRocksDBIterator::seek_to_first() { check_parent_db_is_open(); it_raw_ptr_->SeekToFirst(); }
+void PyRocksDBIterator::seek_to_last() { check_parent_db_is_open(); it_raw_ptr_->SeekToLast(); }
+void PyRocksDBIterator::seek(const py::bytes& key) { check_parent_db_is_open(); it_raw_ptr_->Seek(static_cast<std::string>(key)); }
+void PyRocksDBIterator::next() { check_parent_db_is_open(); it_raw_ptr_->Next(); }
+void PyRocksDBIterator::prev() { check_parent_db_is_open(); it_raw_ptr_->Prev(); }
+
+py::object PyRocksDBIterator::key() {
+    check_parent_db_is_open();
+    if (it_raw_ptr_ && it_raw_ptr_->Valid()) {
+        return py::bytes(it_raw_ptr_->key().ToString());
+    }
+    return py::none();
+}
+
+py::object PyRocksDBIterator::value() {
+    check_parent_db_is_open();
+    if (it_raw_ptr_ && it_raw_ptr_->Valid()) {
+        return py::bytes(it_raw_ptr_->value().ToString());
+    }
+    return py::none();
+}
+
+void PyRocksDBIterator::check_status() {
+    check_parent_db_is_open();
+    if (it_raw_ptr_) {
+        rocksdb::Status s = it_raw_ptr_->status();
+        if (!s.ok()) throw RocksDBException("Iterator error: " + s.ToString());
+    }
+}
+
+// --- PYBIND11 MODULE DEFINITION ---
+PYBIND11_MODULE(_pyrex, m) {
+    m.doc() = R"doc(
+        A robust, high-performance Python wrapper for the RocksDB key-value store.
+
+        This module provides two main classes for interacting with RocksDB:
+        1. PyRocksDB: A simple interface for standard key-value operations on a
+           database with a single (default) column family.
+        2. PyRocksDBExtended: An advanced interface that inherits from PyRocksDB and
+           adds full support for creating, managing, and using multiple Column Families.
+    )doc";
+
+    // 1. Create the Python exception type and give it a docstring.
+    static py::exception<RocksDBException> rocksdb_exception(m, "RocksDBException", PyExc_RuntimeError);
+    rocksdb_exception.doc() = R"doc(
+        Custom exception raised for RocksDB-specific operational errors.
+
+        This exception is raised when a RocksDB operation fails for reasons
+        such as I/O errors, corruption, invalid arguments, or when an operation
+        is attempted on a closed database.
+    )doc";
+
+    // 2. Register a translator that maps the C++ exception to the Python one.
+    py::register_exception_translator([](std::exception_ptr p) {
+        try {
+            if (p) {
+                std::rethrow_exception(p);
+            }
+        } catch (const RocksDBException &e) {
+            // Use PyErr_SetString to set the Python error object correctly.
+            // 'rocksdb_exception' is a static variable and accessible without capture.
+            PyErr_SetString(rocksdb_exception.ptr(), e.what());
+        }
+    });
+
+
+    py::enum_<rocksdb::CompressionType>(m, "CompressionType", R"doc(
+        Enum for different compression types supported by RocksDB.
+    )doc")
+        .value("kNoCompression", rocksdb::kNoCompression, "No compression.")
+        .value("kSnappyCompression", rocksdb::kSnappyCompression, "Snappy compression (default).")
+        .value("kBZip2Compression", rocksdb::kBZip2Compression, "BZip2 compression.")
+        .value("kLZ4Compression", rocksdb::kLZ4Compression, "LZ4 compression.")
+        .value("kLZ4HCCompression", rocksdb::kLZ4HCCompression, "LZ4HC (high compression) compression.")
+        .value("kXpressCompression", rocksdb::kXpressCompression, "Xpress compression.")
+        .value("kZSTD", rocksdb::kZSTD, "Zstandard compression.");
+        
+    py::class_<PyReadOptions, std::shared_ptr<PyReadOptions>>(m, "ReadOptions", R"doc(
+        Configuration options for read operations (Get, Iterator).
+    )doc")
+        .def(py::init<>(), "Constructs a new ReadOptions object with default settings.")
+        .def_property("fill_cache", &PyReadOptions::get_fill_cache, &PyReadOptions::set_fill_cache, "If True, reads will fill the block cache. Defaults to True.")
+        .def_property("verify_checksums", &PyReadOptions::get_verify_checksums, &PyReadOptions::set_verify_checksums, "If True, all data read from underlying storage will be verified against its checksums. Defaults to True.");
+
+    py::class_<PyWriteOptions, std::shared_ptr<PyWriteOptions>>(m, "WriteOptions", R"doc(
+        Configuration options for write operations (Put, Delete, Write).
+    )doc")
+        .def(py::init<>(), "Constructs a new WriteOptions object with default settings.")
+        .def_property("sync", &PyWriteOptions::get_sync, &PyWriteOptions::set_sync, "If True, the write will be flushed from the OS buffer cache before the write is considered complete. Defaults to False.")
+        .def_property("disable_wal", &PyWriteOptions::get_disable_wal, &PyWriteOptions::set_disable_wal, "If True, writes will not be written to the Write Ahead Log. Defaults to False.");
+
+    py::class_<PyOptions>(m, "PyOptions", R"doc(
+        Configuration options for opening and managing a RocksDB database.
+
+        This class wraps `rocksdb::Options` and `rocksdb::ColumnFamilyOptions`
+        to provide a convenient way to configure database behavior from Python.
+    )doc")
+        .def(py::init<>(), "Constructs a new PyOptions object with default settings.")
+        .def_property("create_if_missing", &PyOptions::get_create_if_missing, &PyOptions::set_create_if_missing, "If True, the database will be created if it is missing. Defaults to True.")
+        .def_property("error_if_exists", &PyOptions::get_error_if_exists, &PyOptions::set_error_if_exists, "If True, an error is raised if the database already exists. Defaults to False.")
+        .def_property("max_open_files", &PyOptions::get_max_open_files, &PyOptions::set_max_open_files, "Number of open files that can be used by the DB. Defaults to -1 (unlimited).")
+        .def_property("write_buffer_size", &PyOptions::get_write_buffer_size, &PyOptions::set_write_buffer_size, "Amount of data to build up in a memory buffer (MemTable) before flushing. Defaults to 64MB.")
+        .def_property("compression", &PyOptions::get_compression, &PyOptions::set_compression, "The compression type to use for sst files. Defaults to Snappy.")
+        .def_property("max_background_jobs", &PyOptions::get_max_background_jobs, &PyOptions::set_max_background_jobs, "Maximum number of concurrent background jobs (compactions and flushes).")
+        .def("increase_parallelism", &PyOptions::increase_parallelism, py::arg("total_threads"), R"doc(
+            Increases RocksDB's parallelism by tuning background threads.
+
+            Args:
+                total_threads (int): The total number of background threads to use.
+        )doc", py::call_guard<py::gil_scoped_release>())
+        .def("optimize_for_small_db", &PyOptions::optimize_for_small_db, R"doc(
+            Optimizes RocksDB for small databases by reducing memory and CPU consumption.
+        )doc", py::call_guard<py::gil_scoped_release>())
+        .def("use_block_based_bloom_filter", &PyOptions::use_block_based_bloom_filter, py::arg("bits_per_key") = 10.0, R"doc(
+            Enables a Bloom filter for block-based tables to speed up 'Get' operations.
+
+            Args:
+                bits_per_key (float): The number of bits per key for the Bloom filter.
+                    Higher values reduce false positives but increase memory usage.
+        )doc", py::call_guard<py::gil_scoped_release>())
+        .def_property("cf_write_buffer_size", &PyOptions::get_cf_write_buffer_size, &PyOptions::set_cf_write_buffer_size, "Default write_buffer_size for newly created Column Families.")
+        .def_property("cf_compression", &PyOptions::get_cf_compression, &PyOptions::set_cf_compression, "Default compression type for newly created Column Families.");
+
+    py::class_<PyColumnFamilyHandle, std::shared_ptr<PyColumnFamilyHandle>>(m, "ColumnFamilyHandle", R"doc(
+        Represents a handle to a RocksDB Column Family.
+
+        This object is used to perform operations on a specific data partition
+        within a `PyRocksDBExtended` instance.
+    )doc")
+        .def_property_readonly("name", &PyColumnFamilyHandle::get_name, "The name of this column family.")
+        .def("is_valid", &PyColumnFamilyHandle::is_valid, "Checks if the handle is still valid (i.e., has not been dropped).");
+
+    py::class_<PyWriteBatch>(m, "PyWriteBatch", R"doc(
+        A batch of write operations (Put, Delete) that can be applied atomically.
+    )doc")
+        .def(py::init<>(), "Constructs an empty write batch.")
+        .def("put", &PyWriteBatch::put, py::arg("key"), py::arg("value"), "Adds a key-value pair to the batch for the default column family.")
+        .def("put_cf", &PyWriteBatch::put_cf, py::arg("cf_handle"), py::arg("key"), py::arg("value"), "Adds a key-value pair to the batch for a specific column family.")
+        .def("delete", &PyWriteBatch::del, py::arg("key"), "Adds a key deletion to the batch for the default column family.")
+        .def("delete_cf", &PyWriteBatch::del_cf, py::arg("cf_handle"), py::arg("key"), "Adds a key deletion to the batch for a specific column family.")
+        .def("merge", &PyWriteBatch::merge, py::arg("key"), py::arg("value"), "Adds a merge operation to the batch for the default column family.")
+        .def("merge_cf", &PyWriteBatch::merge_cf, py::arg("cf_handle"), py::arg("key"), py::arg("value"), "Adds a merge operation to the batch for a specific column family.")
+        .def("clear", &PyWriteBatch::clear, "Clears all operations from the batch.");
+
+    py::class_<PyRocksDBIterator, std::shared_ptr<PyRocksDBIterator>>(m, "PyRocksDBIterator", R"doc(
+        An iterator for traversing key-value pairs in a RocksDB database.
+    )doc")
+        .def("valid", &PyRocksDBIterator::valid, "Returns True if the iterator is currently positioned at a valid entry.", py::call_guard<py::gil_scoped_release>())
+        .def("seek_to_first", &PyRocksDBIterator::seek_to_first, "Positions the iterator at the first key.", py::call_guard<py::gil_scoped_release>())
+        .def("seek_to_last", &PyRocksDBIterator::seek_to_last, "Positions the iterator at the last key.", py::call_guard<py::gil_scoped_release>())
+        .def("seek", &PyRocksDBIterator::seek, py::arg("key"), "Positions the iterator at the first key >= the given key.", py::call_guard<py::gil_scoped_release>())
+        .def("next", &PyRocksDBIterator::next, "Moves the iterator to the next entry.", py::call_guard<py::gil_scoped_release>())
+        .def("prev", &PyRocksDBIterator::prev, "Moves the iterator to the previous entry.", py::call_guard<py::gil_scoped_release>())
+        .def("key", &PyRocksDBIterator::key, "Returns the current key as bytes, or None if invalid.")
+        .def("value", &PyRocksDBIterator::value, "Returns the current value as bytes, or None if invalid.")
+        .def("check_status", &PyRocksDBIterator::check_status, "Raises RocksDBException if an error occurred during iteration.", py::call_guard<py::gil_scoped_release>());
+
+    py::class_<PyRocksDB, std::shared_ptr<PyRocksDB>>(m, "PyRocksDB", R"doc(
+        A Python wrapper for RocksDB providing simple key-value storage.
+
+        This class interacts exclusively with the 'default' column family.
+        For multi-column-family support, use `PyRocksDBExtended`.
+    )doc")
+        .def(py::init<const std::string&, PyOptions*, bool>(), 
+            py::arg("path"), 
+            py::arg("options") = nullptr,
+            py::arg("read_only") = false,
+            R"doc(
+            Opens a RocksDB database at the specified path.
+
+            Args:
+                path (str): The file system path to the database.
+                options (PyOptions, optional): Custom options for configuration.
+                read_only (bool, optional): If True, opens the database in read-only mode.
+                                            Defaults to False.
+        )doc", py::call_guard<py::gil_scoped_release>())
+        .def("put", &PyRocksDB::put, py::arg("key"), py::arg("value"), py::arg("write_options") = nullptr, "Inserts a key-value pair.", py::call_guard<py::gil_scoped_release>())
+        .def("get", &PyRocksDB::get, py::arg("key"), py::arg("read_options") = nullptr, "Retrieves the value for a key.")
+        .def("delete", &PyRocksDB::del, py::arg("key"), py::arg("write_options") = nullptr, "Deletes a key.", py::call_guard<py::gil_scoped_release>())
+        .def("write", &PyRocksDB::write, py::arg("write_batch"), py::arg("write_options") = nullptr, "Applies a batch of operations atomically.", py::call_guard<py::gil_scoped_release>())
+        .def("new_iterator", &PyRocksDB::new_iterator, py::arg("read_options") = nullptr, "Creates a new iterator.", py::keep_alive<0, 1>())
+        .def("get_options", &PyRocksDB::get_options, "Returns the options the database was opened with.")
+        .def_property("default_read_options", &PyRocksDB::get_default_read_options, &PyRocksDB::set_default_read_options, "The default ReadOptions used for get and iterator operations.")
+        .def_property("default_write_options", &PyRocksDB::get_default_write_options, &PyRocksDB::set_default_write_options, "The default WriteOptions used for put, delete, and write operations.")
+        .def("close", &PyRocksDB::close, "Closes the database, releasing resources and the lock.", py::call_guard<py::gil_scoped_release>())
+        .def("__enter__", [](PyRocksDB &db) -> PyRocksDB& { return db; })
+        .def("__exit__", [](PyRocksDB &db, py::object /* type */, py::object /* value */, py::object /* traceback */) {
+            db.close();
+        });
+
+    py::class_<PyRocksDBExtended, PyRocksDB, std::shared_ptr<PyRocksDBExtended>>(m, "PyRocksDBExtended", R"doc(
+        An advanced Python wrapper for RocksDB with full Column Family support.
+    )doc")
+        .def(py::init<const std::string&, PyOptions*, bool>(), 
+            py::arg("path"), 
+            py::arg("options") = nullptr, 
+            py::arg("read_only") = false, 
+            R"doc(
+            Opens or creates a RocksDB database with Column Family support.
+
+            Args:
+                path (str): The file system path to the database.
+                options (PyOptions, optional): Custom options for configuration.
+                read_only (bool, optional): If True, opens the database in read-only mode.
+                                            Defaults to False.
+        )doc", py::call_guard<py::gil_scoped_release>())
+
+        .def("put_cf", &PyRocksDBExtended::put_cf, py::arg("cf_handle"), py::arg("key"), py::arg("value"), py::arg("write_options") = nullptr, "Inserts a key-value pair into a specific column family.", py::call_guard<py::gil_scoped_release>())
+        .def("get_cf", &PyRocksDBExtended::get_cf, py::arg("cf_handle"), py::arg("key"), py::arg("read_options") = nullptr, "Retrieves the value for a key from a specific column family.")
+        .def("delete_cf", &PyRocksDBExtended::del_cf, py::arg("cf_handle"), py::arg("key"), py::arg("write_options") = nullptr, "Deletes a key from a specific column family.", py::call_guard<py::gil_scoped_release>())
+        .def("list_column_families", &PyRocksDBExtended::list_column_families, "Lists the names of all existing column families.")
+        .def("create_column_family", &PyRocksDBExtended::create_column_family, py::arg("name"), py::arg("cf_options") = nullptr, "Creates a new column family.", py::call_guard<py::gil_scoped_release>())
+        .def("drop_column_family", &PyRocksDBExtended::drop_column_family, py::arg("cf_handle"), "Drops a column family.", py::call_guard<py::gil_scoped_release>())
+        .def("new_cf_iterator", &PyRocksDBExtended::new_cf_iterator, py::arg("cf_handle"), py::arg("read_options") = nullptr, "Creates a new iterator for a specific column family.", py::keep_alive<0, 1>())
+        .def("get_column_family", &PyRocksDBExtended::get_column_family, py::arg("name"), "Retrieves a ColumnFamilyHandle by its name.")
+        .def_property_readonly("default_cf", &PyRocksDBExtended::get_default_cf, "Returns the handle for the default column family.");
+}
+

pyrex_rocksdb-0.1.4.dist-info/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

pyrex_rocksdb-0.1.4.dist-info/METADATA

@@ -0,0 +1,122 @@
+Metadata-Version: 2.1
+Name: pyrex-rocksdb
+Version: 0.1.4
+Summary: A fast RocksDB wrapper for Python using pybind11.
+Author-email: Charilaos Mylonas <mylonas.charilaos@gmail.com>
+Project-URL: Homepage, https://github.com/mylonasc/pyrex
+Project-URL: Repository, https://github.com/mylonasc/pyrex
+Keywords: rocksdb,database,key-value,pybind11
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Database
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: sphinx; extra == "dev"
+Requires-Dist: sphinx-rtd-theme; extra == "dev"
+Requires-Dist: cibuildwheel; extra == "dev"
+Requires-Dist: pybind11-stubgen~=2.5.4; extra == "dev"
+Requires-Dist: mypy~=1.10; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+
+
+[![PyPI version](https://img.shields.io/pypi/v/pyrex-rocksdb.svg)](https://pypi.org/project/pyrex-rocksdb/)
+[![Python versions](https://img.shields.io/pypi/pyversions/pyrex-rocksdb.svg)](https://img.shields.io/pypi/pyversions/pyrex-rocksdb/)
+
+
+![pyrex](https://raw.githubusercontent.com/mylonasc/pyrex/main/assets/logo.png)
+
+# Installation
+
+
+# pyrex-rocksdb
+A python wrapper for the original (C++) version of RocksDB.
+
+Currently MacOS and Linux wheels are available.
+
+## Installation
+
+For linux systems, wheels are provided and can be installed from pypi using:
+
+```bash
+pip install pyrex-rocksdb
+```
+
+For Windows and MacOS I have built an earlier version of the library.
+I will re-build once I include certain other important features in the API that are not yet implemented.
+
+
+
+## Motivation
+
+This library is intended for providing a fast, write-optimized, in-process key value (KV) store in python. Therefore the "big brothers" of the database are the likes of MongoDB and Cassandra. The difference is that you don't need a separate server to run this (hence "in-process") and it is designed to be fairly portable. 
+
+RocksDB, which is the underlying storage engine of this database, is an LSM-tree engine. An LSM-tree is different from the ballanced tree index databases (e.g., [B-tree](https://en.wikipedia.org/wiki/B-tree)/ and [B+tree](https://en.wikipedia.org/wiki/B%2B_tree) databases). LSM-tree databases offer very high write throughputs and better space efficiency. See more about the motivation for LSM-tree databases (and RocksDB in particular) in [this talk](https://www.youtube.com/watch?v=V_C-T5S-w8g).
+
+### LSM-tree + SSTable engine basics
+To understand where `pyrex` provides efficiency gains, it is important to understand some basics about the underlying `RocksDB` engine. 
+
+RocksDB and LevelDB are **key-value stores** with a **Log-Structured Merge-tree (LSM-tree)** architecture. 
+
+The key components of LSM-tree architectures are 
+* A **MemTable** that stores in-memory sorted data
+* A set of **Sorted-String tables (SSTables)** which are immutable sorted files on disk where data from the MemTable is flushed
+* The process of **Compaction**, which is a background process that merges the SSTables to remove redundant data and keep read performance high.
+
+In such databases, fast writes create many small, sorted data files called SSTables. To prevent reads from slowing down by checking too many files, a background process called compaction merges these SSTables together. This process organizes the data into levels, where newer, overlapping files sit in Level 0 and are progressively merged into higher levels (Level 1, Level 2, etc.). Each higher level contains larger, non-overlapping files, which ensures that finding a key remains efficient and old data is purged to save space. There are several optimizations and configurations possible for these processes (configurability and "pluggability" are commonly cited RocksDB advantages). 
+
+However the main big advantage of RocksDB over LevelDB is its **multi-threaded compaction support** (LevelDB supports only single threaded compaction, which comes with significant performance limitations). 
+There are several other configurability advantages RocksDB offers over LevelDB. For a more elaborate enumaration of RocksDB advantages please refer to the [RocksDB wiki](https://github.com/facebook/rocksdb/wiki/Features-Not-in-LevelDB). 
+
+Not all are currently supported by the `pyrex` API, but I'm working on supporting more of them. Feel free to open an issue if there is a feature you want to see (or open a pull request).
+
+
+## Example usage:
+
+Here is a simple example showing the usage of put/get in the DB:
+
+```python
+import pyrex
+import os
+import shutil
+
+DB_PATH = "./test_rocksdb_minimal"
+
+with pyrex.PyRocksDB(DB_PATH) as db:
+    db.put(b"my_key", b"my_value")
+    retrieved_value = db.get(b"my_key")
+
+print(f"Retrieved: {retrieved_value.decode()}") # Output: Retrieved: my_value
+
+```
+
+for more examples check the relevant folder and the documentation.
+
+## Installation
+
+<details>
+  <summary>Note on CICD</summary>
+The wheels provided are not completely platform-independent at the moment. 
+I heavily rely on github actions to develop since I don't own mac or windows machines.
+The CICD workflow for package builds is under development A windows/macos/linux build was successful, but further development is needed.
+</details>
+
+## Benchmarks
+
+`Pyrex` was benchmarked against [plyvel](https://github.com/wbolster/plyvel) and [lmdb](https://github.com/jnwatson/py-lmdb/) (which is based on a B+tree -- based architecture and relies on OS's block cache). 
+
+Initial benchmarks are promissing and to be reported soon.
+
+

pyrex_rocksdb-0.1.4.dist-info/RECORD

@@ -0,0 +1,15 @@
+pyrex/__init__.py,sha256=zshmllNLYDo3znwRaknHeAd4obEkjS3jK6UkcXAsvw4,831
+pyrex/_pyrex.cpp,sha256=rTj0pKRt3M1ttRYOhN53kTCoRnetmnuS93c9MMdtGvQ,38172
+pyrex/_pyrex.cpython-38-x86_64-linux-gnu.so,sha256=Rj_Xj81XrlXZoNGuvuM6aEM_NU0eWxXzff3cjOCqka0,15611121
+pyrex_rocksdb.libs/libbz2-b428631a.so.1.0.8,sha256=yNT-YG4YnyKLDORihi0Csabys6xeMBmxfwShJYrJsQo,79185
+pyrex_rocksdb.libs/libgcc_s-0cd532bd.so.1,sha256=yPk0-VjyKzucjnkP3mvC0vVaua6Ln17qZUJbICcXgtA,181737
+pyrex_rocksdb.libs/liblz4-af355be2.so.1.10.0,sha256=1l7gNbbgRYTtETZg2ZQzjg-mutZ3wSlpm4wQP1By-3s,155537
+pyrex_rocksdb.libs/libsnappy-f36b9e28.so.1.2.2,sha256=TqZ4Uf1Jn2ParASUMKhTY55L7owWh0xVh9Rhn3Kraj0,65233
+pyrex_rocksdb.libs/libstdc++-5d72f927.so.6.0.33,sha256=fogxHsmB1_D6C-a_-uHh8Ei_6Qh52a8vLlicJRM3ehk,3562401
+pyrex_rocksdb.libs/liburing-20646edb.so.2.9,sha256=inggmvA5uM-DUCVKf_oWwVjf8TOj_mvc6SzQvo2Od4c,27825
+pyrex_rocksdb.libs/libzstd-f3c21b15.so.1.5.7,sha256=bKuFOLGu-ETlWtit2osjhuOZLQPPp-mW1vIcgxkSIrU,728201
+pyrex_rocksdb-0.1.4.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+pyrex_rocksdb-0.1.4.dist-info/METADATA,sha256=xT3J-0H5XWUPpu2ZRZZgfLWfHUmN7eCVTJRo7AbBu9I,6077
+pyrex_rocksdb-0.1.4.dist-info/WHEEL,sha256=AtKzrIIwO6LyEQPNa-CKogjoLSeXFnST8-hqmpwwZQA,110
+pyrex_rocksdb-0.1.4.dist-info/top_level.txt,sha256=Hyct9jOureNtYbpQ0AUae8uzaC--sgtHGo5Kevyspgg,14
+pyrex_rocksdb-0.1.4.dist-info/RECORD,,

pyrex_rocksdb-0.1.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.3.2)
+Root-Is-Purelib: false
+Tag: cp38-cp38-musllinux_1_2_x86_64
+

pyrex_rocksdb-0.1.4.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+pyrex
+rocksdb