timestamp-store 1.0.0__tar.gz

timestamp_store-1.0.0/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/MANIFEST.in

@@ -0,0 +1,11 @@
+include README.md
+include LICENSE
+include pyproject.toml
+
+recursive-include timestamp_store/src *.cpp *.h *.hpp
+recursive-include timestamp_store *.so *.dylib *.dll
+
+global-exclude __pycache__
+global-exclude *.py[cod]
+global-exclude *.so.*
+global-exclude .git*

timestamp_store-1.0.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,60 @@
+# 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/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=45", "wheel", "setuptools-scm>=6.2"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "timestamp-store"
+version = "1.0.0"
+description = "Fast timestamp-based data structure with O(log N) operations"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.7"
+authors = [
+    {name = "Shutkanos", email = "Shutkanos836926@mail.ru"}
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: C++",
+    "Operating System :: OS Independent",
+]
+keywords = ["timestamp", "data-structure", "ctypes"]
+
+[project.urls]
+Homepage = "https://github.com/shutkanos/timestamp_store"
+Repository = "https://github.com/shutkanos/timestamp_store"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["timestamp_store*"]
+
+[tool.setuptools.package-data]
+timestamp_store = ["src/*.cpp", "*.so", "*.dylib", "*.dll"]

timestamp_store-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

timestamp_store-1.0.0/setup.py

@@ -0,0 +1,360 @@
+import os
+import sys
+import platform
+import subprocess
+import shutil
+from pathlib import Path
+
+from setuptools import setup, find_packages
+from setuptools.command.build_py import build_py
+from setuptools.command.develop import develop
+from setuptools.command.install import install
+from setuptools.command.egg_info import egg_info
+
+
+def get_library_name():
+    system = platform.system()
+    if system == "Windows":
+        return "timestamp_store.dll"
+    elif system == "Darwin":
+        return "libtimestamp_store.dylib"
+    else:
+        return "libtimestamp_store.so"
+
+
+def find_mingw_path():
+    mingw_search_paths = [
+        Path("C:/msys64/mingw64/bin"),
+        Path("C:/msys64/ucrt64/bin"),
+        Path("C:/msys64/clang64/bin"),
+        Path("C:/msys64/mingw32/bin"),
+        Path("C:/msys2/mingw64/bin"),
+        Path("C:/msys2/ucrt64/bin"),
+        Path("C:/mingw64/bin"),
+        Path("C:/mingw/bin"),
+        Path("C:/MinGW/bin"),
+        Path("C:/tools/mingw64/bin"),
+        Path(os.environ.get("USERPROFILE", "")) / "scoop/apps/mingw/current/bin",
+        Path(os.environ.get("ProgramFiles", "C:\\Program Files")) / "mingw-w64/x86_64-8.1.0-posix-seh-rt_v6-rev0/mingw64/bin",
+        Path(os.environ.get("ProgramFiles", "C:\\Program Files")) / "mingw64/bin",
+    ]
+
+    for env_var in ["MINGW_HOME", "MINGW64_HOME", "MSYS2_HOME"]:
+        if env_var in os.environ:
+            env_path = Path(os.environ[env_var])
+            if (env_path / "bin" / "g++.exe").exists():
+                mingw_search_paths.insert(0, env_path / "bin")
+            elif (env_path / "g++.exe").exists():
+                mingw_search_paths.insert(0, env_path)
+
+    for path in mingw_search_paths:
+        if path.exists() and (path / "g++.exe").exists():
+            print(f"Found MinGW at: {path}")
+            return path
+
+    return None
+
+
+def find_msvc_vcvarsall():
+    program_files_x86 = os.environ.get("ProgramFiles(x86)", "C:\\Program Files (x86)")
+    program_files = os.environ.get("ProgramFiles", "C:\\Program Files")
+
+    vswhere_paths = [
+        Path(program_files_x86) / "Microsoft Visual Studio/Installer/vswhere.exe",
+        Path(program_files) / "Microsoft Visual Studio/Installer/vswhere.exe",
+    ]
+
+    vswhere = None
+    for p in vswhere_paths:
+        if p.exists():
+            vswhere = p
+            break
+
+    if vswhere:
+        try:
+            result = subprocess.run(
+                [
+                    str(vswhere),
+                    "-latest",
+                    "-property", "installationPath",
+                    "-requires", "Microsoft.VisualStudio.Component.VC.Tools.x86.x64"
+                ],
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            vs_path = Path(result.stdout.strip())
+            vcvarsall = vs_path / "VC/Auxiliary/Build/vcvarsall.bat"
+            if vcvarsall.exists():
+                print(f"Found MSVC vcvarsall at: {vcvarsall}")
+                return vcvarsall
+        except subprocess.CalledProcessError:
+            pass
+
+    vs_years = ["2022", "2019", "2017"]
+    vs_editions = ["Enterprise", "Professional", "Community", "BuildTools"]
+
+    for year in vs_years:
+        for edition in vs_editions:
+            for pf in [program_files, program_files_x86]:
+                vcvarsall = Path(pf) / f"Microsoft Visual Studio/{year}/{edition}/VC/Auxiliary/Build/vcvarsall.bat"
+                if vcvarsall.exists():
+                    print(f"Found MSVC vcvarsall at: {vcvarsall}")
+                    return vcvarsall
+
+    return None
+
+
+def get_msvc_environment(vcvarsall):
+    arch = "x64" if platform.machine().endswith('64') else "x86"
+
+    cmd = f'"{vcvarsall}" {arch} >nul 2>&1 && set'
+
+    try:
+        result = subprocess.run(
+            cmd,
+            shell=True,
+            capture_output=True,
+            text=True,
+            check=True
+        )
+
+        env = {}
+        for line in result.stdout.splitlines():
+            if '=' in line:
+                key, _, value = line.partition('=')
+                env[key] = value
+
+        return env
+    except subprocess.CalledProcessError as e:
+        print(f"Warning: Failed to setup MSVC environment: {e}")
+        return None
+
+
+def get_compiler_command():
+    system = platform.system()
+    lib_name = get_library_name()
+
+    src_dir = Path(__file__).parent / "timestamp_store" / "src"
+    cpp_file = src_dir / "timestamp_store.cpp"
+    output_dir = Path(__file__).parent / "timestamp_store"
+    output_file = output_dir / lib_name
+
+    env = os.environ.copy()
+
+    if system == "Windows":
+        mingw_path = find_mingw_path()
+        if mingw_path:
+            env["PATH"] = str(mingw_path) + os.pathsep + env.get("PATH", "")
+
+            gpp_path = mingw_path / "g++.exe"
+
+            return [
+                str(gpp_path),
+                "-O3", "-std=c++17", "-shared",
+                "-static-libgcc",
+                "-static-libstdc++",
+                "-static",
+                "-o", str(output_file),
+                str(cpp_file)
+            ], env
+
+        vcvarsall = find_msvc_vcvarsall()
+        if vcvarsall:
+            msvc_env = get_msvc_environment(vcvarsall)
+            if msvc_env:
+                return [
+                    "cl",
+                    "/O2",
+                    "/LD",
+                    "/EHsc",
+                    "/std:c++17",
+                    "/MT",
+                    str(cpp_file),
+                    f"/Fe:{output_file}",
+                    f"/Fo:{output_dir}\\",
+                ], msvc_env
+
+        if shutil.which("g++"):
+            print("Using g++ from PATH")
+            return [
+                "g++", "-O3", "-std=c++17", "-shared",
+                "-static-libgcc", "-static-libstdc++",
+                "-o", str(output_file),
+                str(cpp_file)
+            ], env
+
+        if shutil.which("cl"):
+            print("Using cl from PATH")
+            return [
+                "cl", "/O2", "/LD", "/EHsc",
+                "/std:c++17", "/MT",
+                str(cpp_file),
+                f"/Fe:{output_file}"
+            ], env
+        raise RuntimeError(
+            "No C++ compiler found on Windows!\n\n"
+            "Please install one of the following:\n"
+            "1. MSYS2 MinGW: https://www.msys2.org/\n"
+            "   Then run: pacman -S mingw-w64-x86_64-gcc\n\n"
+            "2. Visual Studio Build Tools: https://visualstudio.microsoft.com/visual-cpp-build-tools/\n"
+            "   Select 'Desktop development with C++'\n\n"
+            "3. Standalone MinGW-w64: https://www.mingw-w64.org/downloads/"
+        )
+
+    elif system == "Darwin":
+        compiler = "clang++" if shutil.which("clang++") else "g++"
+        return [
+            compiler, "-O3", "-std=c++17",
+            "-shared", "-fPIC",
+            "-o", str(output_file),
+            str(cpp_file)
+        ], env
+
+    else:
+        if not shutil.which("g++"):
+            raise RuntimeError(
+                "g++ not found. Please install:\n"
+                "Ubuntu/Debian: sudo apt install g++\n"
+                "Fedora: sudo dnf install gcc-c++\n"
+                "Arch: sudo pacman -S gcc"
+            )
+        return [
+            "g++", "-O3", "-std=c++17",
+            "-shared", "-fPIC",
+            "-o", str(output_file),
+            str(cpp_file)
+        ], env
+
+
+def compile_cpp_library():
+    lib_name = get_library_name()
+    output_dir = Path(__file__).parent / "timestamp_store"
+    output_file = output_dir / lib_name
+
+    if output_file.exists():
+        print(f"Library {lib_name} already exists, skipping compilation")
+        return
+
+    print(f"Compiling C++ library: {lib_name}")
+    print(f"Platform: {platform.system()} {platform.machine()}")
+
+    try:
+        cmd, env = get_compiler_command()
+        print(f"Running: {' '.join(cmd)}")
+
+        path_preview = env.get("PATH", "").split(os.pathsep)[:3]
+        print(f"PATH preview: {path_preview}")
+
+        result = subprocess.run(
+            cmd,
+            check=True,
+            capture_output=True,
+            text=True,
+            env=env,
+            cwd=str(output_dir)
+        )
+
+        if result.stdout:
+            print(result.stdout)
+
+        if output_file.exists():
+            print(f"Successfully compiled {lib_name}")
+            print(f"Library size: {output_file.stat().st_size} bytes")
+        else:
+            raise RuntimeError(f"Compilation succeeded but {lib_name} not found")
+
+    except subprocess.CalledProcessError as e:
+        print(f"Compilation failed!")
+        print(f"Command: {' '.join(cmd)}")
+        print(f"stdout: {e.stdout}")
+        print(f"stderr: {e.stderr}")
+        raise RuntimeError(f"Failed to compile C++ library: {e}")
+    except FileNotFoundError as e:
+        raise RuntimeError(
+            f"C++ compiler not found: {e}\n"
+            f"Please install g++, clang++, or MSVC."
+        )
+    finally:
+        if platform.system() == "Windows":
+            for ext in [".obj", ".exp", ".lib"]:
+                for f in output_dir.glob(f"*{ext}"):
+                    try:
+                        f.unlink()
+                    except:
+                        pass
+
+
+class BuildPyWithCompile(build_py):
+    def run(self):
+        compile_cpp_library()
+        super().run()
+
+        lib_name = get_library_name()
+        src_lib = Path(__file__).parent / "timestamp_store" / lib_name
+
+        if src_lib.exists():
+            dest_dir = Path(self.build_lib) / "timestamp_store"
+            dest_dir.mkdir(parents=True, exist_ok=True)
+            dest_lib = dest_dir / lib_name
+            shutil.copy2(src_lib, dest_lib)
+            print(f"Copied {lib_name} to {dest_lib}")
+
+
+class DevelopWithCompile(develop):
+    def run(self):
+        compile_cpp_library()
+        super().run()
+
+
+class InstallWithCompile(install):
+    def run(self):
+        compile_cpp_library()
+        super().run()
+
+
+class EggInfoWithCompile(egg_info):
+    def run(self):
+        compile_cpp_library()
+        super().run()
+
+long_description = ""
+if os.path.exists("README.md"):
+    with open("README.md", encoding="utf-8") as f:
+        long_description = f.read()
+
+setup(
+    name="timestamp-store",
+    version="1.0.0",
+    description="Fast timestamp-based data structure with O(log N) operations",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author='Shutkanos',
+    author_email='Shutkanos836926@mail.ru',
+    url="https://github.com/shutkanos/timestamp_store",
+    packages=find_packages(),
+    package_data={
+        "timestamp_store": [
+            "src/*.cpp",
+            "*.so",
+            "*.dylib",
+            "*.dll",
+        ],
+    },
+    include_package_data=True,
+    python_requires=">=3.7",
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: C++",
+        "Operating System :: OS Independent",
+    ],
+    cmdclass={
+        "build_py": BuildPyWithCompile,
+        "develop": DevelopWithCompile,
+        "install": InstallWithCompile,
+        "egg_info": EggInfoWithCompile,
+    },
+)

timestamp_store-1.0.0/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-1.0.0/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-1.0.0/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/timestamp_store.egg-info/PKG-INFO

@@ -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/timestamp_store.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+timestamp_store/__init__.py
+timestamp_store/timestamp_store.dll
+timestamp_store/wrapper.py
+timestamp_store.egg-info/PKG-INFO
+timestamp_store.egg-info/SOURCES.txt
+timestamp_store.egg-info/dependency_links.txt
+timestamp_store.egg-info/top_level.txt
+timestamp_store/src/timestamp_store.cpp

timestamp_store-1.0.0/timestamp_store.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

timestamp_store-1.0.0/timestamp_store.egg-info/top_level.txt

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