timestamp-store 1.0.0__py3-none-any.whl

timestamp_store/__init__.py

@@ -0,0 +1,18 @@
+"""
+TimestampStore - fast data structure for pairs (id, timestamp)
+
+Usage example:
+    from timestamp_store import TimestampStore
+
+    store = TimestampStore()
+    store.add(1, 100)
+    store.add(2, 50)
+
+    removed = store.remove_timestamp(80)  # [2]
+    removed = store.remove_timestamp(120) # [1]
+"""
+
+from .wrapper import TimestampStore
+
+__version__ = "1.0.0"
+__all__ = ["TimestampStore"]

timestamp_store/src/timestamp_store.cpp

@@ -0,0 +1,203 @@
+#include <map>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+#include <cstdint>
+#include <algorithm>
+
+class TimestampStore {
+private:
+    std::map<int64_t, std::unordered_set<int64_t>> time_to_ids_;
+
+    std::unordered_map<int64_t, int64_t> id_to_time_;
+
+public:
+    TimestampStore() = default;
+
+    void add(int64_t id, int64_t timestamp) {
+        auto it = id_to_time_.find(id);
+
+        if (it != id_to_time_.end()) {
+            int64_t old_time = it->second;
+
+            if (old_time == timestamp) {
+                return;
+            }
+
+            auto old_time_it = time_to_ids_.find(old_time);
+            if (old_time_it != time_to_ids_.end()) {
+                old_time_it->second.erase(id);
+                if (old_time_it->second.empty()) {
+                    time_to_ids_.erase(old_time_it);
+                }
+            }
+
+            it->second = timestamp;
+        } else {
+            id_to_time_[id] = timestamp;
+        }
+
+        time_to_ids_[timestamp].insert(id);
+    }
+
+    bool remove(int64_t id) {
+        auto it = id_to_time_.find(id);
+        if (it == id_to_time_.end()) {
+            return false;
+        }
+
+        int64_t timestamp = it->second;
+        id_to_time_.erase(it);
+
+        auto time_it = time_to_ids_.find(timestamp);
+        if (time_it != time_to_ids_.end()) {
+            time_it->second.erase(id);
+            if (time_it->second.empty()) {
+                time_to_ids_.erase(time_it);
+            }
+        }
+
+        return true;
+    }
+
+    std::vector<int64_t> remove_before_timestamp(int64_t timestamp) {
+        std::vector<int64_t> removed_ids;
+
+        while (!time_to_ids_.empty()) {
+            auto it = time_to_ids_.begin();
+
+            if (it->first >= timestamp) {
+                break;
+            }
+
+            for (int64_t id : it->second) {
+                removed_ids.push_back(id);
+                id_to_time_.erase(id);
+            }
+
+            time_to_ids_.erase(it);
+        }
+
+        return removed_ids;
+    }
+
+    size_t size() const {
+        return id_to_time_.size();
+    }
+
+    bool empty() const {
+        return id_to_time_.empty();
+    }
+
+    int64_t get_min_timestamp() const {
+        if (time_to_ids_.empty()) {
+            return -1;
+        }
+        return time_to_ids_.begin()->first;
+    }
+
+    bool contains(int64_t id) const {
+        return id_to_time_.count(id) > 0;
+    }
+
+    int64_t get_timestamp(int64_t id) const {
+        auto it = id_to_time_.find(id);
+        if (it == id_to_time_.end()) {
+            return -1;
+        }
+        return it->second;
+    }
+};
+
+
+// ============================================================================
+// C API ctypes
+// ============================================================================
+
+#ifdef _WIN32
+    #define EXPORT extern "C" __declspec(dllexport)
+#else
+    #define EXPORT extern "C" __attribute__((visibility("default")))
+#endif
+
+EXPORT TimestampStore* ts_create() {
+    return new TimestampStore();
+}
+
+EXPORT TimestampStore* ts_create_from_arrays(
+    const int64_t* ids,
+    const int64_t* timestamps,
+    int64_t count
+) {
+    TimestampStore* store = new TimestampStore();
+    for (int64_t i = 0; i < count; ++i) {
+        store->add(ids[i], timestamps[i]);
+    }
+    return store;
+}
+
+EXPORT void ts_destroy(TimestampStore* store) {
+    delete store;
+}
+
+EXPORT void ts_add(TimestampStore* store, int64_t id, int64_t timestamp) {
+    if (store) {
+        store->add(id, timestamp);
+    }
+}
+
+EXPORT int32_t ts_remove(TimestampStore* store, int64_t id) {
+    if (!store) return 0;
+    return store->remove(id) ? 1 : 0;
+}
+
+EXPORT int64_t* ts_remove_before_timestamp(
+    TimestampStore* store,
+    int64_t timestamp,
+    int64_t* out_size
+) {
+    if (!store || !out_size) {
+        if (out_size) *out_size = 0;
+        return nullptr;
+    }
+
+    std::vector<int64_t> result = store->remove_before_timestamp(timestamp);
+    *out_size = static_cast<int64_t>(result.size());
+
+    if (result.empty()) {
+        return nullptr;
+    }
+
+    int64_t* arr = new int64_t[result.size()];
+    std::copy(result.begin(), result.end(), arr);
+    return arr;
+}
+
+EXPORT void ts_free_array(int64_t* arr) {
+    delete[] arr;
+}
+
+EXPORT int64_t ts_size(TimestampStore* store) {
+    if (!store) return 0;
+    return static_cast<int64_t>(store->size());
+}
+
+EXPORT int32_t ts_empty(TimestampStore* store) {
+    if (!store) return 1;
+    return store->empty() ? 1 : 0;
+}
+
+EXPORT int64_t ts_get_min_timestamp(TimestampStore* store) {
+    if (!store) return -1;
+    return store->get_min_timestamp();
+}
+
+EXPORT int32_t ts_contains(TimestampStore* store, int64_t id) {
+    if (!store) return 0;
+    return store->contains(id) ? 1 : 0;
+}
+
+EXPORT int64_t ts_get_timestamp(TimestampStore* store, int64_t id) {
+    if (!store) return -1;
+    return store->get_timestamp(id);
+}

timestamp_store/wrapper.py

@@ -0,0 +1,175 @@
+import ctypes
+import platform
+from pathlib import Path
+from typing import List, Tuple, Optional, Union, Dict
+
+class TimestampStore:
+    _lib: ctypes.CDLL = None
+    _lib_path: str = None
+
+    @classmethod
+    def _get_lib_name(cls) -> str:
+        system = platform.system()
+        if system == "Windows":
+            return "timestamp_store.dll"
+        elif system == "Darwin":
+            return "libtimestamp_store.dylib"
+        else:
+            return "libtimestamp_store.so"
+
+    @classmethod
+    def _find_library(cls) -> str:
+        lib_name = cls._get_lib_name()
+
+        search_paths = [
+            Path(__file__).parent / lib_name,
+            Path(__file__).parent / "src" / lib_name,
+            Path.cwd() / lib_name,
+        ]
+
+        for path in search_paths:
+            if path.exists():
+                return str(path)
+
+        raise FileNotFoundError(
+            f"Could not find {lib_name}. "
+            f"Searched in: {[str(p) for p in search_paths]}. "
+            f"Try reinstalling the package: pip install --force-reinstall git+https://github.com/shutkanos/timestamp_store.git"
+        )
+
+    @classmethod
+    def _load_library(cls, lib_path: Optional[str] = None) -> ctypes.CDLL:
+        if lib_path is None:
+            lib_path = cls._find_library()
+
+        if cls._lib is not None and cls._lib_path == lib_path:
+            return cls._lib
+
+        lib = ctypes.CDLL(lib_path)
+
+        lib.ts_create.restype = ctypes.c_void_p
+        lib.ts_create.argtypes = []
+
+        lib.ts_create_from_arrays.restype = ctypes.c_void_p
+        lib.ts_create_from_arrays.argtypes = [
+            ctypes.POINTER(ctypes.c_int64),
+            ctypes.POINTER(ctypes.c_int64),
+            ctypes.c_int64
+        ]
+
+        lib.ts_destroy.restype = None
+        lib.ts_destroy.argtypes = [ctypes.c_void_p]
+
+        lib.ts_add.restype = None
+        lib.ts_add.argtypes = [ctypes.c_void_p, ctypes.c_int64, ctypes.c_int64]
+
+        lib.ts_remove.restype = ctypes.c_int32
+        lib.ts_remove.argtypes = [ctypes.c_void_p, ctypes.c_int64]
+
+        lib.ts_remove_before_timestamp.restype = ctypes.POINTER(ctypes.c_int64)
+        lib.ts_remove_before_timestamp.argtypes = [
+            ctypes.c_void_p,
+            ctypes.c_int64,
+            ctypes.POINTER(ctypes.c_int64)
+        ]
+
+        lib.ts_free_array.restype = None
+        lib.ts_free_array.argtypes = [ctypes.POINTER(ctypes.c_int64)]
+
+        lib.ts_size.restype = ctypes.c_int64
+        lib.ts_size.argtypes = [ctypes.c_void_p]
+
+        lib.ts_empty.restype = ctypes.c_int32
+        lib.ts_empty.argtypes = [ctypes.c_void_p]
+
+        lib.ts_get_min_timestamp.restype = ctypes.c_int64
+        lib.ts_get_min_timestamp.argtypes = [ctypes.c_void_p]
+
+        lib.ts_contains.restype = ctypes.c_int32
+        lib.ts_contains.argtypes = [ctypes.c_void_p, ctypes.c_int64]
+
+        lib.ts_get_timestamp.restype = ctypes.c_int64
+        lib.ts_get_timestamp.argtypes = [ctypes.c_void_p, ctypes.c_int64]
+
+        cls._lib = lib
+        cls._lib_path = lib_path
+        return lib
+
+    def __init__(self, data: Optional[Union[List[Tuple[int, int]], Dict[int, int]]] = None, *, lib_path: Optional[str] = None):
+        self._lib_instance = self._load_library(lib_path)
+
+        if data is None:
+            self._store = self._lib_instance.ts_create()
+        else:
+            if isinstance(data, dict):
+                pairs = list(data.items())
+            else:
+                pairs = list(data)
+
+            if not pairs:
+                self._store = self._lib_instance.ts_create()
+            else:
+                n = len(pairs)
+                ids_array = (ctypes.c_int64 * n)()
+                timestamps_array = (ctypes.c_int64 * n)()
+
+                for i, (id_val, ts_val) in enumerate(pairs):
+                    ids_array[i] = id_val
+                    timestamps_array[i] = ts_val
+
+                self._store = self._lib_instance.ts_create_from_arrays(
+                    ids_array, timestamps_array, n
+                )
+
+        if not self._store:
+            raise MemoryError("Failed to create TimestampStore")
+
+    def __del__(self):
+        if hasattr(self, '_store') and self._store and hasattr(self, '_lib_instance'):
+            self._lib_instance.ts_destroy(self._store)
+            self._store = None
+
+    def add(self, id: int, timestamp: int) -> None:
+        self._lib_instance.ts_add(self._store, id, timestamp)
+
+    def remove(self, id: int) -> bool:
+        return bool(self._lib_instance.ts_remove(self._store, id))
+
+    def remove_timestamp(self, timestamp: int) -> List[int]:
+        """
+        Delete all elements with a timestamp value less than the specified argument
+        :return: list of deleted IDs.
+        """
+        size = ctypes.c_int64(0)
+        arr_ptr = self._lib_instance.ts_remove_before_timestamp(
+            self._store,
+            timestamp,
+            ctypes.byref(size)
+        )
+
+        if size.value == 0 or not arr_ptr:
+            return []
+
+        try:
+            result = [arr_ptr[i] for i in range(size.value)]
+        finally:
+            self._lib_instance.ts_free_array(arr_ptr)
+
+        return result
+
+    def get_timestamp(self, id: int) -> Optional[int]:
+        ts = self._lib_instance.ts_get_timestamp(self._store, id)
+        return ts if ts >= 0 else None
+
+    def get_min_timestamp(self) -> Optional[int]:
+        ts = self._lib_instance.ts_get_min_timestamp(self._store)
+        return ts if ts >= 0 else None
+
+    def __len__(self) -> int:
+        return self._lib_instance.ts_size(self._store)
+
+    def __bool__(self) -> bool:
+        return not self._lib_instance.ts_empty(self._store)
+
+    def __contains__(self, id: int) -> bool:
+        return bool(self._lib_instance.ts_contains(self._store, id))

timestamp_store-1.0.0.dist-info/METADATA

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: timestamp-store
+Version: 1.0.0
+Summary: Fast timestamp-based data structure with O(log N) operations
+Home-page: https://github.com/shutkanos/timestamp_store
+Author: Shutkanos
+Author-email: Shutkanos <Shutkanos836926@mail.ru>
+License: MIT
+Project-URL: Homepage, https://github.com/shutkanos/timestamp_store
+Project-URL: Repository, https://github.com/shutkanos/timestamp_store
+Keywords: timestamp,data-structure,ctypes
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+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: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: C++
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# TimestampStore
+
+Fast data structure for (id, timestamp) pairs with O(log N) operations.
+Warning! Created by claude-opus-4.5 without human intervention.
+
+## Installation
+
+```bash
+pip install git+https://github.com/shutkanos/timestamp_store.git
+```
+
+**Requirements:** C++ compiler (g++, clang++, or MSVC)
+
+### Installing compiler
+
+- **Ubuntu/Debian:** `sudo apt install g++`
+- **macOS:** `xcode-select --install`
+- **Windows:** Install [Visual Studio Build Tools](https://visualstudio.microsoft.com/visual-cpp-build-tools/) or:
+
+PowerShell:
+```PowerShell
+winget install -e --id MSYS2.MSYS2
+```
+MSYS2:
+```
+pacman -S mingw-w64-x86_64-gcc
+```
+
+## Usage
+
+```python
+from timestamp_store import TimestampStore
+
+store = TimestampStore()
+
+# Add pairs
+store.add(1, 100)
+store.add(2, 50)
+store.add(3, 150)
+
+# Remove all with timestamp < 120
+removed = store.remove_timestamp(120)
+print(removed)  # [2, 1]
+
+# Remove by id
+store.remove(3)
+
+# Create from list
+store = TimestampStore([(1, 100), (2, 200)])
+# Create from dict
+store = TimestampStore({1: 100, 2: 200})
+```
+
+## Complexity
+
+| Operation | Complexity |
+|-----------|------------|
+| `add(id, timestamp)` | O(log N) |
+| `remove(id)` | O(log N) |
+| `remove_timestamp(ts)` | O(K) where K = removed count |

timestamp_store-1.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+timestamp_store/__init__.py,sha256=TGRhO4_Fs0QnCgx6jYLlbIsuv0I7vMjVUqKspdbp32Q,409
+timestamp_store/timestamp_store.dll,sha256=SgRDJZ6UGQmUh2WLtEDriXyDEF3kEmBX1CNNm232SmY,731228
+timestamp_store/wrapper.py,sha256=xuoPlaVgl19DQcJbvmmnoqPRhsBnTaTxrLqgw-hbZsA,5935
+timestamp_store/src/timestamp_store.cpp,sha256=cxu0BDutMk498rR1MGB0KF-d6fP0oWztLTx0M4B-y1s,5038
+timestamp_store-1.0.0.dist-info/licenses/LICENSE,sha256=K7_kNJPZ5f_96bFuI_3LzOuIigXOx8q4pA9Z5sZ18Pc,1086
+timestamp_store-1.0.0.dist-info/METADATA,sha256=IE_k9DKNRoeAM9qLhKdcWsC-zToHHihJ6hLLSgZgwc8,2632
+timestamp_store-1.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+timestamp_store-1.0.0.dist-info/top_level.txt,sha256=SYxzkaPTIfm4d0Zbo6qSNINe6kIhTwc_HxmKHEENTdY,16
+timestamp_store-1.0.0.dist-info/RECORD,,

timestamp_store-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

timestamp_store-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Shutkanos
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

timestamp_store-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+timestamp_store