pyrex-rocksdb 0.1.0__cp312-cp312-macosx_14_0_arm64.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,302 @@
+// rocksdb_wrapper.cpp
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+// NEW: Include for std::unique_ptr
+#include <memory>
+
+#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"
+
+#include <iostream>
+#include <string>
+#include <cstring>
+
+namespace py = pybind11;
+
+// Define a custom exception for RocksDB errors
+class RocksDBException : public std::runtime_error {
+public:
+    explicit RocksDBException(const std::string& msg) : std::runtime_error(msg) {}
+};
+
+// --- PyOptions class to wrap rocksdb::Options ---
+class PyOptions {
+public:
+    rocksdb::Options options_;
+
+    PyOptions() : options_() {}
+
+    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) {
+        if (options_.table_factory == nullptr ||
+            std::strcmp(options_.table_factory->Name(), "BlockBasedTable") != 0) {
+            options_.table_factory.reset(rocksdb::NewBlockBasedTableFactory());
+        }
+
+        rocksdb::BlockBasedTableOptions table_options;
+        // NOTE: This part assumes we are creating a new policy, not modifying an existing one.
+        // This is a reasonable simplification for a wrapper.
+        
+        // Create a new bloom filter policy
+        table_options.filter_policy.reset(rocksdb::NewBloomFilterPolicy(bits_per_key));
+        options_.table_factory.reset(rocksdb::NewBlockBasedTableFactory(table_options));
+    }
+};
+
+// --- PyWriteBatch class to wrap rocksdb::WriteBatch ---
+class PyWriteBatch {
+public:
+    rocksdb::WriteBatch wb_;
+
+    PyWriteBatch() : wb_() {}
+
+    void put(const py::bytes& key_bytes, const py::bytes& value_bytes) {
+        wb_.Put(static_cast<std::string>(key_bytes), static_cast<std::string>(value_bytes));
+    }
+
+    void del(const py::bytes& key_bytes) {
+        wb_.Delete(static_cast<std::string>(key_bytes));
+    }
+
+    void clear() {
+        wb_.Clear();
+    }
+};
+
+// --- PyRocksDBIterator class to wrap rocksdb::Iterator ---
+class PyRocksDBIterator {
+public:
+    // Raw pointer to the RocksDB Iterator.
+    // The lifetime of this pointer is managed by this class's constructor/destructor.
+    rocksdb::Iterator* it_;
+
+    explicit PyRocksDBIterator(rocksdb::Iterator* it) : it_(it) {
+        if (!it_) {
+            throw RocksDBException("Failed to create RocksDB iterator: null pointer received.");
+        }
+        // std::cout << "DEBUG: Creating RocksDB iterator." << std::endl; // Optional: for debugging
+    }
+
+    // Destructor: Ensures the C++ iterator is deleted when this object is destroyed.
+    ~PyRocksDBIterator() {
+        if (it_ != nullptr) {
+            std::cout << "DEBUG: Deleting RocksDB iterator." << std::endl;
+            delete it_;
+            it_ = nullptr;
+        }
+    }
+
+    bool valid() const {
+        return it_->Valid();
+    }
+
+    void seek_to_first() {
+        it_->SeekToFirst();
+    }
+
+    void seek_to_last() {
+        it_->SeekToLast();
+    }
+
+    void seek(const py::bytes& key_bytes) {
+        it_->Seek(static_cast<std::string>(key_bytes));
+    }
+
+    void next() {
+        it_->Next();
+    }
+
+    void prev() {
+        it_->Prev();
+    }
+
+    py::object key() {
+        if (it_->Valid()) {
+            return py::bytes(it_->key().ToString());
+        }
+        return py::none();
+    }
+
+    py::object value() {
+        if (it_->Valid()) {
+            return py::bytes(it_->value().ToString());
+        }
+        return py::none();
+    }
+
+    void check_status() {
+        rocksdb::Status status = it_->status();
+        if (!status.ok()) {
+            throw RocksDBException("RocksDB Iterator error: " + status.ToString());
+        }
+    }
+};
+
+// --- PyRocksDB class to wrap rocksdb::DB ---
+class PyRocksDB {
+public:
+    rocksdb::DB* db_;
+    PyOptions opened_options_; // Store the options used to open the DB
+    std::string path_;         // IMPROVEMENT: Store the path for accurate debug messages
+
+    PyRocksDB(const std::string& path, PyOptions* py_options = nullptr) : db_(nullptr), path_(path) {
+        rocksdb::Options actual_options;
+
+        if (py_options != nullptr) {
+            actual_options = py_options->options_;
+        } else {
+            actual_options.create_if_missing = true;
+        }
+
+        opened_options_.options_ = actual_options;
+
+        rocksdb::Status status = rocksdb::DB::Open(actual_options, path_, &db_);
+
+        if (!status.ok()) {
+            throw RocksDBException("Failed to open RocksDB at " + path_ + ": " + status.ToString());
+        }
+
+        std::cout << "RocksDB opened successfully at: " << path_ << std::endl;
+    }
+
+    ~PyRocksDB() {
+        if (db_ != nullptr) {
+            // IMPROVEMENT: Use the stored path_ member for a reliable close message.
+            std::cout << "DEBUG: Closing RocksDB database at " << path_ << std::endl;
+            delete db_;
+            db_ = nullptr;
+        }
+    }
+
+    void put(const py::bytes& key_bytes, const py::bytes& value_bytes) {
+        rocksdb::Status status = db_->Put(rocksdb::WriteOptions(),
+                                         static_cast<std::string>(key_bytes),
+                                         static_cast<std::string>(value_bytes));
+        if (!status.ok()) {
+            throw RocksDBException("Failed to put key-value pair: " + status.ToString());
+        }
+    }
+
+    py::object get(const py::bytes& key_bytes) {
+        std::string value_str;
+        rocksdb::Status status = db_->Get(rocksdb::ReadOptions(), static_cast<std::string>(key_bytes), &value_str);
+
+        if (status.ok()) {
+            return py::bytes(value_str);
+        } else if (status.IsNotFound()) {
+            return py::none();
+        } else {
+            throw RocksDBException("Failed to get value for key: " + status.ToString());
+        }
+    }
+
+    // This method is safe to return by value, as PyOptions is a simple
+    // wrapper around a copyable rocksdb::Options object.
+    PyOptions get_options() const {
+        return opened_options_;
+    }
+
+    void write(PyWriteBatch& py_write_batch) {
+        rocksdb::Status status = db_->Write(rocksdb::WriteOptions(), &py_write_batch.wb_);
+        if (!status.ok()) {
+            throw RocksDBException("Failed to write batch: " + status.ToString());
+        }
+    }
+
+    // **FIXED**: Return a unique_ptr to transfer ownership to pybind11.
+    // This prevents the temporary iterator object from being destroyed prematurely.
+    std::unique_ptr<PyRocksDBIterator> new_iterator() {
+        rocksdb::ReadOptions read_options;
+        return std::make_unique<PyRocksDBIterator>(db_->NewIterator(read_options));
+    }
+};
+
+// --- PYBIND11 MODULE DEFINITION ---
+PYBIND11_MODULE(_pyrex, m) {
+    m.doc() = "pybind11 RocksDB wrapper";
+
+    py::register_exception<RocksDBException>(m, "RocksDBException");
+
+    py::enum_<rocksdb::CompressionType>(m, "CompressionType")
+        .value("kNoCompression", rocksdb::kNoCompression)
+        .value("kSnappyCompression", rocksdb::kSnappyCompression)
+        .value("kBZip2Compression", rocksdb::kBZip2Compression)
+        .value("kLZ4Compression", rocksdb::kLZ4Compression)
+        .value("kLZ4HCCompression", rocksdb::kLZ4HCCompression)
+        .value("kXpressCompression", rocksdb::kXpressCompression)
+        .value("kZSTD", rocksdb::kZSTD)
+        .value("kDisableCompressionOption", rocksdb::kDisableCompressionOption)
+        .export_values();
+
+    py::class_<PyOptions>(m, "PyOptions")
+        .def(py::init<>())
+        .def_property("create_if_missing", &PyOptions::get_create_if_missing, &PyOptions::set_create_if_missing)
+        .def_property("error_if_exists", &PyOptions::get_error_if_exists, &PyOptions::set_error_if_exists)
+        .def_property("max_open_files", &PyOptions::get_max_open_files, &PyOptions::set_max_open_files)
+        .def_property("write_buffer_size", &PyOptions::get_write_buffer_size, &PyOptions::set_write_buffer_size)
+        .def_property("compression", &PyOptions::get_compression, &PyOptions::set_compression)
+        .def_property("max_background_jobs", &PyOptions::get_max_background_jobs, &PyOptions::set_max_background_jobs)
+        .def("increase_parallelism", &PyOptions::increase_parallelism, py::arg("total_threads"))
+        .def("optimize_for_small_db", &PyOptions::optimize_for_small_db)
+        .def("use_block_based_bloom_filter", &PyOptions::use_block_based_bloom_filter, py::arg("bits_per_key") = 10.0);
+
+    py::class_<PyWriteBatch>(m, "PyWriteBatch")
+        .def(py::init<>())
+        .def("put", &PyWriteBatch::put, py::arg("key"), py::arg("value"))
+        .def("delete", &PyWriteBatch::del, py::arg("key"))
+        .def("clear", &PyWriteBatch::clear);
+
+    py::class_<PyRocksDBIterator>(m, "PyRocksDBIterator")
+        .def("valid", &PyRocksDBIterator::valid)
+        .def("seek_to_first", &PyRocksDBIterator::seek_to_first)
+        .def("seek_to_last", &PyRocksDBIterator::seek_to_last)
+        .def("seek", &PyRocksDBIterator::seek, py::arg("key"))
+        .def("next", &PyRocksDBIterator::next)
+        .def("prev", &PyRocksDBIterator::prev)
+        .def("key", &PyRocksDBIterator::key)
+        .def("value", &PyRocksDBIterator::value)
+        .def("check_status", &PyRocksDBIterator::check_status);
+
+    py::class_<PyRocksDB>(m, "PyRocksDB")
+        .def(py::init<const std::string&, PyOptions*>(), py::arg("path"), py::arg("options") = nullptr)
+        .def("put", &PyRocksDB::put, py::arg("key"), py::arg("value"))
+        .def("get", &PyRocksDB::get, py::arg("key"))
+        .def("get_options", &PyRocksDB::get_options)
+        .def("write", &PyRocksDB::write, py::arg("write_batch"))
+        .def("new_iterator", &PyRocksDB::new_iterator,
+             "Creates and returns a new RocksDB iterator.",
+             py::keep_alive<0, 1>()
+        ); 
+}

pyrex_rocksdb-0.1.0.dist-info/METADATA

@@ -0,0 +1,76 @@
+Metadata-Version: 2.4
+Name: pyrex-rocksdb
+Version: 0.1.0
+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: twine; extra == "dev"
+Dynamic: license-file
+
+[![Build Status](https://github.com/mylonasc/pyrex/actions/workflows/build_wheels.yml/badge.svg)](https://github.com/mylonasc/pyrex/actions/workflows/build_wheels.yml)
+
+# pyrex
+a python rocksdb wrapper
+
+## Motivation
+rocksdb python wrappers are broken. This is yet another attempt to create a working python wrapper for rocksdb.
+
+## Example usage:
+Check the `test.py` file.
+
+## Installation
+
+On Linux/macOS: Open your terminal, navigate to the parent directory of my_rocksdb_wrapper, and run:
+
+
+Build and Use the Wrapper:
+After saving the files, follow these steps to build and use your Python wrapper:
+
+### Prerequisites:
+
+* RocksDB C++ Library Installed (headers and libraries accessible). (in Ubuntu `sudo apt-get install librocksdb` may suffice)
+* C++11 compatible compiler (e.g., g++ or clang++).
+* Python 3.7+ and its development headers.    
+
+* Python pybind11 package: `pip install pybind11`
+
+Python setuptools package: `pip install --upgrade setuptools`
+
+### Adjust setup.py (if needed):
+
+Open setup.py and verify that `include_dirs` and `library_dirs` correctly point to your RocksDB installation paths. 
+If RocksDB is not in `/usr/local/include` or `/usr/local/lib`, update these paths.
+
+If RocksDB was built with specific compression libraries (like Snappy, Zlib, LZ4, Zstandard), add their corresponding names (e.g., 'snappy', 'z') to the libraries list.
+
+Compile the Wrapper:
+Navigate to the directory containing rocksdb_wrapper.cpp and setup.py in your terminal, and run:
+
+```Bash
+
+python setup.py install
+```
+

pyrex_rocksdb-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+pyrex/__init__.py,sha256=zshmllNLYDo3znwRaknHeAd4obEkjS3jK6UkcXAsvw4,831
+pyrex/_pyrex.cpython-312-darwin.so,sha256=hkoAwtprFoZamx3W55FLQUTnZMD77RfPQjxiV6UEo6E,540080
+pyrex/_pyrex.cpp,sha256=mgzrP3PpeDVylK7pkjts2L8hv_tuiQ_Mfy-80r39o8I,10986
+pyrex/.dylibs/libsnappy.1.2.2.dylib,sha256=RtFJkVOnmB0FU6L5PGz-SRdNhutch4TzcNi-wB13m_0,79184
+pyrex/.dylibs/liblz4.1.10.0.dylib,sha256=k7TzQdjquM1GQIEVgXlSdUc9wfXAF7lCCMVqOWU0l2o,176960
+pyrex/.dylibs/librocksdb.10.4.2.dylib,sha256=ybpmZR-J9Hr88Nf_Bkl7ae8siEQPfn8A20dmzJl-X7U,11266240
+pyrex/.dylibs/libgflags.2.2.2.dylib,sha256=uiE_yjZcs48WAx0cx5VsLtCi-Jf1tip-QamzYNGTG70,172336
+pyrex/.dylibs/libzstd.1.5.7.dylib,sha256=c-Z4ifatarhfQRED6aESDQIMTHw8XxG_OYBBdVYdDVg,670240
+pyrex_rocksdb-0.1.0.dist-info/RECORD,,
+pyrex_rocksdb-0.1.0.dist-info/WHEEL,sha256=VrhWOWJdu4wN9IKhAFBqWPMo6yuww-SFg9GbWc0qbmI,136
+pyrex_rocksdb-0.1.0.dist-info/top_level.txt,sha256=0YbfttFoNSJjWKBullYqKklNMzgq7obw3oD751OmOOo,6
+pyrex_rocksdb-0.1.0.dist-info/METADATA,sha256=-5O5YaIogXmPdAxSHCo-XlghhcZzMAJyAcN-gYnfYf8,2830
+pyrex_rocksdb-0.1.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358

pyrex_rocksdb-0.1.0.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp312-cp312-macosx_14_0_arm64
+Generator: delocate 0.13.0
+

pyrex_rocksdb-0.1.0.dist-info/licenses/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.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyrex